List of Compress [text.Baldanders.info]

io.Copy を上限付きで実行する

2020-12-06T05:10:36+00:00

「もうlintに怒られない！Goでより安全にzipを扱うために」を読んで「なるほど！」と思ったが，（おそらくコードをかなり端折ってるんだと思うが）サンプル・コードがツッコミどころ満載なので，うちのブログでも覚え書として記しておく。自作ツールでも圧縮データの解凍処理を使ってるしね。

gosec について

ところで，上述のリンク先で使われている gosec は統合 linter である golangci-lint から呼び出すことができるが，既定では無効になっている。有効にするには --enable オプションで gosec を指定すればよい。

$ golangci-lint run --enable gosec ./...

gosec が既定で有効になっていないのは，特に unsafe 標準パッケージを使っている場合の誤検知が多すぎるかららしい。私の環境で試してみたが処理速度的には問題ないようなので，一度は試してみてもいいかもしれない。

最初のサンプル・コード

まずは起点となるサンプル・コードを挙げておこう。こんな感じでどうだろう。

package main

import (
	"bytes"
	"compress/zlib"
	"fmt"
	"io"
	"os"
	"strings"
)

func compress(dst io.Writer, src io.Reader) error {
	zw := zlib.NewWriter(dst)
	defer zw.Close()

	if _, err := io.Copy(zw, src); err != nil {
		return err
	}
	return nil
}

func extract(dst io.Writer, src io.Reader) error {
	r, err := zlib.NewReader(src)
	if err != nil {
		return err
	}
	if _, err := io.Copy(dst, r); err != nil {
		return err
	}
	return nil
}

func main() {
	content := "Hello world\n" //raw data
	zbuf := &bytes.Buffer{}
	//compress raw data
	if err := compress(zbuf, strings.NewReader(content)); err != nil {
		fmt.Fprintln(os.Stderr, err)
		return
	}
	//display compressed data
	b := zbuf.Bytes()
	fmt.Printf("%d bytes: %v\n", len(b), b)
	//extract from compressed data
	buf := &bytes.Buffer{}
	err := extract(buf, bytes.NewReader(b))
	if err != nil {
		fmt.Fprintln(os.Stderr, err)
		return
	}
	//display extracted data
	if _, err := io.Copy(os.Stdout, buf); err != nil {
		fmt.Fprintln(os.Stderr, err)
		return
	}
}

最初に紹介した記事で使っている archive/zip パッケージはファイルシステムを含んでいるので，今回はもっとシンプルに compress/zlib パッケージ（RFC 1950 準拠）を使ってみた。これならデータの圧縮と解凍のみ注視できるだろう。

このコードを実行すると

$ go run sample.go 
24 bytes: [120 156 242 72 205 201 201 87 40 207 47 202 73 225 2 4 0 0 255 255 28 242 4 71]
Hello world

と一応は問題なく動く。これで準備OK。

Decompression Bomb Vulnerability

では，このコードに対して lint をかけてみる。

