List of Random [text.Baldanders.info]

PuTTY 0.81 がリリースされた【セキュリティ・アップデート】

2024-04-16T11:42:46+00:00

Windows 用の SSH クライアントソフトである PuTTY について ECDSA 署名に絡んで秘密鍵が漏洩するリスクがあるらしい。

PuTTY vulnerability vuln-p521-bias

Every version of the PuTTY tools from 0.68 to 0.80 inclusive has a critical vulnerability in the code that generates signatures from ECDSA private keys which use the NIST P521 curve. (PuTTY, or Pageant, generates a signature from a key when using it to authenticate you to an SSH server.)

via PuTTY vulnerability vuln-p521-bias

上の引用の通り，対象となるのは PuTTY 0,68 から 0.80 までのバージョン。最新の 0.81 で修正されている。なお FileZilla, WinSCP, TortoiseGit, TortoiseSVN といったアプリケーションには PuTTY がバンドルされていることがあるので，これらのアップデート情報にも注意すること。 PuTTY は年に1,2回くらいの頻度でセキュリティ・アップデートが発生するので（ちゃんとメンテされてる証拠），バンドル品は使わないほうがいいと思うなぁ。

日本語カスタム版は PuTTY-ranvis がおすすめ。こちらも 0.81 がリリースされた。

PuTTYrv (PuTTY-ranvis) - Ranvis software

厄介なことに今回はアプリケーションを更新しただけではダメで，認証鍵を新しいものに差し替える必要があるかも知れない。ただし対象となるのは NIST P-521 楕円曲線を使った ECDSA 鍵のみ。それ以外はとりあえずセーフということで（笑）

今回の脆弱性は ECDSA 署名時に使用する nonce を生成するための乱数生成に起因するものらしい。以前から DSA/ECDSA の実装上のネックとなっているのがこの乱数生成部分で，ここの実装をサボると秘密鍵の漏洩に繋がることが知られている。まぁ，今回はサボったわけではないだろうが，何らかの不備があったということだろう。

というわけで，新たに認証鍵を作成するのなら EdDSA (ed25519 曲線) 鍵にすることをお勧めする。 EdDSA は2023年にリリースされた NIST FIPS 186-5 に標準として正式に組み込まれたので，仕事用でも大手を振って使ってよい。

CVE-2024-31497

In PuTTY 0.68 through 0.80 before 0.81, biased ECDSA nonce generation allows an attacker to recover a user’s NIST P-521 secret key via a quick attack in approximately 60 signatures. This is especially important in a scenario where an adversary is able to read messages signed by PuTTY or Pageant. The required set of signed messages may be publicly readable because they are stored in a public Git service that supports use of SSH for commit signing, and the signatures were made by Pageant through an agent-forwarding mechanism. In other words, an adversary may already have enough signature information to compromise a victim’s private key, even if there is no further use of vulnerable PuTTY versions. After a key compromise, an adversary may be able to conduct supply-chain attacks on software maintained in Git. A second, independent scenario is that the adversary is an operator of an SSH server to which the victim authenticates (for remote login or file copy), even though this server is not fully trusted by the victim, and the victim uses the same private key for SSH connections to other services operated by other entities. Here, the rogue server operator (who would otherwise have no way to determine the victim’s private key) can derive the victim’s private key, and then use it for unauthorized access to those other services. If the other services include Git services, then again it may be possible to conduct supply-chain attacks on software maintained in Git. This also affects, for example, FileZilla before 3.67.0, WinSCP before 6.3.3, TortoiseGit before 2.15.0.1, and TortoiseSVN through 1.14.6.

via CVE-2024-31497

以下未稿。

ブックマーク

参考

SSH Mastery: OpenSSH, PuTTY, Tunnels and Keys (IT Mastery Book 12) (English Edition): Lucas, Michael W (著); Tilted Windmill Press 2018-02-06 (Release 2018-02-06); Kindle版; B079NL1L9K (ASIN); 評価

タイトルを見て “SSH Mystery” と空目したアホは私です。洋書だけど英語不得手の私にも読める内容。

reviewed by Spiegel on 2021-01-11 (powered by PA-APIv5)

暗号技術入門第3版　秘密の国のアリス: 結城浩 (著); SBクリエイティブ 2015-08-25 (Release 2015-09-17); Kindle版; B015643CPE (ASIN); 評価

SHA-3 や Bitcoin/Blockchain など新しい知見や技術要素を大幅追加。暗号技術を使うだけならこれ1冊でとりあえず無問題。

reviewed by Spiegel on 2015-09-20 (powered by PA-APIv5)

暗号化プライバシーを救った反乱者たち: スティーブン・レビー (著), 斉藤隆央 (翻訳); 紀伊國屋書店 2002-02-16; 単行本; 4314009071 (ASIN), 9784314009072 (EAN), 4314009071 (ISBN); 評価

20世紀末，暗号技術の世界で何があったのか。知りたかったらこちらを読むべし！

reviewed by Spiegel on 2015-03-09 (powered by PA-APIv5)

github.com/goark/mt/v2 をリリースした

2024-03-09T11:45:42+00:00

Go 1.22 で math/rand/v2 パッケージが登場したため， Mersenne Twister 疑似乱数生成器を実装した拙作の github.com/goark/mt パッケージも math/rand/v2 に対応することにした。

まずはバージョンを v2 に上げて，以下のインポート・パスに変更した。

import "github.com/goark/mt/v2"

また go.mod も同様に

require github.com/goark/mt/v2 v2.0.1

とする。

例として github.com/goark/mt/v2 パッケージと math/rand/v2 パッケージを組み合わせて標準正規分布する値を1万個生成してみる。こんな感じ。

package main

import (
    "fmt"
    "math"
    "math/rand/v2"

    "github.com/goark/mt/v2/mt19937"
)

func main() {
    rnd := rand.New(mt19937.New(rand.Int64()))
    points := []float64{}
    max := 0.0
    min := 1.0
    sum := 0.0
    for range 10000 {
        point := rnd.NormFloat64()
        points = append(points, point)
        min = math.Min(min, point)
        max = math.Max(max, point)
        sum += point
    }
    n := float64(len(points))
    ave := sum / n
    d2 := 0.0
    for _, p := range points {
        d2 += (p - ave) * (p - ave)
    }
    fmt.Println("           minimum: ", min)
    fmt.Println("           maximum: ", max)
    fmt.Println("           average: ", ave)
    fmt.Println("standard deviation: ", math.Sqrt(d2/n))
}

これを実行するとこんな感じになる。

$ go run sample.go
           minimum:  -4.465497509270884
           maximum:  4.409945906326592
           average:  0.010399867661332784
standard deviation:  1.0027323703801945

まぁまぁ妥当な感じ？

math/rand および math/rand/v2 パッケージのトップレベル関数群の疑似乱数生成器が ChaCha8 になったおかげで seed を与えるのがめっちゃ楽になった。これだけでもありがたい。ともかくこれで，乱数生成周りの調査と対応は一通り完了かな。

ブックマーク

参考図書

プログラミング言語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言語 100Tips ありがちなミスを把握し、実装を最適化する impress top gearシリーズ: Teiva Harsanyi (著), 柴田芳樹 (著); インプレス 2023-08-18 (Release 2023-08-18); Kindle版; B0CFL1DK8Q (ASIN); 評価

版元で PDF 版を購入可能。事実上の Effective Go とも言える充実の内容。オリジナルは敢えてタイトルに “tips” という単語を入れるのを避けたのに邦題が「100 Tips」とかなっていて，原作者がお怒りとの噂（あくまで噂）

reviewed by Spiegel on 2023-08-18 (powered by PA-APIv5)

効率的なGo ―データ指向によるGoアプリケーションの性能最適化: Bartłomiej Płotka (著), 山口能迪 (翻訳); オライリー・ジャパン 2024-02-24; 単行本（ソフトカバー）; 4814400535 (ASIN), 9784814400539 (EAN), 4814400535 (ISBN); 評価

版元で Ebook を買える。Go言語のリファレンス本ではない。フトウェア工学，プログラミング（の考え方）を学ぶ教科書的な位置づけかなぁ。

reviewed by Spiegel on 2024-04-21 (powered by PA-APIv5)

暗号技術入門第3版　秘密の国のアリス: 結城浩 (著); SBクリエイティブ 2015-08-25 (Release 2015-09-17); Kindle版; B015643CPE (ASIN); 評価

SHA-3 や Bitcoin/Blockchain など新しい知見や技術要素を大幅追加。暗号技術を使うだけならこれ1冊でとりあえず無問題。

reviewed by Spiegel on 2015-09-20 (powered by PA-APIv5)

数学ガール／乱択アルゴリズム: 結城浩 (著); SBクリエイティブ 2011-02-25 (Release 2014-03-12); Kindle版; B00I8AT1FO (ASIN); 評価

工学ガール，リサちゃん登場！

reviewed by Spiegel on 2015-04-19 (powered by PA-APIv5)

Go 1.22 における疑似乱数生成器

2024-03-07T13:20:40+00:00

Go 1.22 の math/rand パッケージと追加された math/rand/v2 パッケージを眺めている。

おそらく Go 1.22 における疑似乱数関連の最大のトピックは ChaCha8 がランタイムに組み込まれ，疑似乱数生成器の既定アルゴリズムになったことだろう。

The Salsa20 family of stream ciphers : これがベースになる論文かな
Salsa20 - Wikipedia
C2SP/chacha8rand.md at main · C2SP/C2SP · GitHub
つくって理解するストリーム暗号 ChaCha20 - ちりもつもればミルキーウェイ : Go でサンプルコードを書いておられる。ありがたや

ChaCha はストリーム暗号の一種で，簡単に言うと，疑似乱数を生成してそれを平文と XOR するというものらしい。このうちの疑似乱数を生成する部分を切り出しているようだ。ストリーム暗号に使うものなので，暗号技術的にセキュアでかつ速いというのが特徴になるだろうか。ちなみに ChaCha の後ろについている 20 とか 8 とかはラウンド数を示しているそうな。

ChaCha は OpenSSL だか OpenSSH だかでも見かけたような（うろ覚え）。もし結城浩さんが『暗号技術入門』の第4版を出される機会があれば，付録でいいので是非 ChaCha にも言及して欲しい。

