vendor/golang.org/x/crypto/ssh/agent/server_test.go

   1 // Copyright 2012 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 agent
   6
   7 import (
   8         "crypto"
   9         "crypto/rand"
  10         "fmt"
  11         "testing"
  12
  13         "golang.org/x/crypto/ssh"
  14 )
  15
  16 func TestServer(t *testing.T) {
  17         c1, c2, err := netPipe()
  18         if err != nil {
  19                 t.Fatalf("netPipe: %v", err)
  20         }
  21         defer c1.Close()
  22         defer c2.Close()
  23         client := NewClient(c1)
  24
  25         go ServeAgent(NewKeyring(), c2)
  26
  27         testAgentInterface(t, client, testPrivateKeys["rsa"], nil, 0)
  28 }
  29
  30 func TestLockServer(t *testing.T) {
  31         testLockAgent(NewKeyring(), t)
  32 }
  33
  34 func TestSetupForwardAgent(t *testing.T) {
  35         a, b, err := netPipe()
  36         if err != nil {
  37                 t.Fatalf("netPipe: %v", err)
  38         }
  39
  40         defer a.Close()
  41         defer b.Close()
  42
  43         _, socket, cleanup := startAgent(t)
  44         defer cleanup()
  45
  46         serverConf := ssh.ServerConfig{
  47                 NoClientAuth: true,
  48         }
  49         serverConf.AddHostKey(testSigners["rsa"])
  50         incoming := make(chan *ssh.ServerConn, 1)
  51         go func() {
  52                 conn, _, _, err := ssh.NewServerConn(a, &serverConf)
  53                 if err != nil {
  54                         t.Fatalf("Server: %v", err)
  55                 }
  56                 incoming <- conn
  57         }()
  58
  59         conf := ssh.ClientConfig{
  60                 HostKeyCallback: ssh.InsecureIgnoreHostKey(),
  61         }
  62         conn, chans, reqs, err := ssh.NewClientConn(b, "", &conf)
  63         if err != nil {
  64                 t.Fatalf("NewClientConn: %v", err)
  65         }
  66         client := ssh.NewClient(conn, chans, reqs)
  67
  68         if err := ForwardToRemote(client, socket); err != nil {
  69                 t.Fatalf("SetupForwardAgent: %v", err)
  70         }
  71
  72         server := <-incoming
  73         ch, reqs, err := server.OpenChannel(channelType, nil)
  74         if err != nil {
  75                 t.Fatalf("OpenChannel(%q): %v", channelType, err)
  76         }
  77         go ssh.DiscardRequests(reqs)
  78
  79         agentClient := NewClient(ch)
  80         testAgentInterface(t, agentClient, testPrivateKeys["rsa"], nil, 0)
  81         conn.Close()
  82 }
  83
  84 func TestV1ProtocolMessages(t *testing.T) {
  85         c1, c2, err := netPipe()
  86         if err != nil {
  87                 t.Fatalf("netPipe: %v", err)
  88         }
  89         defer c1.Close()
  90         defer c2.Close()
  91         c := NewClient(c1)
  92
  93         go ServeAgent(NewKeyring(), c2)
  94
  95         testV1ProtocolMessages(t, c.(*client))
  96 }
  97
  98 func testV1ProtocolMessages(t *testing.T, c *client) {
  99         reply, err := c.call([]byte{agentRequestV1Identities})
 100         if err != nil {
 101                 t.Fatalf("v1 request all failed: %v", err)
 102         }
 103         if msg, ok := reply.(*agentV1IdentityMsg); !ok || msg.Numkeys != 0 {
 104                 t.Fatalf("invalid request all response: %#v", reply)
 105         }
 106
 107         reply, err = c.call([]byte{agentRemoveAllV1Identities})
 108         if err != nil {
 109                 t.Fatalf("v1 remove all failed: %v", err)
 110         }
 111         if _, ok := reply.(*successAgentMsg); !ok {
 112                 t.Fatalf("invalid remove all response: %#v", reply)
 113         }
 114 }
 115
 116 func verifyKey(sshAgent Agent) error {
 117         keys, err := sshAgent.List()
 118         if err != nil {
 119                 return fmt.Errorf("listing keys: %v", err)
 120         }
 121
 122         if len(keys) != 1 {
 123                 return fmt.Errorf("bad number of keys found. expected 1, got %d", len(keys))
 124         }
 125
 126         buf := make([]byte, 128)
 127         if _, err := rand.Read(buf); err != nil {
 128                 return fmt.Errorf("rand: %v", err)
 129         }
 130
 131         sig, err := sshAgent.Sign(keys[0], buf)
 132         if err != nil {
 133                 return fmt.Errorf("sign: %v", err)
 134         }
 135
 136         if err := keys[0].Verify(buf, sig); err != nil {
 137                 return fmt.Errorf("verify: %v", err)
 138         }
 139         return nil
 140 }
 141
 142 func addKeyToAgent(key crypto.PrivateKey) error {
 143         sshAgent := NewKeyring()
 144         if err := sshAgent.Add(AddedKey{PrivateKey: key}); err != nil {
 145                 return fmt.Errorf("add: %v", err)
 146         }
 147         return verifyKey(sshAgent)
 148 }
 149
 150 func TestKeyTypes(t *testing.T) {
 151         for k, v := range testPrivateKeys {
 152                 if err := addKeyToAgent(v); err != nil {
 153                         t.Errorf("error adding key type %s, %v", k, err)
 154                 }
 155                 if err := addCertToAgentSock(v, nil); err != nil {
 156                         t.Errorf("error adding key type %s, %v", k, err)
 157                 }
 158         }
 159 }
 160
 161 func addCertToAgentSock(key crypto.PrivateKey, cert *ssh.Certificate) error {
 162         a, b, err := netPipe()
 163         if err != nil {
 164                 return err
 165         }
 166         agentServer := NewKeyring()
 167         go ServeAgent(agentServer, a)
 168
 169         agentClient := NewClient(b)
 170         if err := agentClient.Add(AddedKey{PrivateKey: key, Certificate: cert}); err != nil {
 171                 return fmt.Errorf("add: %v", err)
 172         }
 173         return verifyKey(agentClient)
 174 }
 175
 176 func addCertToAgent(key crypto.PrivateKey, cert *ssh.Certificate) error {
 177         sshAgent := NewKeyring()
 178         if err := sshAgent.Add(AddedKey{PrivateKey: key, Certificate: cert}); err != nil {
 179                 return fmt.Errorf("add: %v", err)
 180         }
 181         return verifyKey(sshAgent)
 182 }
 183
 184 func TestCertTypes(t *testing.T) {
 185         for keyType, key := range testPublicKeys {
 186                 cert := &ssh.Certificate{
 187                         ValidPrincipals: []string{"gopher1"},
 188                         ValidAfter:      0,
 189                         ValidBefore:     ssh.CertTimeInfinity,
 190                         Key:             key,
 191                         Serial:          1,
 192                         CertType:        ssh.UserCert,
 193                         SignatureKey:    testPublicKeys["rsa"],
 194                         Permissions: ssh.Permissions{
 195                                 CriticalOptions: map[string]string{},
 196                                 Extensions:      map[string]string{},
 197                         },
 198                 }
 199                 if err := cert.SignCert(rand.Reader, testSigners["rsa"]); err != nil {
 200                         t.Fatalf("signcert: %v", err)
 201                 }
 202                 if err := addCertToAgent(testPrivateKeys[keyType], cert); err != nil {
 203                         t.Fatalf("%v", err)
 204                 }
 205                 if err := addCertToAgentSock(testPrivateKeys[keyType], cert); err != nil {
 206                         t.Fatalf("%v", err)
 207                 }
 208         }
 209 }