code review 5373055: exp/ssh: add client side support for publickey auth

src/pkg/exp/ssh/client.go

 // Copyright 2011 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
 package ssh
 
 import (
         "crypto"
         "crypto/rand"
         "errors"
@@ skipping 17 matching lines @@
 // Client returns a new SSH client connection using c as the underlying transport.
 func Client(c net.Conn, config *ClientConfig) (*ClientConn, error) {
         conn := &ClientConn{
                 transport: newTransport(c, config.rand()),
                 config:    config,
         }
         if err := conn.handshake(); err != nil {
                 conn.Close()
                 return nil, err
         }
-        if err := conn.authenticate(); err != nil {
-                conn.Close()
-                return nil, err
-        }
         go conn.mainLoop()
         return conn, nil
 }
 
 // handshake performs the client side key exchange. See RFC 4253 Section 7.
 func (c *ClientConn) handshake() error {
         var magics handshakeMagics
 
         if _, err := c.Write(clientVersion); err != nil {
                 return err
@@ skipping 69 matching lines @@
         }
         if err = c.transport.writer.setupKeys(clientKeys, K, H, H, hashFunc); err != nil {
                 return err
         }
         if packet, err = c.readPacket(); err != nil {
                 return err
         }
         if packet[0] != msgNewKeys {
                 return UnexpectedMessageError{msgNewKeys, packet[0]}
         }
-        return c.transport.reader.setupKeys(serverKeys, K, H, H, hashFunc)
+        if err := c.transport.reader.setupKeys(serverKeys, K, H, H, hashFunc); err != nil {
+                return err
+        }
+        return c.authenticate(H)
 }
 
 // kexDH performs Diffie-Hellman key agreement on a ClientConn. The
 // returned values are given the same names as in RFC 4253, section 8.
 func (c *ClientConn) kexDH(group *dhGroup, hashFunc crypto.Hash, magics *handshakeMagics, hostKeyAlgo string) ([]byte, []byte, error) {
         x, err := rand.Int(c.config.rand(), group.p)
         if err != nil {
                 return nil, nil, err
         }
         X := new(big.Int).Exp(group.g, x, group.p)
@@ skipping 311 matching lines @@
                 if !ok {
                         return 0, io.EOF
                 }
         }
         panic("unreachable")
 }
 
 func (r *chanReader) Close() error {
         return r.writePacket(marshal(msgChannelEOF, channelEOFMsg{r.id}))
 }