ランタイムに ChaCha8 疑似乱数生成器を組み込む

ChaCha8 疑似乱数生成器のアルゴリズムは internal/chacha8rand パッケージに実装されている。中身については割愛させてもらう。 Internal パッケージなので，サードパーティのパッケージからは直接参照できない。

まずは runtime パッケージに組み込んでいる部分を見てみる。ちょっと長いけどご容赦。

// OS-specific startup can set startupRand if the OS passes
// random data to the process at startup time.
// For example Linux passes 16 bytes in the auxv vector.
var startupRand []byte

// globalRand holds the global random state.
// It is only used at startup and for creating new m's.
// Otherwise the per-m random state should be used
// by calling goodrand.
var globalRand struct {
    lock  mutex
    seed  [32]byte
    state chacha8rand.State
    init  bool
}

var readRandomFailed bool

// randinit initializes the global random state.
// It must be called before any use of grand.
func randinit() {
    lock(&globalRand.lock)
    if globalRand.init {
        fatal("randinit twice")
    }

    seed := &globalRand.seed
    if startupRand != nil {
        for i, c := range startupRand {
            seed[i%len(seed)] ^= c
        }
        clear(startupRand)
        startupRand = nil
    } else {
        if readRandom(seed[:]) != len(seed) {
            // readRandom should never fail, but if it does we'd rather
            // not make Go binaries completely unusable, so make up
            // some random data based on the current time.
            readRandomFailed = true
            readTimeRandom(seed[:])
        }
    }
    globalRand.state.Init(*seed)
    clear(seed[:])
    globalRand.init = true
    unlock(&globalRand.lock)
}

// readTimeRandom stretches any entropy in the current time
// into entropy the length of r and XORs it into r.
// This is a fallback for when readRandom does not read
// the full requested amount.
// Whatever entropy r already contained is preserved.
func readTimeRandom(r []byte) {
    // Inspired by wyrand.
    // An earlier version of this code used getg().m.procid as well,
    // but note that this is called so early in startup that procid
    // is not initialized yet.
    v := uint64(nanotime())
    for len(r) > 0 {
        v ^= 0xa0761d6478bd642f
        v *= 0xe7037ed1a0b428db
        size := 8
        if len(r) < 8 {
            size = len(r)
        }
        for i := 0; i < size; i++ {
            r[i] ^= byte(v >> (8 * i))
        }
        r = r[size:]
        v = v>>32 | v<<32
    }
}

via runtime/rand.go

これは疑似乱数生成器の状態（主に seed）を管理してる部分かな。最初の seed は乱数デバイスから取ってるんだね。これに失敗すると時刻から生成する，と。ユーザ側は明示的に seed を指定する必要がなくなるということやね。

// readTimeRandom stretches any entropy in the current time
// into entropy the length of r and XORs it into r.
// This is a fallback for when readRandom does not read
// the full requested amount.
// Whatever entropy r already contained is preserved.
func readTimeRandom(r []byte) {
    // Inspired by wyrand.
    // An earlier version of this code used getg().m.procid as well,
    // but note that this is called so early in startup that procid
    // is not initialized yet.
    v := uint64(nanotime())
    for len(r) > 0 {
        v ^= 0xa0761d6478bd642f
        v *= 0xe7037ed1a0b428db
        size := 8
        if len(r) < 8 {
            size = len(r)
        }
        for i := 0; i < size; i++ {
            r[i] ^= byte(v >> (8 * i))
        }
        r = r[size:]
        v = v>>32 | v<<32
    }
}

// bootstrapRand returns a random uint64 from the global random generator.
func bootstrapRand() uint64 {
    lock(&globalRand.lock)
    if !globalRand.init {
        fatal("randinit missed")
    }
    for {
        if x, ok := globalRand.state.Next(); ok {
            unlock(&globalRand.lock)
            return x
        }
        globalRand.state.Refill()
    }
}

// bootstrapRandReseed reseeds the bootstrap random number generator,
// clearing from memory any trace of previously returned random numbers.
func bootstrapRandReseed() {
    lock(&globalRand.lock)
    if !globalRand.init {
        fatal("randinit missed")
    }
    globalRand.state.Reseed()
    unlock(&globalRand.lock)
}

// rand32 is uint32(rand()), called from compiler-generated code.
//go:nosplit
func rand32() uint32 {
    return uint32(rand())
}

// rand returns a random uint64 from the per-m chacha8 state.
// Do not change signature: used via linkname from other packages.
//go:nosplit
//go:linkname rand
func rand() uint64 {
    // Note: We avoid acquirem here so that in the fast path
    // there is just a getg, an inlined c.Next, and a return.
    // The performance difference on a 16-core AMD is
    // 3.7ns/call this way versus 4.3ns/call with acquirem (+16%).
    mp := getg().m
    c := &mp.chacha8
    for {
        // Note: c.Next is marked nosplit,
        // so we don't need to use mp.locks
        // on the fast path, which is that the
        // first attempt succeeds.
        x, ok := c.Next()
        if ok {
            return x
        }
        mp.locks++ // hold m even though c.Refill may do stack split checks
        c.Refill()
        mp.locks--
    }
}

// mrandinit initializes the random state of an m.
func mrandinit(mp *m) {
    var seed [4]uint64
    for i := range seed {
        seed[i] = bootstrapRand()
    }
    bootstrapRandReseed() // erase key we just extracted
    mp.chacha8.Init64(seed)
    mp.cheaprand = rand()
}

via runtime/rand.go

mrandinit() 関数でランタイムを初期化して，それを使って実際に乱数を取得してるのが rand() 関数だね。ふむふむ。

math/rand パッケージのトップレベル関数群にランタイムの ChaCha8 を組み込む

それじゃあ math/rand パッケージの方を見てみよう。

//go:linkname runtime_rand runtime.rand
func runtime_rand() uint64

via math/rand/rand.go

go:linkname ディレクティブの説明は割愛する。こうやってリンクしてるということで飲み込んでいただければ（笑）そうそう。 go:linkname ディレクティブは unsafe パッケージを要求するので，真似するときは要注意だよ。

ともかく，この runtime_rand() 関数を使って rand.Source インタフェース互換の構造体 runtimeSource を定義している。

// runtimeSource is an implementation of Source64 that uses the runtime
// fastrand functions.
type runtimeSource struct {
    // The mutex is used to avoid race conditions in Read.
    mu sync.Mutex
}

func (*runtimeSource) Int63() int64 {
    return int64(runtime_rand() & rngMask)
}

func (*runtimeSource) Seed(int64) {
    panic("internal error: call to runtimeSource.Seed")
}

func (*runtimeSource) Uint64() uint64 {
    return runtime_rand()
}

via math/rand/rand.go

Seed() メソッドを呼び出したら panic 吐くとか容赦ないな（笑） runtimeSource はこんな風に使う。

// globalRandGenerator is the source of random numbers for the top-level
// convenience functions. When possible it uses the runtime fastrand64
// function to avoid locking. This is not possible if the user called Seed,
// either explicitly or implicitly via GODEBUG=randautoseed=0.
var globalRandGenerator atomic.Pointer[Rand]

var randautoseed = godebug.New("randautoseed")

// globalRand returns the generator to use for the top-level convenience
// functions.
func globalRand() *Rand {
    if r := globalRandGenerator.Load(); r != nil {
        return r
    }

    // This is the first call. Initialize based on GODEBUG.
    var r *Rand
    if randautoseed.Value() == "0" {
        randautoseed.IncNonDefault()
        r = New(new(lockedSource))
        r.Seed(1)
    } else {
        r = &Rand{
            src: &runtimeSource{},
            s64: &runtimeSource{},
        }
    }

    if !globalRandGenerator.CompareAndSwap(nil, r) {
        // Two different goroutines called some top-level
        // function at the same time. While the results in
        // that case are unpredictable, if we just use r here,
        // and we are using a seed, we will most likely return
        // the same value for both calls. That doesn't seem ideal.
        // Just use the first one to get in.
        return globalRandGenerator.Load()
    }

    return r
}

via math/rand/rand.go

// Seed uses the provided seed value to initialize the default Source to a
// deterministic state. Seed values that have the same remainder when
// divided by 2³¹-1 generate the same pseudo-random sequence.
// Seed, unlike the [Rand.Seed] method, is safe for concurrent use.
//
// If Seed is not called, the generator is seeded randomly at program startup.
//
// Prior to Go 1.20, the generator was seeded like Seed(1) at program startup.
// To force the old behavior, call Seed(1) at program startup.
// Alternately, set GODEBUG=randautoseed=0 in the environment
// before making any calls to functions in this package.
//
// Deprecated: As of Go 1.20 there is no reason to call Seed with
// a random value. Programs that call Seed with a known value to get
// a specific sequence of results should use New(NewSource(seed)) to
// obtain a local random generator.
func Seed(seed int64) {
    orig := globalRandGenerator.Load()

    // If we are already using a lockedSource, we can just re-seed it.
    if orig != nil {
        if _, ok := orig.src.(*lockedSource); ok {
            orig.Seed(seed)
            return
        }
    }

    // Otherwise either
    // 1) orig == nil, which is the normal case when Seed is the first
    // top-level function to be called, or
    // 2) orig is already a runtimeSource, in which case we need to change
    // to a lockedSource.
    // Either way we do the same thing.

    r := New(new(lockedSource))
    r.Seed(seed)

    if !globalRandGenerator.CompareAndSwap(orig, r) {
        // Something changed underfoot. Retry to be safe.
        Seed(seed)
    }
}

via math/rand/rand.go

つまり，環境変数 GODEBUG で明示的に指定（randautoseed=0）するか最初に rand.Seed() 関数を呼び出すかしない限りランタイムに組み込んだ ChaCha8 疑似乱数生成器が有効になるっちうわけだ。ちなみに lockedSource は math/rand パッケージに従来からある疑似乱数生成器で，名前の通り，ちゃんと mutex で排他処理している。

math/rand/v2 パッケージにおける Source インタフェースの定義

では，いよいよ Go 1.22 で追加された math/rand/v2 パッケージを見てみよう。

math/rand パッケージと math/rand/v2 パッケージとの大きな違いは rand.Source インタフェースが非互換になっていることだろう。

math/rand パッケージの Source インタフェースの定義は以下の通り。

