cmd/bpa-operator/vendor/golang.org/x/crypto/ssh/common.go

   1 // Copyright 2011 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 package ssh
   6
   7 import (
   8         "crypto"
   9         "crypto/rand"
  10         "fmt"
  11         "io"
  12         "math"
  13         "sync"
  14
  15         _ "crypto/sha1"
  16         _ "crypto/sha256"
  17         _ "crypto/sha512"
  18 )
  19
  20 // These are string constants in the SSH protocol.
  21 const (
  22         compressionNone = "none"
  23         serviceUserAuth = "ssh-userauth"
  24         serviceSSH      = "ssh-connection"
  25 )
  26
  27 // supportedCiphers lists ciphers we support but might not recommend.
  28 var supportedCiphers = []string{
  29         "aes128-ctr", "aes192-ctr", "aes256-ctr",
  30         "aes128-gcm@openssh.com",
  31         chacha20Poly1305ID,
  32         "arcfour256", "arcfour128", "arcfour",
  33         aes128cbcID,
  34         tripledescbcID,
  35 }
  36
  37 // preferredCiphers specifies the default preference for ciphers.
  38 var preferredCiphers = []string{
  39         "aes128-gcm@openssh.com",
  40         chacha20Poly1305ID,
  41         "aes128-ctr", "aes192-ctr", "aes256-ctr",
  42 }
  43
  44 // supportedKexAlgos specifies the supported key-exchange algorithms in
  45 // preference order.
  46 var supportedKexAlgos = []string{
  47         kexAlgoCurve25519SHA256,
  48         // P384 and P521 are not constant-time yet, but since we don't
  49         // reuse ephemeral keys, using them for ECDH should be OK.
  50         kexAlgoECDH256, kexAlgoECDH384, kexAlgoECDH521,
  51         kexAlgoDH14SHA1, kexAlgoDH1SHA1,
  52 }
  53
  54 // supportedHostKeyAlgos specifies the supported host-key algorithms (i.e. methods
  55 // of authenticating servers) in preference order.
  56 var supportedHostKeyAlgos = []string{
  57         CertAlgoRSAv01, CertAlgoDSAv01, CertAlgoECDSA256v01,
  58         CertAlgoECDSA384v01, CertAlgoECDSA521v01, CertAlgoED25519v01,
  59
  60         KeyAlgoECDSA256, KeyAlgoECDSA384, KeyAlgoECDSA521,
  61         KeyAlgoRSA, KeyAlgoDSA,
  62
  63         KeyAlgoED25519,
  64 }
  65
  66 // supportedMACs specifies a default set of MAC algorithms in preference order.
  67 // This is based on RFC 4253, section 6.4, but with hmac-md5 variants removed
  68 // because they have reached the end of their useful life.
  69 var supportedMACs = []string{
  70         "hmac-sha2-256-etm@openssh.com", "hmac-sha2-256", "hmac-sha1", "hmac-sha1-96",
  71 }
  72
  73 var supportedCompressions = []string{compressionNone}
  74
  75 // hashFuncs keeps the mapping of supported algorithms to their respective
  76 // hashes needed for signature verification.
  77 var hashFuncs = map[string]crypto.Hash{
  78         KeyAlgoRSA:          crypto.SHA1,
  79         KeyAlgoDSA:          crypto.SHA1,
  80         KeyAlgoECDSA256:     crypto.SHA256,
  81         KeyAlgoECDSA384:     crypto.SHA384,
  82         KeyAlgoECDSA521:     crypto.SHA512,
  83         CertAlgoRSAv01:      crypto.SHA1,
  84         CertAlgoDSAv01:      crypto.SHA1,
  85         CertAlgoECDSA256v01: crypto.SHA256,
  86         CertAlgoECDSA384v01: crypto.SHA384,
  87         CertAlgoECDSA521v01: crypto.SHA512,
  88 }
  89
  90 // unexpectedMessageError results when the SSH message that we received didn't
  91 // match what we wanted.
  92 func unexpectedMessageError(expected, got uint8) error {
  93         return fmt.Errorf("ssh: unexpected message type %d (expected %d)", got, expected)
  94 }
  95
  96 // parseError results from a malformed SSH message.
  97 func parseError(tag uint8) error {
  98         return fmt.Errorf("ssh: parse error in message type %d", tag)
  99 }
 100
 101 func findCommon(what string, client []string, server []string) (common string, err error) {
 102         for _, c := range client {
 103                 for _, s := range server {
 104                         if c == s {
 105                                 return c, nil
 106                         }
 107                 }
 108         }
 109         return "", fmt.Errorf("ssh: no common algorithm for %s; client offered: %v, server offered: %v", what, client, server)
 110 }
 111
 112 type directionAlgorithms struct {
 113         Cipher      string
 114         MAC         string
 115         Compression string
 116 }
 117
 118 // rekeyBytes returns a rekeying intervals in bytes.
 119 func (a *directionAlgorithms) rekeyBytes() int64 {
 120         // According to RFC4344 block ciphers should rekey after
 121         // 2^(BLOCKSIZE/4) blocks. For all AES flavors BLOCKSIZE is
 122         // 128.
 123         switch a.Cipher {
 124         case "aes128-ctr", "aes192-ctr", "aes256-ctr", gcmCipherID, aes128cbcID:
 125                 return 16 * (1 << 32)
 126
 127         }
 128
 129         // For others, stick with RFC4253 recommendation to rekey after 1 Gb of data.
 130         return 1 << 30
 131 }
 132
 133 type algorithms struct {
 134         kex     string
 135         hostKey string
 136         w       directionAlgorithms
 137         r       directionAlgorithms
 138 }
 139
 140 func findAgreedAlgorithms(clientKexInit, serverKexInit *kexInitMsg) (algs *algorithms, err error) {
 141         result := &algorithms{}
 142
 143         result.kex, err = findCommon("key exchange", clientKexInit.KexAlgos, serverKexInit.KexAlgos)
 144         if err != nil {
 145                 return
 146         }
 147
 148         result.hostKey, err = findCommon("host key", clientKexInit.ServerHostKeyAlgos, serverKexInit.ServerHostKeyAlgos)
 149         if err != nil {
 150                 return
 151         }
 152
 153         result.w.Cipher, err = findCommon("client to server cipher", clientKexInit.CiphersClientServer, serverKexInit.CiphersClientServer)
 154         if err != nil {
 155                 return
 156         }
 157
 158         result.r.Cipher, err = findCommon("server to client cipher", clientKexInit.CiphersServerClient, serverKexInit.CiphersServerClient)
 159         if err != nil {
 160                 return
 161         }
 162
 163         result.w.MAC, err = findCommon("client to server MAC", clientKexInit.MACsClientServer, serverKexInit.MACsClientServer)
 164         if err != nil {
 165                 return
 166         }
 167
 168         result.r.MAC, err = findCommon("server to client MAC", clientKexInit.MACsServerClient, serverKexInit.MACsServerClient)
 169         if err != nil {
 170                 return
 171         }
 172
 173         result.w.Compression, err = findCommon("client to server compression", clientKexInit.CompressionClientServer, serverKexInit.CompressionClientServer)
 174         if err != nil {
 175                 return
 176         }
 177
 178         result.r.Compression, err = findCommon("server to client compression", clientKexInit.CompressionServerClient, serverKexInit.CompressionServerClient)
 179         if err != nil {
 180                 return
 181         }
 182
 183         return result, nil
 184 }
 185
 186 // If rekeythreshold is too small, we can't make any progress sending
 187 // stuff.
 188 const minRekeyThreshold uint64 = 256
 189
 190 // Config contains configuration data common to both ServerConfig and
 191 // ClientConfig.
 192 type Config struct {
 193         // Rand provides the source of entropy for cryptographic
 194         // primitives. If Rand is nil, the cryptographic random reader
 195         // in package crypto/rand will be used.
 196         Rand io.Reader
 197
 198         // The maximum number of bytes sent or received after which a
 199         // new key is negotiated. It must be at least 256. If
 200         // unspecified, a size suitable for the chosen cipher is used.
 201         RekeyThreshold uint64
 202
 203         // The allowed key exchanges algorithms. If unspecified then a
 204         // default set of algorithms is used.
 205         KeyExchanges []string
 206
 207         // The allowed cipher algorithms. If unspecified then a sensible
 208         // default is used.
 209         Ciphers []string
 210
 211         // The allowed MAC algorithms. If unspecified then a sensible default
 212         // is used.
 213         MACs []string
 214 }
 215
 216 // SetDefaults sets sensible values for unset fields in config. This is
 217 // exported for testing: Configs passed to SSH functions are copied and have
 218 // default values set automatically.
 219 func (c *Config) SetDefaults() {
 220         if c.Rand == nil {
 221                 c.Rand = rand.Reader
 222         }
 223         if c.Ciphers == nil {
 224                 c.Ciphers = preferredCiphers
 225         }
 226         var ciphers []string
 227         for _, c := range c.Ciphers {
 228                 if cipherModes[c] != nil {
 229                         // reject the cipher if we have no cipherModes definition
 230                         ciphers = append(ciphers, c)
 231                 }
 232         }
 233         c.Ciphers = ciphers
 234
 235         if c.KeyExchanges == nil {
 236                 c.KeyExchanges = supportedKexAlgos
 237         }
 238
 239         if c.MACs == nil {
 240                 c.MACs = supportedMACs
 241         }
 242
 243         if c.RekeyThreshold == 0 {
 244                 // cipher specific default
 245         } else if c.RekeyThreshold < minRekeyThreshold {
 246                 c.RekeyThreshold = minRekeyThreshold
 247         } else if c.RekeyThreshold >= math.MaxInt64 {
 248                 // Avoid weirdness if somebody uses -1 as a threshold.
 249                 c.RekeyThreshold = math.MaxInt64
 250         }
 251 }
 252
 253 // buildDataSignedForAuth returns the data that is signed in order to prove
 254 // possession of a private key. See RFC 4252, section 7.
 255 func buildDataSignedForAuth(sessionID []byte, req userAuthRequestMsg, algo, pubKey []byte) []byte {
 256         data := struct {
 257                 Session []byte
 258                 Type    byte
 259                 User    string
 260                 Service string
 261                 Method  string
 262                 Sign    bool
 263                 Algo    []byte
 264                 PubKey  []byte
 265         }{
 266                 sessionID,
 267                 msgUserAuthRequest,
 268                 req.User,
 269                 req.Service,
 270                 req.Method,
 271                 true,
 272                 algo,
 273                 pubKey,
 274         }
 275         return Marshal(data)
 276 }
 277
 278 func appendU16(buf []byte, n uint16) []byte {
 279         return append(buf, byte(n>>8), byte(n))
 280 }
 281
 282 func appendU32(buf []byte, n uint32) []byte {
 283         return append(buf, byte(n>>24), byte(n>>16), byte(n>>8), byte(n))
 284 }
 285
 286 func appendU64(buf []byte, n uint64) []byte {
 287         return append(buf,
 288                 byte(n>>56), byte(n>>48), byte(n>>40), byte(n>>32),
 289                 byte(n>>24), byte(n>>16), byte(n>>8), byte(n))
 290 }
 291
 292 func appendInt(buf []byte, n int) []byte {
 293         return appendU32(buf, uint32(n))
 294 }
 295
 296 func appendString(buf []byte, s string) []byte {
 297         buf = appendU32(buf, uint32(len(s)))
 298         buf = append(buf, s...)
 299         return buf
 300 }
 301
 302 func appendBool(buf []byte, b bool) []byte {
 303         if b {
 304                 return append(buf, 1)
 305         }
 306         return append(buf, 0)
 307 }
 308
 309 // newCond is a helper to hide the fact that there is no usable zero
 310 // value for sync.Cond.
 311 func newCond() *sync.Cond { return sync.NewCond(new(sync.Mutex)) }
 312
 313 // window represents the buffer available to clients
 314 // wishing to write to a channel.
 315 type window struct {
 316         *sync.Cond
 317         win          uint32 // RFC 4254 5.2 says the window size can grow to 2^32-1
 318         writeWaiters int
 319         closed       bool
 320 }
 321
 322 // add adds win to the amount of window available
 323 // for consumers.
 324 func (w *window) add(win uint32) bool {
 325         // a zero sized window adjust is a noop.
 326         if win == 0 {
 327                 return true
 328         }
 329         w.L.Lock()
 330         if w.win+win < win {
 331                 w.L.Unlock()
 332                 return false
 333         }
 334         w.win += win
 335         // It is unusual that multiple goroutines would be attempting to reserve
 336         // window space, but not guaranteed. Use broadcast to notify all waiters
 337         // that additional window is available.
 338         w.Broadcast()
 339         w.L.Unlock()
 340         return true
 341 }
 342
 343 // close sets the window to closed, so all reservations fail
 344 // immediately.
 345 func (w *window) close() {
 346         w.L.Lock()
 347         w.closed = true
 348         w.Broadcast()
 349         w.L.Unlock()
 350 }
 351
 352 // reserve reserves win from the available window capacity.
 353 // If no capacity remains, reserve will block. reserve may
 354 // return less than requested.
 355 func (w *window) reserve(win uint32) (uint32, error) {
 356         var err error
 357         w.L.Lock()
 358         w.writeWaiters++
 359         w.Broadcast()
 360         for w.win == 0 && !w.closed {
 361                 w.Wait()
 362         }
 363         w.writeWaiters--
 364         if w.win < win {
 365                 win = w.win
 366         }
 367         w.win -= win
 368         if w.closed {
 369                 err = io.EOF
 370         }
 371         w.L.Unlock()
 372         return win, err
 373 }
 374
 375 // waitWriterBlocked waits until some goroutine is blocked for further
 376 // writes. It is used in tests only.
 377 func (w *window) waitWriterBlocked() {
 378         w.Cond.L.Lock()
 379         for w.writeWaiters == 0 {
 380                 w.Cond.Wait()
 381         }
 382         w.Cond.L.Unlock()
 383 }