vendor/golang.org/x/crypto/ssh/transport_test.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         "bytes"
   9         "crypto/rand"
  10         "encoding/binary"
  11         "strings"
  12         "testing"
  13 )
  14
  15 func TestReadVersion(t *testing.T) {
  16         longversion := strings.Repeat("SSH-2.0-bla", 50)[:253]
  17         cases := map[string]string{
  18                 "SSH-2.0-bla\r\n":    "SSH-2.0-bla",
  19                 "SSH-2.0-bla\n":      "SSH-2.0-bla",
  20                 longversion + "\r\n": longversion,
  21         }
  22
  23         for in, want := range cases {
  24                 result, err := readVersion(bytes.NewBufferString(in))
  25                 if err != nil {
  26                         t.Errorf("readVersion(%q): %s", in, err)
  27                 }
  28                 got := string(result)
  29                 if got != want {
  30                         t.Errorf("got %q, want %q", got, want)
  31                 }
  32         }
  33 }
  34
  35 func TestReadVersionError(t *testing.T) {
  36         longversion := strings.Repeat("SSH-2.0-bla", 50)[:253]
  37         cases := []string{
  38                 longversion + "too-long\r\n",
  39         }
  40         for _, in := range cases {
  41                 if _, err := readVersion(bytes.NewBufferString(in)); err == nil {
  42                         t.Errorf("readVersion(%q) should have failed", in)
  43                 }
  44         }
  45 }
  46
  47 func TestExchangeVersionsBasic(t *testing.T) {
  48         v := "SSH-2.0-bla"
  49         buf := bytes.NewBufferString(v + "\r\n")
  50         them, err := exchangeVersions(buf, []byte("xyz"))
  51         if err != nil {
  52                 t.Errorf("exchangeVersions: %v", err)
  53         }
  54
  55         if want := "SSH-2.0-bla"; string(them) != want {
  56                 t.Errorf("got %q want %q for our version", them, want)
  57         }
  58 }
  59
  60 func TestExchangeVersions(t *testing.T) {
  61         cases := []string{
  62                 "not\x000allowed",
  63                 "not allowed\n",
  64         }
  65         for _, c := range cases {
  66                 buf := bytes.NewBufferString("SSH-2.0-bla\r\n")
  67                 if _, err := exchangeVersions(buf, []byte(c)); err == nil {
  68                         t.Errorf("exchangeVersions(%q): should have failed", c)
  69                 }
  70         }
  71 }
  72
  73 type closerBuffer struct {
  74         bytes.Buffer
  75 }
  76
  77 func (b *closerBuffer) Close() error {
  78         return nil
  79 }
  80
  81 func TestTransportMaxPacketWrite(t *testing.T) {
  82         buf := &closerBuffer{}
  83         tr := newTransport(buf, rand.Reader, true)
  84         huge := make([]byte, maxPacket+1)
  85         err := tr.writePacket(huge)
  86         if err == nil {
  87                 t.Errorf("transport accepted write for a huge packet.")
  88         }
  89 }
  90
  91 func TestTransportMaxPacketReader(t *testing.T) {
  92         var header [5]byte
  93         huge := make([]byte, maxPacket+128)
  94         binary.BigEndian.PutUint32(header[0:], uint32(len(huge)))
  95         // padding.
  96         header[4] = 0
  97
  98         buf := &closerBuffer{}
  99         buf.Write(header[:])
 100         buf.Write(huge)
 101
 102         tr := newTransport(buf, rand.Reader, true)
 103         _, err := tr.readPacket()
 104         if err == nil {
 105                 t.Errorf("transport succeeded reading huge packet.")
 106         } else if !strings.Contains(err.Error(), "large") {
 107                 t.Errorf("got %q, should mention %q", err.Error(), "large")
 108         }
 109 }