// A Source represents a source of uniformly-distributed
// pseudo-random int64 values in the range [0, 1<<63).
//
// A Source is not safe for concurrent use by multiple goroutines.
type Source interface {
    Int63() int64
    Seed(seed int64)
}

// A Source64 is a [Source] that can also generate
// uniformly-distributed pseudo-random uint64 values in
// the range [0, 1<<64) directly.
// If a [Rand] r's underlying [Source] s implements Source64,
// then r.Uint64 returns the result of one call to s.Uint64
// instead of making two calls to s.Int63.
type Source64 interface {
    Source
    Uint64() uint64
}

via math/rand/rand.go

これに対して math/rand/v2 ではこう定義されている。

// A Source is a source of uniformly-distributed
// pseudo-random uint64 values in the range [0, 1<<64).
//
// A Source is not safe for concurrent use by multiple goroutines.
type Source interface {
    Uint64() uint64
}

via math/rand/v2/rand.go

どえらシンプル！ Seed() メソッドがなくなったのは大きいね。これによって runtimeSource やトップレベル関数群が参照する globalRand の定義もめっさシンプルになった。

// globalRand is the source of random numbers for the top-level
// convenience functions.
var globalRand = &Rand{src: &runtimeSource{}}

//go:linkname runtime_rand runtime.rand
func runtime_rand() uint64

// runtimeSource is a Source that uses the runtime fastrand functions.
type runtimeSource struct{}

func (*runtimeSource) Uint64() uint64 {
    return runtime_rand()
}

via math/rand/v2/rand.go

うんうん。シンプルが一番だね。

ChaCha8 を rand.Source にする

ChaCha8 疑似乱数生成器を疑似乱数の Source として明示的に組み込む場合は， rand.NewChaCha8() 関数を使って生成する。

import "internal/chacha8rand"

// A ChaCha8 is a ChaCha8-based cryptographically strong
// random number generator.
type ChaCha8 struct {
    state chacha8rand.State
}

// NewChaCha8 returns a new ChaCha8 seeded with the given seed.
func NewChaCha8(seed [32]byte) *ChaCha8 {
    c := new(ChaCha8)
    c.state.Init(seed)
    return c
}

// Seed resets the ChaCha8 to behave the same way as NewChaCha8(seed).
func (c *ChaCha8) Seed(seed [32]byte) {
    c.state.Init(seed)
}

// Uint64 returns a uniformly distributed random uint64 value.
func (c *ChaCha8) Uint64() uint64 {
    for {
        x, ok := c.state.Next()
        if ok {
            return x
        }
        c.state.Refill()
    }
}

via math/rand/v2/chacha8.go

ランタイムに組み込まれているものと違って，こちらは排他処理を行っていない。並行的に安全（concurrency safe）ではないわけだ。なので平行処理下で math/rand/v2 の ChaCha8 を扱う場合は要注意である。つか，平行処理下で ChaCha8 疑似乱数生成器を使うならトップレベル関数群を使うべきだろう。

PCG を rand.Source にする

math/rand/v2 にはもうひとつ疑似乱数生成器が用意されている。 PCG (Permuted Congruential Generator) というそうな。

// A PCG is a PCG generator with 128 bits of internal state.
// A zero PCG is equivalent to NewPCG(0, 0).
type PCG struct {
    hi uint64
    lo uint64
}

// NewPCG returns a new PCG seeded with the given values.
func NewPCG(seed1, seed2 uint64) *PCG {
    return &PCG{seed1, seed2}
}

via math/rand/v2/pcg.go

PCG は線形合同法（LCG）のバリエーションなんだそうで， LCG の統計学上の欠点を改善したものらしい。 2014年に発表された比較的新しいアルゴリズムのようだが，今のところは欠点のようなものは特に指摘されてないとか。当然ながら暗号技術分野では使えない。

こちらも並行的に安全ではないのでご注意を。

これから math/rand を使う理由はないかな

今までは math/rand で用意されている疑似乱数生成器は暗号技術的にセキュアではない（要件である「予測困難性」を満たさない）ため使いどころを考えなければならなかったが Go 1.22 から math/rand, math/rand/v2 ともに ChaCha8 が既定の疑似乱数生成器なったため用途を選ばずカジュアルに使えるようになるだろう。そうなると，これから疑似乱数生成器を使おうというとききに，わざわざ math/rand を使う理由はないかな。 math/rand って無駄に複雑になってる感じだもんなぁ。

ちなみに math/rand/v2 では Read() 関数もなくなっているが， math/rand でも rand.Read() 関数は Deprecated になってるし，リリースノートを見ると， Read() 関数が使いたきゃ crypto/rand パッケージを使え，みたいなことが書いてあるので，まぁそういうことなんだろう。

ブックマーク

参考図書

プログラミング言語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)

Go言語 100Tips ありがちなミスを把握し、実装を最適化する impress top gearシリーズ: Teiva Harsanyi (著), 柴田芳樹 (著); インプレス 2023-08-18 (Release 2023-08-18); Kindle版; B0CFL1DK8Q (ASIN); 評価

reviewed by Spiegel on 2023-08-18 (powered by PA-APIv5)

Go言語による並行処理: Katherine Cox-Buday (著), 山口能迪 (翻訳); オライリージャパン 2018-10-26; 単行本（ソフトカバー）; 4873118468 (ASIN), 9784873118468 (EAN), 4873118468 (ISBN); 評価

Eブック版もある。感想はこちら。 Go 言語で並行処理を書くならこの本は必読書になるだろう。

reviewed by Spiegel on 2020-01-13 (powered by PA-APIv5)

効率的なGo ―データ指向によるGoアプリケーションの性能最適化: Bartłomiej Płotka (著), 山口能迪 (翻訳); オライリー・ジャパン 2024-02-24; 単行本（ソフトカバー）; 4814400535 (ASIN), 9784814400539 (EAN), 4814400535 (ISBN); 評価

版元で Ebook を買える。Go言語のリファレンス本ではない。フトウェア工学，プログラミング（の考え方）を学ぶ教科書的な位置づけかなぁ。

reviewed by Spiegel on 2024-04-21 (powered by PA-APIv5)

暗号技術入門第3版　秘密の国のアリス: 結城浩 (著); SBクリエイティブ 2015-08-25 (Release 2015-09-17); Kindle版; B015643CPE (ASIN); 評価

SHA-3 や Bitcoin/Blockchain など新しい知見や技術要素を大幅追加。暗号技術を使うだけならこれ1冊でとりあえず無問題。

reviewed by Spiegel on 2015-09-20 (powered by PA-APIv5)

赤ずきんチャチャ 1 (りぼんマスコットコミックスDIGITAL): 彩花みん (著); 集英社 1993-02-15 (Release 2014-02-25); Kindle版; B00I8ETG96 (ASIN)

そういえばコミックは読んでないかな。「リボン」は読まなかったからなぁ...

reviewed by Spiegel on 2024-03-07 (powered by PA-APIv5)

ランダムな文字列を生成する

2020-10-16T05:24:30+00:00

疑似乱数に関して面白い記事を見つけたので紹介しつつ，こちらでも試してみる。

お題はこんな感じ：

英数字62文字（a-zA-Z0-9）からランダムに1文字ずつとって指定の長さの文字列を作成する
同じ文字を何度使ってもよい

また，この記事における前提として，以下の interface 型および定数が定義済みであるとする。

package randstr

type Random interface {
    String(int) string
}

const (
    letterBytes    = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
    letterBytesLen = len(letterBytes)
    letterIdxBits  = 6                    // 6 bits to represent a letter index
    letterIdxMask  = 1<<letterIdxBits - 1 // All 1-bits, as many as letterIdxBits
    letterIdxMax   = 63 / letterIdxBits   // # of letter indices fitting in 63 bits
)

じゃあ，いってみようか

math/rand パッケージによる実装

まずは math/rand パッケージを使った実装から。これについては以下のページの議論が参考になる。

How to generate a random string of a fixed length in Go? - Stack Overflow

これを参照しつつ，過程をすっ飛ばして最終的に以下のコードにしてみた。

package randstr

import (
    "math/rand"
    "unsafe"
)

type MathRandom struct {
    src rand.Source
}

func NewMathRandom(seed int64) Random {
    return &MathRandom{src: rand.NewSource(seed)}
}

func (mr *MathRandom) String(len int) string {
    b := make([]byte, len)
    for i, cache, rest := 0, mr.src.Int63(), letterIdxMax; i < len; rest-- {
        if rest <= 0 {
            cache, rest = mr.src.Int63(), letterIdxMax
        }
        if idx := int(cache & letterIdxMask); idx < letterBytesLen {
            b[i] = letterBytes[idx]
            i++
        }
        cache >>= letterIdxBits
    }
    return *(*string)(unsafe.Pointer(&b))
}

Int63() メソッドで63ビット分の乱数を取って6ビットずつ切り出して使うイメージ。ただし参照する letterBytes が62文字分なのに対し6ビット整数では 0-63 まであるので，値がはみ出る場合は取得した6ビット乱数を捨てている。 letterBytes に適当な記号を2文字足してやればロスは無くなるだろうが，お題から外れるので今回は割愛する。

最後の

return *(*string)(unsafe.Pointer(&b))

は少々トリッキーだが []byte インスタンスをコピーなしに string 型にキャストするための「お呪い (おまじない) 」だと思えばいい¹。

文字通り unsafe な操作なので，乱用して「呪い (のろい) 」にならないようご注意を（笑）

crypto/rand パッケージによる実装

次は crypto/rand パッケージを使った実装。

crypto/rand パッケージでは乱数の生成に専用デバイスを使う。

On Linux and FreeBSD, Reader uses getrandom(2) if available, /dev/urandom otherwise. On OpenBSD, Reader uses getentropy(2). On other Unix-like systems, Reader reads from /dev/urandom. On Windows systems, Reader uses the CryptGenRandom API. On Wasm, Reader uses the Web Crypto API.

via rand - The Go Programming Language

そのため math/rand と比べてどうしても処理速度が遅くなる。したがって rand.Read() 関数の呼び出し回数を抑えるよう実装するのがコツである。

最初に挙げた記事を参考にしつつ，こんな感じでどうだろう。

package randstr

import (
    "crypto/rand"
    "unsafe"
)