$ golangci-lint run --enable gosec ./...
sample1.go:27:15: G110: Potential DoS vulnerability via decompression bomb (gosec)
	if _, err := io.Copy(dst, r); err != nil {
	             ^

おー，出た出た。

“Decompression bomb” というのは

A zip bomb, also known as a zip of death or decompression bomb, is a malicious archive file designed to crash or render useless the program or system reading it. It is often employed to disable antivirus software, in order to create an opening for more traditional viruses.

via Zip bomb - Wikipedia

ということで，主にウイルス対策ツールをターゲットにした攻撃手段らしい。まぁ 42.zip みたいなファイルを解凍したら普通にシステムが死ぬと思うけど（笑）

解凍処理の改修

“Decompression bomb” を緩和する方法はいくつかあるようだが，いちばん安直なのは io.Copy() 関数に上限を設けることだろう。そのための関数として io.CopyN() が用意されている。

func io.CopyN(dst io.Writer, src io.Reader, n int64) (written int64, err error)

機能としては

CopyN copies n bytes (or until an error) from src to dst. It returns the number of bytes copied and the earliest error encountered while copying. On return, written == n if and only if err == nil.

via io - The Go Programming Language

ということで

err == nil なら上限いっぱいまで読み込み完了
err の値が io.EOF ならストリームの終端まで読み込み完了
err の値が io.EOF 以外ならエラー

と見なすことができそうだ。そこで最初のサンプルコードの extract() 関数を以下のように書き直す。

const maxSize = 1024 * 1024 * 1024 //1GB

var ErrTooLarge = errors.New("too laege decompressed data")

func extract(dst io.Writer, src io.Reader) error {
	r, err := zlib.NewReader(src)
	if err != nil {
		return err
	}
	if _, err := io.CopyN(dst, r, maxSize); err != nil {
		if errors.Is(err, io.EOF) {
			return nil
		}
		return err
	}
	return ErrTooLarge
}

とりあえずコピーの上限は1GBとした（深い意味はない）。これで少なくとも gosec に怒られることはなくなる。

これ仕込むのかぁ。頑張ろう。

ブックマーク

参考図書

プログラミング言語Go (ADDISON-WESLEY PROFESSIONAL COMPUTING SERIES): Alan A.A. Donovan (著), Brian W. Kernighan (著), 柴田芳樹 (翻訳); 丸善出版 2016-06-20; 単行本（ソフトカバー）; 4621300253 (ASIN), 9784621300251 (EAN), 4621300253 (ISBN); 評価

著者のひとりは（あの「バイブル」とも呼ばれる）通称 “K&R” の K のほうである。この本は Go 言語の教科書と言ってもいいだろう。と思ったら絶版状態らしい（2025-01 現在）。復刊を望む！

reviewed by Spiegel on 2016-07-13 (powered by PA-APIv5)

Go 言語でデータ圧縮と解凍

2017-12-03T11:07:25+00:00

最近データ圧縮と解凍でちょっと悩んだので覚え書きとしてまとめておく。

ZLIB 圧縮と解凍（RFC 1950）

RFC 1950 で定義される圧縮方式。

Go 言語では標準パッケージの compress/zlib で提供される。コードで書くとこんな感じ。

package main

import (
    "bytes"
    "compress/zlib"
    "fmt"
    "io"
    "os"
)

func compress(r io.Reader) (*bytes.Buffer, error) {
    buf := new(bytes.Buffer)
    zw := zlib.NewWriter(buf)
    defer zw.Close()

    if _, err := io.Copy(zw, r); err != nil {
        return buf, err
    }
    return buf, nil
}

func extract(zr io.Reader) (io.Reader, error) {
    return zlib.NewReader(zr)
}

func main() {
    content := "Hello world\n" //raw data
    //compress raw data
    zr, err := compress(bytes.NewBufferString(content))
    if err != nil {
        fmt.Fprintln(os.Stderr, err)
        return
    }
    //display compressed data
    b := zr.Bytes()
    fmt.Printf("%d bytes: %v\n", len(b), b)
    //extract from compressed data
    r, err := extract(zr)
    if err != nil {
        fmt.Fprintln(os.Stderr, err)
        return
    }
    //display extracted data
    io.Copy(os.Stdout, r)
}

実行結果はこんな感じになる。

$ go run zlib.go
24 bytes: [120 156 242 72 205 201 201 87 40 207 47 202 73 225 2 4 0 0 255 255 28 242 4 71]
Hello world

DEFLATE 圧縮と解凍（RFC 1951）

RFC 1951 で定義される圧縮方式。

Go 言語では標準パッケージの compress/flate で提供される。コードで書くとこんな感じ。

package main

import (
    "bytes"
    "compress/flate"
    "fmt"
    "io"
    "os"
)

func compress(r io.Reader) (*bytes.Buffer, error) {
    buf := new(bytes.Buffer)
    zw, err := flate.NewWriter(buf, flate.BestCompression)
    if err != nil {
        return buf, err
    }
    defer zw.Close()

    if _, err := io.Copy(zw, r); err != nil {
        return buf, err
    }
    return buf, nil
}

func extract(zr io.Reader) (io.Reader, error) {
    return flate.NewReader(zr), nil
}

func main() {
    content := "Hello world\n" //raw data
    //compress raw data
    zr, err := compress(bytes.NewBufferString(content))
    if err != nil {
        fmt.Fprintln(os.Stderr, err)
        return
    }
    //display compressed data
    b := zr.Bytes()
    fmt.Printf("%d bytes: %v\n", len(b), b)
    //extract from compressed data
    r, err := extract(zr)
    if err != nil {
        fmt.Fprintln(os.Stderr, err)
        return
    }
    //display extracted data
    io.Copy(os.Stdout, r)
}

分かりやすいように関数のインタフェースを合わせてある。

実行結果はこんな感じになる。

$ go run zip.go
18 bytes: [242 72 205 201 201 87 40 207 47 202 73 225 2 4 0 0 255 255]
Hello world

実は C 言語などでは， RFC 1951 は RFC 1950 と同じ zlib で提供される。だから私はてっきり RFC 1951 も compress/zlib で操作できると思いこんでいて，途方に暮れていたのだ。うん。次からは間違えないぞ！

ついでに他の方式も紹介しておこう。

Gzip 圧縮と解凍（RFC 1952）

RFC 1952 で定義される圧縮方式。これも C 言語などでは zlib で提供されている。データというよりファイル圧縮に使うものだが，データ圧縮にも使えないことはない。

Go 言語では標準パッケージの compress/gzip で提供されるのだが，実は以前に紹介している。

Gzip 操作について覚え書き

今回は上述のコードに合わせて書き直してみる。

package main

import (
    "bytes"
    "compress/gzip"
    "fmt"
    "io"
    "os"
)

func compress(r io.Reader) (*bytes.Buffer, error) {
    buf := new(bytes.Buffer)
    zw, err := gzip.NewWriterLevel(buf, gzip.BestCompression)
    if err != nil {
        return buf, err
    }
    defer zw.Close()

    if _, err := io.Copy(zw, r); err != nil {
        return buf, err
    }
    return buf, nil
}

func extract(zr io.Reader) (io.Reader, error) {
    return gzip.NewReader(zr)
}

func main() {
    content := "Hello world\n" //raw data
    //compress raw data
    zr, err := compress(bytes.NewBufferString(content))
    if err != nil {
        fmt.Fprintln(os.Stderr, err)
        return
    }
    //display compressed data
    b := zr.Bytes()
    fmt.Printf("%d bytes: %v\n", len(b), b)
    //extract from compressed data
    r, err := extract(zr)
    if err != nil {
        fmt.Fprintln(os.Stderr, err)
        return
    }
    //display extracted data
    io.Copy(os.Stdout, r)
}

実行結果はこんな感じになる。

$ go run gzip.go
36 bytes: [31 139 8 0 0 0 0 0 2 255 242 72 205 201 201 87 40 207 47 202 73 225 2 4 0 0 255 255 213 224 57 183 12 0 0 0]
Hello world

RFC 1950, RFC 1951, RFC 1952 はデータのフォーマットが違うだけで圧縮アルゴリズムは同じ。なので，単純にデータを圧縮するだけなら RFC 1951 でいいという話になる。

Bzip2 圧縮と解凍

これは zlib 系の圧縮アルゴリズムとは異なる系統。 zlib よりも圧縮率がいいと言われている。これもデータというよりファイル圧縮に使うものだが，データ圧縮にも使えないことはない。

Go 言語では標準パッケージの compress/bzip2 で提供されるのだが，解凍しかサポートされてない。

しょうがないので解凍のみ書いてみる。

package main

import (
    "bytes"
    "compress/bzip2"
    "fmt"
    "io"
    "os"
)

func extract(zr io.Reader) (io.Reader, error) {
    return bzip2.NewReader(zr), nil
}

func main() {
    cdata := []byte{66, 90, 104, 57, 49, 65, 89, 38, 83, 89, 176, 48, 136, 246, 0, 0, 1, 85, 128, 0, 16, 64, 0, 0, 64, 6, 4, 144, 128, 32, 0, 34, 40, 246, 166, 244, 8, 6, 4, 105, 205, 172, 132, 162, 238, 72, 167, 10, 18, 22, 6, 17, 30, 192}
    //display compressed data
    fmt.Printf("%d bytes: %v\n", len(cdata), cdata)
    //extract from compressed data
    r, err := extract(bytes.NewReader(cdata))
    if err != nil {
        fmt.Fprintln(os.Stderr, err)
        return
    }
    //display extracted data
    io.Copy(os.Stdout, r)
}

実行結果はこんな感じになる。

$ go run bzip2.go
54 bytes: [66 90 104 57 49 65 89 38 83 89 176 48 136 246 0 0 1 85 128 0 16 64 0 0 64 6 4 144 128 32 0 34 40 246 166 244 8 6 4 105 205 172 132 162 238 72 167 10 18 22 6 17 30 192]
Hello world

とはいえ「圧縮機能がないのは困るなぁ」と思って探したら，ありました。

dsnet/compress: Collection of compression related Go packages.

これを使ってこれまでと同じように圧縮と解凍の処理を書き直してみる。

package main

import (
    "bytes"
    "fmt"
    "io"
    "os"

    "github.com/dsnet/compress/bzip2"
)

func compress(r io.Reader) (*bytes.Buffer, error) {
    buf := new(bytes.Buffer)
    zw, err := bzip2.NewWriter(buf, &bzip2.WriterConfig{Level: bzip2.BestCompression})
    if err != nil {
        return buf, err
    }
    defer zw.Close()

    if _, err := io.Copy(zw, r); err != nil {
        return buf, err
    }
    return buf, nil
}

func extract(zr io.Reader) (io.Reader, error) {
    return bzip2.NewReader(zr, new(bzip2.ReaderConfig))
}

func main() {
    content := "Hello world\n" //raw data
    //compress raw data
    zr, err := compress(bytes.NewBufferString(content))
    if err != nil {
        fmt.Fprintln(os.Stderr, err)
        return
    }
    //display compressed data
    b := zr.Bytes()
    fmt.Printf("%d bytes: %v\n", len(b), b)
    //extract from compressed data
    r, err := extract(zr)
    if err != nil {
        fmt.Fprintln(os.Stderr, err)
        return
    }
    //display extracted data
    io.Copy(os.Stdout, r)
}

実行結果はこんな感じになる。

$ go run bzip2.go
54 bytes: [66 90 104 57 49 65 89 38 83 89 176 48 136 246 0 0 1 85 128 0 16 64 0 0 64 6 4 144 128 32 0 34 40 246 166 244 8 6 4 105 205 172 132 162 238 72 167 10 18 22 6 17 30 192]
Hello world

めでたし。

ブックマーク

今回は言及しなかった archive/* パッケージ周りの記事を中心にブックマークしてみた。

参考図書

プログラミング言語Go (ADDISON-WESLEY PROFESSIONAL COMPUTING SERIES): Alan A.A. Donovan (著), Brian W. Kernighan (著), 柴田芳樹 (翻訳); 丸善出版 2016-06-20; 単行本（ソフトカバー）; 4621300253 (ASIN), 9784621300251 (EAN), 4621300253 (ISBN); 評価

reviewed by Spiegel on 2016-07-13 (powered by PA-APIv5)

Gzip 操作について覚え書き

2017-09-19T08:31:49+00:00

gzip のやり方 - Qiita

この記事を見て「んん？」となったので，覚え書きとして gzip パッケージについて紹介する。

リンク先の記事で挙げられているコードは以下の通り。

func makeGzip(body string) []byte {
    var b bytes.Buffer
    gw := gzip.NewWriter(&b)
    _, err := gw.Write([]byte(body)); if err != nil {
        ...
    }
    gw.Flush()
    gw.Close()
    return b.Bytes()
}

ここで gw.Close() 関数を defer 指定すると返ってくるバイト列が不完全なデータになってしまう，という話。これは，リンク先の記事で指摘されている通り， gzip.Writer.Close() 関数で gzip のフッタデータをフラッシュしているからである。

Close closes the Writer by flushing any unwritten data to the underlying io.Writer and writing the GZIP footer. It does not close the underlying io.Writer.

via gzip - The Go Programming Language

つまり defer で指定した関数は return 後に駆動するため b.Bytes() 関数を呼び出した時点ではまだ不完全なデータということになる¹。

ここでちょっと考える。

関数の再利用性を考えるのなら，関数内でバッファを生成してバッファ処理の結果を返すのはあまり筋がよろしくない。また圧縮データを書き込む先はメモリバッファじゃなくてファイルかもしれない。

ゆえに関数をこう書き換える。

func makeGzip(dst io.Writer, content []byte) error {
    zw, err := gzip.NewWriterLevel(dst, gzip.BestCompression)
    if err != nil {
        return err
    }
    defer zw.Close()

    if _, err := zw.Write(content); err != nil {
        return err
    }
    return nil
}

つまり圧縮データの書き込み先である Writer を引数で指定するのである。これなら生成した gzip.Writer.Close() 関数を問題なく defer で指定できる。

これを踏まえて完全なコードは以下のようになる。

package main

import (
    "compress/gzip"
    "fmt"
    "io"
    "os"
)

func makeGzip(dst io.Writer, content []byte) error {
    zw, err := gzip.NewWriterLevel(dst, gzip.BestCompression)
    if err != nil {
        return err
    }
    defer zw.Close()

    if _, err := zw.Write(content); err != nil {
        return err
    }
    return nil
}

func main() {
    content := []byte("Hello world\n")

    file, err := os.Create("test.txt.gz")
    if err != nil {
        fmt.Fprintln(os.Stderr, err)
        return
    }
    defer file.Close()

    if err := makeGzip(file, content); err != nil {
        fmt.Fprintln(os.Stderr, err)
        return
    }
}

このコードでは圧縮データの書き込む先をファイルにしている。もちろん書き込み先を bytes.Buffer に置き換えることもできる。このようにインスタンスの生存期間を意識することで Go 言語の得意なパターンに嵌めることが容易になる。

ついでに対となる読み込み処理のコードも示しておこう。ここでは復元したデータを標準出力に直接出力している。

package main

import (
    "compress/gzip"
    "fmt"
    "io"
    "os"
)

func readGzip(dst io.Writer, src io.Reader) error {
    zr, err := gzip.NewReader(src)
    if err != nil {
        return err
    }
    defer zr.Close()

    io.Copy(dst, zr)

    return nil
}

func main() {
    file, err := os.Open("test.txt.gz")
    if err != nil {
        fmt.Fprintln(os.Stderr, err)
        return
    }
    defer file.Close()

    if err := readGzip(os.Stdout, file); err != nil {
        fmt.Fprintln(os.Stderr, err)
        return
    }
}

ところで，ファイル操作では生のデータを直接 gzip 圧縮するシチュエーションは少なく，大抵は tar と組み合わせることになる。そこで tar と組み合わせ，指定フォルダ直下の複数ファイルを gzip 圧縮するコードも以下に示しておく。

package main

import (
    "archive/tar"
    "compress/gzip"
    "fmt"
    "io"
    "io/ioutil"
    "os"
    "path/filepath"
)

func makeTarGzip(dst io.Writer, rt string) error {
    zw, err := gzip.NewWriterLevel(dst, gzip.BestCompression)
    if err != nil {
        return err
    }
    defer zw.Close()

    tw := tar.NewWriter(zw)
    defer tw.Close()

    filepath.Walk(rt, func(path string, info os.FileInfo, err error) error {
        if info.IsDir() {
            return nil
        }
        fmt.Println(path)

        hd, e := tar.FileInfoHeader(info, "")
        if e != nil {
            return e
        }
        content, e := ioutil.ReadFile(path)
        if e != nil {
            return e
        }

        if e := tw.WriteHeader(hd); e != nil {
            return e
        }
        if _, e := tw.Write(content); e != nil {
            return e
        }
        return nil
    })
    if err != nil {
        return err
    }

    return nil
}

func main() {
    file, err := os.Create("test.tar.gz")
    if err != nil {
        fmt.Fprintln(os.Stderr, err)
        return
    }
    defer file.Close()

    if err := makeTarGzip(file, "./"); err != nil {
        fmt.Fprintln(os.Stderr, err)
        return
    }
}

【追記】別解あります

実は最初の makeGzip() には別解がある。要するに gzip 処理部分を関数スコープで囲ってしまえばいいのだ。実際にはこんな感じ。

func makeGzip(body []byte) ([]byte, error) {
    var b bytes.Buffer
    err := func() error {
        gw := gzip.NewWriter(&b)
        defer gw.Close()

        if _, err := gw.Write(body); err != nil {
            return err
        }
        return nil
    }()
    return b.Bytes(), err
}

完全なコードはこんな感じになる。

package main

import (
    "bytes"
    "compress/gzip"
    "fmt"
    "os"
)

func makeGzip(body []byte) ([]byte, error) {
    var b bytes.Buffer
    err := func() error {
        gw := gzip.NewWriter(&b)
        defer gw.Close()

        if _, err := gw.Write(body); err != nil {
            return err
        }
        return nil
    }()
    return b.Bytes(), err
}

func main() {
    content := []byte("Hello world\n")

    file, err := os.Create("test.txt.gz")
    if err != nil {
        fmt.Fprintln(os.Stderr, err)
        return
    }
    defer file.Close()

    z, err := makeGzip(content)
    if err != nil {
        fmt.Fprintln(os.Stderr, err)
        return
    }

    if _, err := file.Write(z); err != nil {
        fmt.Fprintln(os.Stderr, err)
        return
    }
}

このように（defer を含む）一連の処理を関数スコープで囲うやり方は，条件分岐や繰り返し処理の中で役に立つこともあるだろう。

ブックマーク

参考図書

プログラミング言語Go (ADDISON-WESLEY PROFESSIONAL COMPUTING SERIES): Alan A.A. Donovan (著), Brian W. Kernighan (著), 柴田芳樹 (翻訳); 丸善出版 2016-06-20; 単行本（ソフトカバー）; 4621300253 (ASIN), 9784621300251 (EAN), 4621300253 (ISBN); 評価

reviewed by Spiegel on 2016-07-13 (powered by PA-APIv5)

この挙動から分かるとおり， bytes.Buffer.Bytes() 関数は，バッファの内容をそのまま返しているのではなく，内容のコピーを返している。 ↩︎