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