← Back to branch summary

~juju-qa/ubuntu/xenial/juju/2.0-rc2

« back to all changes in this revision

Viewing changes to src/golang.org/x/crypto/ssh/agent/server_test.go

  • Committer: Nicholas Skaggs
  • Date: 2016-09-30 14:39:30 UTC
  • mfrom: (1.8.1)
  • Revision ID: nicholas.skaggs@canonical.com-20160930143930-vwwhrefh6ftckccy
import upstream

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/golang.org/x/crypto/ssh/agent/server_test.go
5
5
package agent
6
6
 
7
7
import (
 
8
        "crypto"
 
9
        "crypto/rand"
 
10
        "fmt"
8
11
        "testing"
9
12
 
10
13
        "golang.org/x/crypto/ssh"
75
78
        testAgentInterface(t, agentClient, testPrivateKeys["rsa"], nil, 0)
76
79
        conn.Close()
77
80
}
 
81
 
 
82
func TestV1ProtocolMessages(t *testing.T) {
 
83
        c1, c2, err := netPipe()
 
84
        if err != nil {
 
85
                t.Fatalf("netPipe: %v", err)
 
86
        }
 
87
        defer c1.Close()
 
88
        defer c2.Close()
 
89
        c := NewClient(c1)
 
90
 
 
91
        go ServeAgent(NewKeyring(), c2)
 
92
 
 
93
        testV1ProtocolMessages(t, c.(*client))
 
94
}
 
95
 
 
96
func testV1ProtocolMessages(t *testing.T, c *client) {
 
97
        reply, err := c.call([]byte{agentRequestV1Identities})
 
98
        if err != nil {
 
99
                t.Fatalf("v1 request all failed: %v", err)
 
100
        }
 
101
        if msg, ok := reply.(*agentV1IdentityMsg); !ok || msg.Numkeys != 0 {
 
102
                t.Fatalf("invalid request all response: %#v", reply)
 
103
        }
 
104
 
 
105
        reply, err = c.call([]byte{agentRemoveAllV1Identities})
 
106
        if err != nil {
 
107
                t.Fatalf("v1 remove all failed: %v", err)
 
108
        }
 
109
        if _, ok := reply.(*successAgentMsg); !ok {
 
110
                t.Fatalf("invalid remove all response: %#v", reply)
 
111
        }
 
112
}
 
113
 
 
114
func verifyKey(sshAgent Agent) error {
 
115
        keys, err := sshAgent.List()
 
116
        if err != nil {
 
117
                return fmt.Errorf("listing keys: %v", err)
 
118
        }
 
119
 
 
120
        if len(keys) != 1 {
 
121
                return fmt.Errorf("bad number of keys found. expected 1, got %d", len(keys))
 
122
        }
 
123
 
 
124
        buf := make([]byte, 128)
 
125
        if _, err := rand.Read(buf); err != nil {
 
126
                return fmt.Errorf("rand: %v", err)
 
127
        }
 
128
 
 
129
        sig, err := sshAgent.Sign(keys[0], buf)
 
130
        if err != nil {
 
131
                return fmt.Errorf("sign: %v", err)
 
132
        }
 
133
 
 
134
        if err := keys[0].Verify(buf, sig); err != nil {
 
135
                return fmt.Errorf("verify: %v", err)
 
136
        }
 
137
        return nil
 
138
}
 
139
 
 
140
func addKeyToAgent(key crypto.PrivateKey) error {
 
141
        sshAgent := NewKeyring()
 
142
        if err := sshAgent.Add(AddedKey{PrivateKey: key}); err != nil {
 
143
                return fmt.Errorf("add: %v", err)
 
144
        }
 
145
        return verifyKey(sshAgent)
 
146
}
 
147
 
 
148
func TestKeyTypes(t *testing.T) {
 
149
        for k, v := range testPrivateKeys {
 
150
                if err := addKeyToAgent(v); err != nil {
 
151
                        t.Errorf("error adding key type %s, %v", k, err)
 
152
                }
 
153
                if err := addCertToAgentSock(v, nil); err != nil {
 
154
                        t.Errorf("error adding key type %s, %v", k, err)
 
155
                }
 
156
        }
 
157
}
 
158
 
 
159
func addCertToAgentSock(key crypto.PrivateKey, cert *ssh.Certificate) error {
 
160
        a, b, err := netPipe()
 
161
        if err != nil {
 
162
                return err
 
163
        }
 
164
        agentServer := NewKeyring()
 
165
        go ServeAgent(agentServer, a)
 
166
 
 
167
        agentClient := NewClient(b)
 
168
        if err := agentClient.Add(AddedKey{PrivateKey: key, Certificate: cert}); err != nil {
 
169
                return fmt.Errorf("add: %v", err)
 
170
        }
 
171
        return verifyKey(agentClient)
 
172
}
 
173
 
 
174
func addCertToAgent(key crypto.PrivateKey, cert *ssh.Certificate) error {
 
175
        sshAgent := NewKeyring()
 
176
        if err := sshAgent.Add(AddedKey{PrivateKey: key, Certificate: cert}); err != nil {
 
177
                return fmt.Errorf("add: %v", err)
 
178
        }
 
179
        return verifyKey(sshAgent)
 
180
}
 
181
 
 
182
func TestCertTypes(t *testing.T) {
 
183
        for keyType, key := range testPublicKeys {
 
184
                cert := &ssh.Certificate{
 
185
                        ValidPrincipals: []string{"gopher1"},
 
186
                        ValidAfter:      0,
 
187
                        ValidBefore:     ssh.CertTimeInfinity,
 
188
                        Key:             key,
 
189
                        Serial:          1,
 
190
                        CertType:        ssh.UserCert,
 
191
                        SignatureKey:    testPublicKeys["rsa"],
 
192
                        Permissions: ssh.Permissions{
 
193
                                CriticalOptions: map[string]string{},
 
194
                                Extensions:      map[string]string{},
 
195
                        },
 
196
                }
 
197
                if err := cert.SignCert(rand.Reader, testSigners["rsa"]); err != nil {
 
198
                        t.Fatalf("signcert: %v", err)
 
199
                }
 
200
                if err := addCertToAgent(testPrivateKeys[keyType], cert); err != nil {
 
201
                        t.Fatalf("%v", err)
 
202
                }
 
203
                if err := addCertToAgentSock(testPrivateKeys[keyType], cert); err != nil {
 
204
                        t.Fatalf("%v", err)
 
205
                }
 
206
        }
 
207
}