クロスプラットフォームで動作するintunewinファイルの作成・解凍ツールを作った

package main

import (
    "archive/zip"
    "bytes"
    "fmt"
    "io"
    "os"
    "github.com/kenchan0130/intunewin/pkg/intunewin"
)

func main() {
    // Pack: ZIPアーカイブを作成
    zipBuf := new(bytes.Buffer)
    zipWriter := zip.NewWriter(zipBuf)
    
    // ファイルをZIPに追加
    w1, _ := zipWriter.Create("app.exe")
    w1.Write([]byte("executable content"))
    
    w2, _ := zipWriter.Create("config/settings.json")
    w2.Write([]byte(`{"version": "1.0"}`))
    
    zipWriter.Close()
    
    // ZIPをintunewin形式にパッケージ化
    packedReader, err := intunewin.PackReader(bytes.NewReader(zipBuf.Bytes()), "MyApp", "app.exe")
    if err != nil {
        fmt.Printf("Pack failed: %v\n", err)
        return
    }
    
    // ファイルに書き込み
    packedData, _ := io.ReadAll(packedReader)
    os.WriteFile("myapp.intunewin", packedData, 0644)
    
    // Unpack: intunewinファイルからZIPを抽出
    input, _ := os.ReadFile("myapp.intunewin")
    
    unpackedZipReader, err := intunewin.UnpackReader(bytes.NewReader(input))
    if err != nil {
        fmt.Printf("Unpack failed: %v\n", err)
        return
    }
    
    // ZIPデータを読み取り
    unpackedZipData, _ := io.ReadAll(unpackedZipReader)
    
    // ZIPからファイルを展開
    zipReader, _ := zip.NewReader(bytes.NewReader(unpackedZipData), int64(len(unpackedZipData)))
    for _, file := range zipReader.File {
        fmt.Printf("File: %s\n", file.Name)
    }
}

func Encrypt(input io.Reader, output io.Writer, encryptionKey, macKey, iv []byte) ([]byte, error) {
    block, err := aes.NewCipher(encryptionKey)
    if err != nil {
        return nil, fmt.Errorf("failed to create cipher: %w", err)
    }

    // 入力データを全て読み込み
    plaintext, err := io.ReadAll(input)
    if err != nil {
        return nil, fmt.Errorf("failed to read input: %w", err)
    }

    // PKCS7パディングを適用
    plaintext = pkcs7Pad(plaintext, aes.BlockSize)

    // データを暗号化
    mode := cipher.NewCBCEncrypter(block, iv)
    ciphertext := make([]byte, len(plaintext))
    mode.CryptBlocks(ciphertext, plaintext)

    // IV + 暗号化データのHMACを計算
    h := hmac.New(sha256.New, macKey)
    h.Write(iv)
    h.Write(ciphertext)
    mac := h.Sum(nil)

    // [HMAC][IV][暗号化データ]の順で出力
    output.Write(mac)
    output.Write(iv)
    output.Write(ciphertext)

    return mac, nil
}

func pkcs7Pad(data []byte, blockSize int) []byte {
    padding := blockSize - (len(data) % blockSize)
    padText := make([]byte, padding)
    for i := range padText {
        padText[i] = byte(padding)
    }
    return append(data, padText...)
}

func Decrypt(input io.Reader, output io.Writer, encryptionKey, macKey []byte) error {
    // HMACを読み取り
    storedMac := make([]byte, 32)
    if _, err := io.ReadFull(input, storedMac); err != nil {
        return fmt.Errorf("failed to read HMAC: %w", err)
    }

    // IVを読み取り
    iv := make([]byte, aes.BlockSize)
    if _, err := io.ReadFull(input, iv); err != nil {
        return fmt.Errorf("failed to read IV: %w", err)
    }

    // 暗号化データを全て読み取り
    encryptedData, err := io.ReadAll(input)
    if err != nil {
        return fmt.Errorf("failed to read encrypted data: %w", err)
    }

    // HMACを検証
    h := hmac.New(sha256.New, macKey)
    h.Write(iv)
    h.Write(encryptedData)
    computedMac := h.Sum(nil)

    if !hmac.Equal(storedMac, computedMac) {
        return fmt.Errorf("HMAC verification failed")
    }

    // データを復号化
    block, err := aes.NewCipher(encryptionKey)
    if err != nil {
        return fmt.Errorf("failed to create cipher: %w", err)
    }

    if len(encryptedData)%aes.BlockSize != 0 {
        return fmt.Errorf("encrypted data length is not a multiple of block size")
    }

    mode := cipher.NewCBCDecrypter(block, iv)
    plaintext := make([]byte, len(encryptedData))
    mode.CryptBlocks(plaintext, encryptedData)

    // PKCS7パディングを除去
    plaintext, err = pkcs7Unpad(plaintext, aes.BlockSize)
    if err != nil {
        return fmt.Errorf("failed to remove padding: %w", err)
    }

    output.Write(plaintext)
    return nil
}