type CryptoRandom struct{}

func NewCryptoRandom() Random {
    return &CryptoRandom{}
}

func (cr *CryptoRandom) String(len int) string {
    b := make([]byte, len)
    for i, offset, size, rest := 0, 0, 0, 0; i < len; rest-- {
        //fmt.Println(i, offset, size, rest)
        if rest <= 0 {
            offset = i
            var err error
            size, err = rand.Read(b[offset:])
            if err != nil || size <= 0 {
                return ""
            }
            rest = size
        }
        if idx := int(b[offset+(size-rest)] & letterIdxMask); idx < letterBytesLen {
            b[i] = letterBytes[idx]
            i++
        }
    }
    return *(*string)(unsafe.Pointer(&b))
}

インタフェースを合わせるためにエラーハンドリングをサボっているが，ご容赦を。

rand.Read() 関数で乱数をいったんバッファに展開し，その後文字に置き換えていく。ただし letterBytes からはみ出る場合はその値を捨てて，捨てた分をまとめて rand.Read() 関数で再取得する，という動作を繰り返している。

ベンチマークをとってみる

んじゃあ，これらのコードを使ってベンチマークをとってみよう。こんなテスト・コードでどうだろう。

package randstr_test

import (
    "randstr"
    "testing"
    "time"
)

const (
    len64   = 64
    len128  = 128
    max512  = len64 * 8
    max1024 = len128 * 8
)

func BenchmarkRandomStringMath64t8(b *testing.B) {
    r := randstr.NewMathRandom(time.Now().UnixNano())
    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        for n := 0; n < max512/len64; n++ {
            _ = r.String(len64)
        }
    }
}

func BenchmarkRandomStringMath512(b *testing.B) {
    r := randstr.NewMathRandom(time.Now().UnixNano())
    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        _ = r.String(max512)
    }
}

func BenchmarkRandomStringMath128t8(b *testing.B) {
    r := randstr.NewMathRandom(time.Now().UnixNano())
    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        for n := 0; n < max1024/len128; n++ {
            _ = r.String(len128)
        }
    }
}

func BenchmarkRandomStringMath1024(b *testing.B) {
    r := randstr.NewMathRandom(time.Now().UnixNano())
    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        _ = r.String(max1024)
    }
}

func BenchmarkRandomStringCrypto64t8(b *testing.B) {
    r := randstr.NewCryptoRandom()
    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        for n := 0; n < max512/len64; n++ {
            _ = r.String(len64)
        }
    }
}

func BenchmarkRandomStringCrypto512(b *testing.B) {
    r := randstr.NewCryptoRandom()
    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        _ = r.String(max512)
    }
}

func BenchmarkRandomStringCrypto128t8(b *testing.B) {
    r := randstr.NewCryptoRandom()
    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        for n := 0; n < max1024/len128; n++ {
            _ = r.String(len128)
        }
    }
}

func BenchmarkRandomStringCrypto1024(b *testing.B) {
    r := randstr.NewCryptoRandom()
    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        _ = r.String(max1024)
    }
}

処理内容を表にするとこんな感じ。

テスト名	使用パッケージ	処理内容
`BenchmarkRandomStringMath64t8`	`math/rand`	64バイト文字列生成×8
`BenchmarkRandomStringMath512`	`math/rand`	512バイト文字列生成
`BenchmarkRandomStringMath128t8`	`math/rand`	128バイト文字列生成×8
`BenchmarkRandomStringMath1024`	`math/rand`	1,024バイト文字列生成
`BenchmarkRandomStringCrypto64t8`	`crypto/rand`	64バイト文字列生成×8
`BenchmarkRandomStringCrypto512`	`crypto/rand`	512バイト文字列生成
`BenchmarkRandomStringCrypto128t8`	`crypto/rand`	128バイト文字列生成×8
`BenchmarkRandomStringCrypto1024`	`crypto/rand`	1,024バイト文字列生成

では実際に動かしてみよう。

$ go test -bench RandomString -benchmem
goos: linux
goarch: amd64
pkg: randstr
BenchmarkRandomStringMath64t8-4            641556          1616 ns/op         512 B/op           8 allocs/op
BenchmarkRandomStringMath512-4             899421          1386 ns/op         512 B/op           1 allocs/op
BenchmarkRandomStringMath128t8-4           357760          3093 ns/op        1024 B/op           8 allocs/op
BenchmarkRandomStringMath1024-4            407550          2820 ns/op        1024 B/op           1 allocs/op
BenchmarkRandomStringCrypto64t8-4           81285         14320 ns/op         512 B/op           8 allocs/op
BenchmarkRandomStringCrypto512-4           241180          4827 ns/op         512 B/op           1 allocs/op
BenchmarkRandomStringCrypto128t8-4          64815         18358 ns/op        1024 B/op           8 allocs/op
BenchmarkRandomStringCrypto1024-4          149160          8212 ns/op        1024 B/op           1 allocs/op
PASS
ok      randstr    10.851s

これも表にまとめてみる。処理回数でソートしているのでご注意を。

使用パッケージ	処理内容	ns/op	Alloc Size	Alloc Count	Ratio
`math/rand`	64バイト文字列生成×8	1,616	512	8	1.0
`math/rand`	128バイト文字列生成×8	3,093	1024	8	1.9
`crypto/rand`	64バイト文字列生成×8	14,329	512	8	8.9
`crypto/rand`	128バイト文字列生成×8	18,358	1024	8	11.3

`math/rand`	512バイト文字列生成	1,386	512	1	1.0
`math/rand`	1,024バイト文字列生成	2,820	1024	1	2.0
`crypto/rand`	512バイト文字列生成	4,827	512	1	3.5
`crypto/rand`	1,024バイト文字列生成	8,212	1024	1	5.9

math/rand パッケージを使った実装は分かりやすい。文字列が長くなると処理時間が長くなり，アロケーション回数が多いと更に時間がかかる。

crypto/rand パッケージについては，やはりメソッドの呼び出し回数がボトルネックになっているようだ。文字列の長さやアロケーション回数の影響を大きく上回っている。

math/rand パッケージを使った実装でも Read() メソッドでまとめて乱数を取得したほうが速くなるんじゃね？って思うよね。私も思った。ので，実際に試してベンチマークもとったのだが， Int63() メソッドで63ビットずつ取るほうが速いのよ，これが。

まぁ，中身を見れば分かるが，math/rand パッケージの Read() メソッドは中で Int63() メソッドを呼び出して8ビットずつ切り分けているだけなので，そのオーバヘッド分だけ遅くなってしまうようだ。残念！

科学技術用の疑似乱数生成器と暗号技術用の乱数生成器

科学技術用の疑似乱数生成器と暗号技術用の乱数生成器では求められる要件が異なる。

科学技術用の疑似乱数生成器で最重要なのは「高次元均等分布」な乱数を生成できることで，その次に重要なのは高速に乱数が生成できることである。

一方，暗号技術用の乱数生成器で最重要なのは「予測困難性」である。

たとえば，科学技術用の疑似乱数生成器の多くは，アルゴリズムで乱数を生成するため，起点となる seed が決まれば生成される値が確定してしまう。これが科学技術用の疑似乱数生成器が暗号技術には向かないとされる理由だ。

しかし，現時点の技術で「予測困難」な乱数を作るためには何らかの方法で外乱要素（またはエントロピー源）を組み込む必要があるため²，どうしても乱数の生成速度が遅くなる。大量の乱数を必要とする科学技術計算には向かないわけだ。

というわけで math/rand と crypto/rand はトレードオフの関係にある。上手く使い分けて欲しい。

ブックマーク

参考図書

プログラミング言語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)

Goならわかるシステムプログラミング: 渋川よしき (著), ごっちん (イラスト); ラムダノート 2017-10-23; 単行本（ソフトカバー）; 4908686033 (ASIN), 9784908686030 (EAN), 4908686033 (ISBN); 評価

PDF 版あり。ファイルやソケットなどに代表される順次アクセスの汎化である io.Reader / io.Writer およびその派生・特化クラス，またプロセスやスレッドに関する解説が秀逸だと思う。さらに Docker コアの libcontainer についても解説がある。

reviewed by Spiegel on 2018-10-19 (powered by PA-APIv5)

改訂2版みんなのGo言語: 松木雅幸 (著), mattn (著), 藤原俊一郎 (著), 中島大一 (著), 上田拓也 (著), 牧大輔 (著), 鈴木健太 (著); 技術評論社 2019-08-01 (Release 2019-08-01); Kindle版; B07VPSXF6N (ASIN); 評価

改訂2版の目玉は7章の「データベースの扱い方」が追加されたことだろう。他の章では，大まかな構成は1版と同じだが細かい部分が変わっていて Go 1.12 への言及まであるのには驚いた。

reviewed by Spiegel on 2019-08-12 (powered by PA-APIv5)

*(*string)(unsafe.Pointer(&b)) なキャストは strings.Builder の String() メソッドで使われている手法の丸パクリだったりする（笑） ↩︎
/dev/urandom はハードウェア・デバイスから十分なエントロピー源が得られない場合は内部で疑似乱数生成器を使用する。このため一時は /dev/urandom の脆弱性が疑われたが，現時点では事実上は問題ないとされている。一方で，スマートデバイスのような場合はハードウェア・デバイスからのエントロピー源だけでは外部から推測され易いため，性能のよい疑似乱数生成器を組み合わせるほうが有効になる場合もあるようだ。 ↩︎

「今あなた以外に○○人が見ています」デモ

2019-10-21T13:58:57+00:00

ぶちウケた！

旅行予約サイトの「今あなた以外に○○人が見ています」はウソだったことが判明 - GIGAZINE

この記事によると

JavaScriptで以下のような部分を発見。完全に28から44までの数字がランダムに生成され、それが表示されているだけだったことが判明しました。つまり、One Travelの「○○人がこの搭乗券をチェックしています」という部分は全くのウソであり、ユーザーにフライトの予約を急がせるためのものだったというわけです。

旅行予約サイトの「今あなた以外に○○人が見ています」はウソだったことが判明より

なんだって。

ちうわけで，戯れにデモ・コードを書いてみた。こんな感じでどうだろう。

