src/crypto/rand/rand_unix.go

   1 // Copyright 2010 The Go Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style
   3 // license that can be found in the LICENSE file.
   4
   5 //go:build aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || plan9 || solaris
   6 // +build aix darwin dragonfly freebsd linux netbsd openbsd plan9 solaris
   7
   8 // Unix cryptographically secure pseudorandom number
   9 // generator.
  10
  11 package rand
  12
  13 import (
  14         "bufio"
  15         "crypto/aes"
  16         "crypto/cipher"
  17         "encoding/binary"
  18         "io"
  19         "os"
  20         "runtime"
  21         "sync"
  22         "sync/atomic"
  23         "time"
  24 )
  25
  26 import "crypto/internal/boring"
  27
  28 const urandomDevice = "/dev/urandom"
  29
  30 // Easy implementation: read from /dev/urandom.
  31 // This is sufficient on Linux, OS X, and FreeBSD.
  32
  33 func init() {
  34         if boring.Enabled {
  35                 Reader = boring.RandReader
  36                 return
  37         }
  38         if runtime.GOOS == "plan9" {
  39                 Reader = newReader(nil)
  40         } else {
  41                 Reader = &devReader{name: urandomDevice}
  42         }
  43 }
  44
  45 // A devReader satisfies reads by reading the file named name.
  46 type devReader struct {
  47         name string
  48         f    io.Reader
  49         mu   sync.Mutex
  50         used int32 // atomic; whether this devReader has been used
  51 }
  52
  53 // altGetRandom if non-nil specifies an OS-specific function to get
  54 // urandom-style randomness.
  55 var altGetRandom func([]byte) (ok bool)
  56
  57 func warnBlocked() {
  58         println("crypto/rand: blocked for 60 seconds waiting to read random data from the kernel")
  59 }
  60
  61 func (r *devReader) Read(b []byte) (n int, err error) {
  62         boring.Unreachable()
  63         if atomic.CompareAndSwapInt32(&r.used, 0, 1) {
  64                 // First use of randomness. Start timer to warn about
  65                 // being blocked on entropy not being available.
  66                 t := time.AfterFunc(60*time.Second, warnBlocked)
  67                 defer t.Stop()
  68         }
  69         if altGetRandom != nil && r.name == urandomDevice && altGetRandom(b) {
  70                 return len(b), nil
  71         }
  72         r.mu.Lock()
  73         defer r.mu.Unlock()
  74         if r.f == nil {
  75                 f, err := os.Open(r.name)
  76                 if f == nil {
  77                         return 0, err
  78                 }
  79                 if runtime.GOOS == "plan9" {
  80                         r.f = f
  81                 } else {
  82                         r.f = bufio.NewReader(hideAgainReader{f})
  83                 }
  84         }
  85         return r.f.Read(b)
  86 }
  87
  88 var isEAGAIN func(error) bool // set by eagain.go on unix systems
  89
  90 // hideAgainReader masks EAGAIN reads from /dev/urandom.
  91 // See golang.org/issue/9205
  92 type hideAgainReader struct {
  93         r io.Reader
  94 }
  95
  96 func (hr hideAgainReader) Read(p []byte) (n int, err error) {
  97         n, err = hr.r.Read(p)
  98         if err != nil && isEAGAIN != nil && isEAGAIN(err) {
  99                 err = nil
 100         }
 101         return
 102 }
 103
 104 // Alternate pseudo-random implementation for use on
 105 // systems without a reliable /dev/urandom.
 106
 107 // newReader returns a new pseudorandom generator that
 108 // seeds itself by reading from entropy. If entropy == nil,
 109 // the generator seeds itself by reading from the system's
 110 // random number generator, typically /dev/random.
 111 // The Read method on the returned reader always returns
 112 // the full amount asked for, or else it returns an error.
 113 //
 114 // The generator uses the X9.31 algorithm with AES-128,
 115 // reseeding after every 1 MB of generated data.
 116 func newReader(entropy io.Reader) io.Reader {
 117         if entropy == nil {
 118                 entropy = &devReader{name: "/dev/random"}
 119         }
 120         return &reader{entropy: entropy}
 121 }
 122
 123 type reader struct {
 124         mu                   sync.Mutex
 125         budget               int // number of bytes that can be generated
 126         cipher               cipher.Block
 127         entropy              io.Reader
 128         time, seed, dst, key [aes.BlockSize]byte
 129 }
 130
 131 func (r *reader) Read(b []byte) (n int, err error) {
 132         boring.Unreachable()
 133         r.mu.Lock()
 134         defer r.mu.Unlock()
 135         n = len(b)
 136
 137         for len(b) > 0 {
 138                 if r.budget == 0 {
 139                         _, err := io.ReadFull(r.entropy, r.seed[0:])
 140                         if err != nil {
 141                                 return n - len(b), err
 142                         }
 143                         _, err = io.ReadFull(r.entropy, r.key[0:])
 144                         if err != nil {
 145                                 return n - len(b), err
 146                         }
 147                         r.cipher, err = aes.NewCipher(r.key[0:])
 148                         if err != nil {
 149                                 return n - len(b), err
 150                         }
 151                         r.budget = 1 << 20 // reseed after generating 1MB
 152                 }
 153                 r.budget -= aes.BlockSize
 154
 155                 // ANSI X9.31 (== X9.17) algorithm, but using AES in place of 3DES.
 156                 //
 157                 // single block:
 158                 // t = encrypt(time)
 159                 // dst = encrypt(t^seed)
 160                 // seed = encrypt(t^dst)
 161                 ns := time.Now().UnixNano()
 162                 binary.BigEndian.PutUint64(r.time[:], uint64(ns))
 163                 r.cipher.Encrypt(r.time[0:], r.time[0:])
 164                 for i := 0; i < aes.BlockSize; i++ {
 165                         r.dst[i] = r.time[i] ^ r.seed[i]
 166                 }
 167                 r.cipher.Encrypt(r.dst[0:], r.dst[0:])
 168                 for i := 0; i < aes.BlockSize; i++ {
 169                         r.seed[i] = r.time[i] ^ r.dst[i]
 170                 }
 171                 r.cipher.Encrypt(r.seed[0:], r.seed[0:])
 172
 173                 m := copy(b, r.dst[0:])
 174                 b = b[m:]
 175         }
 176
 177         return n, nil
 178 }