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

$ intunewin pack <ソースフォルダ> <出力ファイル.intunewin>

$ intunewin pack ./myapp ./dist/myapp.intunewin
Packing ./myapp to ./dist/myapp.intunewin...
Successfully created ./dist/myapp.intunewin

$ intunewin unpack <入力ファイル.intunewin> <出力フォルダ>

$ intunewin unpack myapp.intunewin ./extracted
Unpacking myapp.intunewin to ./extracted...
Successfully extracted to ./extracted

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)
    }
}

IntuneWinPackage/
├── Metadata/
│   └── Detection.xml    # 暗号鍵やファイル情報のメタデータ
└── Contents/
    └── IntunePackage.intunewin    # 暗号化されたコンテンツ

<ApplicationInfo xmlns:xsd="http://www.w3.org/2001/XMLSchema"
                 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
                 ToolVersion="1.4.0.0">
  <Name>MyApp</Name>
  <UnencryptedContentSize>1234567</UnencryptedContentSize>
  <FileName>IntunePackage.intunewin</FileName>
  <SetupFile>setup.exe</SetupFile>
  <EncryptionInfo>
    <EncryptionKey>Base64エンコードされた256ビットAES鍵</EncryptionKey>
    <MacKey>Base64エンコードされた256ビットHMAC鍵</MacKey>
    <InitializationVector>Base64エンコードされた128ビットIV</InitializationVector>
    <Mac>Base64エンコードされたHMAC値</Mac>
    <ProfileIdentifier>ProfileVersion1</ProfileIdentifier>
    <FileDigest>Base64エンコードされたSHA256ハッシュ</FileDigest>
    <FileDigestAlgorithm>SHA256</FileDigestAlgorithm>
  </EncryptionInfo>
</ApplicationInfo>

[HMAC (32バイト)][IV (16バイト)][暗号化データ]

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
}