<div id='demo' class='box'></div>
<script>
  let rn = Math.floor( Math.random() * 17 ) + 28;
  let p = document.createElement('p');
  p.appendChild(document.createTextNode('今あなた以外に'+rn+'人が見ています'));
  p.setAttribute('class', 'center');
  document.getElementById('demo').appendChild(p);
</script>

実際に試してみよう。

「今あなた以外に○○人が見ています」デモ

おー。できたできた。

最小の労力で最大の効果。これ最初に考えた奴は天才だろ（笑）

JavaScriptリファレンス第6版: David Flanagan (著), 木下哲也 (翻訳); オライリージャパン 2012-08-10; 単行本（ソフトカバー）; 4873115531 (ASIN), 9784873115535 (EAN), 4873115531 (ISBN); 評価

最初に私が JavaScript を勉強したのって，これよりも更に古い版だったんだよなぁ。この版でも今となっては古すぎて使い物にならないけど（笑）

reviewed by Spiegel on 2019-10-21 (powered by PA-APIv5)

疑似乱数生成器 goark/mt

2019-09-22T08:37:19+00:00

Mersenne Twister とは松本眞・西村拓士両氏によって1996年に発表された擬似乱数生成アルゴリズムである。他の擬似乱数生成アルゴリズムと比べて以下の特徴があるそうだ。

従来の様々な生成法の欠点を考慮して設計されています

従来にない長周期, 高次元均等分布を持ちます（周期が $2^{19937}-1$ で、623次元超立方体の中に均等に分布することが証明されています）

生成速度がかなり速い

メモリ効率が良い

Mersenne Twister とは?より

特に2番目が重要で，モンテカルロ法などの科学技術計算に向いている。 Ruby などの一部のプログラミング言語では標準の疑似乱数生成器として組み込まれているらしい。

github.com/goark/mt/v2 パッケージは Mersenne Twister のオリジナルコード（C/C++）を pure Go で書き直したものである。

github.com/goark/mt/v2 パッケージの特徴は以下の通り。

math/rand/v2 パッケージ互換で rand.Rand のソースとして利用できる
並行的に安全（concurrency safe）な構成にできる（mt.PRNG 型を利用した場合）

github.com/goark/mt/v2/mt19937.Source の機能

github.com/goark/mt/v2/mt19937 パッケージは 64bit版 Mersenne Twister を元に pure Go で書き直したものである。

mt19937.Source はそのまま疑似乱数生成器として使える。たとえば以下のように記述する。

package main

import (
    "fmt"

    "github.com/goark/mt/v2"
    "github.com/goark/mt/v2/mt19937"
)

func main() {
    fmt.Println(mt.New(mt19937.New(19650218)).Uint64())
    //Output:
    //13735441942630277712
}

提供するメソッドは以下の通り。

メソッド	機能
`Source.Seed(int64)`	乱数のシードをセットする
`Source.SeedArray([]uint64)`	乱数のシード（配列）をセットする
`Source.Uint64() uint64`	乱数として範囲 $[0, 2^{64}-1]$ の整数値を生成する
`Source.Real(int) float64`	乱数として浮動小数点数値を生成する

Source.Real() 関数の引数による乱数の出力範囲は以下の通り。

引数	生成範囲
1	範囲 $[0, 1)$ の浮動小数点数値
2	範囲 $(0, 1)$ の浮動小数点数値
上記以外	範囲 $[0, 1]$ の浮動小数点数値

なお mt19937.Source は並行的に安全ではないので goroutine 間でインスタンスを共有できない。

math/rand/v2 パッケージと組み合わせる

mt19937.Source を math/rand/v2 パッケージの rand.Rand のソースとして利用するには以下のように記述すればよい。

package main

import (
    "fmt"
    "math/rand/v2"

    "github.com/goark/mt/v2/mt19937"
)

func main() {
    fmt.Println(rand.New(mt19937.New(19650218)).Uint64())
    //Output:
    //13735441942630277712
}

これで rand.Rand が提供するメソッドはすべて使える。ただし rand.Rand 自体も並行的に安全ではないので，取り扱いにはやはり注意が必要である。

mt.PRNG と組み合わせる

mt19937.Source 型を mt.PRNG 型と組み合わせることで並行的に安全な構成にできる。たとえばこんな感じに記述できる。

package main

import (
    "fmt"
    "math/rand/v2"
    "sync"
    "time"

    "github.com/goark/mt/v2"
    "github.com/goark/mt/v2/mt19937"
)

func main() {
    start := time.Now()
    wg := sync.WaitGroup{}
    prng := mt.New(mt19937.New(rand.Int64()))
    for i := 0; i < 1000; i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            for i := 0; i < 10000; i++ {
                prng.Uint64()
            }
        }()
    }
    wg.Wait()
    fmt.Println("Time:", time.Now().Sub(start))
}

mt.PRNG 型は github.com/goark/mt/v2/mt19937.Source のラッパーになっている。

import (
    "math/rand/v2"
    "sync"
)

// Source represents a source of uniformly-distributed
type Source interface {
    rand.Source
    SeedArray([]uint64)
    Real(int) float64
}

// PRNG is class of pseudo random number generator.
type PRNG struct {
    source Source
    mutex  *sync.Mutex
}

io.Reader 互換の疑似乱数生成器

mt.PRNG のインスタンスから mt.Reader 型のインスタンスを生成できる。こんな感じに記述できる。

package main

import (
    "encoding/binary"
    "fmt"
    "math/rand/v2"
    "sync"

    "github.com/goark/mt/v2"
    "github.com/goark/mt/v2/mt19937"
)

func main() {
    wg := sync.WaitGroup{}
    prng := mt.New(mt19937.New(rand.Int64()))
    for i := 0; i < 1000; i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            r := prng.NewReader()
            buf := [8]byte{}
            for i := 0; i < 10000; i++ {
                ct, err := r.Read(buf[:])
                if err != nil {
                    return
                }
                fmt.Println(binary.LittleEndian.Uint64(buf[:ct]))
            }
        }()
    }
    wg.Wait()
}

mt.Reader 型は io.Reader インタフェースと互換性がある。また mt.Reader インスタンスも並行的に安全なので goroutine 間で共有可能である。

ライセンスについて

github.com/goark/mt/v2 パッケージは MIT ライセンスで提供している。

オリジナルの Mersenne Twister コードは GPL または BSD ライセンスで提供されているが MIT ライセンスに書き換えてもいいらしい。

Mersenne Twisterの商業利用について

というわけで github.com/goark/mt/v2 パッケージは MIT ライセンスで提供することにした。ご利用はお気軽に。

参考図書

プログラミング言語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)

数学ガール／乱択アルゴリズム: 結城浩 (著); SBクリエイティブ 2011-02-25 (Release 2014-03-12); Kindle版; B00I8AT1FO (ASIN); 評価

工学ガール，リサちゃん登場！

reviewed by Spiegel on 2015-04-19 (powered by PA-APIv5)

疑似乱数生成器 spiegel-im-spiegel/mt をリリースした

2019-09-22T08:37:19+00:00

ついカッとなって書いた。反省はしていない。

spiegel-im-spiegel/mt: Mersenne Twister; Pseudo Random Number Generator, Implemented by Golang

Mersenne Twister の Go 言語実装はいくつかあるのだが，やっぱ他人が作る道具は使いにくいよね，というわけで自分で書いてしまった（笑） spiegel-im-spiegel/mt の特徴は以下の通り。

math/rand 互換で rand.Rand のソースとして利用できる
goroutine-safe な構成にできる（mt.PRNG 型を利用した場合）

使い方は以下を参照のこと。

疑似乱数生成器 spiegel-im-spiegel/mt

一応，ベンチマークテストもしてみた。

package main

import (
	"math/rand"
	"testing"
	"time"

	"github.com/spiegel-im-spiegel/mt"
	"github.com/spiegel-im-spiegel/mt/mt19937"
)

const count = 10000000

func BenchmarkRandomALFG(b *testing.B) {
	rnd := rand.NewSource(time.Now().UnixNano()).(rand.Source64)
	b.ResetTimer()
	for i := 0; i < count; i++ {
		rnd.Uint64()
	}
}

func BenchmarkRandomMT19917(b *testing.B) {
	rnd := mt19937.NewSource(time.Now().UnixNano())
	b.ResetTimer()
	for i := 0; i < count; i++ {
		rnd.Uint64()
	}
}

func BenchmarkRandomALFGRand(b *testing.B) {
	rnd := rand.New(rand.NewSource(time.Now().UnixNano()))
	b.ResetTimer()
	for i := 0; i < count; i++ {
		rnd.Uint64()
	}
}

func BenchmarkRandomMT19917Rand(b *testing.B) {
	rnd := rand.New(mt19937.NewSource(time.Now().UnixNano()))
	b.ResetTimer()
	for i := 0; i < count; i++ {
		rnd.Uint64()
	}
}

func BenchmarkRandomALFGLocked(b *testing.B) {
	b.ResetTimer()
	for i := 0; i < count; i++ {
		rand.Uint64()
	}
}

func BenchmarkRandomMT19917Locked(b *testing.B) {
	rnd := mt.New(mt19937.NewSource(time.Now().UnixNano()))
	b.ResetTimer()
	for i := 0; i < count; i++ {
		rnd.Uint64()
	}
}

テスト対象は以下の通り。

テスト名	対象
`BenchmarkRandomALFG`	math/rand 標準アルゴリズム¹
`BenchmarkRandomMT19917`	`mt/mt19937` パッケージ
`BenchmarkRandomALFGRand`	math/rand （`rand.Rand` ラッパ）
`BenchmarkRandomMT19917Rand`	`mt/mt19937` （`rand.Rand` ラッパ）
`BenchmarkRandomALFGLocked`	math/rand Sync バージョン
`BenchmarkRandomMT19917Locked`	`mt/mt19937` ＋ `mt.PRNG`

このベンチマークテストの実行結果は以下の通り。

$ go test -bench Random -benchmem
goos: linux
goarch: amd64
pkg: github.com/spiegel-im-spiegel/mt/benchmark
BenchmarkRandomALFG-4            	1000000000	         0.0492 ns/op	       0 B/op	       0 allocs/op
BenchmarkRandomMT19917-4         	1000000000	         0.0651 ns/op	       0 B/op	       0 allocs/op
BenchmarkRandomALFGRand-4        	1000000000	         0.0749 ns/op	       0 B/op	       0 allocs/op
BenchmarkRandomMT19917Rand-4     	1000000000	         0.0846 ns/op	       0 B/op	       0 allocs/op
BenchmarkRandomALFGLocked-4      	1000000000	         0.176 ns/op	       0 B/op	       0 allocs/op
BenchmarkRandomMT19917Locked-4   	1000000000	         0.192 ns/op	       0 B/op	       0 allocs/op
PASS
ok  	github.com/spiegel-im-spiegel/mt/benchmark	7.081s

というわけで math/rand のほうが若干速いかな。乱数としての性能は別の機会に。

参考図書

プログラミング言語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)

数学ガール／乱択アルゴリズム: 結城浩 (著); SBクリエイティブ 2011-02-25 (Release 2014-03-12); Kindle版; B00I8AT1FO (ASIN); 評価

工学ガール，リサちゃん登場！

reviewed by Spiegel on 2015-04-19 (powered by PA-APIv5)

math/rand パッケージに実装されている擬似乱数生成器はラグ付フィボナッチ法（Lagged Fibonacci Generator）のバリエーションらしい。 ↩︎

Go の疑似乱数生成器は並行的に安全ではないらしい（追記あり）

2019-09-17T14:27:18+00:00

面白い記事みっけ！

【Go】rand.Sourceを並列で使いまわすなんて何事だ - Qiita

折角なので便乗記事を書いてみる。

まぁ，内部状態を持つオブジェクトは，状態が変わらない（immutable）か操作が並行的に安全（concurrency safe）であることが仕様・設計として明確であるものでない限り，複数の goroutine 間でインスタンスを共有してはいけない，というのは基本中の基本である。

ましてや標準の math/rand パッケージは rand.Source インタフェースを満たすのであればユーザ側で任意のアルゴリズムを用意することもできるので，並行的に安全であることを期待するほうが間違っているとも言える。

まずは，件の記事で書かれているコードを挙げておこう。ただし動作に直接関係ないコードは極力省いている。

package main

import (
    "math/rand"
    "sync"
    "time"
)

var randSource = NewRandSource()

func NewRandSource() *rand.Rand {
    return rand.New(rand.NewSource(time.Now().UnixNano()))
}

func calcRand() {
    for i := 0; i < 10000; i++ {
        randSource.Intn(1000)
    }
}

func main() {
    wg := sync.WaitGroup{}
    for i := 0; i < 1000; i++ {
        wg.Add(1)
        go func() {
            calcRand()
            wg.Done()
        }()
    }
    wg.Wait()
}

ポイントは rand.Rand インスタンスを初期化時にひとつだけ生成し，複数の goroutine で使い回している点である。これを実行すると以下のように panic を吐く。

$ go run -trimpath sample.go
panic: runtime error: index out of range [-1]

goroutine 94 [running]:
math/rand.(*rngSource).Uint64(...)
    math/rand/rng.go:249
math/rand.(*rngSource).Int63(0xc000083500, 0x50321535775976c1)
    math/rand/rng.go:234 +0x93
math/rand.(*Rand).Int63(...)
    math/rand/rand.go:85
math/rand.(*Rand).Int31(...)
    math/rand/rand.go:99
math/rand.(*Rand).Int31n(0xc000088090, 0x3e8, 0x1fd)
    math/rand/rand.go:134 +0x5f
math/rand.(*Rand).Intn(0xc000088090, 0x3e8, 0x1fd)
    math/rand/rand.go:172 +0x45
main.calcRand()
    sample@/sample.go:17 +0x3f
main.main.func1(0xc000098000)
    sample@/sample.go:26 +0x22
created by main.main
    sample@/sample.go:25 +0x78
exit status 2

panic が発生する仕組みは件の記事に分かりやすく解説されているので参照のこと。

goroutine ごとにインスタンスを生成する

件の記事では解決方法が（具体的には）示されていないので，こちらでいくつか考えてみよう。

一番簡単なのは goroutine ごとに rand.Rand インスタンスを生成することだ。こんな感じに変えたらどうだろう。

func calcRand(rnd* rand.Rand) {
    for i := 0; i < 10000; i++ {
        rnd.Intn(1000)
    }
}

func main() {
    wg := sync.WaitGroup{}
    for i := 0; i < 1000; i++ {
        wg.Add(1)
        go func() {
            calcRand(NewRandSource())
            wg.Done()
        }()
    }
    wg.Wait()
}

これで必要十分に機能するし，少なくとも panic は起こらない。このやり方の欠点は（goroutine ごとに rand.Rand インスタンスが生成されるため）元のコードより（僅かだが）高コストになることと，疑似乱数生成器の性能がアルゴリズムだけでなく seed の選び方にも依存する，というあたりだろうか。

まぁ math/rand の標準アルゴリズム¹ であれば性能に関してはさしたる問題にはならないだろう。

Generator Pattern を使う

今回の例ではあまりオススメではないのだが，並行処理の Generator Pattern を使う手もある。

まず NewRandSource() 関数を以下の関数で置き換える。

func NewGenerator() <-chan int {
    rnd := rand.New(rand.NewSource(time.Now().UnixNano()))
    ch := make(chan int)
    go func() {
        defer close(ch)
        for {
            ch <- rnd.Intn(1000)
        }
    }()
    return ch
}

こうすれば rand.Rand インスタンスはひとつで済むし（seed もひとつ），持ち回すインスタンスは channel のみなので並行的に安全にできる。乱数の取り出し側はこう書き換えればよい。

func calcRand(gen <-chan int) {
    for i := 0; i < 10000; i++ {
        if _ , ok := <-gen; !ok {
            return
        }
    }
}

func main() {
    wg := sync.WaitGroup{}
    gen := NewGenerator()
    for i := 0; i < 1000; i++ {
        wg.Add(1)
        go func() {
            calcRand(gen)
            wg.Done()
        }()
    }
    wg.Wait()
}

このコードの欠点は「遅い」ことに尽きる。まぁ channel の読み書きで同期を取る必要があるから遅くなって当たり前だけど。

今回のようなケースではなく，例えば generator がハードウェア制御を伴うものだったり singleton を含む処理だったり channel の読み書きにかかるコストに対して他の処理が相対的に大きくなったり …などなど，状況によっては Generator Pattern のほうが有利になる場合もあるだろう。

Generator Pattern は平行処理のデザインパターンの中では比較的単純なものだが応用範囲が広い。 Go 言語の goroutine 自体は（OS スレッドなどと比べて）かなり安価で手軽に構成できるので，積極的に試してみるといいと思う。

おまけの追記

そうそう。上の NewGenerator() 関数で生成・駆動される goroutine は自力で終了できない。なので，以下のように

func NewGenerator(ctx context.Context) <-chan int {
    rnd := rand.New(rand.NewSource(time.Now().UnixNano()))
    ch := make(chan int)
    go func() {
        defer close(ch)
        for {
            select {
            case <-ctx.Done():
                return
            default:
                ch <- rnd.Intn(1000)
            }
        }
    }()
    return ch
}

外部からキャンセルイベントを流し込めるようにするといいかもしれない。

【2019-09-20 追記】実は標準で並行的に安全な疑似乱数生成器が用意されていた

あれから math/rand のソースコードを眺めてて気がついたのだが，実は並行的に安全な疑似乱数生成器が標準で用意されていた。

たとえば rand.Intn() 関数を見ると

// Intn returns, as an int, a non-negative pseudo-random number in [0,n)
// from the default Source.
// It panics if n <= 0.
func Intn(n int) int { return globalRand.Intn(n) }

とか書かれていて，じゃあ globalRand って何なん？と思って見てみたら

type lockedSource struct {
	lk  sync.Mutex
	src Source64
}


func (r *lockedSource) Int63() (n int64) {
	r.lk.Lock()
	n = r.src.Int63()
	r.lk.Unlock()
	return
}

func (r *lockedSource) Uint64() (n uint64) {
	r.lk.Lock()
	n = r.src.Uint64()
	r.lk.Unlock()
	return
}

func (r *lockedSource) Seed(seed int64) {
	r.lk.Lock()
	r.src.Seed(seed)
	r.lk.Unlock()
}

...

var globalRand = New(&lockedSource{src: NewSource(1).(Source64)})

とか書かれているわけですよ。なんだ，ちゃんと sync.Mutex で排他制御してるんぢゃん。

というわけで，最初のコードは

package main

import (
	"math/rand"
	"sync"
	"time"
)

func calcRnad() {
	for i := 0; i < 10000; i++ {
		rand.Intn(1000)
	}
}

func main() {
	rand.Seed(time.Now().UnixNano())
	wg := sync.WaitGroup{}
	for i := 0; i < 1000; i++ {
		wg.Add(1)
		go func() {
			calcRnad()
			wg.Done()
		}()
	}
	wg.Wait()
}

と書けば panic を吐くことなくちゃんと終了する。若干遅くはなるけど，それでも Generator Pattern を使うよりは全然速い。

ブックマーク

参考図書

Go言語による並行処理: Katherine Cox-Buday (著), 山口能迪 (翻訳); オライリージャパン 2018-10-26; 単行本（ソフトカバー）; 4873118468 (ASIN), 9784873118468 (EAN), 4873118468 (ISBN); 評価

Eブック版もある。感想はこちら。 Go 言語で並行処理を書くならこの本は必読書になるだろう。

reviewed by Spiegel on 2020-01-13 (powered by PA-APIv5)

プログラミング言語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)

math/rand パッケージに実装されている擬似乱数生成器はラグ付フィボナッチ法（Lagged Fibonacci Generator）のバリエーションらしい。 ↩︎

「《命》に関わる確率」を疑似乱数を使って解いてみる

2019-04-23T12:06:30+00:00

cakes で連載中の「数学ガールの秘密ノート」。今回の「確率の冒険：《命》に関わる確率（前編）」はなかなか面白かった。確率や統計は直感に反する場合があって，そういう事例を考えるのは本当に楽しい。

今回のプロブレムを整理してみよう。

《○○菌》に感染している人は《全人口の1%》である

○○菌に感染しているか否かを調べる《判定キット》がある。判定キットは感染しているか否かを《90%の確率》で正しく判定する

《感染している》という判定のことを《陽性》と呼ぶ

《感染していない》という判定のことを《陰性》と呼ぶ

ある人を判定キットで調べたら《陽性》だった。この人が○○菌に実際に感染している確率を求めよ

確率の冒険：《命》に関わる確率（前編）より

きちんとした解法は本編を読んでいただくとして，この記事では疑似乱数を用いたシミュレーションで解いてみる。

指定した確率で真偽を出力するクラス

まずは指定した確率で真偽を出力するクラスを考えてみる。 Go 言語でね（笑）

こんな感じでどうだろう。

package prob

import (
	"math"
	"math/rand"
	"time"
)

func New(p float64) <-chan bool {
	ch := make(chan bool)
	go func() {
		defer close(ch)
		max := 1000000
		limit := percent(p, max)
		rnd := rand.New(rand.NewSource(time.Now().UnixNano()))
		for {
			n := rnd.Intn(max) + 1
			ch <- n < limit
		}
	}()
	return ch
}

func percent(f float64, max int) int {
	if f < 0 {
		return 0
	}
	if f > 1.0 {
		return max
	}
	return int(math.Floor(f*float64(max) + 0.5))
}

これで

ch := prob.New(0.1)

とすれば channel ch から10%の確率で true が出力される筈である。サンプル・コードを書いて試してみよう。

func probability(try int, ch <-chan bool) int {
	count := 0
	for i := 0; i < try; i++ {
		if <-ch {
			count++
		}
	}
	return count
}

func main() {
	ch := prob.New(0.1)
	min := float64(1)
	max := float64(0)
	sum := float64(0)
	sum2 := float64(0)
	try := 10000
	tryf := float64(try)
	ps := make([]float64, 0, try)
	for i := 0; i < try; i++ {
		count := probability(try, ch)
		p := float64(count) / tryf
		ps = append(ps, p)
		if p < min {
			min = p
		}
		if p > max {
			max = p
		}
		sum += p
		sum2 += p * p
	}
	fmt.Printf("minimum value: %7.5f\n", min)
	fmt.Printf("maximum value: %7.5f\n", max)
	ave := sum / tryf
	fmt.Printf("average: %7.5f\n", ave)
	devi := math.Sqrt(sum2/tryf - ave*ave) //standard deviation
	ct := 0
	for _, p := range ps {
		if ave-devi <= p && p <= ave+devi {
			ct++
		}
	}
	fmt.Printf("standard deviation: %7.5f (%4.1f%%)\n", devi, float64(ct)*100.0/tryf)
}

10,000回の試行で割合を求める処理をワンセットとしてこれを10,000セット繰り返し，最小値・最大値・平均値・標準偏差を求めている。

これを実行するとこんな感じになる。

$ go run prob/sample/sample.go
minimum value: 0.08930
maximum value: 0.11160
average: 0.09999
standard deviation: 0.00299 (67.9%)

まぁこんなもんかな（笑）

感染者と検査キットを定義する。

ではこの prob パッケージを使って感染者と検査キットを定義してみる。

こんな感じでどうだろう。

package note257

import (
	"github.com/spiegel-im-spiegel/mathgirl-problem/prob"
)

type People struct {
	infect <-chan bool
}

type Person bool

func NewPeople() *People {
	return &People{infect: prob.New(0.01)}
}

func (ppl *People) SelectPersion() Person {
	return Person(<-ppl.infect)
}

func (psn Person) Infection() bool {
	return bool(psn)
}

type TestKit struct {
	probability <-chan bool
}

func NewTestKit() *TestKit {
	return &TestKit{probability: prob.New(0.9)}
}

func (tk *TestKit) Inspect(psn Person) bool {
	if psn.Infection() {
		return <-tk.probability
	}
	return !<-tk.probability
}

まず People を定義し，この中から People.SelectPersion() でサンプル Person を選び出す。このサンプルは1%の確率で感染している。感染しているかどうかは Person.Infection() 関数で分かる。

判定キットは TestKit で定義され TestKit.Inspect() 関数で検査結果が出る。このとき

（全体の1%存在する）感染者は90%の確率で陽性（true）になる
（全体の99%存在する）非感染者は10%の確率で陽性（true）になる

のがポイントである。

このパッケージを使って実際に検査を行ってみる。

func probability(ppl *note257.People, tk *note257.TestKit, try int) float64 {
	total := 0
	count := 0
	for i := 0; i < try; i++ {
		psn := ppl.SelectPersion()
		if tk.Inspect(psn) {
			total++
			if psn.Infection() {
				count++
			}
		}
	}
	return float64(count) / float64(total)
}

func main() {
	flag.Parse()
	try, err := strconv.Atoi(flag.Arg(0))
	if err != nil {
		fmt.Fprintln(os.Stderr, err)
		return
	}

	ppl := note257.NewPeople()
	tk := note257.NewTestKit()
	min := float64(1)
	max := float64(0)
	sum := float64(0)
	sum2 := float64(0)
	tryf := float64(try)
	ps := make([]float64, 0, try)
	for i := 0; i < try; i++ {
		p := probability(ppl, tk, try*10)
		ps = append(ps, p)
		if p < min {
			min = p
		}
		if p > max {
			max = p
		}
		sum += p
		sum2 += p * p
	}
	fmt.Printf("minimum value: %7.5f\n", min)
	fmt.Printf("maximum value: %7.5f\n", max)
	ave := sum / tryf
	fmt.Printf("average: %7.5f\n", ave)
	devi := math.Sqrt(sum2/tryf - ave*ave) //standard deviation
	ct := 0
	for _, p := range ps {
		if ave-devi <= p && p <= ave+devi {
			ct++
		}
	}
	fmt.Printf("standard deviation: %7.5f (%4.1f%%)\n", devi, float64(ct)*100.0/tryf)
}

probability() 関数で判定キットの結果が陽性だった人の中で実際に感染している人の割合を返している。

たとえば

$ go run note257/sample/sample.go 10000

とすれば probability() 関数による試行を10,000回繰り返すわけだ。私のマシンは遅いので，これを実行するとめっさ時間がかかるのだが，まぁやってみよう。

$ go run note257/sample/sample.go 10000
minimum value: 0.08061
maximum value: 0.10279
average: 0.09092
standard deviation: 0.00272 (68.5%)

平均値が少し高めに出たけど，こんなものかな。

結果だけを見れば直感に反するかも知れないが，こうやって実際にコードを書いてみると納得感が強まる。やっぱプログラマはコードを書いてナンボだよね（笑）

ブックマーク

参考図書

プログラマの数学第2版: 結城浩 (著); SBクリエイティブ 2018-01-16 (Release 2018-02-08); Kindle版; B079JLW5YN (ASIN); 評価

タイトル通りプログラマ必読書。第2版では機械学習に関する章が付録に追加された。

reviewed by Spiegel on 2018-03-19 (powered by PA-APIv5)

いかにして問題をとくか: G. ポリア (著), Polya,G. (原著), 賢信, 柿内 (翻訳); 丸善 1975-04-01; 単行本; 4621045938 (ASIN), 9784621045930 (EAN), 4621045938 (ISBN); 評価

数学書。というか問いの立てかたやものの考え方についての指南書。のようなものかな。

reviewed by Spiegel on 2014-09-26 (powered by PA-APIv5)

プログラミング言語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)

モンテカルロ法による円周率の推定（その4 PRNG）

2016-11-20T14:33:55+00:00

「モンテカルロ法による円周率の推定」もひととおり終わったので，今回は擬似乱数生成器（pseudo random number generator）の話。

math/rand の擬似乱数生成器

Go 言語では math/rand パッケージで擬似乱数を取り扱えることは「その1」で紹介した通り。 math/rand パッケージに実装されている擬似乱数生成器はラグ付フィボナッチ法（Lagged Fibonacci Generator）のバリエーションらしい。

If I am not mistaken again, the generator is an ALFG (Additive Lagged Fibonacci Generator, thats what Wikipedia calls it). Knuth describes the algorithm in Volume 2 of The art of computer programming in section 3.2.2 (around equation 7). Both Wikipedia and Knuth state the parameter combination 607,273 as possible combination with a period length of 2^(e-1) * (2^607-1) where e is the length of the random number in bits.
I actually found a few references examining its properties and it seems to be a good rng so faar, but there is still seems to be a lack of mathematical background and it is fairly easy to get into trouble by not seeding properly.

via [Announce] A rand package for high quality 64bit random numbers (possibly go2)

ラグ付フィボナッチ法は線形合同法（後述）を改善することを目的としたものでフィボナッチ数の生成法を元にしている。

Lagged Fibonacci generator - Wikipedia

ラグ付フィボナッチ法は以下の式で表される。

\begin{alignat*}{2} S_{n} \equiv S_{n-j} * S_{n-k} \pmod{m}, & \; & 0 \lt j \lt k \end{alignat*}

ラグ付フィボナッチ法は $ * $ 演算子によってバリエーションがあるが math/rand パッケージの実装では加算を使うため “Additive Lagged Fibonacci Generator” ということらしい。ソースコードで言うとこの部分かな。

// Int63 returns a non-negative pseudo-random 63-bit integer as an int64.
func (rng *rngSource) Int63() int64 {
    rng.tap--
    if rng.tap < 0 {
        rng.tap += _LEN
    }

    rng.feed--
    if rng.feed < 0 {
        rng.feed += _LEN
    }

    x := (rng.vec[rng.feed] + rng.vec[rng.tap]) & _MASK
    rng.vec[rng.feed] = x
    return x
}

擬似乱数生成器のバリエーション

math/rand パッケージでは以下の interface を持つ別の擬似乱数生成器を使うことができる。

// A Source represents a source of uniformly-distributed
// pseudo-random int64 values in the range [0, 1<<63).
type Source interface {
    Int63() int64
    Seed(seed int64)
}

以下に2つほど紹介する。

線形合同法

線形合同法（Linear Congruential Generator）は昔の擬似乱数ライブラリでよく使われていたアルゴリズムで，以下の式で表される。

\[ X_{n+1} = (A \times X_{n} + B) \bmod M \]

定数 $A$ および $B$ の与え方により幾つかバリエーションがある。

線形合同法のメリットは実装サイズが小さく計算量も少ない点だろうか。一方デメリットとしては，多次元で疎に分布する性質があり，周期も小さいため乱数を大量に発生させる必要がある科学技術シミュレーションなどには向かないと言われている。このためメモリサイズが限られるマイクロ・コントローラのようなものでもない限り線形合同法が使われることはなくなった。

Go 言語でわざわざ線形合同法を実装しているパッケージは少ないのだが，たとえば以下のパッケージがある¹。

davidminor/gorand: Basic golang implementation of a permuted congruential generator for pseudorandom number generation

Mersenne Twister

Mersenne Twister とは松本眞・西村拓士両氏によって1996年に発表された擬似乱数生成アルゴリズムである。他の擬似乱数生成アルゴリズムと比べて以下の特徴があるそうだ。（「Mersenne Twister とは?」より）

従来の様々な生成法の欠点を考慮して設計されています。
従来にない長周期，高次元均等分布を持ちます。（周期が $2^{19937}-1$ で²、623次元超立方体の中に均等に分布することが証明されています。）
生成速度がかなり速い。（処理系にもよりますが、パイプライン処理やキャッシュメモリのあるシステムでは、Cの標準ライブラリの rand() より高速なこともあります。なお、開発当時には cokus 版は rand() より4倍程度高速でしたが、その後 ANSI-C の rand() が LCG 法から lagged-fibonacci に変更されたこともあり、2002年現在 rand と MT の速度差はあまりありません。）
メモリ効率が良い。（32ビット以上のマシン用に設計された mt19937.c は、 624ワードのワーキングメモリを消費するだけです。 1ワードは32ビット長とします。

ちなみに Mersenne Twister のオリジナル・コードは BSD ライセンスで提供されている。

公式のリポジトリには C/C++ による実装のみのようだが， Go 言語で実装している人もいるようである。

seehuhn/mt19937: An implementation of Takuji Nishimura’s and Makoto Matsumoto’s Mersenne Twister pseudo random number generator in Go.
nutterts/randgen: Pseudo Random Number Generators implementing the Go(lang) math/rand.Source Interface
farces/mt19937_64: Mersenne Twister (int64) for Go
cuixin/goalg: golang algorithms
cpmech/gosl: Go scientific library : SFMT や TinyMT に対応。オリジナルのコードを cgo で結合しているのでクロス環境では注意

擬似乱数生成器を組み込む

では，先ほど紹介した擬似乱数生成器を今回のコードに組み込んでみることにしよう。こんな感じ。

package gencmplx

import (
    "math/rand"

    "github.com/davidminor/gorand/lcg"
    "github.com/seehuhn/mt19937"
)

//RNGs is kind of RNG
type RNGs int

const (
    NULL RNGs = iota
    GO
    LCG
    MT
)

//NewRndSource returns Source of random numbers
func NewRndSource(rng RNGs, seed int64) rand.Source {
    switch rng {
    case LCG:
        return lcg.NewLcg64(uint64(seed))
    case MT:
        mt := mt19937.New()
        mt.Seed(seed)
        return mt
    default:
        return rand.NewSource(seed)
    }
}

gencmplx.NewRndSource() 関数で rand.Source オブジェクトを生成する³。これを「その1」で作った gencmplx.New() 関数に渡せばよい。

CLI は以下のように調整してみた。

$ go run main.go estmt --help
Estimate of Pi with Monte Carlo method.

Usage:
  pi estmt [flags]

Flags:
  -e, --ecount int   Count of estimate (default 100)

Global Flags:
  -p, --pcount int       Count of points (default 10000)
  -r, --rsource string   Source of RNG (GO/LCG/MT) (default "GO")

で，それぞれの擬似乱数生成器で評価を行ってみようと思ったのだが，今回のケースに限ってはあまり違いが出ないようである。

まずは線形合同法の場合。

$ go run main.go estmt -e 10000 -p 100000 -r LCG > estmt100k-lcg.dat
random number generator: LCG
minimum value: 3.12204
maximum value: 3.16224
average value: 3.14164
standard deviation: 0.00524 (68.3%)

次は Mersenne Twister の場合。

$ go run main.go estmt -e 10000 -p 100000 -r MT > estmt100k-mt.dat
random number generator: MT
minimum value: 3.12380
maximum value: 3.16140
average value: 3.14165
standard deviation: 0.00517 (67.8%)

もっと多次元だったりすると変わってくるのかなぁ。

暗号技術用途の乱数生成器

Go 言語では暗号技術用途の乱数として crypto/rand パッケージが用意されている。これは math/rand とは互換性がない。

具体的には，UNIX 系のプラットフォームでは乱数生成に /dev/urandom デバイスを参照している⁴。また Windows プラットフォームでは CryptoAPI 2.0 の CryptGenRandom 関数を使っている⁵。

そもそも暗号技術用途の乱数生成器は科学技術シミュレーションやゲームで使う擬似乱数生成器とは要件が異なる。

従前の観点から統計的にテストされた乱雑性は、セキュリティ用途に要求される予測困難性と同等ではありません。
例えば、（CRC Standard Mathematical Tables からのランダムテーブルのような）広く利用可能な一定のシーケンスの利用は、攻撃者に対して非常に弱いです。これを学習したり、推測する攻撃者は、容易に（過去・未来を問わず）そのシーケンス [CRC] に基づいて、すべてのセキュリティを破ることができます。他の例として、AES を 1, 2, 3 ... のような連続した整数を暗号化する一定の鍵と共に使うことは、優れた統計的乱雑性をもつが予測可能な出力を作り出します。他方、6 面のサイコロを連続して転がして、その結果の値を ASCII にエンコードすることは、実質的に予測困難なコンポーネントをもちながらも「統計的に貧弱な出力」を作り出します。それゆえ、「統計的テストの合否は、『何かが予測不可能であるか否か、あるいは、予測可能であるか否か』を表さないこと」に注意してください。

RFC 4086 - セキュリティのための乱雑性についての要件より

暗号技術用途の乱数生成器は，暗号分野においては中核技術のひとつであるが，一度に大量の乱数を生成させる必要のある科学技術シミュレーションなどの用途には向かない。上手く使い分けてほしい。

ブックマーク

Go 言語に関するブックマーク集はこちら。

参考図書

プログラミング言語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)

暗号技術入門第3版　秘密の国のアリス: 結城浩 (著); SBクリエイティブ 2015-08-25 (Release 2015-09-17); Kindle版; B015643CPE (ASIN); 評価

SHA-3 や Bitcoin/Blockchain など新しい知見や技術要素を大幅追加。暗号技術を使うだけならこれ1冊でとりあえず無問題。

reviewed by Spiegel on 2015-09-20 (powered by PA-APIv5)

ただし github.com/davidminor/gorand/lcg には不具合があって Int63() 関数で負の値を出力する場合がある。とりあえず fork 版の github.com/spiegel-im-spiegel/gorand/lcg で修正している。 Pull request も出したけど，古いコードだし，もうメンテしてないかなぁ。 ↩︎
$2^{19937}-1$ はメルセンヌ素数で Mersenne Twister の名前の由来になっている。 Mersenne Twister では周期サイズごとに複数の実装があるが， $2^{19937}-1$ がポピュラーな実装として広く使われているようだ。 ↩︎
Go 言語におけるオブジェクトの多態性については「Go 言語における「オブジェクト」」を参考にどうぞ。 ↩︎
/dev/urandom はハードウェア・デバイスから十分なエントロピー源が得られない場合は内部で疑似乱数生成器を使用する。このため一時は /dev/urandom の脆弱性が疑われたが，現時点では事実上は問題ないとされている。一方で，スマートデバイスのような場合はハードウェア・デバイスからのエントロピー源だけでは外部から推測され易いため，性能のよい疑似乱数生成器を組み合わせるほうが有効になる場合もあるようだ。 ↩︎
CryptGenRandom 関数の内部実装は公開されていないが，やはりキーボードやマウス等のデバイスの挙動をエントロピー源とし， NIST の SP800-90 勧告に従った実装をしているようである。余談だが SP800-90 は乱数生成の一部のアルゴリズムで脆弱性が発見され（これがまた NSA 絡みだったものだから大騒ぎになった），現在は修正版の SP800-90A Revision 1が発行されている。（参考：擬似乱数生成アルゴリズム Dual_EC_DRBG について） ↩︎

List of Random [text.Baldanders.info]

PuTTY 0.81 がリリースされた【セキュリティ・アップデート】

CVE-2024-31497

ブックマーク

参考

github.com/goark/mt/v2 をリリースした

ブックマーク

参考図書

Go 1.22 における疑似乱数生成器

ランタイムに ChaCha8 疑似乱数生成器を組み込む

math/rand パッケージのトップレベル関数群にランタイムの ChaCha8 を組み込む

math/rand/v2 パッケージにおける Source インタフェースの定義

ChaCha8 を rand.Source にする

PCG を rand.Source にする

これから math/rand を使う理由はないかな

ブックマーク

参考図書

ランダムな文字列を生成する

math/rand パッケージによる実装

crypto/rand パッケージによる実装

ベンチマークをとってみる

科学技術用の疑似乱数生成器と暗号技術用の乱数生成器

ブックマーク

参考図書

「今あなた以外に○○人が見ています」デモ

疑似乱数生成器 goark/mt

github.com/goark/mt/v2/mt19937.Source の機能

math/rand/v2 パッケージと組み合わせる

mt.PRNG と組み合わせる

io.Reader 互換の疑似乱数生成器

ライセンスについて

参考図書

疑似乱数生成器 spiegel-im-spiegel/mt をリリースした

参考図書

Go の疑似乱数生成器は並行的に安全ではないらしい（追記あり）

goroutine ごとにインスタンスを生成する

Generator Pattern を使う

おまけの追記

【2019-09-20 追記】 実は標準で並行的に安全な疑似乱数生成器が用意されていた

ブックマーク

参考図書

「《命》に関わる確率」を疑似乱数を使って解いてみる

指定した確率で真偽を出力するクラス

感染者と検査キットを定義する。

ブックマーク

参考図書

モンテカルロ法による円周率の推定（その4 PRNG）

math/rand の擬似乱数生成器

擬似乱数生成器のバリエーション

線形合同法

Mersenne Twister

擬似乱数生成器を組み込む

暗号技術用途の乱数生成器

ブックマーク

参考図書

【2019-09-20 追記】実は標準で並行的に安全な疑似乱数生成器が用意されていた