Merge branch 'develop' of https://github.com/gogits/gogs into developtokarchuk/v1.17
Emrah URHAN
9 years ago
commit
737da1a374
@ -0,0 +1,35 @@ |
||||
LDFLAGS += -X "github.com/gogits/gogs/modules/setting.BuildTime=$(shell date -u '+%Y-%m-%d %I:%M:%S %Z')"
|
||||
LDFLAGS += -X "github.com/gogits/gogs/modules/setting.BuildGitHash=$(shell git rev-parse HEAD)"
|
||||
|
||||
TAGS = ""
|
||||
|
||||
RELEASE_ROOT = "release"
|
||||
RELEASE_GOGS = "release/gogs"
|
||||
NOW = $(shell date -u '+%Y%m%d%I%M%S')
|
||||
|
||||
.PHONY: build pack release bindata clean |
||||
|
||||
build: |
||||
go install -ldflags '$(LDFLAGS)' -tags '$(TAGS)'
|
||||
go build -ldflags '$(LDFLAGS)' -tags '$(TAGS)'
|
||||
|
||||
govet: |
||||
go tool vet -composites=false -methods=false -structtags=false .
|
||||
|
||||
pack: |
||||
rm -rf $(RELEASE_GOGS)
|
||||
mkdir -p $(RELEASE_GOGS)
|
||||
cp -r gogs LICENSE README.md README_ZH.md templates public scripts $(RELEASE_GOGS)
|
||||
rm -rf $(RELEASE_GOGS)/public/config.codekit $(RELEASE_GOGS)/public/less
|
||||
cd $(RELEASE_ROOT) && zip -r gogs.$(NOW).zip "gogs"
|
||||
|
||||
release: build pack |
||||
|
||||
bindata: |
||||
go-bindata -o=modules/bindata/bindata.go -ignore="\\.DS_Store|README.md" -pkg=bindata conf/...
|
||||
|
||||
clean: |
||||
go clean -i ./...
|
||||
|
||||
clean-mac: clean |
||||
find . -name ".DS_Store" -print0 | xargs -0 rm
|
||||
@ -0,0 +1,42 @@ |
||||
// Copyright 2015 The Gogs Authors. All rights reserved.
|
||||
// Use of this source code is governed by a MIT-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
package cmd |
||||
|
||||
import ( |
||||
"time" |
||||
|
||||
"github.com/codegangsta/cli" |
||||
) |
||||
|
||||
func stringFlag(name, value, usage string) cli.StringFlag { |
||||
return cli.StringFlag{ |
||||
Name: name, |
||||
Value: value, |
||||
Usage: usage, |
||||
} |
||||
} |
||||
|
||||
func boolFlag(name, usage string) cli.BoolFlag { |
||||
return cli.BoolFlag{ |
||||
Name: name, |
||||
Usage: usage, |
||||
} |
||||
} |
||||
|
||||
func intFlag(name string, value int, usage string) cli.IntFlag { |
||||
return cli.IntFlag{ |
||||
Name: name, |
||||
Value: value, |
||||
Usage: usage, |
||||
} |
||||
} |
||||
|
||||
func durationFlag(name string, value time.Duration, usage string) cli.DurationFlag { |
||||
return cli.DurationFlag{ |
||||
Name: name, |
||||
Value: value, |
||||
Usage: usage, |
||||
} |
||||
} |
||||
@ -1,20 +1,29 @@ |
||||
# This file lists all PUBLIC individuals having contributed content to the translation. |
||||
# Order of name is meaningless. |
||||
# Entries are in alphabetical order. |
||||
|
||||
Akihiro YAGASAKI <yaggytter@momiage.com> |
||||
Alexander Steinhöfer <kontakt@lx-s.de> |
||||
Alexandre Magno <alexandre.mbm@gmail.com> |
||||
Barış Arda Yılmaz <ardayilmazgamer@gmail.com> |
||||
Christoph Kisfeld <christoph.kisfeld@gmail.com> |
||||
Daniel Speichert <daniel@speichert.pl> |
||||
Gregor Santner <gdev@live.de> |
||||
Huimin Wang <wanghm2009@hotmail.co.jp> |
||||
ilko <email> |
||||
Thomas Fanninger <gogs.thomas@fanninger.at> |
||||
Łukasz Jan Niemier <lukasz@niemier.pl> |
||||
Lafriks <lafriks@gmail.com> |
||||
Luc Stepniewski <luc@stepniewski.fr> |
||||
Miguel de la Cruz <miguel@mcrx.me> |
||||
Marc Schiller <marc@schiller.im> |
||||
Morten Sørensen <klim8d@gmail.com> |
||||
Natan Albuquerque <natanalbuquerque5@gmail.com> |
||||
Akihiro YAGASAKI <yaggytter AT momiage DOT com> |
||||
Alexander Steinhöfer <kontakt AT lx-s DOT de> |
||||
Alexandre Magno <alexandre DOT mbm AT gmail DOT com> |
||||
Andrey Nering <andrey AT nering DOT com DOT br> |
||||
Arthur Aslanyan <arthur DOT e DOT aslanyan AT gmail DOT com> |
||||
Barış Arda Yılmaz <ardayilmazgamer AT gmail DOT com> |
||||
Christoph Kisfeld <christoph DOT kisfeld AT gmail DOT com> |
||||
Daniel Speichert <daniel AT speichert DOT pl> |
||||
Dmitriy Nogay <me AT catwhocode DOT ga> |
||||
Gregor Santner <gdev AT live DOT de> |
||||
Hamid Feizabadi <hamidfzm AT gmail DOT com> |
||||
Huimin Wang <wanghm2009 AT hotmail DOT co DOT jp> |
||||
ilko |
||||
Lafriks <lafriks AT gmail DOT com> |
||||
Lauri Ojansivu <x AT xet7 DOT org> |
||||
Luc Stepniewski <luc AT stepniewski DOT fr> |
||||
Marc Schiller <marc AT schiller DOT im> |
||||
Miguel de la Cruz <miguel AT mcrx DOT me> |
||||
Morten Sørensen <klim8d AT gmail DOT com> |
||||
Natan Albuquerque <natanalbuquerque5 AT gmail DOT com> |
||||
Odilon Junior <odilon DOT junior93 AT gmail DOT com> |
||||
Thomas Fanninger <gogs DOT thomas AT fanninger DOT at> |
||||
Tilmann Bach <tilmann AT outlook DOT com> |
||||
Vladimir Vissoultchev <wqweto AT gmail DOT com> |
||||
YJSoft <yjsoft AT yjsoft DOT pe DOT kr> |
||||
Łukasz Jan Niemier <lukasz AT niemier DOT pl> |
||||
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
@ -1,12 +0,0 @@ |
||||
web: |
||||
build: . |
||||
links: |
||||
- mysql |
||||
ports: |
||||
- "3000:3000" |
||||
|
||||
mysql: |
||||
image: mysql |
||||
environment: |
||||
- MYSQL_ROOT_PASSWORD=gogs |
||||
- MYSQL_DATABASE=gogs |
||||
@ -0,0 +1,7 @@ |
||||
#!/bin/sh |
||||
|
||||
if test -f ./setup; then |
||||
source ./setup |
||||
fi |
||||
|
||||
exec gosu root /sbin/syslogd -nS -O- |
||||
File diff suppressed because one or more lines are too long
@ -1,615 +0,0 @@ |
||||
// Copyright 2012 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 agent implements a client to an ssh-agent daemon. |
||||
|
||||
References: |
||||
[PROTOCOL.agent]: http://cvsweb.openbsd.org/cgi-bin/cvsweb/src/usr.bin/ssh/PROTOCOL.agent?rev=HEAD
|
||||
*/ |
||||
package agent |
||||
|
||||
import ( |
||||
"bytes" |
||||
"crypto/dsa" |
||||
"crypto/ecdsa" |
||||
"crypto/elliptic" |
||||
"crypto/rsa" |
||||
"encoding/base64" |
||||
"encoding/binary" |
||||
"errors" |
||||
"fmt" |
||||
"io" |
||||
"math/big" |
||||
"sync" |
||||
|
||||
"github.com/gogits/gogs/modules/crypto/ssh" |
||||
) |
||||
|
||||
// Agent represents the capabilities of an ssh-agent.
|
||||
type Agent interface { |
||||
// List returns the identities known to the agent.
|
||||
List() ([]*Key, error) |
||||
|
||||
// Sign has the agent sign the data using a protocol 2 key as defined
|
||||
// in [PROTOCOL.agent] section 2.6.2.
|
||||
Sign(key ssh.PublicKey, data []byte) (*ssh.Signature, error) |
||||
|
||||
// Add adds a private key to the agent.
|
||||
Add(key AddedKey) error |
||||
|
||||
// Remove removes all identities with the given public key.
|
||||
Remove(key ssh.PublicKey) error |
||||
|
||||
// RemoveAll removes all identities.
|
||||
RemoveAll() error |
||||
|
||||
// Lock locks the agent. Sign and Remove will fail, and List will empty an empty list.
|
||||
Lock(passphrase []byte) error |
||||
|
||||
// Unlock undoes the effect of Lock
|
||||
Unlock(passphrase []byte) error |
||||
|
||||
// Signers returns signers for all the known keys.
|
||||
Signers() ([]ssh.Signer, error) |
||||
} |
||||
|
||||
// AddedKey describes an SSH key to be added to an Agent.
|
||||
type AddedKey struct { |
||||
// PrivateKey must be a *rsa.PrivateKey, *dsa.PrivateKey or
|
||||
// *ecdsa.PrivateKey, which will be inserted into the agent.
|
||||
PrivateKey interface{} |
||||
// Certificate, if not nil, is communicated to the agent and will be
|
||||
// stored with the key.
|
||||
Certificate *ssh.Certificate |
||||
// Comment is an optional, free-form string.
|
||||
Comment string |
||||
// LifetimeSecs, if not zero, is the number of seconds that the
|
||||
// agent will store the key for.
|
||||
LifetimeSecs uint32 |
||||
// ConfirmBeforeUse, if true, requests that the agent confirm with the
|
||||
// user before each use of this key.
|
||||
ConfirmBeforeUse bool |
||||
} |
||||
|
||||
// See [PROTOCOL.agent], section 3.
|
||||
const ( |
||||
agentRequestV1Identities = 1 |
||||
|
||||
// 3.2 Requests from client to agent for protocol 2 key operations
|
||||
agentAddIdentity = 17 |
||||
agentRemoveIdentity = 18 |
||||
agentRemoveAllIdentities = 19 |
||||
agentAddIdConstrained = 25 |
||||
|
||||
// 3.3 Key-type independent requests from client to agent
|
||||
agentAddSmartcardKey = 20 |
||||
agentRemoveSmartcardKey = 21 |
||||
agentLock = 22 |
||||
agentUnlock = 23 |
||||
agentAddSmartcardKeyConstrained = 26 |
||||
|
||||
// 3.7 Key constraint identifiers
|
||||
agentConstrainLifetime = 1 |
||||
agentConstrainConfirm = 2 |
||||
) |
||||
|
||||
// maxAgentResponseBytes is the maximum agent reply size that is accepted. This
|
||||
// is a sanity check, not a limit in the spec.
|
||||
const maxAgentResponseBytes = 16 << 20 |
||||
|
||||
// Agent messages:
|
||||
// These structures mirror the wire format of the corresponding ssh agent
|
||||
// messages found in [PROTOCOL.agent].
|
||||
|
||||
// 3.4 Generic replies from agent to client
|
||||
const agentFailure = 5 |
||||
|
||||
type failureAgentMsg struct{} |
||||
|
||||
const agentSuccess = 6 |
||||
|
||||
type successAgentMsg struct{} |
||||
|
||||
// See [PROTOCOL.agent], section 2.5.2.
|
||||
const agentRequestIdentities = 11 |
||||
|
||||
type requestIdentitiesAgentMsg struct{} |
||||
|
||||
// See [PROTOCOL.agent], section 2.5.2.
|
||||
const agentIdentitiesAnswer = 12 |
||||
|
||||
type identitiesAnswerAgentMsg struct { |
||||
NumKeys uint32 `sshtype:"12"` |
||||
Keys []byte `ssh:"rest"` |
||||
} |
||||
|
||||
// See [PROTOCOL.agent], section 2.6.2.
|
||||
const agentSignRequest = 13 |
||||
|
||||
type signRequestAgentMsg struct { |
||||
KeyBlob []byte `sshtype:"13"` |
||||
Data []byte |
||||
Flags uint32 |
||||
} |
||||
|
||||
// See [PROTOCOL.agent], section 2.6.2.
|
||||
|
||||
// 3.6 Replies from agent to client for protocol 2 key operations
|
||||
const agentSignResponse = 14 |
||||
|
||||
type signResponseAgentMsg struct { |
||||
SigBlob []byte `sshtype:"14"` |
||||
} |
||||
|
||||
type publicKey struct { |
||||
Format string |
||||
Rest []byte `ssh:"rest"` |
||||
} |
||||
|
||||
// Key represents a protocol 2 public key as defined in
|
||||
// [PROTOCOL.agent], section 2.5.2.
|
||||
type Key struct { |
||||
Format string |
||||
Blob []byte |
||||
Comment string |
||||
} |
||||
|
||||
func clientErr(err error) error { |
||||
return fmt.Errorf("agent: client error: %v", err) |
||||
} |
||||
|
||||
// String returns the storage form of an agent key with the format, base64
|
||||
// encoded serialized key, and the comment if it is not empty.
|
||||
func (k *Key) String() string { |
||||
s := string(k.Format) + " " + base64.StdEncoding.EncodeToString(k.Blob) |
||||
|
||||
if k.Comment != "" { |
||||
s += " " + k.Comment |
||||
} |
||||
|
||||
return s |
||||
} |
||||
|
||||
// Type returns the public key type.
|
||||
func (k *Key) Type() string { |
||||
return k.Format |
||||
} |
||||
|
||||
// Marshal returns key blob to satisfy the ssh.PublicKey interface.
|
||||
func (k *Key) Marshal() []byte { |
||||
return k.Blob |
||||
} |
||||
|
||||
// Verify satisfies the ssh.PublicKey interface, but is not
|
||||
// implemented for agent keys.
|
||||
func (k *Key) Verify(data []byte, sig *ssh.Signature) error { |
||||
return errors.New("agent: agent key does not know how to verify") |
||||
} |
||||
|
||||
type wireKey struct { |
||||
Format string |
||||
Rest []byte `ssh:"rest"` |
||||
} |
||||
|
||||
func parseKey(in []byte) (out *Key, rest []byte, err error) { |
||||
var record struct { |
||||
Blob []byte |
||||
Comment string |
||||
Rest []byte `ssh:"rest"` |
||||
} |
||||
|
||||
if err := ssh.Unmarshal(in, &record); err != nil { |
||||
return nil, nil, err |
||||
} |
||||
|
||||
var wk wireKey |
||||
if err := ssh.Unmarshal(record.Blob, &wk); err != nil { |
||||
return nil, nil, err |
||||
} |
||||
|
||||
return &Key{ |
||||
Format: wk.Format, |
||||
Blob: record.Blob, |
||||
Comment: record.Comment, |
||||
}, record.Rest, nil |
||||
} |
||||
|
||||
// client is a client for an ssh-agent process.
|
||||
type client struct { |
||||
// conn is typically a *net.UnixConn
|
||||
conn io.ReadWriter |
||||
// mu is used to prevent concurrent access to the agent
|
||||
mu sync.Mutex |
||||
} |
||||
|
||||
// NewClient returns an Agent that talks to an ssh-agent process over
|
||||
// the given connection.
|
||||
func NewClient(rw io.ReadWriter) Agent { |
||||
return &client{conn: rw} |
||||
} |
||||
|
||||
// call sends an RPC to the agent. On success, the reply is
|
||||
// unmarshaled into reply and replyType is set to the first byte of
|
||||
// the reply, which contains the type of the message.
|
||||
func (c *client) call(req []byte) (reply interface{}, err error) { |
||||
c.mu.Lock() |
||||
defer c.mu.Unlock() |
||||
|
||||
msg := make([]byte, 4+len(req)) |
||||
binary.BigEndian.PutUint32(msg, uint32(len(req))) |
||||
copy(msg[4:], req) |
||||
if _, err = c.conn.Write(msg); err != nil { |
||||
return nil, clientErr(err) |
||||
} |
||||
|
||||
var respSizeBuf [4]byte |
||||
if _, err = io.ReadFull(c.conn, respSizeBuf[:]); err != nil { |
||||
return nil, clientErr(err) |
||||
} |
||||
respSize := binary.BigEndian.Uint32(respSizeBuf[:]) |
||||
if respSize > maxAgentResponseBytes { |
||||
return nil, clientErr(err) |
||||
} |
||||
|
||||
buf := make([]byte, respSize) |
||||
if _, err = io.ReadFull(c.conn, buf); err != nil { |
||||
return nil, clientErr(err) |
||||
} |
||||
reply, err = unmarshal(buf) |
||||
if err != nil { |
||||
return nil, clientErr(err) |
||||
} |
||||
return reply, err |
||||
} |
||||
|
||||
func (c *client) simpleCall(req []byte) error { |
||||
resp, err := c.call(req) |
||||
if err != nil { |
||||
return err |
||||
} |
||||
if _, ok := resp.(*successAgentMsg); ok { |
||||
return nil |
||||
} |
||||
return errors.New("agent: failure") |
||||
} |
||||
|
||||
func (c *client) RemoveAll() error { |
||||
return c.simpleCall([]byte{agentRemoveAllIdentities}) |
||||
} |
||||
|
||||
func (c *client) Remove(key ssh.PublicKey) error { |
||||
req := ssh.Marshal(&agentRemoveIdentityMsg{ |
||||
KeyBlob: key.Marshal(), |
||||
}) |
||||
return c.simpleCall(req) |
||||
} |
||||
|
||||
func (c *client) Lock(passphrase []byte) error { |
||||
req := ssh.Marshal(&agentLockMsg{ |
||||
Passphrase: passphrase, |
||||
}) |
||||
return c.simpleCall(req) |
||||
} |
||||
|
||||
func (c *client) Unlock(passphrase []byte) error { |
||||
req := ssh.Marshal(&agentUnlockMsg{ |
||||
Passphrase: passphrase, |
||||
}) |
||||
return c.simpleCall(req) |
||||
} |
||||
|
||||
// List returns the identities known to the agent.
|
||||
func (c *client) List() ([]*Key, error) { |
||||
// see [PROTOCOL.agent] section 2.5.2.
|
||||
req := []byte{agentRequestIdentities} |
||||
|
||||
msg, err := c.call(req) |
||||
if err != nil { |
||||
return nil, err |
||||
} |
||||
|
||||
switch msg := msg.(type) { |
||||
case *identitiesAnswerAgentMsg: |
||||
if msg.NumKeys > maxAgentResponseBytes/8 { |
||||
return nil, errors.New("agent: too many keys in agent reply") |
||||
} |
||||
keys := make([]*Key, msg.NumKeys) |
||||
data := msg.Keys |
||||
for i := uint32(0); i < msg.NumKeys; i++ { |
||||
var key *Key |
||||
var err error |
||||
if key, data, err = parseKey(data); err != nil { |
||||
return nil, err |
||||
} |
||||
keys[i] = key |
||||
} |
||||
return keys, nil |
||||
case *failureAgentMsg: |
||||
return nil, errors.New("agent: failed to list keys") |
||||
} |
||||
panic("unreachable") |
||||
} |
||||
|
||||
// Sign has the agent sign the data using a protocol 2 key as defined
|
||||
// in [PROTOCOL.agent] section 2.6.2.
|
||||
func (c *client) Sign(key ssh.PublicKey, data []byte) (*ssh.Signature, error) { |
||||
req := ssh.Marshal(signRequestAgentMsg{ |
||||
KeyBlob: key.Marshal(), |
||||
Data: data, |
||||
}) |
||||
|
||||
msg, err := c.call(req) |
||||
if err != nil { |
||||
return nil, err |
||||
} |
||||
|
||||
switch msg := msg.(type) { |
||||
case *signResponseAgentMsg: |
||||
var sig ssh.Signature |
||||
if err := ssh.Unmarshal(msg.SigBlob, &sig); err != nil { |
||||
return nil, err |
||||
} |
||||
|
||||
return &sig, nil |
||||
case *failureAgentMsg: |
||||
return nil, errors.New("agent: failed to sign challenge") |
||||
} |
||||
panic("unreachable") |
||||
} |
||||
|
||||
// unmarshal parses an agent message in packet, returning the parsed
|
||||
// form and the message type of packet.
|
||||
func unmarshal(packet []byte) (interface{}, error) { |
||||
if len(packet) < 1 { |
||||
return nil, errors.New("agent: empty packet") |
||||
} |
||||
var msg interface{} |
||||
switch packet[0] { |
||||
case agentFailure: |
||||
return new(failureAgentMsg), nil |
||||
case agentSuccess: |
||||
return new(successAgentMsg), nil |
||||
case agentIdentitiesAnswer: |
||||
msg = new(identitiesAnswerAgentMsg) |
||||
case agentSignResponse: |
||||
msg = new(signResponseAgentMsg) |
||||
default: |
||||
return nil, fmt.Errorf("agent: unknown type tag %d", packet[0]) |
||||
} |
||||
if err := ssh.Unmarshal(packet, msg); err != nil { |
||||
return nil, err |
||||
} |
||||
return msg, nil |
||||
} |
||||
|
||||
type rsaKeyMsg struct { |
||||
Type string `sshtype:"17"` |
||||
N *big.Int |
||||
E *big.Int |
||||
D *big.Int |
||||
Iqmp *big.Int // IQMP = Inverse Q Mod P
|
||||
P *big.Int |
||||
Q *big.Int |
||||
Comments string |
||||
Constraints []byte `ssh:"rest"` |
||||
} |
||||
|
||||
type dsaKeyMsg struct { |
||||
Type string `sshtype:"17"` |
||||
P *big.Int |
||||
Q *big.Int |
||||
G *big.Int |
||||
Y *big.Int |
||||
X *big.Int |
||||
Comments string |
||||
Constraints []byte `ssh:"rest"` |
||||
} |
||||
|
||||
type ecdsaKeyMsg struct { |
||||
Type string `sshtype:"17"` |
||||
Curve string |
||||
KeyBytes []byte |
||||
D *big.Int |
||||
Comments string |
||||
Constraints []byte `ssh:"rest"` |
||||
} |
||||
|
||||
// Insert adds a private key to the agent.
|
||||
func (c *client) insertKey(s interface{}, comment string, constraints []byte) error { |
||||
var req []byte |
||||
switch k := s.(type) { |
||||
case *rsa.PrivateKey: |
||||
if len(k.Primes) != 2 { |
||||
return fmt.Errorf("agent: unsupported RSA key with %d primes", len(k.Primes)) |
||||
} |
||||
k.Precompute() |
||||
req = ssh.Marshal(rsaKeyMsg{ |
||||
Type: ssh.KeyAlgoRSA, |
||||
N: k.N, |
||||
E: big.NewInt(int64(k.E)), |
||||
D: k.D, |
||||
Iqmp: k.Precomputed.Qinv, |
||||
P: k.Primes[0], |
||||
Q: k.Primes[1], |
||||
Comments: comment, |
||||
Constraints: constraints, |
||||
}) |
||||
case *dsa.PrivateKey: |
||||
req = ssh.Marshal(dsaKeyMsg{ |
||||
Type: ssh.KeyAlgoDSA, |
||||
P: k.P, |
||||
Q: k.Q, |
||||
G: k.G, |
||||
Y: k.Y, |
||||
X: k.X, |
||||
Comments: comment, |
||||
Constraints: constraints, |
||||
}) |
||||
case *ecdsa.PrivateKey: |
||||
nistID := fmt.Sprintf("nistp%d", k.Params().BitSize) |
||||
req = ssh.Marshal(ecdsaKeyMsg{ |
||||
Type: "ecdsa-sha2-" + nistID, |
||||
Curve: nistID, |
||||
KeyBytes: elliptic.Marshal(k.Curve, k.X, k.Y), |
||||
D: k.D, |
||||
Comments: comment, |
||||
Constraints: constraints, |
||||
}) |
||||
default: |
||||
return fmt.Errorf("agent: unsupported key type %T", s) |
||||
} |
||||
|
||||
// if constraints are present then the message type needs to be changed.
|
||||
if len(constraints) != 0 { |
||||
req[0] = agentAddIdConstrained |
||||
} |
||||
|
||||
resp, err := c.call(req) |
||||
if err != nil { |
||||
return err |
||||
} |
||||
if _, ok := resp.(*successAgentMsg); ok { |
||||
return nil |
||||
} |
||||
return errors.New("agent: failure") |
||||
} |
||||
|
||||
type rsaCertMsg struct { |
||||
Type string `sshtype:"17"` |
||||
CertBytes []byte |
||||
D *big.Int |
||||
Iqmp *big.Int // IQMP = Inverse Q Mod P
|
||||
P *big.Int |
||||
Q *big.Int |
||||
Comments string |
||||
Constraints []byte `ssh:"rest"` |
||||
} |
||||
|
||||
type dsaCertMsg struct { |
||||
Type string `sshtype:"17"` |
||||
CertBytes []byte |
||||
X *big.Int |
||||
Comments string |
||||
Constraints []byte `ssh:"rest"` |
||||
} |
||||
|
||||
type ecdsaCertMsg struct { |
||||
Type string `sshtype:"17"` |
||||
CertBytes []byte |
||||
D *big.Int |
||||
Comments string |
||||
Constraints []byte `ssh:"rest"` |
||||
} |
||||
|
||||
// Insert adds a private key to the agent. If a certificate is given,
|
||||
// that certificate is added instead as public key.
|
||||
func (c *client) Add(key AddedKey) error { |
||||
var constraints []byte |
||||
|
||||
if secs := key.LifetimeSecs; secs != 0 { |
||||
constraints = append(constraints, agentConstrainLifetime) |
||||
|
||||
var secsBytes [4]byte |
||||
binary.BigEndian.PutUint32(secsBytes[:], secs) |
||||
constraints = append(constraints, secsBytes[:]...) |
||||
} |
||||
|
||||
if key.ConfirmBeforeUse { |
||||
constraints = append(constraints, agentConstrainConfirm) |
||||
} |
||||
|
||||
if cert := key.Certificate; cert == nil { |
||||
return c.insertKey(key.PrivateKey, key.Comment, constraints) |
||||
} else { |
||||
return c.insertCert(key.PrivateKey, cert, key.Comment, constraints) |
||||
} |
||||
} |
||||
|
||||
func (c *client) insertCert(s interface{}, cert *ssh.Certificate, comment string, constraints []byte) error { |
||||
var req []byte |
||||
switch k := s.(type) { |
||||
case *rsa.PrivateKey: |
||||
if len(k.Primes) != 2 { |
||||
return fmt.Errorf("agent: unsupported RSA key with %d primes", len(k.Primes)) |
||||
} |
||||
k.Precompute() |
||||
req = ssh.Marshal(rsaCertMsg{ |
||||
Type: cert.Type(), |
||||
CertBytes: cert.Marshal(), |
||||
D: k.D, |
||||
Iqmp: k.Precomputed.Qinv, |
||||
P: k.Primes[0], |
||||
Q: k.Primes[1], |
||||
Comments: comment, |
||||
Constraints: constraints, |
||||
}) |
||||
case *dsa.PrivateKey: |
||||
req = ssh.Marshal(dsaCertMsg{ |
||||
Type: cert.Type(), |
||||
CertBytes: cert.Marshal(), |
||||
X: k.X, |
||||
Comments: comment, |
||||
}) |
||||
case *ecdsa.PrivateKey: |
||||
req = ssh.Marshal(ecdsaCertMsg{ |
||||
Type: cert.Type(), |
||||
CertBytes: cert.Marshal(), |
||||
D: k.D, |
||||
Comments: comment, |
||||
}) |
||||
default: |
||||
return fmt.Errorf("agent: unsupported key type %T", s) |
||||
} |
||||
|
||||
// if constraints are present then the message type needs to be changed.
|
||||
if len(constraints) != 0 { |
||||
req[0] = agentAddIdConstrained |
||||
} |
||||
|
||||
signer, err := ssh.NewSignerFromKey(s) |
||||
if err != nil { |
||||
return err |
||||
} |
||||
if bytes.Compare(cert.Key.Marshal(), signer.PublicKey().Marshal()) != 0 { |
||||
return errors.New("agent: signer and cert have different public key") |
||||
} |
||||
|
||||
resp, err := c.call(req) |
||||
if err != nil { |
||||
return err |
||||
} |
||||
if _, ok := resp.(*successAgentMsg); ok { |
||||
return nil |
||||
} |
||||
return errors.New("agent: failure") |
||||
} |
||||
|
||||
// Signers provides a callback for client authentication.
|
||||
func (c *client) Signers() ([]ssh.Signer, error) { |
||||
keys, err := c.List() |
||||
if err != nil { |
||||
return nil, err |
||||
} |
||||
|
||||
var result []ssh.Signer |
||||
for _, k := range keys { |
||||
result = append(result, &agentKeyringSigner{c, k}) |
||||
} |
||||
return result, nil |
||||
} |
||||
|
||||
type agentKeyringSigner struct { |
||||
agent *client |
||||
pub ssh.PublicKey |
||||
} |
||||
|
||||
func (s *agentKeyringSigner) PublicKey() ssh.PublicKey { |
||||
return s.pub |
||||
} |
||||
|
||||
func (s *agentKeyringSigner) Sign(rand io.Reader, data []byte) (*ssh.Signature, error) { |
||||
// The agent has its own entropy source, so the rand argument is ignored.
|
||||
return s.agent.Sign(s.pub, data) |
||||
} |
||||
@ -1,287 +0,0 @@ |
||||
// Copyright 2012 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 agent |
||||
|
||||
import ( |
||||
"bytes" |
||||
"crypto/rand" |
||||
"errors" |
||||
"net" |
||||
"os" |
||||
"os/exec" |
||||
"path/filepath" |
||||
"strconv" |
||||
"testing" |
||||
|
||||
"github.com/gogits/gogs/modules/crypto/ssh" |
||||
) |
||||
|
||||
// startAgent executes ssh-agent, and returns a Agent interface to it.
|
||||
func startAgent(t *testing.T) (client Agent, socket string, cleanup func()) { |
||||
if testing.Short() { |
||||
// ssh-agent is not always available, and the key
|
||||
// types supported vary by platform.
|
||||
t.Skip("skipping test due to -short") |
||||
} |
||||
|
||||
bin, err := exec.LookPath("ssh-agent") |
||||
if err != nil { |
||||
t.Skip("could not find ssh-agent") |
||||
} |
||||
|
||||
cmd := exec.Command(bin, "-s") |
||||
out, err := cmd.Output() |
||||
if err != nil { |
||||
t.Fatalf("cmd.Output: %v", err) |
||||
} |
||||
|
||||
/* Output looks like: |
||||
|
||||
SSH_AUTH_SOCK=/tmp/ssh-P65gpcqArqvH/agent.15541; export SSH_AUTH_SOCK; |
||||
SSH_AGENT_PID=15542; export SSH_AGENT_PID; |
||||
echo Agent pid 15542; |
||||
*/ |
||||
fields := bytes.Split(out, []byte(";")) |
||||
line := bytes.SplitN(fields[0], []byte("="), 2) |
||||
line[0] = bytes.TrimLeft(line[0], "\n") |
||||
if string(line[0]) != "SSH_AUTH_SOCK" { |
||||
t.Fatalf("could not find key SSH_AUTH_SOCK in %q", fields[0]) |
||||
} |
||||
socket = string(line[1]) |
||||
|
||||
line = bytes.SplitN(fields[2], []byte("="), 2) |
||||
line[0] = bytes.TrimLeft(line[0], "\n") |
||||
if string(line[0]) != "SSH_AGENT_PID" { |
||||
t.Fatalf("could not find key SSH_AGENT_PID in %q", fields[2]) |
||||
} |
||||
pidStr := line[1] |
||||
pid, err := strconv.Atoi(string(pidStr)) |
||||
if err != nil { |
||||
t.Fatalf("Atoi(%q): %v", pidStr, err) |
||||
} |
||||
|
||||
conn, err := net.Dial("unix", string(socket)) |
||||
if err != nil { |
||||
t.Fatalf("net.Dial: %v", err) |
||||
} |
||||
|
||||
ac := NewClient(conn) |
||||
return ac, socket, func() { |
||||
proc, _ := os.FindProcess(pid) |
||||
if proc != nil { |
||||
proc.Kill() |
||||
} |
||||
conn.Close() |
||||
os.RemoveAll(filepath.Dir(socket)) |
||||
} |
||||
} |
||||
|
||||
func testAgent(t *testing.T, key interface{}, cert *ssh.Certificate, lifetimeSecs uint32) { |
||||
agent, _, cleanup := startAgent(t) |
||||
defer cleanup() |
||||
|
||||
testAgentInterface(t, agent, key, cert, lifetimeSecs) |
||||
} |
||||
|
||||
func testAgentInterface(t *testing.T, agent Agent, key interface{}, cert *ssh.Certificate, lifetimeSecs uint32) { |
||||
signer, err := ssh.NewSignerFromKey(key) |
||||
if err != nil { |
||||
t.Fatalf("NewSignerFromKey(%T): %v", key, err) |
||||
} |
||||
// The agent should start up empty.
|
||||
if keys, err := agent.List(); err != nil { |
||||
t.Fatalf("RequestIdentities: %v", err) |
||||
} else if len(keys) > 0 { |
||||
t.Fatalf("got %d keys, want 0: %v", len(keys), keys) |
||||
} |
||||
|
||||
// Attempt to insert the key, with certificate if specified.
|
||||
var pubKey ssh.PublicKey |
||||
if cert != nil { |
||||
err = agent.Add(AddedKey{ |
||||
PrivateKey: key, |
||||
Certificate: cert, |
||||
Comment: "comment", |
||||
LifetimeSecs: lifetimeSecs, |
||||
}) |
||||
pubKey = cert |
||||
} else { |
||||
err = agent.Add(AddedKey{PrivateKey: key, Comment: "comment", LifetimeSecs: lifetimeSecs}) |
||||
pubKey = signer.PublicKey() |
||||
} |
||||
if err != nil { |
||||
t.Fatalf("insert(%T): %v", key, err) |
||||
} |
||||
|
||||
// Did the key get inserted successfully?
|
||||
if keys, err := agent.List(); err != nil { |
||||
t.Fatalf("List: %v", err) |
||||
} else if len(keys) != 1 { |
||||
t.Fatalf("got %v, want 1 key", keys) |
||||
} else if keys[0].Comment != "comment" { |
||||
t.Fatalf("key comment: got %v, want %v", keys[0].Comment, "comment") |
||||
} else if !bytes.Equal(keys[0].Blob, pubKey.Marshal()) { |
||||
t.Fatalf("key mismatch") |
||||
} |
||||
|
||||
// Can the agent make a valid signature?
|
||||
data := []byte("hello") |
||||
sig, err := agent.Sign(pubKey, data) |
||||
if err != nil { |
||||
t.Fatalf("Sign(%s): %v", pubKey.Type(), err) |
||||
} |
||||
|
||||
if err := pubKey.Verify(data, sig); err != nil { |
||||
t.Fatalf("Verify(%s): %v", pubKey.Type(), err) |
||||
} |
||||
} |
||||
|
||||
func TestAgent(t *testing.T) { |
||||
for _, keyType := range []string{"rsa", "dsa", "ecdsa"} { |
||||
testAgent(t, testPrivateKeys[keyType], nil, 0) |
||||
} |
||||
} |
||||
|
||||
func TestCert(t *testing.T) { |
||||
cert := &ssh.Certificate{ |
||||
Key: testPublicKeys["rsa"], |
||||
ValidBefore: ssh.CertTimeInfinity, |
||||
CertType: ssh.UserCert, |
||||
} |
||||
cert.SignCert(rand.Reader, testSigners["ecdsa"]) |
||||
|
||||
testAgent(t, testPrivateKeys["rsa"], cert, 0) |
||||
} |
||||
|
||||
func TestConstraints(t *testing.T) { |
||||
testAgent(t, testPrivateKeys["rsa"], nil, 3600 /* lifetime in seconds */) |
||||
} |
||||
|
||||
// netPipe is analogous to net.Pipe, but it uses a real net.Conn, and
|
||||
// therefore is buffered (net.Pipe deadlocks if both sides start with
|
||||
// a write.)
|
||||
func netPipe() (net.Conn, net.Conn, error) { |
||||
listener, err := net.Listen("tcp", "127.0.0.1:0") |
||||
if err != nil { |
||||
return nil, nil, err |
||||
} |
||||
defer listener.Close() |
||||
c1, err := net.Dial("tcp", listener.Addr().String()) |
||||
if err != nil { |
||||
return nil, nil, err |
||||
} |
||||
|
||||
c2, err := listener.Accept() |
||||
if err != nil { |
||||
c1.Close() |
||||
return nil, nil, err |
||||
} |
||||
|
||||
return c1, c2, nil |
||||
} |
||||
|
||||
func TestAuth(t *testing.T) { |
||||
a, b, err := netPipe() |
||||
if err != nil { |
||||
t.Fatalf("netPipe: %v", err) |
||||
} |
||||
|
||||
defer a.Close() |
||||
defer b.Close() |
||||
|
||||
agent, _, cleanup := startAgent(t) |
||||
defer cleanup() |
||||
|
||||
if err := agent.Add(AddedKey{PrivateKey: testPrivateKeys["rsa"], Comment: "comment"}); err != nil { |
||||
t.Errorf("Add: %v", err) |
||||
} |
||||
|
||||
serverConf := ssh.ServerConfig{} |
||||
serverConf.AddHostKey(testSigners["rsa"]) |
||||
serverConf.PublicKeyCallback = func(c ssh.ConnMetadata, key ssh.PublicKey) (*ssh.Permissions, error) { |
||||
if bytes.Equal(key.Marshal(), testPublicKeys["rsa"].Marshal()) { |
||||
return nil, nil |
||||
} |
||||
|
||||
return nil, errors.New("pubkey rejected") |
||||
} |
||||
|
||||
go func() { |
||||
conn, _, _, err := ssh.NewServerConn(a, &serverConf) |
||||
if err != nil { |
||||
t.Fatalf("Server: %v", err) |
||||
} |
||||
conn.Close() |
||||
}() |
||||
|
||||
conf := ssh.ClientConfig{} |
||||
conf.Auth = append(conf.Auth, ssh.PublicKeysCallback(agent.Signers)) |
||||
conn, _, _, err := ssh.NewClientConn(b, "", &conf) |
||||
if err != nil { |
||||
t.Fatalf("NewClientConn: %v", err) |
||||
} |
||||
conn.Close() |
||||
} |
||||
|
||||
func TestLockClient(t *testing.T) { |
||||
agent, _, cleanup := startAgent(t) |
||||
defer cleanup() |
||||
testLockAgent(agent, t) |
||||
} |
||||
|
||||
func testLockAgent(agent Agent, t *testing.T) { |
||||
if err := agent.Add(AddedKey{PrivateKey: testPrivateKeys["rsa"], Comment: "comment 1"}); err != nil { |
||||
t.Errorf("Add: %v", err) |
||||
} |
||||
if err := agent.Add(AddedKey{PrivateKey: testPrivateKeys["dsa"], Comment: "comment dsa"}); err != nil { |
||||
t.Errorf("Add: %v", err) |
||||
} |
||||
if keys, err := agent.List(); err != nil { |
||||
t.Errorf("List: %v", err) |
||||
} else if len(keys) != 2 { |
||||
t.Errorf("Want 2 keys, got %v", keys) |
||||
} |
||||
|
||||
passphrase := []byte("secret") |
||||
if err := agent.Lock(passphrase); err != nil { |
||||
t.Errorf("Lock: %v", err) |
||||
} |
||||
|
||||
if keys, err := agent.List(); err != nil { |
||||
t.Errorf("List: %v", err) |
||||
} else if len(keys) != 0 { |
||||
t.Errorf("Want 0 keys, got %v", keys) |
||||
} |
||||
|
||||
signer, _ := ssh.NewSignerFromKey(testPrivateKeys["rsa"]) |
||||
if _, err := agent.Sign(signer.PublicKey(), []byte("hello")); err == nil { |
||||
t.Fatalf("Sign did not fail") |
||||
} |
||||
|
||||
if err := agent.Remove(signer.PublicKey()); err == nil { |
||||
t.Fatalf("Remove did not fail") |
||||
} |
||||
|
||||
if err := agent.RemoveAll(); err == nil { |
||||
t.Fatalf("RemoveAll did not fail") |
||||
} |
||||
|
||||
if err := agent.Unlock(nil); err == nil { |
||||
t.Errorf("Unlock with wrong passphrase succeeded") |
||||
} |
||||
if err := agent.Unlock(passphrase); err != nil { |
||||
t.Errorf("Unlock: %v", err) |
||||
} |
||||
|
||||
if err := agent.Remove(signer.PublicKey()); err != nil { |
||||
t.Fatalf("Remove: %v", err) |
||||
} |
||||
|
||||
if keys, err := agent.List(); err != nil { |
||||
t.Errorf("List: %v", err) |
||||
} else if len(keys) != 1 { |
||||
t.Errorf("Want 1 keys, got %v", keys) |
||||
} |
||||
} |
||||
@ -1,103 +0,0 @@ |
||||
// Copyright 2014 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 agent |
||||
|
||||
import ( |
||||
"errors" |
||||
"io" |
||||
"net" |
||||
"sync" |
||||
|
||||
"github.com/gogits/gogs/modules/crypto/ssh" |
||||
) |
||||
|
||||
// RequestAgentForwarding sets up agent forwarding for the session.
|
||||
// ForwardToAgent or ForwardToRemote should be called to route
|
||||
// the authentication requests.
|
||||
func RequestAgentForwarding(session *ssh.Session) error { |
||||
ok, err := session.SendRequest("auth-agent-req@openssh.com", true, nil) |
||||
if err != nil { |
||||
return err |
||||
} |
||||
if !ok { |
||||
return errors.New("forwarding request denied") |
||||
} |
||||
return nil |
||||
} |
||||
|
||||
// ForwardToAgent routes authentication requests to the given keyring.
|
||||
func ForwardToAgent(client *ssh.Client, keyring Agent) error { |
||||
channels := client.HandleChannelOpen(channelType) |
||||
if channels == nil { |
||||
return errors.New("agent: already have handler for " + channelType) |
||||
} |
||||
|
||||
go func() { |
||||
for ch := range channels { |
||||
channel, reqs, err := ch.Accept() |
||||
if err != nil { |
||||
continue |
||||
} |
||||
go ssh.DiscardRequests(reqs) |
||||
go func() { |
||||
ServeAgent(keyring, channel) |
||||
channel.Close() |
||||
}() |
||||
} |
||||
}() |
||||
return nil |
||||
} |
||||
|
||||
const channelType = "auth-agent@openssh.com" |
||||
|
||||
// ForwardToRemote routes authentication requests to the ssh-agent
|
||||
// process serving on the given unix socket.
|
||||
func ForwardToRemote(client *ssh.Client, addr string) error { |
||||
channels := client.HandleChannelOpen(channelType) |
||||
if channels == nil { |
||||
return errors.New("agent: already have handler for " + channelType) |
||||
} |
||||
conn, err := net.Dial("unix", addr) |
||||
if err != nil { |
||||
return err |
||||
} |
||||
conn.Close() |
||||
|
||||
go func() { |
||||
for ch := range channels { |
||||
channel, reqs, err := ch.Accept() |
||||
if err != nil { |
||||
continue |
||||
} |
||||
go ssh.DiscardRequests(reqs) |
||||
go forwardUnixSocket(channel, addr) |
||||
} |
||||
}() |
||||
return nil |
||||
} |
||||
|
||||
func forwardUnixSocket(channel ssh.Channel, addr string) { |
||||
conn, err := net.Dial("unix", addr) |
||||
if err != nil { |
||||
return |
||||
} |
||||
|
||||
var wg sync.WaitGroup |
||||
wg.Add(2) |
||||
go func() { |
||||
io.Copy(conn, channel) |
||||
conn.(*net.UnixConn).CloseWrite() |
||||
wg.Done() |
||||
}() |
||||
go func() { |
||||
io.Copy(channel, conn) |
||||
channel.CloseWrite() |
||||
wg.Done() |
||||
}() |
||||
|
||||
wg.Wait() |
||||
conn.Close() |
||||
channel.Close() |
||||
} |
||||
@ -1,184 +0,0 @@ |
||||
// Copyright 2014 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 agent |
||||
|
||||
import ( |
||||
"bytes" |
||||
"crypto/rand" |
||||
"crypto/subtle" |
||||
"errors" |
||||
"fmt" |
||||
"sync" |
||||
|
||||
"github.com/gogits/gogs/modules/crypto/ssh" |
||||
) |
||||
|
||||
type privKey struct { |
||||
signer ssh.Signer |
||||
comment string |
||||
} |
||||
|
||||
type keyring struct { |
||||
mu sync.Mutex |
||||
keys []privKey |
||||
|
||||
locked bool |
||||
passphrase []byte |
||||
} |
||||
|
||||
var errLocked = errors.New("agent: locked") |
||||
|
||||
// NewKeyring returns an Agent that holds keys in memory. It is safe
|
||||
// for concurrent use by multiple goroutines.
|
||||
func NewKeyring() Agent { |
||||
return &keyring{} |
||||
} |
||||
|
||||
// RemoveAll removes all identities.
|
||||
func (r *keyring) RemoveAll() error { |
||||
r.mu.Lock() |
||||
defer r.mu.Unlock() |
||||
if r.locked { |
||||
return errLocked |
||||
} |
||||
|
||||
r.keys = nil |
||||
return nil |
||||
} |
||||
|
||||
// Remove removes all identities with the given public key.
|
||||
func (r *keyring) Remove(key ssh.PublicKey) error { |
||||
r.mu.Lock() |
||||
defer r.mu.Unlock() |
||||
if r.locked { |
||||
return errLocked |
||||
} |
||||
|
||||
want := key.Marshal() |
||||
found := false |
||||
for i := 0; i < len(r.keys); { |
||||
if bytes.Equal(r.keys[i].signer.PublicKey().Marshal(), want) { |
||||
found = true |
||||
r.keys[i] = r.keys[len(r.keys)-1] |
||||
r.keys = r.keys[len(r.keys)-1:] |
||||
continue |
||||
} else { |
||||
i++ |
||||
} |
||||
} |
||||
|
||||
if !found { |
||||
return errors.New("agent: key not found") |
||||
} |
||||
return nil |
||||
} |
||||
|
||||
// Lock locks the agent. Sign and Remove will fail, and List will empty an empty list.
|
||||
func (r *keyring) Lock(passphrase []byte) error { |
||||
r.mu.Lock() |
||||
defer r.mu.Unlock() |
||||
if r.locked { |
||||
return errLocked |
||||
} |
||||
|
||||
r.locked = true |
||||
r.passphrase = passphrase |
||||
return nil |
||||
} |
||||
|
||||
// Unlock undoes the effect of Lock
|
||||
func (r *keyring) Unlock(passphrase []byte) error { |
||||
r.mu.Lock() |
||||
defer r.mu.Unlock() |
||||
if !r.locked { |
||||
return errors.New("agent: not locked") |
||||
} |
||||
if len(passphrase) != len(r.passphrase) || 1 != subtle.ConstantTimeCompare(passphrase, r.passphrase) { |
||||
return fmt.Errorf("agent: incorrect passphrase") |
||||
} |
||||
|
||||
r.locked = false |
||||
r.passphrase = nil |
||||
return nil |
||||
} |
||||
|
||||
// List returns the identities known to the agent.
|
||||
func (r *keyring) List() ([]*Key, error) { |
||||
r.mu.Lock() |
||||
defer r.mu.Unlock() |
||||
if r.locked { |
||||
// section 2.7: locked agents return empty.
|
||||
return nil, nil |
||||
} |
||||
|
||||
var ids []*Key |
||||
for _, k := range r.keys { |
||||
pub := k.signer.PublicKey() |
||||
ids = append(ids, &Key{ |
||||
Format: pub.Type(), |
||||
Blob: pub.Marshal(), |
||||
Comment: k.comment}) |
||||
} |
||||
return ids, nil |
||||
} |
||||
|
||||
// Insert adds a private key to the keyring. If a certificate
|
||||
// is given, that certificate is added as public key. Note that
|
||||
// any constraints given are ignored.
|
||||
func (r *keyring) Add(key AddedKey) error { |
||||
r.mu.Lock() |
||||
defer r.mu.Unlock() |
||||
if r.locked { |
||||
return errLocked |
||||
} |
||||
signer, err := ssh.NewSignerFromKey(key.PrivateKey) |
||||
|
||||
if err != nil { |
||||
return err |
||||
} |
||||
|
||||
if cert := key.Certificate; cert != nil { |
||||
signer, err = ssh.NewCertSigner(cert, signer) |
||||
if err != nil { |
||||
return err |
||||
} |
||||
} |
||||
|
||||
r.keys = append(r.keys, privKey{signer, key.Comment}) |
||||
|
||||
return nil |
||||
} |
||||
|
||||
// Sign returns a signature for the data.
|
||||
func (r *keyring) Sign(key ssh.PublicKey, data []byte) (*ssh.Signature, error) { |
||||
r.mu.Lock() |
||||
defer r.mu.Unlock() |
||||
if r.locked { |
||||
return nil, errLocked |
||||
} |
||||
|
||||
wanted := key.Marshal() |
||||
for _, k := range r.keys { |
||||
if bytes.Equal(k.signer.PublicKey().Marshal(), wanted) { |
||||
return k.signer.Sign(rand.Reader, data) |
||||
} |
||||
} |
||||
return nil, errors.New("not found") |
||||
} |
||||
|
||||
// Signers returns signers for all the known keys.
|
||||
func (r *keyring) Signers() ([]ssh.Signer, error) { |
||||
r.mu.Lock() |
||||
defer r.mu.Unlock() |
||||
if r.locked { |
||||
return nil, errLocked |
||||
} |
||||
|
||||
s := make([]ssh.Signer, 0, len(r.keys)) |
||||
for _, k := range r.keys { |
||||
s = append(s, k.signer) |
||||
} |
||||
return s, nil |
||||
} |
||||
@ -1,209 +0,0 @@ |
||||
// Copyright 2012 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 agent |
||||
|
||||
import ( |
||||
"crypto/rsa" |
||||
"encoding/binary" |
||||
"fmt" |
||||
"io" |
||||
"log" |
||||
"math/big" |
||||
|
||||
"github.com/gogits/gogs/modules/crypto/ssh" |
||||
) |
||||
|
||||
// Server wraps an Agent and uses it to implement the agent side of
|
||||
// the SSH-agent, wire protocol.
|
||||
type server struct { |
||||
agent Agent |
||||
} |
||||
|
||||
func (s *server) processRequestBytes(reqData []byte) []byte { |
||||
rep, err := s.processRequest(reqData) |
||||
if err != nil { |
||||
if err != errLocked { |
||||
// TODO(hanwen): provide better logging interface?
|
||||
log.Printf("agent %d: %v", reqData[0], err) |
||||
} |
||||
return []byte{agentFailure} |
||||
} |
||||
|
||||
if err == nil && rep == nil { |
||||
return []byte{agentSuccess} |
||||
} |
||||
|
||||
return ssh.Marshal(rep) |
||||
} |
||||
|
||||
func marshalKey(k *Key) []byte { |
||||
var record struct { |
||||
Blob []byte |
||||
Comment string |
||||
} |
||||
record.Blob = k.Marshal() |
||||
record.Comment = k.Comment |
||||
|
||||
return ssh.Marshal(&record) |
||||
} |
||||
|
||||
type agentV1IdentityMsg struct { |
||||
Numkeys uint32 `sshtype:"2"` |
||||
} |
||||
|
||||
type agentRemoveIdentityMsg struct { |
||||
KeyBlob []byte `sshtype:"18"` |
||||
} |
||||
|
||||
type agentLockMsg struct { |
||||
Passphrase []byte `sshtype:"22"` |
||||
} |
||||
|
||||
type agentUnlockMsg struct { |
||||
Passphrase []byte `sshtype:"23"` |
||||
} |
||||
|
||||
func (s *server) processRequest(data []byte) (interface{}, error) { |
||||
switch data[0] { |
||||
case agentRequestV1Identities: |
||||
return &agentV1IdentityMsg{0}, nil |
||||
case agentRemoveIdentity: |
||||
var req agentRemoveIdentityMsg |
||||
if err := ssh.Unmarshal(data, &req); err != nil { |
||||
return nil, err |
||||
} |
||||
|
||||
var wk wireKey |
||||
if err := ssh.Unmarshal(req.KeyBlob, &wk); err != nil { |
||||
return nil, err |
||||
} |
||||
|
||||
return nil, s.agent.Remove(&Key{Format: wk.Format, Blob: req.KeyBlob}) |
||||
|
||||
case agentRemoveAllIdentities: |
||||
return nil, s.agent.RemoveAll() |
||||
|
||||
case agentLock: |
||||
var req agentLockMsg |
||||
if err := ssh.Unmarshal(data, &req); err != nil { |
||||
return nil, err |
||||
} |
||||
|
||||
return nil, s.agent.Lock(req.Passphrase) |
||||
|
||||
case agentUnlock: |
||||
var req agentLockMsg |
||||
if err := ssh.Unmarshal(data, &req); err != nil { |
||||
return nil, err |
||||
} |
||||
return nil, s.agent.Unlock(req.Passphrase) |
||||
|
||||
case agentSignRequest: |
||||
var req signRequestAgentMsg |
||||
if err := ssh.Unmarshal(data, &req); err != nil { |
||||
return nil, err |
||||
} |
||||
|
||||
var wk wireKey |
||||
if err := ssh.Unmarshal(req.KeyBlob, &wk); err != nil { |
||||
return nil, err |
||||
} |
||||
|
||||
k := &Key{ |
||||
Format: wk.Format, |
||||
Blob: req.KeyBlob, |
||||
} |
||||
|
||||
sig, err := s.agent.Sign(k, req.Data) // TODO(hanwen): flags.
|
||||
if err != nil { |
||||
return nil, err |
||||
} |
||||
return &signResponseAgentMsg{SigBlob: ssh.Marshal(sig)}, nil |
||||
case agentRequestIdentities: |
||||
keys, err := s.agent.List() |
||||
if err != nil { |
||||
return nil, err |
||||
} |
||||
|
||||
rep := identitiesAnswerAgentMsg{ |
||||
NumKeys: uint32(len(keys)), |
||||
} |
||||
for _, k := range keys { |
||||
rep.Keys = append(rep.Keys, marshalKey(k)...) |
||||
} |
||||
return rep, nil |
||||
case agentAddIdentity: |
||||
return nil, s.insertIdentity(data) |
||||
} |
||||
|
||||
return nil, fmt.Errorf("unknown opcode %d", data[0]) |
||||
} |
||||
|
||||
func (s *server) insertIdentity(req []byte) error { |
||||
var record struct { |
||||
Type string `sshtype:"17"` |
||||
Rest []byte `ssh:"rest"` |
||||
} |
||||
if err := ssh.Unmarshal(req, &record); err != nil { |
||||
return err |
||||
} |
||||
|
||||
switch record.Type { |
||||
case ssh.KeyAlgoRSA: |
||||
var k rsaKeyMsg |
||||
if err := ssh.Unmarshal(req, &k); err != nil { |
||||
return err |
||||
} |
||||
|
||||
priv := rsa.PrivateKey{ |
||||
PublicKey: rsa.PublicKey{ |
||||
E: int(k.E.Int64()), |
||||
N: k.N, |
||||
}, |
||||
D: k.D, |
||||
Primes: []*big.Int{k.P, k.Q}, |
||||
} |
||||
priv.Precompute() |
||||
|
||||
return s.agent.Add(AddedKey{PrivateKey: &priv, Comment: k.Comments}) |
||||
} |
||||
return fmt.Errorf("not implemented: %s", record.Type) |
||||
} |
||||
|
||||
// ServeAgent serves the agent protocol on the given connection. It
|
||||
// returns when an I/O error occurs.
|
||||
func ServeAgent(agent Agent, c io.ReadWriter) error { |
||||
s := &server{agent} |
||||
|
||||
var length [4]byte |
||||
for { |
||||
if _, err := io.ReadFull(c, length[:]); err != nil { |
||||
return err |
||||
} |
||||
l := binary.BigEndian.Uint32(length[:]) |
||||
if l > maxAgentResponseBytes { |
||||
// We also cap requests.
|
||||
return fmt.Errorf("agent: request too large: %d", l) |
||||
} |
||||
|
||||
req := make([]byte, l) |
||||
if _, err := io.ReadFull(c, req); err != nil { |
||||
return err |
||||
} |
||||
|
||||
repData := s.processRequestBytes(req) |
||||
if len(repData) > maxAgentResponseBytes { |
||||
return fmt.Errorf("agent: reply too large: %d bytes", len(repData)) |
||||
} |
||||
|
||||
binary.BigEndian.PutUint32(length[:], uint32(len(repData))) |
||||
if _, err := c.Write(length[:]); err != nil { |
||||
return err |
||||
} |
||||
if _, err := c.Write(repData); err != nil { |
||||
return err |
||||
} |
||||
} |
||||
} |
||||
@ -1,77 +0,0 @@ |
||||
// Copyright 2012 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 agent |
||||
|
||||
import ( |
||||
"testing" |
||||
|
||||
"github.com/gogits/gogs/modules/crypto/ssh" |
||||
) |
||||
|
||||
func TestServer(t *testing.T) { |
||||
c1, c2, err := netPipe() |
||||
if err != nil { |
||||
t.Fatalf("netPipe: %v", err) |
||||
} |
||||
defer c1.Close() |
||||
defer c2.Close() |
||||
client := NewClient(c1) |
||||
|
||||
go ServeAgent(NewKeyring(), c2) |
||||
|
||||
testAgentInterface(t, client, testPrivateKeys["rsa"], nil, 0) |
||||
} |
||||
|
||||
func TestLockServer(t *testing.T) { |
||||
testLockAgent(NewKeyring(), t) |
||||
} |
||||
|
||||
func TestSetupForwardAgent(t *testing.T) { |
||||
a, b, err := netPipe() |
||||
if err != nil { |
||||
t.Fatalf("netPipe: %v", err) |
||||
} |
||||
|
||||
defer a.Close() |
||||
defer b.Close() |
||||
|
||||
_, socket, cleanup := startAgent(t) |
||||
defer cleanup() |
||||
|
||||
serverConf := ssh.ServerConfig{ |
||||
NoClientAuth: true, |
||||
} |
||||
serverConf.AddHostKey(testSigners["rsa"]) |
||||
incoming := make(chan *ssh.ServerConn, 1) |
||||
go func() { |
||||
conn, _, _, err := ssh.NewServerConn(a, &serverConf) |
||||
if err != nil { |
||||
t.Fatalf("Server: %v", err) |
||||
} |
||||
incoming <- conn |
||||
}() |
||||
|
||||
conf := ssh.ClientConfig{} |
||||
conn, chans, reqs, err := ssh.NewClientConn(b, "", &conf) |
||||
if err != nil { |
||||
t.Fatalf("NewClientConn: %v", err) |
||||
} |
||||
client := ssh.NewClient(conn, chans, reqs) |
||||
|
||||
if err := ForwardToRemote(client, socket); err != nil { |
||||
t.Fatalf("SetupForwardAgent: %v", err) |
||||
} |
||||
|
||||
server := <-incoming |
||||
ch, reqs, err := server.OpenChannel(channelType, nil) |
||||
if err != nil { |
||||
t.Fatalf("OpenChannel(%q): %v", channelType, err) |
||||
} |
||||
go ssh.DiscardRequests(reqs) |
||||
|
||||
agentClient := NewClient(ch) |
||||
testAgentInterface(t, agentClient, testPrivateKeys["rsa"], nil, 0) |
||||
conn.Close() |
||||
} |
||||
@ -1,64 +0,0 @@ |
||||
// Copyright 2014 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.
|
||||
|
||||
// IMPLEMENTOR NOTE: To avoid a package loop, this file is in three places:
|
||||
// ssh/, ssh/agent, and ssh/test/. It should be kept in sync across all three
|
||||
// instances.
|
||||
|
||||
package agent |
||||
|
||||
import ( |
||||
"crypto/rand" |
||||
"fmt" |
||||
|
||||
"github.com/gogits/gogs/modules/crypto/ssh" |
||||
"github.com/gogits/gogs/modules/crypto/ssh/testdata" |
||||
) |
||||
|
||||
var ( |
||||
testPrivateKeys map[string]interface{} |
||||
testSigners map[string]ssh.Signer |
||||
testPublicKeys map[string]ssh.PublicKey |
||||
) |
||||
|
||||
func init() { |
||||
var err error |
||||
|
||||
n := len(testdata.PEMBytes) |
||||
testPrivateKeys = make(map[string]interface{}, n) |
||||
testSigners = make(map[string]ssh.Signer, n) |
||||
testPublicKeys = make(map[string]ssh.PublicKey, n) |
||||
for t, k := range testdata.PEMBytes { |
||||
testPrivateKeys[t], err = ssh.ParseRawPrivateKey(k) |
||||
if err != nil { |
||||
panic(fmt.Sprintf("Unable to parse test key %s: %v", t, err)) |
||||
} |
||||
testSigners[t], err = ssh.NewSignerFromKey(testPrivateKeys[t]) |
||||
if err != nil { |
||||
panic(fmt.Sprintf("Unable to create signer for test key %s: %v", t, err)) |
||||
} |
||||
testPublicKeys[t] = testSigners[t].PublicKey() |
||||
} |
||||
|
||||
// Create a cert and sign it for use in tests.
|
||||
testCert := &ssh.Certificate{ |
||||
Nonce: []byte{}, // To pass reflect.DeepEqual after marshal & parse, this must be non-nil
|
||||
ValidPrincipals: []string{"gopher1", "gopher2"}, // increases test coverage
|
||||
ValidAfter: 0, // unix epoch
|
||||
ValidBefore: ssh.CertTimeInfinity, // The end of currently representable time.
|
||||
Reserved: []byte{}, // To pass reflect.DeepEqual after marshal & parse, this must be non-nil
|
||||
Key: testPublicKeys["ecdsa"], |
||||
SignatureKey: testPublicKeys["rsa"], |
||||
Permissions: ssh.Permissions{ |
||||
CriticalOptions: map[string]string{}, |
||||
Extensions: map[string]string{}, |
||||
}, |
||||
} |
||||
testCert.SignCert(rand.Reader, testSigners["rsa"]) |
||||
testPrivateKeys["cert"] = testPrivateKeys["ecdsa"] |
||||
testSigners["cert"], err = ssh.NewCertSigner(testCert, testSigners["ecdsa"]) |
||||
if err != nil { |
||||
panic(fmt.Sprintf("Unable to create certificate signer: %v", err)) |
||||
} |
||||
} |
||||
@ -1,122 +0,0 @@ |
||||
// Copyright 2013 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 ( |
||||
"errors" |
||||
"io" |
||||
"net" |
||||
"testing" |
||||
) |
||||
|
||||
type server struct { |
||||
*ServerConn |
||||
chans <-chan NewChannel |
||||
} |
||||
|
||||
func newServer(c net.Conn, conf *ServerConfig) (*server, error) { |
||||
sconn, chans, reqs, err := NewServerConn(c, conf) |
||||
if err != nil { |
||||
return nil, err |
||||
} |
||||
go DiscardRequests(reqs) |
||||
return &server{sconn, chans}, nil |
||||
} |
||||
|
||||
func (s *server) Accept() (NewChannel, error) { |
||||
n, ok := <-s.chans |
||||
if !ok { |
||||
return nil, io.EOF |
||||
} |
||||
return n, nil |
||||
} |
||||
|
||||
func sshPipe() (Conn, *server, error) { |
||||
c1, c2, err := netPipe() |
||||
if err != nil { |
||||
return nil, nil, err |
||||
} |
||||
|
||||
clientConf := ClientConfig{ |
||||
User: "user", |
||||
} |
||||
serverConf := ServerConfig{ |
||||
NoClientAuth: true, |
||||
} |
||||
serverConf.AddHostKey(testSigners["ecdsa"]) |
||||
done := make(chan *server, 1) |
||||
go func() { |
||||
server, err := newServer(c2, &serverConf) |
||||
if err != nil { |
||||
done <- nil |
||||
} |
||||
done <- server |
||||
}() |
||||
|
||||
client, _, reqs, err := NewClientConn(c1, "", &clientConf) |
||||
if err != nil { |
||||
return nil, nil, err |
||||
} |
||||
|
||||
server := <-done |
||||
if server == nil { |
||||
return nil, nil, errors.New("server handshake failed.") |
||||
} |
||||
go DiscardRequests(reqs) |
||||
|
||||
return client, server, nil |
||||
} |
||||
|
||||
func BenchmarkEndToEnd(b *testing.B) { |
||||
b.StopTimer() |
||||
|
||||
client, server, err := sshPipe() |
||||
if err != nil { |
||||
b.Fatalf("sshPipe: %v", err) |
||||
} |
||||
|
||||
defer client.Close() |
||||
defer server.Close() |
||||
|
||||
size := (1 << 20) |
||||
input := make([]byte, size) |
||||
output := make([]byte, size) |
||||
b.SetBytes(int64(size)) |
||||
done := make(chan int, 1) |
||||
|
||||
go func() { |
||||
newCh, err := server.Accept() |
||||
if err != nil { |
||||
b.Fatalf("Client: %v", err) |
||||
} |
||||
ch, incoming, err := newCh.Accept() |
||||
go DiscardRequests(incoming) |
||||
for i := 0; i < b.N; i++ { |
||||
if _, err := io.ReadFull(ch, output); err != nil { |
||||
b.Fatalf("ReadFull: %v", err) |
||||
} |
||||
} |
||||
ch.Close() |
||||
done <- 1 |
||||
}() |
||||
|
||||
ch, in, err := client.OpenChannel("speed", nil) |
||||
if err != nil { |
||||
b.Fatalf("OpenChannel: %v", err) |
||||
} |
||||
go DiscardRequests(in) |
||||
|
||||
b.ResetTimer() |
||||
b.StartTimer() |
||||
for i := 0; i < b.N; i++ { |
||||
if _, err := ch.Write(input); err != nil { |
||||
b.Fatalf("WriteFull: %v", err) |
||||
} |
||||
} |
||||
ch.Close() |
||||
b.StopTimer() |
||||
|
||||
<-done |
||||
} |
||||
@ -1,98 +0,0 @@ |
||||
// Copyright 2012 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 ( |
||||
"io" |
||||
"sync" |
||||
) |
||||
|
||||
// buffer provides a linked list buffer for data exchange
|
||||
// between producer and consumer. Theoretically the buffer is
|
||||
// of unlimited capacity as it does no allocation of its own.
|
||||
type buffer struct { |
||||
// protects concurrent access to head, tail and closed
|
||||
*sync.Cond |
||||
|
||||
head *element // the buffer that will be read first
|
||||
tail *element // the buffer that will be read last
|
||||
|
||||
closed bool |
||||
} |
||||
|
||||
// An element represents a single link in a linked list.
|
||||
type element struct { |
||||
buf []byte |
||||
next *element |
||||
} |
||||
|
||||
// newBuffer returns an empty buffer that is not closed.
|
||||
func newBuffer() *buffer { |
||||
e := new(element) |
||||
b := &buffer{ |
||||
Cond: newCond(), |
||||
head: e, |
||||
tail: e, |
||||
} |
||||
return b |
||||
} |
||||
|
||||
// write makes buf available for Read to receive.
|
||||
// buf must not be modified after the call to write.
|
||||
func (b *buffer) write(buf []byte) { |
||||
b.Cond.L.Lock() |
||||
e := &element{buf: buf} |
||||
b.tail.next = e |
||||
b.tail = e |
||||
b.Cond.Signal() |
||||
b.Cond.L.Unlock() |
||||
} |
||||
|
||||
// eof closes the buffer. Reads from the buffer once all
|
||||
// the data has been consumed will receive os.EOF.
|
||||
func (b *buffer) eof() error { |
||||
b.Cond.L.Lock() |
||||
b.closed = true |
||||
b.Cond.Signal() |
||||
b.Cond.L.Unlock() |
||||
return nil |
||||
} |
||||
|
||||
// Read reads data from the internal buffer in buf. Reads will block
|
||||
// if no data is available, or until the buffer is closed.
|
||||
func (b *buffer) Read(buf []byte) (n int, err error) { |
||||
b.Cond.L.Lock() |
||||
defer b.Cond.L.Unlock() |
||||
|
||||
for len(buf) > 0 { |
||||
// if there is data in b.head, copy it
|
||||
if len(b.head.buf) > 0 { |
||||
r := copy(buf, b.head.buf) |
||||
buf, b.head.buf = buf[r:], b.head.buf[r:] |
||||
n += r |
||||
continue |
||||
} |
||||
// if there is a next buffer, make it the head
|
||||
if len(b.head.buf) == 0 && b.head != b.tail { |
||||
b.head = b.head.next |
||||
continue |
||||
} |
||||
|
||||
// if at least one byte has been copied, return
|
||||
if n > 0 { |
||||
break |
||||
} |
||||
|
||||
// if nothing was read, and there is nothing outstanding
|
||||
// check to see if the buffer is closed.
|
||||
if b.closed { |
||||
err = io.EOF |
||||
break |
||||
} |
||||
// out of buffers, wait for producer
|
||||
b.Cond.Wait() |
||||
} |
||||
return |
||||
} |
||||
@ -1,87 +0,0 @@ |
||||
// 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 ( |
||||
"io" |
||||
"testing" |
||||
) |
||||
|
||||
var alphabet = []byte("abcdefghijklmnopqrstuvwxyz") |
||||
|
||||
func TestBufferReadwrite(t *testing.T) { |
||||
b := newBuffer() |
||||
b.write(alphabet[:10]) |
||||
r, _ := b.Read(make([]byte, 10)) |
||||
if r != 10 { |
||||
t.Fatalf("Expected written == read == 10, written: 10, read %d", r) |
||||
} |
||||
|
||||
b = newBuffer() |
||||
b.write(alphabet[:5]) |
||||
r, _ = b.Read(make([]byte, 10)) |
||||
if r != 5 { |
||||
t.Fatalf("Expected written == read == 5, written: 5, read %d", r) |
||||
} |
||||
|
||||
b = newBuffer() |
||||
b.write(alphabet[:10]) |
||||
r, _ = b.Read(make([]byte, 5)) |
||||
if r != 5 { |
||||
t.Fatalf("Expected written == 10, read == 5, written: 10, read %d", r) |
||||
} |
||||
|
||||
b = newBuffer() |
||||
b.write(alphabet[:5]) |
||||
b.write(alphabet[5:15]) |
||||
r, _ = b.Read(make([]byte, 10)) |
||||
r2, _ := b.Read(make([]byte, 10)) |
||||
if r != 10 || r2 != 5 || 15 != r+r2 { |
||||
t.Fatal("Expected written == read == 15") |
||||
} |
||||
} |
||||
|
||||
func TestBufferClose(t *testing.T) { |
||||
b := newBuffer() |
||||
b.write(alphabet[:10]) |
||||
b.eof() |
||||
_, err := b.Read(make([]byte, 5)) |
||||
if err != nil { |
||||
t.Fatal("expected read of 5 to not return EOF") |
||||
} |
||||
b = newBuffer() |
||||
b.write(alphabet[:10]) |
||||
b.eof() |
||||
r, err := b.Read(make([]byte, 5)) |
||||
r2, err2 := b.Read(make([]byte, 10)) |
||||
if r != 5 || r2 != 5 || err != nil || err2 != nil { |
||||
t.Fatal("expected reads of 5 and 5") |
||||
} |
||||
|
||||
b = newBuffer() |
||||
b.write(alphabet[:10]) |
||||
b.eof() |
||||
r, err = b.Read(make([]byte, 5)) |
||||
r2, err2 = b.Read(make([]byte, 10)) |
||||
r3, err3 := b.Read(make([]byte, 10)) |
||||
if r != 5 || r2 != 5 || r3 != 0 || err != nil || err2 != nil || err3 != io.EOF { |
||||
t.Fatal("expected reads of 5 and 5 and 0, with EOF") |
||||
} |
||||
|
||||
b = newBuffer() |
||||
b.write(make([]byte, 5)) |
||||
b.write(make([]byte, 10)) |
||||
b.eof() |
||||
r, err = b.Read(make([]byte, 9)) |
||||
r2, err2 = b.Read(make([]byte, 3)) |
||||
r3, err3 = b.Read(make([]byte, 3)) |
||||
r4, err4 := b.Read(make([]byte, 10)) |
||||
if err != nil || err2 != nil || err3 != nil || err4 != io.EOF { |
||||
t.Fatalf("Expected EOF on forth read only, err=%v, err2=%v, err3=%v, err4=%v", err, err2, err3, err4) |
||||
} |
||||
if r != 9 || r2 != 3 || r3 != 3 || r4 != 0 { |
||||
t.Fatal("Expected written == read == 15", r, r2, r3, r4) |
||||
} |
||||
} |
||||
@ -1,501 +0,0 @@ |
||||
// Copyright 2012 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 ( |
||||
"bytes" |
||||
"errors" |
||||
"fmt" |
||||
"io" |
||||
"net" |
||||
"sort" |
||||
"time" |
||||
) |
||||
|
||||
// These constants from [PROTOCOL.certkeys] represent the algorithm names
|
||||
// for certificate types supported by this package.
|
||||
const ( |
||||
CertAlgoRSAv01 = "ssh-rsa-cert-v01@openssh.com" |
||||
CertAlgoDSAv01 = "ssh-dss-cert-v01@openssh.com" |
||||
CertAlgoECDSA256v01 = "ecdsa-sha2-nistp256-cert-v01@openssh.com" |
||||
CertAlgoECDSA384v01 = "ecdsa-sha2-nistp384-cert-v01@openssh.com" |
||||
CertAlgoECDSA521v01 = "ecdsa-sha2-nistp521-cert-v01@openssh.com" |
||||
) |
||||
|
||||
// Certificate types distinguish between host and user
|
||||
// certificates. The values can be set in the CertType field of
|
||||
// Certificate.
|
||||
const ( |
||||
UserCert = 1 |
||||
HostCert = 2 |
||||
) |
||||
|
||||
// Signature represents a cryptographic signature.
|
||||
type Signature struct { |
||||
Format string |
||||
Blob []byte |
||||
} |
||||
|
||||
// CertTimeInfinity can be used for OpenSSHCertV01.ValidBefore to indicate that
|
||||
// a certificate does not expire.
|
||||
const CertTimeInfinity = 1<<64 - 1 |
||||
|
||||
// An Certificate represents an OpenSSH certificate as defined in
|
||||
// [PROTOCOL.certkeys]?rev=1.8.
|
||||
type Certificate struct { |
||||
Nonce []byte |
||||
Key PublicKey |
||||
Serial uint64 |
||||
CertType uint32 |
||||
KeyId string |
||||
ValidPrincipals []string |
||||
ValidAfter uint64 |
||||
ValidBefore uint64 |
||||
Permissions |
||||
Reserved []byte |
||||
SignatureKey PublicKey |
||||
Signature *Signature |
||||
} |
||||
|
||||
// genericCertData holds the key-independent part of the certificate data.
|
||||
// Overall, certificates contain an nonce, public key fields and
|
||||
// key-independent fields.
|
||||
type genericCertData struct { |
||||
Serial uint64 |
||||
CertType uint32 |
||||
KeyId string |
||||
ValidPrincipals []byte |
||||
ValidAfter uint64 |
||||
ValidBefore uint64 |
||||
CriticalOptions []byte |
||||
Extensions []byte |
||||
Reserved []byte |
||||
SignatureKey []byte |
||||
Signature []byte |
||||
} |
||||
|
||||
func marshalStringList(namelist []string) []byte { |
||||
var to []byte |
||||
for _, name := range namelist { |
||||
s := struct{ N string }{name} |
||||
to = append(to, Marshal(&s)...) |
||||
} |
||||
return to |
||||
} |
||||
|
||||
type optionsTuple struct { |
||||
Key string |
||||
Value []byte |
||||
} |
||||
|
||||
type optionsTupleValue struct { |
||||
Value string |
||||
} |
||||
|
||||
// serialize a map of critical options or extensions
|
||||
// issue #10569 - per [PROTOCOL.certkeys] and SSH implementation,
|
||||
// we need two length prefixes for a non-empty string value
|
||||
func marshalTuples(tups map[string]string) []byte { |
||||
keys := make([]string, 0, len(tups)) |
||||
for key := range tups { |
||||
keys = append(keys, key) |
||||
} |
||||
sort.Strings(keys) |
||||
|
||||
var ret []byte |
||||
for _, key := range keys { |
||||
s := optionsTuple{Key: key} |
||||
if value := tups[key]; len(value) > 0 { |
||||
s.Value = Marshal(&optionsTupleValue{value}) |
||||
} |
||||
ret = append(ret, Marshal(&s)...) |
||||
} |
||||
return ret |
||||
} |
||||
|
||||
// issue #10569 - per [PROTOCOL.certkeys] and SSH implementation,
|
||||
// we need two length prefixes for a non-empty option value
|
||||
func parseTuples(in []byte) (map[string]string, error) { |
||||
tups := map[string]string{} |
||||
var lastKey string |
||||
var haveLastKey bool |
||||
|
||||
for len(in) > 0 { |
||||
var key, val, extra []byte |
||||
var ok bool |
||||
|
||||
if key, in, ok = parseString(in); !ok { |
||||
return nil, errShortRead |
||||
} |
||||
keyStr := string(key) |
||||
// according to [PROTOCOL.certkeys], the names must be in
|
||||
// lexical order.
|
||||
if haveLastKey && keyStr <= lastKey { |
||||
return nil, fmt.Errorf("ssh: certificate options are not in lexical order") |
||||
} |
||||
lastKey, haveLastKey = keyStr, true |
||||
// the next field is a data field, which if non-empty has a string embedded
|
||||
if val, in, ok = parseString(in); !ok { |
||||
return nil, errShortRead |
||||
} |
||||
if len(val) > 0 { |
||||
val, extra, ok = parseString(val) |
||||
if !ok { |
||||
return nil, errShortRead |
||||
} |
||||
if len(extra) > 0 { |
||||
return nil, fmt.Errorf("ssh: unexpected trailing data after certificate option value") |
||||
} |
||||
tups[keyStr] = string(val) |
||||
} else { |
||||
tups[keyStr] = "" |
||||
} |
||||
} |
||||
return tups, nil |
||||
} |
||||
|
||||
func parseCert(in []byte, privAlgo string) (*Certificate, error) { |
||||
nonce, rest, ok := parseString(in) |
||||
if !ok { |
||||
return nil, errShortRead |
||||
} |
||||
|
||||
key, rest, err := parsePubKey(rest, privAlgo) |
||||
if err != nil { |
||||
return nil, err |
||||
} |
||||
|
||||
var g genericCertData |
||||
if err := Unmarshal(rest, &g); err != nil { |
||||
return nil, err |
||||
} |
||||
|
||||
c := &Certificate{ |
||||
Nonce: nonce, |
||||
Key: key, |
||||
Serial: g.Serial, |
||||
CertType: g.CertType, |
||||
KeyId: g.KeyId, |
||||
ValidAfter: g.ValidAfter, |
||||
ValidBefore: g.ValidBefore, |
||||
} |
||||
|
||||
for principals := g.ValidPrincipals; len(principals) > 0; { |
||||
principal, rest, ok := parseString(principals) |
||||
if !ok { |
||||
return nil, errShortRead |
||||
} |
||||
c.ValidPrincipals = append(c.ValidPrincipals, string(principal)) |
||||
principals = rest |
||||
} |
||||
|
||||
c.CriticalOptions, err = parseTuples(g.CriticalOptions) |
||||
if err != nil { |
||||
return nil, err |
||||
} |
||||
c.Extensions, err = parseTuples(g.Extensions) |
||||
if err != nil { |
||||
return nil, err |
||||
} |
||||
c.Reserved = g.Reserved |
||||
k, err := ParsePublicKey(g.SignatureKey) |
||||
if err != nil { |
||||
return nil, err |
||||
} |
||||
|
||||
c.SignatureKey = k |
||||
c.Signature, rest, ok = parseSignatureBody(g.Signature) |
||||
if !ok || len(rest) > 0 { |
||||
return nil, errors.New("ssh: signature parse error") |
||||
} |
||||
|
||||
return c, nil |
||||
} |
||||
|
||||
type openSSHCertSigner struct { |
||||
pub *Certificate |
||||
signer Signer |
||||
} |
||||
|
||||
// NewCertSigner returns a Signer that signs with the given Certificate, whose
|
||||
// private key is held by signer. It returns an error if the public key in cert
|
||||
// doesn't match the key used by signer.
|
||||
func NewCertSigner(cert *Certificate, signer Signer) (Signer, error) { |
||||
if bytes.Compare(cert.Key.Marshal(), signer.PublicKey().Marshal()) != 0 { |
||||
return nil, errors.New("ssh: signer and cert have different public key") |
||||
} |
||||
|
||||
return &openSSHCertSigner{cert, signer}, nil |
||||
} |
||||
|
||||
func (s *openSSHCertSigner) Sign(rand io.Reader, data []byte) (*Signature, error) { |
||||
return s.signer.Sign(rand, data) |
||||
} |
||||
|
||||
func (s *openSSHCertSigner) PublicKey() PublicKey { |
||||
return s.pub |
||||
} |
||||
|
||||
const sourceAddressCriticalOption = "source-address" |
||||
|
||||
// CertChecker does the work of verifying a certificate. Its methods
|
||||
// can be plugged into ClientConfig.HostKeyCallback and
|
||||
// ServerConfig.PublicKeyCallback. For the CertChecker to work,
|
||||
// minimally, the IsAuthority callback should be set.
|
||||
type CertChecker struct { |
||||
// SupportedCriticalOptions lists the CriticalOptions that the
|
||||
// server application layer understands. These are only used
|
||||
// for user certificates.
|
||||
SupportedCriticalOptions []string |
||||
|
||||
// IsAuthority should return true if the key is recognized as
|
||||
// an authority. This allows for certificates to be signed by other
|
||||
// certificates.
|
||||
IsAuthority func(auth PublicKey) bool |
||||
|
||||
// Clock is used for verifying time stamps. If nil, time.Now
|
||||
// is used.
|
||||
Clock func() time.Time |
||||
|
||||
// UserKeyFallback is called when CertChecker.Authenticate encounters a
|
||||
// public key that is not a certificate. It must implement validation
|
||||
// of user keys or else, if nil, all such keys are rejected.
|
||||
UserKeyFallback func(conn ConnMetadata, key PublicKey) (*Permissions, error) |
||||
|
||||
// HostKeyFallback is called when CertChecker.CheckHostKey encounters a
|
||||
// public key that is not a certificate. It must implement host key
|
||||
// validation or else, if nil, all such keys are rejected.
|
||||
HostKeyFallback func(addr string, remote net.Addr, key PublicKey) error |
||||
|
||||
// IsRevoked is called for each certificate so that revocation checking
|
||||
// can be implemented. It should return true if the given certificate
|
||||
// is revoked and false otherwise. If nil, no certificates are
|
||||
// considered to have been revoked.
|
||||
IsRevoked func(cert *Certificate) bool |
||||
} |
||||
|
||||
// CheckHostKey checks a host key certificate. This method can be
|
||||
// plugged into ClientConfig.HostKeyCallback.
|
||||
func (c *CertChecker) CheckHostKey(addr string, remote net.Addr, key PublicKey) error { |
||||
cert, ok := key.(*Certificate) |
||||
if !ok { |
||||
if c.HostKeyFallback != nil { |
||||
return c.HostKeyFallback(addr, remote, key) |
||||
} |
||||
return errors.New("ssh: non-certificate host key") |
||||
} |
||||
if cert.CertType != HostCert { |
||||
return fmt.Errorf("ssh: certificate presented as a host key has type %d", cert.CertType) |
||||
} |
||||
|
||||
return c.CheckCert(addr, cert) |
||||
} |
||||
|
||||
// Authenticate checks a user certificate. Authenticate can be used as
|
||||
// a value for ServerConfig.PublicKeyCallback.
|
||||
func (c *CertChecker) Authenticate(conn ConnMetadata, pubKey PublicKey) (*Permissions, error) { |
||||
cert, ok := pubKey.(*Certificate) |
||||
if !ok { |
||||
if c.UserKeyFallback != nil { |
||||
return c.UserKeyFallback(conn, pubKey) |
||||
} |
||||
return nil, errors.New("ssh: normal key pairs not accepted") |
||||
} |
||||
|
||||
if cert.CertType != UserCert { |
||||
return nil, fmt.Errorf("ssh: cert has type %d", cert.CertType) |
||||
} |
||||
|
||||
if err := c.CheckCert(conn.User(), cert); err != nil { |
||||
return nil, err |
||||
} |
||||
|
||||
return &cert.Permissions, nil |
||||
} |
||||
|
||||
// CheckCert checks CriticalOptions, ValidPrincipals, revocation, timestamp and
|
||||
// the signature of the certificate.
|
||||
func (c *CertChecker) CheckCert(principal string, cert *Certificate) error { |
||||
if c.IsRevoked != nil && c.IsRevoked(cert) { |
||||
return fmt.Errorf("ssh: certicate serial %d revoked", cert.Serial) |
||||
} |
||||
|
||||
for opt, _ := range cert.CriticalOptions { |
||||
// sourceAddressCriticalOption will be enforced by
|
||||
// serverAuthenticate
|
||||
if opt == sourceAddressCriticalOption { |
||||
continue |
||||
} |
||||
|
||||
found := false |
||||
for _, supp := range c.SupportedCriticalOptions { |
||||
if supp == opt { |
||||
found = true |
||||
break |
||||
} |
||||
} |
||||
if !found { |
||||
return fmt.Errorf("ssh: unsupported critical option %q in certificate", opt) |
||||
} |
||||
} |
||||
|
||||
if len(cert.ValidPrincipals) > 0 { |
||||
// By default, certs are valid for all users/hosts.
|
||||
found := false |
||||
for _, p := range cert.ValidPrincipals { |
||||
if p == principal { |
||||
found = true |
||||
break |
||||
} |
||||
} |
||||
if !found { |
||||
return fmt.Errorf("ssh: principal %q not in the set of valid principals for given certificate: %q", principal, cert.ValidPrincipals) |
||||
} |
||||
} |
||||
|
||||
if !c.IsAuthority(cert.SignatureKey) { |
||||
return fmt.Errorf("ssh: certificate signed by unrecognized authority") |
||||
} |
||||
|
||||
clock := c.Clock |
||||
if clock == nil { |
||||
clock = time.Now |
||||
} |
||||
|
||||
unixNow := clock().Unix() |
||||
if after := int64(cert.ValidAfter); after < 0 || unixNow < int64(cert.ValidAfter) { |
||||
return fmt.Errorf("ssh: cert is not yet valid") |
||||
} |
||||
if before := int64(cert.ValidBefore); cert.ValidBefore != uint64(CertTimeInfinity) && (unixNow >= before || before < 0) { |
||||
return fmt.Errorf("ssh: cert has expired") |
||||
} |
||||
if err := cert.SignatureKey.Verify(cert.bytesForSigning(), cert.Signature); err != nil { |
||||
return fmt.Errorf("ssh: certificate signature does not verify") |
||||
} |
||||
|
||||
return nil |
||||
} |
||||
|
||||
// SignCert sets c.SignatureKey to the authority's public key and stores a
|
||||
// Signature, by authority, in the certificate.
|
||||
func (c *Certificate) SignCert(rand io.Reader, authority Signer) error { |
||||
c.Nonce = make([]byte, 32) |
||||
if _, err := io.ReadFull(rand, c.Nonce); err != nil { |
||||
return err |
||||
} |
||||
c.SignatureKey = authority.PublicKey() |
||||
|
||||
sig, err := authority.Sign(rand, c.bytesForSigning()) |
||||
if err != nil { |
||||
return err |
||||
} |
||||
c.Signature = sig |
||||
return nil |
||||
} |
||||
|
||||
var certAlgoNames = map[string]string{ |
||||
KeyAlgoRSA: CertAlgoRSAv01, |
||||
KeyAlgoDSA: CertAlgoDSAv01, |
||||
KeyAlgoECDSA256: CertAlgoECDSA256v01, |
||||
KeyAlgoECDSA384: CertAlgoECDSA384v01, |
||||
KeyAlgoECDSA521: CertAlgoECDSA521v01, |
||||
} |
||||
|
||||
// certToPrivAlgo returns the underlying algorithm for a certificate algorithm.
|
||||
// Panics if a non-certificate algorithm is passed.
|
||||
func certToPrivAlgo(algo string) string { |
||||
for privAlgo, pubAlgo := range certAlgoNames { |
||||
if pubAlgo == algo { |
||||
return privAlgo |
||||
} |
||||
} |
||||
panic("unknown cert algorithm") |
||||
} |
||||
|
||||
func (cert *Certificate) bytesForSigning() []byte { |
||||
c2 := *cert |
||||
c2.Signature = nil |
||||
out := c2.Marshal() |
||||
// Drop trailing signature length.
|
||||
return out[:len(out)-4] |
||||
} |
||||
|
||||
// Marshal serializes c into OpenSSH's wire format. It is part of the
|
||||
// PublicKey interface.
|
||||
func (c *Certificate) Marshal() []byte { |
||||
generic := genericCertData{ |
||||
Serial: c.Serial, |
||||
CertType: c.CertType, |
||||
KeyId: c.KeyId, |
||||
ValidPrincipals: marshalStringList(c.ValidPrincipals), |
||||
ValidAfter: uint64(c.ValidAfter), |
||||
ValidBefore: uint64(c.ValidBefore), |
||||
CriticalOptions: marshalTuples(c.CriticalOptions), |
||||
Extensions: marshalTuples(c.Extensions), |
||||
Reserved: c.Reserved, |
||||
SignatureKey: c.SignatureKey.Marshal(), |
||||
} |
||||
if c.Signature != nil { |
||||
generic.Signature = Marshal(c.Signature) |
||||
} |
||||
genericBytes := Marshal(&generic) |
||||
keyBytes := c.Key.Marshal() |
||||
_, keyBytes, _ = parseString(keyBytes) |
||||
prefix := Marshal(&struct { |
||||
Name string |
||||
Nonce []byte |
||||
Key []byte `ssh:"rest"` |
||||
}{c.Type(), c.Nonce, keyBytes}) |
||||
|
||||
result := make([]byte, 0, len(prefix)+len(genericBytes)) |
||||
result = append(result, prefix...) |
||||
result = append(result, genericBytes...) |
||||
return result |
||||
} |
||||
|
||||
// Type returns the key name. It is part of the PublicKey interface.
|
||||
func (c *Certificate) Type() string { |
||||
algo, ok := certAlgoNames[c.Key.Type()] |
||||
if !ok { |
||||
panic("unknown cert key type") |
||||
} |
||||
return algo |
||||
} |
||||
|
||||
// Verify verifies a signature against the certificate's public
|
||||
// key. It is part of the PublicKey interface.
|
||||
func (c *Certificate) Verify(data []byte, sig *Signature) error { |
||||
return c.Key.Verify(data, sig) |
||||
} |
||||
|
||||
func parseSignatureBody(in []byte) (out *Signature, rest []byte, ok bool) { |
||||
format, in, ok := parseString(in) |
||||
if !ok { |
||||
return |
||||
} |
||||
|
||||
out = &Signature{ |
||||
Format: string(format), |
||||
} |
||||
|
||||
if out.Blob, in, ok = parseString(in); !ok { |
||||
return |
||||
} |
||||
|
||||
return out, in, ok |
||||
} |
||||
|
||||
func parseSignature(in []byte) (out *Signature, rest []byte, ok bool) { |
||||
sigBytes, rest, ok := parseString(in) |
||||
if !ok { |
||||
return |
||||
} |
||||
|
||||
out, trailing, ok := parseSignatureBody(sigBytes) |
||||
if !ok || len(trailing) > 0 { |
||||
return nil, nil, false |
||||
} |
||||
return |
||||
} |
||||
@ -1,216 +0,0 @@ |
||||
// Copyright 2013 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 ( |
||||
"bytes" |
||||
"crypto/rand" |
||||
"reflect" |
||||
"testing" |
||||
"time" |
||||
) |
||||
|
||||
// Cert generated by ssh-keygen 6.0p1 Debian-4.
|
||||
// % ssh-keygen -s ca-key -I test user-key
|
||||
const exampleSSHCert = `ssh-rsa-cert-v01@openssh.com AAAAHHNzaC1yc2EtY2VydC12MDFAb3BlbnNzaC5jb20AAAAgb1srW/W3ZDjYAO45xLYAwzHBDLsJ4Ux6ICFIkTjb1LEAAAADAQABAAAAYQCkoR51poH0wE8w72cqSB8Sszx+vAhzcMdCO0wqHTj7UNENHWEXGrU0E0UQekD7U+yhkhtoyjbPOVIP7hNa6aRk/ezdh/iUnCIt4Jt1v3Z1h1P+hA4QuYFMHNB+rmjPwAcAAAAAAAAAAAAAAAEAAAAEdGVzdAAAAAAAAAAAAAAAAP//////////AAAAAAAAAIIAAAAVcGVybWl0LVgxMS1mb3J3YXJkaW5nAAAAAAAAABdwZXJtaXQtYWdlbnQtZm9yd2FyZGluZwAAAAAAAAAWcGVybWl0LXBvcnQtZm9yd2FyZGluZwAAAAAAAAAKcGVybWl0LXB0eQAAAAAAAAAOcGVybWl0LXVzZXItcmMAAAAAAAAAAAAAAHcAAAAHc3NoLXJzYQAAAAMBAAEAAABhANFS2kaktpSGc+CcmEKPyw9mJC4nZKxHKTgLVZeaGbFZOvJTNzBspQHdy7Q1uKSfktxpgjZnksiu/tFF9ngyY2KFoc+U88ya95IZUycBGCUbBQ8+bhDtw/icdDGQD5WnUwAAAG8AAAAHc3NoLXJzYQAAAGC8Y9Z2LQKhIhxf52773XaWrXdxP0t3GBVo4A10vUWiYoAGepr6rQIoGGXFxT4B9Gp+nEBJjOwKDXPrAevow0T9ca8gZN+0ykbhSrXLE5Ao48rqr3zP4O1/9P7e6gp0gw8=` |
||||
|
||||
func TestParseCert(t *testing.T) { |
||||
authKeyBytes := []byte(exampleSSHCert) |
||||
|
||||
key, _, _, rest, err := ParseAuthorizedKey(authKeyBytes) |
||||
if err != nil { |
||||
t.Fatalf("ParseAuthorizedKey: %v", err) |
||||
} |
||||
if len(rest) > 0 { |
||||
t.Errorf("rest: got %q, want empty", rest) |
||||
} |
||||
|
||||
if _, ok := key.(*Certificate); !ok { |
||||
t.Fatalf("got %v (%T), want *Certificate", key, key) |
||||
} |
||||
|
||||
marshaled := MarshalAuthorizedKey(key) |
||||
// Before comparison, remove the trailing newline that
|
||||
// MarshalAuthorizedKey adds.
|
||||
marshaled = marshaled[:len(marshaled)-1] |
||||
if !bytes.Equal(authKeyBytes, marshaled) { |
||||
t.Errorf("marshaled certificate does not match original: got %q, want %q", marshaled, authKeyBytes) |
||||
} |
||||
} |
||||
|
||||
// Cert generated by ssh-keygen OpenSSH_6.8p1 OS X 10.10.3
|
||||
// % ssh-keygen -s ca -I testcert -O source-address=192.168.1.0/24 -O force-command=/bin/sleep user.pub
|
||||
// user.pub key: ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQDACh1rt2DXfV3hk6fszSQcQ/rueMId0kVD9U7nl8cfEnFxqOCrNT92g4laQIGl2mn8lsGZfTLg8ksHq3gkvgO3oo/0wHy4v32JeBOHTsN5AL4gfHNEhWeWb50ev47hnTsRIt9P4dxogeUo/hTu7j9+s9lLpEQXCvq6xocXQt0j8MV9qZBBXFLXVT3cWIkSqOdwt/5ZBg+1GSrc7WfCXVWgTk4a20uPMuJPxU4RQwZW6X3+O8Pqo8C3cW0OzZRFP6gUYUKUsTI5WntlS+LAxgw1mZNsozFGdbiOPRnEryE3SRldh9vjDR3tin1fGpA5P7+CEB/bqaXtG3V+F2OkqaMN
|
||||
// Critical Options:
|
||||
// force-command /bin/sleep
|
||||
// source-address 192.168.1.0/24
|
||||
// Extensions:
|
||||
// permit-X11-forwarding
|
||||
// permit-agent-forwarding
|
||||
// permit-port-forwarding
|
||||
// permit-pty
|
||||
// permit-user-rc
|
||||
const exampleSSHCertWithOptions = `ssh-rsa-cert-v01@openssh.com AAAAHHNzaC1yc2EtY2VydC12MDFAb3BlbnNzaC5jb20AAAAgDyysCJY0XrO1n03EeRRoITnTPdjENFmWDs9X58PP3VUAAAADAQABAAABAQDACh1rt2DXfV3hk6fszSQcQ/rueMId0kVD9U7nl8cfEnFxqOCrNT92g4laQIGl2mn8lsGZfTLg8ksHq3gkvgO3oo/0wHy4v32JeBOHTsN5AL4gfHNEhWeWb50ev47hnTsRIt9P4dxogeUo/hTu7j9+s9lLpEQXCvq6xocXQt0j8MV9qZBBXFLXVT3cWIkSqOdwt/5ZBg+1GSrc7WfCXVWgTk4a20uPMuJPxU4RQwZW6X3+O8Pqo8C3cW0OzZRFP6gUYUKUsTI5WntlS+LAxgw1mZNsozFGdbiOPRnEryE3SRldh9vjDR3tin1fGpA5P7+CEB/bqaXtG3V+F2OkqaMNAAAAAAAAAAAAAAABAAAACHRlc3RjZXJ0AAAAAAAAAAAAAAAA//////////8AAABLAAAADWZvcmNlLWNvbW1hbmQAAAAOAAAACi9iaW4vc2xlZXAAAAAOc291cmNlLWFkZHJlc3MAAAASAAAADjE5Mi4xNjguMS4wLzI0AAAAggAAABVwZXJtaXQtWDExLWZvcndhcmRpbmcAAAAAAAAAF3Blcm1pdC1hZ2VudC1mb3J3YXJkaW5nAAAAAAAAABZwZXJtaXQtcG9ydC1mb3J3YXJkaW5nAAAAAAAAAApwZXJtaXQtcHR5AAAAAAAAAA5wZXJtaXQtdXNlci1yYwAAAAAAAAAAAAABFwAAAAdzc2gtcnNhAAAAAwEAAQAAAQEAwU+c5ui5A8+J/CFpjW8wCa52bEODA808WWQDCSuTG/eMXNf59v9Y8Pk0F1E9dGCosSNyVcB/hacUrc6He+i97+HJCyKavBsE6GDxrjRyxYqAlfcOXi/IVmaUGiO8OQ39d4GHrjToInKvExSUeleQyH4Y4/e27T/pILAqPFL3fyrvMLT5qU9QyIt6zIpa7GBP5+urouNavMprV3zsfIqNBbWypinOQAw823a5wN+zwXnhZrgQiHZ/USG09Y6k98y1dTVz8YHlQVR4D3lpTAsKDKJ5hCH9WU4fdf+lU8OyNGaJ/vz0XNqxcToe1l4numLTnaoSuH89pHryjqurB7lJKwAAAQ8AAAAHc3NoLXJzYQAAAQCaHvUIoPL1zWUHIXLvu96/HU1s/i4CAW2IIEuGgxCUCiFj6vyTyYtgxQxcmbfZf6eaITlS6XJZa7Qq4iaFZh75C1DXTX8labXhRSD4E2t//AIP9MC1rtQC5xo6FmbQ+BoKcDskr+mNACcbRSxs3IL3bwCfWDnIw2WbVox9ZdcthJKk4UoCW4ix4QwdHw7zlddlz++fGEEVhmTbll1SUkycGApPFBsAYRTMupUJcYPIeReBI/m8XfkoMk99bV8ZJQTAd7OekHY2/48Ff53jLmyDjP7kNw1F8OaPtkFs6dGJXta4krmaekPy87j+35In5hFj7yoOqvSbmYUkeX70/GGQ` |
||||
|
||||
func TestParseCertWithOptions(t *testing.T) { |
||||
opts := map[string]string{ |
||||
"source-address": "192.168.1.0/24", |
||||
"force-command": "/bin/sleep", |
||||
} |
||||
exts := map[string]string{ |
||||
"permit-X11-forwarding": "", |
||||
"permit-agent-forwarding": "", |
||||
"permit-port-forwarding": "", |
||||
"permit-pty": "", |
||||
"permit-user-rc": "", |
||||
} |
||||
authKeyBytes := []byte(exampleSSHCertWithOptions) |
||||
|
||||
key, _, _, rest, err := ParseAuthorizedKey(authKeyBytes) |
||||
if err != nil { |
||||
t.Fatalf("ParseAuthorizedKey: %v", err) |
||||
} |
||||
if len(rest) > 0 { |
||||
t.Errorf("rest: got %q, want empty", rest) |
||||
} |
||||
cert, ok := key.(*Certificate) |
||||
if !ok { |
||||
t.Fatalf("got %v (%T), want *Certificate", key, key) |
||||
} |
||||
if !reflect.DeepEqual(cert.CriticalOptions, opts) { |
||||
t.Errorf("unexpected critical options - got %v, want %v", cert.CriticalOptions, opts) |
||||
} |
||||
if !reflect.DeepEqual(cert.Extensions, exts) { |
||||
t.Errorf("unexpected Extensions - got %v, want %v", cert.Extensions, exts) |
||||
} |
||||
marshaled := MarshalAuthorizedKey(key) |
||||
// Before comparison, remove the trailing newline that
|
||||
// MarshalAuthorizedKey adds.
|
||||
marshaled = marshaled[:len(marshaled)-1] |
||||
if !bytes.Equal(authKeyBytes, marshaled) { |
||||
t.Errorf("marshaled certificate does not match original: got %q, want %q", marshaled, authKeyBytes) |
||||
} |
||||
} |
||||
|
||||
func TestValidateCert(t *testing.T) { |
||||
key, _, _, _, err := ParseAuthorizedKey([]byte(exampleSSHCert)) |
||||
if err != nil { |
||||
t.Fatalf("ParseAuthorizedKey: %v", err) |
||||
} |
||||
validCert, ok := key.(*Certificate) |
||||
if !ok { |
||||
t.Fatalf("got %v (%T), want *Certificate", key, key) |
||||
} |
||||
checker := CertChecker{} |
||||
checker.IsAuthority = func(k PublicKey) bool { |
||||
return bytes.Equal(k.Marshal(), validCert.SignatureKey.Marshal()) |
||||
} |
||||
|
||||
if err := checker.CheckCert("user", validCert); err != nil { |
||||
t.Errorf("Unable to validate certificate: %v", err) |
||||
} |
||||
invalidCert := &Certificate{ |
||||
Key: testPublicKeys["rsa"], |
||||
SignatureKey: testPublicKeys["ecdsa"], |
||||
ValidBefore: CertTimeInfinity, |
||||
Signature: &Signature{}, |
||||
} |
||||
if err := checker.CheckCert("user", invalidCert); err == nil { |
||||
t.Error("Invalid cert signature passed validation") |
||||
} |
||||
} |
||||
|
||||
func TestValidateCertTime(t *testing.T) { |
||||
cert := Certificate{ |
||||
ValidPrincipals: []string{"user"}, |
||||
Key: testPublicKeys["rsa"], |
||||
ValidAfter: 50, |
||||
ValidBefore: 100, |
||||
} |
||||
|
||||
cert.SignCert(rand.Reader, testSigners["ecdsa"]) |
||||
|
||||
for ts, ok := range map[int64]bool{ |
||||
25: false, |
||||
50: true, |
||||
99: true, |
||||
100: false, |
||||
125: false, |
||||
} { |
||||
checker := CertChecker{ |
||||
Clock: func() time.Time { return time.Unix(ts, 0) }, |
||||
} |
||||
checker.IsAuthority = func(k PublicKey) bool { |
||||
return bytes.Equal(k.Marshal(), |
||||
testPublicKeys["ecdsa"].Marshal()) |
||||
} |
||||
|
||||
if v := checker.CheckCert("user", &cert); (v == nil) != ok { |
||||
t.Errorf("Authenticate(%d): %v", ts, v) |
||||
} |
||||
} |
||||
} |
||||
|
||||
// TODO(hanwen): tests for
|
||||
//
|
||||
// host keys:
|
||||
// * fallbacks
|
||||
|
||||
func TestHostKeyCert(t *testing.T) { |
||||
cert := &Certificate{ |
||||
ValidPrincipals: []string{"hostname", "hostname.domain"}, |
||||
Key: testPublicKeys["rsa"], |
||||
ValidBefore: CertTimeInfinity, |
||||
CertType: HostCert, |
||||
} |
||||
cert.SignCert(rand.Reader, testSigners["ecdsa"]) |
||||
|
||||
checker := &CertChecker{ |
||||
IsAuthority: func(p PublicKey) bool { |
||||
return bytes.Equal(testPublicKeys["ecdsa"].Marshal(), p.Marshal()) |
||||
}, |
||||
} |
||||
|
||||
certSigner, err := NewCertSigner(cert, testSigners["rsa"]) |
||||
if err != nil { |
||||
t.Errorf("NewCertSigner: %v", err) |
||||
} |
||||
|
||||
for _, name := range []string{"hostname", "otherhost"} { |
||||
c1, c2, err := netPipe() |
||||
if err != nil { |
||||
t.Fatalf("netPipe: %v", err) |
||||
} |
||||
defer c1.Close() |
||||
defer c2.Close() |
||||
|
||||
errc := make(chan error) |
||||
|
||||
go func() { |
||||
conf := ServerConfig{ |
||||
NoClientAuth: true, |
||||
} |
||||
conf.AddHostKey(certSigner) |
||||
_, _, _, err := NewServerConn(c1, &conf) |
||||
errc <- err |
||||
}() |
||||
|
||||
config := &ClientConfig{ |
||||
User: "user", |
||||
HostKeyCallback: checker.CheckHostKey, |
||||
} |
||||
_, _, _, err = NewClientConn(c2, name, config) |
||||
|
||||
succeed := name == "hostname" |
||||
if (err == nil) != succeed { |
||||
t.Fatalf("NewClientConn(%q): %v", name, err) |
||||
} |
||||
|
||||
err = <-errc |
||||
if (err == nil) != succeed { |
||||
t.Fatalf("NewServerConn(%q): %v", name, err) |
||||
} |
||||
} |
||||
} |
||||
@ -1,631 +0,0 @@ |
||||
// 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 ( |
||||
"encoding/binary" |
||||
"errors" |
||||
"fmt" |
||||
"io" |
||||
"log" |
||||
"sync" |
||||
) |
||||
|
||||
const ( |
||||
minPacketLength = 9 |
||||
// channelMaxPacket contains the maximum number of bytes that will be
|
||||
// sent in a single packet. As per RFC 4253, section 6.1, 32k is also
|
||||
// the minimum.
|
||||
channelMaxPacket = 1 << 15 |
||||
// We follow OpenSSH here.
|
||||
channelWindowSize = 64 * channelMaxPacket |
||||
) |
||||
|
||||
// NewChannel represents an incoming request to a channel. It must either be
|
||||
// accepted for use by calling Accept, or rejected by calling Reject.
|
||||
type NewChannel interface { |
||||
// Accept accepts the channel creation request. It returns the Channel
|
||||
// and a Go channel containing SSH requests. The Go channel must be
|
||||
// serviced otherwise the Channel will hang.
|
||||
Accept() (Channel, <-chan *Request, error) |
||||
|
||||
// Reject rejects the channel creation request. After calling
|
||||
// this, no other methods on the Channel may be called.
|
||||
Reject(reason RejectionReason, message string) error |
||||
|
||||
// ChannelType returns the type of the channel, as supplied by the
|
||||
// client.
|
||||
ChannelType() string |
||||
|
||||
// ExtraData returns the arbitrary payload for this channel, as supplied
|
||||
// by the client. This data is specific to the channel type.
|
||||
ExtraData() []byte |
||||
} |
||||
|
||||
// A Channel is an ordered, reliable, flow-controlled, duplex stream
|
||||
// that is multiplexed over an SSH connection.
|
||||
type Channel interface { |
||||
// Read reads up to len(data) bytes from the channel.
|
||||
Read(data []byte) (int, error) |
||||
|
||||
// Write writes len(data) bytes to the channel.
|
||||
Write(data []byte) (int, error) |
||||
|
||||
// Close signals end of channel use. No data may be sent after this
|
||||
// call.
|
||||
Close() error |
||||
|
||||
// CloseWrite signals the end of sending in-band
|
||||
// data. Requests may still be sent, and the other side may
|
||||
// still send data
|
||||
CloseWrite() error |
||||
|
||||
// SendRequest sends a channel request. If wantReply is true,
|
||||
// it will wait for a reply and return the result as a
|
||||
// boolean, otherwise the return value will be false. Channel
|
||||
// requests are out-of-band messages so they may be sent even
|
||||
// if the data stream is closed or blocked by flow control.
|
||||
SendRequest(name string, wantReply bool, payload []byte) (bool, error) |
||||
|
||||
// Stderr returns an io.ReadWriter that writes to this channel
|
||||
// with the extended data type set to stderr. Stderr may
|
||||
// safely be read and written from a different goroutine than
|
||||
// Read and Write respectively.
|
||||
Stderr() io.ReadWriter |
||||
} |
||||
|
||||
// Request is a request sent outside of the normal stream of
|
||||
// data. Requests can either be specific to an SSH channel, or they
|
||||
// can be global.
|
||||
type Request struct { |
||||
Type string |
||||
WantReply bool |
||||
Payload []byte |
||||
|
||||
ch *channel |
||||
mux *mux |
||||
} |
||||
|
||||
// Reply sends a response to a request. It must be called for all requests
|
||||
// where WantReply is true and is a no-op otherwise. The payload argument is
|
||||
// ignored for replies to channel-specific requests.
|
||||
func (r *Request) Reply(ok bool, payload []byte) error { |
||||
if !r.WantReply { |
||||
return nil |
||||
} |
||||
|
||||
if r.ch == nil { |
||||
return r.mux.ackRequest(ok, payload) |
||||
} |
||||
|
||||
return r.ch.ackRequest(ok) |
||||
} |
||||
|
||||
// RejectionReason is an enumeration used when rejecting channel creation
|
||||
// requests. See RFC 4254, section 5.1.
|
||||
type RejectionReason uint32 |
||||
|
||||
const ( |
||||
Prohibited RejectionReason = iota + 1 |
||||
ConnectionFailed |
||||
UnknownChannelType |
||||
ResourceShortage |
||||
) |
||||
|
||||
// String converts the rejection reason to human readable form.
|
||||
func (r RejectionReason) String() string { |
||||
switch r { |
||||
case Prohibited: |
||||
return "administratively prohibited" |
||||
case ConnectionFailed: |
||||
return "connect failed" |
||||
case UnknownChannelType: |
||||
return "unknown channel type" |
||||
case ResourceShortage: |
||||
return "resource shortage" |
||||
} |
||||
return fmt.Sprintf("unknown reason %d", int(r)) |
||||
} |
||||
|
||||
func min(a uint32, b int) uint32 { |
||||
if a < uint32(b) { |
||||
return a |
||||
} |
||||
return uint32(b) |
||||
} |
||||
|
||||
type channelDirection uint8 |
||||
|
||||
const ( |
||||
channelInbound channelDirection = iota |
||||
channelOutbound |
||||
) |
||||
|
||||
// channel is an implementation of the Channel interface that works
|
||||
// with the mux class.
|
||||
type channel struct { |
||||
// R/O after creation
|
||||
chanType string |
||||
extraData []byte |
||||
localId, remoteId uint32 |
||||
|
||||
// maxIncomingPayload and maxRemotePayload are the maximum
|
||||
// payload sizes of normal and extended data packets for
|
||||
// receiving and sending, respectively. The wire packet will
|
||||
// be 9 or 13 bytes larger (excluding encryption overhead).
|
||||
maxIncomingPayload uint32 |
||||
maxRemotePayload uint32 |
||||
|
||||
mux *mux |
||||
|
||||
// decided is set to true if an accept or reject message has been sent
|
||||
// (for outbound channels) or received (for inbound channels).
|
||||
decided bool |
||||
|
||||
// direction contains either channelOutbound, for channels created
|
||||
// locally, or channelInbound, for channels created by the peer.
|
||||
direction channelDirection |
||||
|
||||
// Pending internal channel messages.
|
||||
msg chan interface{} |
||||
|
||||
// Since requests have no ID, there can be only one request
|
||||
// with WantReply=true outstanding. This lock is held by a
|
||||
// goroutine that has such an outgoing request pending.
|
||||
sentRequestMu sync.Mutex |
||||
|
||||
incomingRequests chan *Request |
||||
|
||||
sentEOF bool |
||||
|
||||
// thread-safe data
|
||||
remoteWin window |
||||
pending *buffer |
||||
extPending *buffer |
||||
|
||||
// windowMu protects myWindow, the flow-control window.
|
||||
windowMu sync.Mutex |
||||
myWindow uint32 |
||||
|
||||
// writeMu serializes calls to mux.conn.writePacket() and
|
||||
// protects sentClose and packetPool. This mutex must be
|
||||
// different from windowMu, as writePacket can block if there
|
||||
// is a key exchange pending.
|
||||
writeMu sync.Mutex |
||||
sentClose bool |
||||
|
||||
// packetPool has a buffer for each extended channel ID to
|
||||
// save allocations during writes.
|
||||
packetPool map[uint32][]byte |
||||
} |
||||
|
||||
// writePacket sends a packet. If the packet is a channel close, it updates
|
||||
// sentClose. This method takes the lock c.writeMu.
|
||||
func (c *channel) writePacket(packet []byte) error { |
||||
c.writeMu.Lock() |
||||
if c.sentClose { |
||||
c.writeMu.Unlock() |
||||
return io.EOF |
||||
} |
||||
c.sentClose = (packet[0] == msgChannelClose) |
||||
err := c.mux.conn.writePacket(packet) |
||||
c.writeMu.Unlock() |
||||
return err |
||||
} |
||||
|
||||
func (c *channel) sendMessage(msg interface{}) error { |
||||
if debugMux { |
||||
log.Printf("send %d: %#v", c.mux.chanList.offset, msg) |
||||
} |
||||
|
||||
p := Marshal(msg) |
||||
binary.BigEndian.PutUint32(p[1:], c.remoteId) |
||||
return c.writePacket(p) |
||||
} |
||||
|
||||
// WriteExtended writes data to a specific extended stream. These streams are
|
||||
// used, for example, for stderr.
|
||||
func (c *channel) WriteExtended(data []byte, extendedCode uint32) (n int, err error) { |
||||
if c.sentEOF { |
||||
return 0, io.EOF |
||||
} |
||||
// 1 byte message type, 4 bytes remoteId, 4 bytes data length
|
||||
opCode := byte(msgChannelData) |
||||
headerLength := uint32(9) |
||||
if extendedCode > 0 { |
||||
headerLength += 4 |
||||
opCode = msgChannelExtendedData |
||||
} |
||||
|
||||
c.writeMu.Lock() |
||||
packet := c.packetPool[extendedCode] |
||||
// We don't remove the buffer from packetPool, so
|
||||
// WriteExtended calls from different goroutines will be
|
||||
// flagged as errors by the race detector.
|
||||
c.writeMu.Unlock() |
||||
|
||||
for len(data) > 0 { |
||||
space := min(c.maxRemotePayload, len(data)) |
||||
if space, err = c.remoteWin.reserve(space); err != nil { |
||||
return n, err |
||||
} |
||||
if want := headerLength + space; uint32(cap(packet)) < want { |
||||
packet = make([]byte, want) |
||||
} else { |
||||
packet = packet[:want] |
||||
} |
||||
|
||||
todo := data[:space] |
||||
|
||||
packet[0] = opCode |
||||
binary.BigEndian.PutUint32(packet[1:], c.remoteId) |
||||
if extendedCode > 0 { |
||||
binary.BigEndian.PutUint32(packet[5:], uint32(extendedCode)) |
||||
} |
||||
binary.BigEndian.PutUint32(packet[headerLength-4:], uint32(len(todo))) |
||||
copy(packet[headerLength:], todo) |
||||
if err = c.writePacket(packet); err != nil { |
||||
return n, err |
||||
} |
||||
|
||||
n += len(todo) |
||||
data = data[len(todo):] |
||||
} |
||||
|
||||
c.writeMu.Lock() |
||||
c.packetPool[extendedCode] = packet |
||||
c.writeMu.Unlock() |
||||
|
||||
return n, err |
||||
} |
||||
|
||||
func (c *channel) handleData(packet []byte) error { |
||||
headerLen := 9 |
||||
isExtendedData := packet[0] == msgChannelExtendedData |
||||
if isExtendedData { |
||||
headerLen = 13 |
||||
} |
||||
if len(packet) < headerLen { |
||||
// malformed data packet
|
||||
return parseError(packet[0]) |
||||
} |
||||
|
||||
var extended uint32 |
||||
if isExtendedData { |
||||
extended = binary.BigEndian.Uint32(packet[5:]) |
||||
} |
||||
|
||||
length := binary.BigEndian.Uint32(packet[headerLen-4 : headerLen]) |
||||
if length == 0 { |
||||
return nil |
||||
} |
||||
if length > c.maxIncomingPayload { |
||||
// TODO(hanwen): should send Disconnect?
|
||||
return errors.New("ssh: incoming packet exceeds maximum payload size") |
||||
} |
||||
|
||||
data := packet[headerLen:] |
||||
if length != uint32(len(data)) { |
||||
return errors.New("ssh: wrong packet length") |
||||
} |
||||
|
||||
c.windowMu.Lock() |
||||
if c.myWindow < length { |
||||
c.windowMu.Unlock() |
||||
// TODO(hanwen): should send Disconnect with reason?
|
||||
return errors.New("ssh: remote side wrote too much") |
||||
} |
||||
c.myWindow -= length |
||||
c.windowMu.Unlock() |
||||
|
||||
if extended == 1 { |
||||
c.extPending.write(data) |
||||
} else if extended > 0 { |
||||
// discard other extended data.
|
||||
} else { |
||||
c.pending.write(data) |
||||
} |
||||
return nil |
||||
} |
||||
|
||||
func (c *channel) adjustWindow(n uint32) error { |
||||
c.windowMu.Lock() |
||||
// Since myWindow is managed on our side, and can never exceed
|
||||
// the initial window setting, we don't worry about overflow.
|
||||
c.myWindow += uint32(n) |
||||
c.windowMu.Unlock() |
||||
return c.sendMessage(windowAdjustMsg{ |
||||
AdditionalBytes: uint32(n), |
||||
}) |
||||
} |
||||
|
||||
func (c *channel) ReadExtended(data []byte, extended uint32) (n int, err error) { |
||||
switch extended { |
||||
case 1: |
||||
n, err = c.extPending.Read(data) |
||||
case 0: |
||||
n, err = c.pending.Read(data) |
||||
default: |
||||
return 0, fmt.Errorf("ssh: extended code %d unimplemented", extended) |
||||
} |
||||
|
||||
if n > 0 { |
||||
err = c.adjustWindow(uint32(n)) |
||||
// sendWindowAdjust can return io.EOF if the remote
|
||||
// peer has closed the connection, however we want to
|
||||
// defer forwarding io.EOF to the caller of Read until
|
||||
// the buffer has been drained.
|
||||
if n > 0 && err == io.EOF { |
||||
err = nil |
||||
} |
||||
} |
||||
|
||||
return n, err |
||||
} |
||||
|
||||
func (c *channel) close() { |
||||
c.pending.eof() |
||||
c.extPending.eof() |
||||
close(c.msg) |
||||
close(c.incomingRequests) |
||||
c.writeMu.Lock() |
||||
// This is not necesary for a normal channel teardown, but if
|
||||
// there was another error, it is.
|
||||
c.sentClose = true |
||||
c.writeMu.Unlock() |
||||
// Unblock writers.
|
||||
c.remoteWin.close() |
||||
} |
||||
|
||||
// responseMessageReceived is called when a success or failure message is
|
||||
// received on a channel to check that such a message is reasonable for the
|
||||
// given channel.
|
||||
func (c *channel) responseMessageReceived() error { |
||||
if c.direction == channelInbound { |
||||
return errors.New("ssh: channel response message received on inbound channel") |
||||
} |
||||
if c.decided { |
||||
return errors.New("ssh: duplicate response received for channel") |
||||
} |
||||
c.decided = true |
||||
return nil |
||||
} |
||||
|
||||
func (c *channel) handlePacket(packet []byte) error { |
||||
switch packet[0] { |
||||
case msgChannelData, msgChannelExtendedData: |
||||
return c.handleData(packet) |
||||
case msgChannelClose: |
||||
c.sendMessage(channelCloseMsg{PeersId: c.remoteId}) |
||||
c.mux.chanList.remove(c.localId) |
||||
c.close() |
||||
return nil |
||||
case msgChannelEOF: |
||||
// RFC 4254 is mute on how EOF affects dataExt messages but
|
||||
// it is logical to signal EOF at the same time.
|
||||
c.extPending.eof() |
||||
c.pending.eof() |
||||
return nil |
||||
} |
||||
|
||||
decoded, err := decode(packet) |
||||
if err != nil { |
||||
return err |
||||
} |
||||
|
||||
switch msg := decoded.(type) { |
||||
case *channelOpenFailureMsg: |
||||
if err := c.responseMessageReceived(); err != nil { |
||||
return err |
||||
} |
||||
c.mux.chanList.remove(msg.PeersId) |
||||
c.msg <- msg |
||||
case *channelOpenConfirmMsg: |
||||
if err := c.responseMessageReceived(); err != nil { |
||||
return err |
||||
} |
||||
if msg.MaxPacketSize < minPacketLength || msg.MaxPacketSize > 1<<31 { |
||||
return fmt.Errorf("ssh: invalid MaxPacketSize %d from peer", msg.MaxPacketSize) |
||||
} |
||||
c.remoteId = msg.MyId |
||||
c.maxRemotePayload = msg.MaxPacketSize |
||||
c.remoteWin.add(msg.MyWindow) |
||||
c.msg <- msg |
||||
case *windowAdjustMsg: |
||||
if !c.remoteWin.add(msg.AdditionalBytes) { |
||||
return fmt.Errorf("ssh: invalid window update for %d bytes", msg.AdditionalBytes) |
||||
} |
||||
case *channelRequestMsg: |
||||
req := Request{ |
||||
Type: msg.Request, |
||||
WantReply: msg.WantReply, |
||||
Payload: msg.RequestSpecificData, |
||||
ch: c, |
||||
} |
||||
|
||||
c.incomingRequests <- &req |
||||
default: |
||||
c.msg <- msg |
||||
} |
||||
return nil |
||||
} |
||||
|
||||
func (m *mux) newChannel(chanType string, direction channelDirection, extraData []byte) *channel { |
||||
ch := &channel{ |
||||
remoteWin: window{Cond: newCond()}, |
||||
myWindow: channelWindowSize, |
||||
pending: newBuffer(), |
||||
extPending: newBuffer(), |
||||
direction: direction, |
||||
incomingRequests: make(chan *Request, 16), |
||||
msg: make(chan interface{}, 16), |
||||
chanType: chanType, |
||||
extraData: extraData, |
||||
mux: m, |
||||
packetPool: make(map[uint32][]byte), |
||||
} |
||||
ch.localId = m.chanList.add(ch) |
||||
return ch |
||||
} |
||||
|
||||
var errUndecided = errors.New("ssh: must Accept or Reject channel") |
||||
var errDecidedAlready = errors.New("ssh: can call Accept or Reject only once") |
||||
|
||||
type extChannel struct { |
||||
code uint32 |
||||
ch *channel |
||||
} |
||||
|
||||
func (e *extChannel) Write(data []byte) (n int, err error) { |
||||
return e.ch.WriteExtended(data, e.code) |
||||
} |
||||
|
||||
func (e *extChannel) Read(data []byte) (n int, err error) { |
||||
return e.ch.ReadExtended(data, e.code) |
||||
} |
||||
|
||||
func (c *channel) Accept() (Channel, <-chan *Request, error) { |
||||
if c.decided { |
||||
return nil, nil, errDecidedAlready |
||||
} |
||||
c.maxIncomingPayload = channelMaxPacket |
||||
confirm := channelOpenConfirmMsg{ |
||||
PeersId: c.remoteId, |
||||
MyId: c.localId, |
||||
MyWindow: c.myWindow, |
||||
MaxPacketSize: c.maxIncomingPayload, |
||||
} |
||||
c.decided = true |
||||
if err := c.sendMessage(confirm); err != nil { |
||||
return nil, nil, err |
||||
} |
||||
|
||||
return c, c.incomingRequests, nil |
||||
} |
||||
|
||||
func (ch *channel) Reject(reason RejectionReason, message string) error { |
||||
if ch.decided { |
||||
return errDecidedAlready |
||||
} |
||||
reject := channelOpenFailureMsg{ |
||||
PeersId: ch.remoteId, |
||||
Reason: reason, |
||||
Message: message, |
||||
Language: "en", |
||||
} |
||||
ch.decided = true |
||||
return ch.sendMessage(reject) |
||||
} |
||||
|
||||
func (ch *channel) Read(data []byte) (int, error) { |
||||
if !ch.decided { |
||||
return 0, errUndecided |
||||
} |
||||
return ch.ReadExtended(data, 0) |
||||
} |
||||
|
||||
func (ch *channel) Write(data []byte) (int, error) { |
||||
if !ch.decided { |
||||
return 0, errUndecided |
||||
} |
||||
return ch.WriteExtended(data, 0) |
||||
} |
||||
|
||||
func (ch *channel) CloseWrite() error { |
||||
if !ch.decided { |
||||
return errUndecided |
||||
} |
||||
ch.sentEOF = true |
||||
return ch.sendMessage(channelEOFMsg{ |
||||
PeersId: ch.remoteId}) |
||||
} |
||||
|
||||
func (ch *channel) Close() error { |
||||
if !ch.decided { |
||||
return errUndecided |
||||
} |
||||
|
||||
return ch.sendMessage(channelCloseMsg{ |
||||
PeersId: ch.remoteId}) |
||||
} |
||||
|
||||
// Extended returns an io.ReadWriter that sends and receives data on the given,
|
||||
// SSH extended stream. Such streams are used, for example, for stderr.
|
||||
func (ch *channel) Extended(code uint32) io.ReadWriter { |
||||
if !ch.decided { |
||||
return nil |
||||
} |
||||
return &extChannel{code, ch} |
||||
} |
||||
|
||||
func (ch *channel) Stderr() io.ReadWriter { |
||||
return ch.Extended(1) |
||||
} |
||||
|
||||
func (ch *channel) SendRequest(name string, wantReply bool, payload []byte) (bool, error) { |
||||
if !ch.decided { |
||||
return false, errUndecided |
||||
} |
||||
|
||||
if wantReply { |
||||
ch.sentRequestMu.Lock() |
||||
defer ch.sentRequestMu.Unlock() |
||||
} |
||||
|
||||
msg := channelRequestMsg{ |
||||
PeersId: ch.remoteId, |
||||
Request: name, |
||||
WantReply: wantReply, |
||||
RequestSpecificData: payload, |
||||
} |
||||
|
||||
if err := ch.sendMessage(msg); err != nil { |
||||
return false, err |
||||
} |
||||
|
||||
if wantReply { |
||||
m, ok := (<-ch.msg) |
||||
if !ok { |
||||
return false, io.EOF |
||||
} |
||||
switch m.(type) { |
||||
case *channelRequestFailureMsg: |
||||
return false, nil |
||||
case *channelRequestSuccessMsg: |
||||
return true, nil |
||||
default: |
||||
return false, fmt.Errorf("ssh: unexpected response to channel request: %#v", m) |
||||
} |
||||
} |
||||
|
||||
return false, nil |
||||
} |
||||
|
||||
// ackRequest either sends an ack or nack to the channel request.
|
||||
func (ch *channel) ackRequest(ok bool) error { |
||||
if !ch.decided { |
||||
return errUndecided |
||||
} |
||||
|
||||
var msg interface{} |
||||
if !ok { |
||||
msg = channelRequestFailureMsg{ |
||||
PeersId: ch.remoteId, |
||||
} |
||||
} else { |
||||
msg = channelRequestSuccessMsg{ |
||||
PeersId: ch.remoteId, |
||||
} |
||||
} |
||||
return ch.sendMessage(msg) |
||||
} |
||||
|
||||
func (ch *channel) ChannelType() string { |
||||
return ch.chanType |
||||
} |
||||
|
||||
func (ch *channel) ExtraData() []byte { |
||||
return ch.extraData |
||||
} |
||||
@ -1,549 +0,0 @@ |
||||
// 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/aes" |
||||
"crypto/cipher" |
||||
"crypto/rc4" |
||||
"crypto/subtle" |
||||
"encoding/binary" |
||||
"errors" |
||||
"fmt" |
||||
"hash" |
||||
"io" |
||||
"io/ioutil" |
||||
) |
||||
|
||||
const ( |
||||
packetSizeMultiple = 16 // TODO(huin) this should be determined by the cipher.
|
||||
|
||||
// RFC 4253 section 6.1 defines a minimum packet size of 32768 that implementations
|
||||
// MUST be able to process (plus a few more kilobytes for padding and mac). The RFC
|
||||
// indicates implementations SHOULD be able to handle larger packet sizes, but then
|
||||
// waffles on about reasonable limits.
|
||||
//
|
||||
// OpenSSH caps their maxPacket at 256kB so we choose to do
|
||||
// the same. maxPacket is also used to ensure that uint32
|
||||
// length fields do not overflow, so it should remain well
|
||||
// below 4G.
|
||||
maxPacket = 256 * 1024 |
||||
) |
||||
|
||||
// noneCipher implements cipher.Stream and provides no encryption. It is used
|
||||
// by the transport before the first key-exchange.
|
||||
type noneCipher struct{} |
||||
|
||||
func (c noneCipher) XORKeyStream(dst, src []byte) { |
||||
copy(dst, src) |
||||
} |
||||
|
||||
func newAESCTR(key, iv []byte) (cipher.Stream, error) { |
||||
c, err := aes.NewCipher(key) |
||||
if err != nil { |
||||
return nil, err |
||||
} |
||||
return cipher.NewCTR(c, iv), nil |
||||
} |
||||
|
||||
func newRC4(key, iv []byte) (cipher.Stream, error) { |
||||
return rc4.NewCipher(key) |
||||
} |
||||
|
||||
type streamCipherMode struct { |
||||
keySize int |
||||
ivSize int |
||||
skip int |
||||
createFunc func(key, iv []byte) (cipher.Stream, error) |
||||
} |
||||
|
||||
func (c *streamCipherMode) createStream(key, iv []byte) (cipher.Stream, error) { |
||||
if len(key) < c.keySize { |
||||
panic("ssh: key length too small for cipher") |
||||
} |
||||
if len(iv) < c.ivSize { |
||||
panic("ssh: iv too small for cipher") |
||||
} |
||||
|
||||
stream, err := c.createFunc(key[:c.keySize], iv[:c.ivSize]) |
||||
if err != nil { |
||||
return nil, err |
||||
} |
||||
|
||||
var streamDump []byte |
||||
if c.skip > 0 { |
||||
streamDump = make([]byte, 512) |
||||
} |
||||
|
||||
for remainingToDump := c.skip; remainingToDump > 0; { |
||||
dumpThisTime := remainingToDump |
||||
if dumpThisTime > len(streamDump) { |
||||
dumpThisTime = len(streamDump) |
||||
} |
||||
stream.XORKeyStream(streamDump[:dumpThisTime], streamDump[:dumpThisTime]) |
||||
remainingToDump -= dumpThisTime |
||||
} |
||||
|
||||
return stream, nil |
||||
} |
||||
|
||||
// cipherModes documents properties of supported ciphers. Ciphers not included
|
||||
// are not supported and will not be negotiated, even if explicitly requested in
|
||||
// ClientConfig.Crypto.Ciphers.
|
||||
var cipherModes = map[string]*streamCipherMode{ |
||||
// Ciphers from RFC4344, which introduced many CTR-based ciphers. Algorithms
|
||||
// are defined in the order specified in the RFC.
|
||||
"aes128-ctr": {16, aes.BlockSize, 0, newAESCTR}, |
||||
"aes192-ctr": {24, aes.BlockSize, 0, newAESCTR}, |
||||
"aes256-ctr": {32, aes.BlockSize, 0, newAESCTR}, |
||||
|
||||
// Ciphers from RFC4345, which introduces security-improved arcfour ciphers.
|
||||
// They are defined in the order specified in the RFC.
|
||||
"arcfour128": {16, 0, 1536, newRC4}, |
||||
"arcfour256": {32, 0, 1536, newRC4}, |
||||
|
||||
// Cipher defined in RFC 4253, which describes SSH Transport Layer Protocol.
|
||||
// Note that this cipher is not safe, as stated in RFC 4253: "Arcfour (and
|
||||
// RC4) has problems with weak keys, and should be used with caution."
|
||||
// RFC4345 introduces improved versions of Arcfour.
|
||||
"arcfour": {16, 0, 0, newRC4}, |
||||
|
||||
// AES-GCM is not a stream cipher, so it is constructed with a
|
||||
// special case. If we add any more non-stream ciphers, we
|
||||
// should invest a cleaner way to do this.
|
||||
gcmCipherID: {16, 12, 0, nil}, |
||||
|
||||
// insecure cipher, see http://www.isg.rhul.ac.uk/~kp/SandPfinal.pdf
|
||||
// uncomment below to enable it.
|
||||
// aes128cbcID: {16, aes.BlockSize, 0, nil},
|
||||
} |
||||
|
||||
// prefixLen is the length of the packet prefix that contains the packet length
|
||||
// and number of padding bytes.
|
||||
const prefixLen = 5 |
||||
|
||||
// streamPacketCipher is a packetCipher using a stream cipher.
|
||||
type streamPacketCipher struct { |
||||
mac hash.Hash |
||||
cipher cipher.Stream |
||||
|
||||
// The following members are to avoid per-packet allocations.
|
||||
prefix [prefixLen]byte |
||||
seqNumBytes [4]byte |
||||
padding [2 * packetSizeMultiple]byte |
||||
packetData []byte |
||||
macResult []byte |
||||
} |
||||
|
||||
// readPacket reads and decrypt a single packet from the reader argument.
|
||||
func (s *streamPacketCipher) readPacket(seqNum uint32, r io.Reader) ([]byte, error) { |
||||
if _, err := io.ReadFull(r, s.prefix[:]); err != nil { |
||||
return nil, err |
||||
} |
||||
|
||||
s.cipher.XORKeyStream(s.prefix[:], s.prefix[:]) |
||||
length := binary.BigEndian.Uint32(s.prefix[0:4]) |
||||
paddingLength := uint32(s.prefix[4]) |
||||
|
||||
var macSize uint32 |
||||
if s.mac != nil { |
||||
s.mac.Reset() |
||||
binary.BigEndian.PutUint32(s.seqNumBytes[:], seqNum) |
||||
s.mac.Write(s.seqNumBytes[:]) |
||||
s.mac.Write(s.prefix[:]) |
||||
macSize = uint32(s.mac.Size()) |
||||
} |
||||
|
||||
if length <= paddingLength+1 { |
||||
return nil, errors.New("ssh: invalid packet length, packet too small") |
||||
} |
||||
|
||||
if length > maxPacket { |
||||
return nil, errors.New("ssh: invalid packet length, packet too large") |
||||
} |
||||
|
||||
// the maxPacket check above ensures that length-1+macSize
|
||||
// does not overflow.
|
||||
if uint32(cap(s.packetData)) < length-1+macSize { |
||||
s.packetData = make([]byte, length-1+macSize) |
||||
} else { |
||||
s.packetData = s.packetData[:length-1+macSize] |
||||
} |
||||
|
||||
if _, err := io.ReadFull(r, s.packetData); err != nil { |
||||
return nil, err |
||||
} |
||||
mac := s.packetData[length-1:] |
||||
data := s.packetData[:length-1] |
||||
s.cipher.XORKeyStream(data, data) |
||||
|
||||
if s.mac != nil { |
||||
s.mac.Write(data) |
||||
s.macResult = s.mac.Sum(s.macResult[:0]) |
||||
if subtle.ConstantTimeCompare(s.macResult, mac) != 1 { |
||||
return nil, errors.New("ssh: MAC failure") |
||||
} |
||||
} |
||||
|
||||
return s.packetData[:length-paddingLength-1], nil |
||||
} |
||||
|
||||
// writePacket encrypts and sends a packet of data to the writer argument
|
||||
func (s *streamPacketCipher) writePacket(seqNum uint32, w io.Writer, rand io.Reader, packet []byte) error { |
||||
if len(packet) > maxPacket { |
||||
return errors.New("ssh: packet too large") |
||||
} |
||||
|
||||
paddingLength := packetSizeMultiple - (prefixLen+len(packet))%packetSizeMultiple |
||||
if paddingLength < 4 { |
||||
paddingLength += packetSizeMultiple |
||||
} |
||||
|
||||
length := len(packet) + 1 + paddingLength |
||||
binary.BigEndian.PutUint32(s.prefix[:], uint32(length)) |
||||
s.prefix[4] = byte(paddingLength) |
||||
padding := s.padding[:paddingLength] |
||||
if _, err := io.ReadFull(rand, padding); err != nil { |
||||
return err |
||||
} |
||||
|
||||
if s.mac != nil { |
||||
s.mac.Reset() |
||||
binary.BigEndian.PutUint32(s.seqNumBytes[:], seqNum) |
||||
s.mac.Write(s.seqNumBytes[:]) |
||||
s.mac.Write(s.prefix[:]) |
||||
s.mac.Write(packet) |
||||
s.mac.Write(padding) |
||||
} |
||||
|
||||
s.cipher.XORKeyStream(s.prefix[:], s.prefix[:]) |
||||
s.cipher.XORKeyStream(packet, packet) |
||||
s.cipher.XORKeyStream(padding, padding) |
||||
|
||||
if _, err := w.Write(s.prefix[:]); err != nil { |
||||
return err |
||||
} |
||||
if _, err := w.Write(packet); err != nil { |
||||
return err |
||||
} |
||||
if _, err := w.Write(padding); err != nil { |
||||
return err |
||||
} |
||||
|
||||
if s.mac != nil { |
||||
s.macResult = s.mac.Sum(s.macResult[:0]) |
||||
if _, err := w.Write(s.macResult); err != nil { |
||||
return err |
||||
} |
||||
} |
||||
|
||||
return nil |
||||
} |
||||
|
||||
type gcmCipher struct { |
||||
aead cipher.AEAD |
||||
prefix [4]byte |
||||
iv []byte |
||||
buf []byte |
||||
} |
||||
|
||||
func newGCMCipher(iv, key, macKey []byte) (packetCipher, error) { |
||||
c, err := aes.NewCipher(key) |
||||
if err != nil { |
||||
return nil, err |
||||
} |
||||
|
||||
aead, err := cipher.NewGCM(c) |
||||
if err != nil { |
||||
return nil, err |
||||
} |
||||
|
||||
return &gcmCipher{ |
||||
aead: aead, |
||||
iv: iv, |
||||
}, nil |
||||
} |
||||
|
||||
const gcmTagSize = 16 |
||||
|
||||
func (c *gcmCipher) writePacket(seqNum uint32, w io.Writer, rand io.Reader, packet []byte) error { |
||||
// Pad out to multiple of 16 bytes. This is different from the
|
||||
// stream cipher because that encrypts the length too.
|
||||
padding := byte(packetSizeMultiple - (1+len(packet))%packetSizeMultiple) |
||||
if padding < 4 { |
||||
padding += packetSizeMultiple |
||||
} |
||||
|
||||
length := uint32(len(packet) + int(padding) + 1) |
||||
binary.BigEndian.PutUint32(c.prefix[:], length) |
||||
if _, err := w.Write(c.prefix[:]); err != nil { |
||||
return err |
||||
} |
||||
|
||||
if cap(c.buf) < int(length) { |
||||
c.buf = make([]byte, length) |
||||
} else { |
||||
c.buf = c.buf[:length] |
||||
} |
||||
|
||||
c.buf[0] = padding |
||||
copy(c.buf[1:], packet) |
||||
if _, err := io.ReadFull(rand, c.buf[1+len(packet):]); err != nil { |
||||
return err |
||||
} |
||||
c.buf = c.aead.Seal(c.buf[:0], c.iv, c.buf, c.prefix[:]) |
||||
if _, err := w.Write(c.buf); err != nil { |
||||
return err |
||||
} |
||||
c.incIV() |
||||
|
||||
return nil |
||||
} |
||||
|
||||
func (c *gcmCipher) incIV() { |
||||
for i := 4 + 7; i >= 4; i-- { |
||||
c.iv[i]++ |
||||
if c.iv[i] != 0 { |
||||
break |
||||
} |
||||
} |
||||
} |
||||
|
||||
func (c *gcmCipher) readPacket(seqNum uint32, r io.Reader) ([]byte, error) { |
||||
if _, err := io.ReadFull(r, c.prefix[:]); err != nil { |
||||
return nil, err |
||||
} |
||||
length := binary.BigEndian.Uint32(c.prefix[:]) |
||||
if length > maxPacket { |
||||
return nil, errors.New("ssh: max packet length exceeded.") |
||||
} |
||||
|
||||
if cap(c.buf) < int(length+gcmTagSize) { |
||||
c.buf = make([]byte, length+gcmTagSize) |
||||
} else { |
||||
c.buf = c.buf[:length+gcmTagSize] |
||||
} |
||||
|
||||
if _, err := io.ReadFull(r, c.buf); err != nil { |
||||
return nil, err |
||||
} |
||||
|
||||
plain, err := c.aead.Open(c.buf[:0], c.iv, c.buf, c.prefix[:]) |
||||
if err != nil { |
||||
return nil, err |
||||
} |
||||
c.incIV() |
||||
|
||||
padding := plain[0] |
||||
if padding < 4 || padding >= 20 { |
||||
return nil, fmt.Errorf("ssh: illegal padding %d", padding) |
||||
} |
||||
|
||||
if int(padding+1) >= len(plain) { |
||||
return nil, fmt.Errorf("ssh: padding %d too large", padding) |
||||
} |
||||
plain = plain[1 : length-uint32(padding)] |
||||
return plain, nil |
||||
} |
||||
|
||||
// cbcCipher implements aes128-cbc cipher defined in RFC 4253 section 6.1
|
||||
type cbcCipher struct { |
||||
mac hash.Hash |
||||
macSize uint32 |
||||
decrypter cipher.BlockMode |
||||
encrypter cipher.BlockMode |
||||
|
||||
// The following members are to avoid per-packet allocations.
|
||||
seqNumBytes [4]byte |
||||
packetData []byte |
||||
macResult []byte |
||||
|
||||
// Amount of data we should still read to hide which
|
||||
// verification error triggered.
|
||||
oracleCamouflage uint32 |
||||
} |
||||
|
||||
func newAESCBCCipher(iv, key, macKey []byte, algs directionAlgorithms) (packetCipher, error) { |
||||
c, err := aes.NewCipher(key) |
||||
if err != nil { |
||||
return nil, err |
||||
} |
||||
|
||||
cbc := &cbcCipher{ |
||||
mac: macModes[algs.MAC].new(macKey), |
||||
decrypter: cipher.NewCBCDecrypter(c, iv), |
||||
encrypter: cipher.NewCBCEncrypter(c, iv), |
||||
packetData: make([]byte, 1024), |
||||
} |
||||
if cbc.mac != nil { |
||||
cbc.macSize = uint32(cbc.mac.Size()) |
||||
} |
||||
|
||||
return cbc, nil |
||||
} |
||||
|
||||
func maxUInt32(a, b int) uint32 { |
||||
if a > b { |
||||
return uint32(a) |
||||
} |
||||
return uint32(b) |
||||
} |
||||
|
||||
const ( |
||||
cbcMinPacketSizeMultiple = 8 |
||||
cbcMinPacketSize = 16 |
||||
cbcMinPaddingSize = 4 |
||||
) |
||||
|
||||
// cbcError represents a verification error that may leak information.
|
||||
type cbcError string |
||||
|
||||
func (e cbcError) Error() string { return string(e) } |
||||
|
||||
func (c *cbcCipher) readPacket(seqNum uint32, r io.Reader) ([]byte, error) { |
||||
p, err := c.readPacketLeaky(seqNum, r) |
||||
if err != nil { |
||||
if _, ok := err.(cbcError); ok { |
||||
// Verification error: read a fixed amount of
|
||||
// data, to make distinguishing between
|
||||
// failing MAC and failing length check more
|
||||
// difficult.
|
||||
io.CopyN(ioutil.Discard, r, int64(c.oracleCamouflage)) |
||||
} |
||||
} |
||||
return p, err |
||||
} |
||||
|
||||
func (c *cbcCipher) readPacketLeaky(seqNum uint32, r io.Reader) ([]byte, error) { |
||||
blockSize := c.decrypter.BlockSize() |
||||
|
||||
// Read the header, which will include some of the subsequent data in the
|
||||
// case of block ciphers - this is copied back to the payload later.
|
||||
// How many bytes of payload/padding will be read with this first read.
|
||||
firstBlockLength := uint32((prefixLen + blockSize - 1) / blockSize * blockSize) |
||||
firstBlock := c.packetData[:firstBlockLength] |
||||
if _, err := io.ReadFull(r, firstBlock); err != nil { |
||||
return nil, err |
||||
} |
||||
|
||||
c.oracleCamouflage = maxPacket + 4 + c.macSize - firstBlockLength |
||||
|
||||
c.decrypter.CryptBlocks(firstBlock, firstBlock) |
||||
length := binary.BigEndian.Uint32(firstBlock[:4]) |
||||
if length > maxPacket { |
||||
return nil, cbcError("ssh: packet too large") |
||||
} |
||||
if length+4 < maxUInt32(cbcMinPacketSize, blockSize) { |
||||
// The minimum size of a packet is 16 (or the cipher block size, whichever
|
||||
// is larger) bytes.
|
||||
return nil, cbcError("ssh: packet too small") |
||||
} |
||||
// The length of the packet (including the length field but not the MAC) must
|
||||
// be a multiple of the block size or 8, whichever is larger.
|
||||
if (length+4)%maxUInt32(cbcMinPacketSizeMultiple, blockSize) != 0 { |
||||
return nil, cbcError("ssh: invalid packet length multiple") |
||||
} |
||||
|
||||
paddingLength := uint32(firstBlock[4]) |
||||
if paddingLength < cbcMinPaddingSize || length <= paddingLength+1 { |
||||
return nil, cbcError("ssh: invalid packet length") |
||||
} |
||||
|
||||
// Positions within the c.packetData buffer:
|
||||
macStart := 4 + length |
||||
paddingStart := macStart - paddingLength |
||||
|
||||
// Entire packet size, starting before length, ending at end of mac.
|
||||
entirePacketSize := macStart + c.macSize |
||||
|
||||
// Ensure c.packetData is large enough for the entire packet data.
|
||||
if uint32(cap(c.packetData)) < entirePacketSize { |
||||
// Still need to upsize and copy, but this should be rare at runtime, only
|
||||
// on upsizing the packetData buffer.
|
||||
c.packetData = make([]byte, entirePacketSize) |
||||
copy(c.packetData, firstBlock) |
||||
} else { |
||||
c.packetData = c.packetData[:entirePacketSize] |
||||
} |
||||
|
||||
if n, err := io.ReadFull(r, c.packetData[firstBlockLength:]); err != nil { |
||||
return nil, err |
||||
} else { |
||||
c.oracleCamouflage -= uint32(n) |
||||
} |
||||
|
||||
remainingCrypted := c.packetData[firstBlockLength:macStart] |
||||
c.decrypter.CryptBlocks(remainingCrypted, remainingCrypted) |
||||
|
||||
mac := c.packetData[macStart:] |
||||
if c.mac != nil { |
||||
c.mac.Reset() |
||||
binary.BigEndian.PutUint32(c.seqNumBytes[:], seqNum) |
||||
c.mac.Write(c.seqNumBytes[:]) |
||||
c.mac.Write(c.packetData[:macStart]) |
||||
c.macResult = c.mac.Sum(c.macResult[:0]) |
||||
if subtle.ConstantTimeCompare(c.macResult, mac) != 1 { |
||||
return nil, cbcError("ssh: MAC failure") |
||||
} |
||||
} |
||||
|
||||
return c.packetData[prefixLen:paddingStart], nil |
||||
} |
||||
|
||||
func (c *cbcCipher) writePacket(seqNum uint32, w io.Writer, rand io.Reader, packet []byte) error { |
||||
effectiveBlockSize := maxUInt32(cbcMinPacketSizeMultiple, c.encrypter.BlockSize()) |
||||
|
||||
// Length of encrypted portion of the packet (header, payload, padding).
|
||||
// Enforce minimum padding and packet size.
|
||||
encLength := maxUInt32(prefixLen+len(packet)+cbcMinPaddingSize, cbcMinPaddingSize) |
||||
// Enforce block size.
|
||||
encLength = (encLength + effectiveBlockSize - 1) / effectiveBlockSize * effectiveBlockSize |
||||
|
||||
length := encLength - 4 |
||||
paddingLength := int(length) - (1 + len(packet)) |
||||
|
||||
// Overall buffer contains: header, payload, padding, mac.
|
||||
// Space for the MAC is reserved in the capacity but not the slice length.
|
||||
bufferSize := encLength + c.macSize |
||||
if uint32(cap(c.packetData)) < bufferSize { |
||||
c.packetData = make([]byte, encLength, bufferSize) |
||||
} else { |
||||
c.packetData = c.packetData[:encLength] |
||||
} |
||||
|
||||
p := c.packetData |
||||
|
||||
// Packet header.
|
||||
binary.BigEndian.PutUint32(p, length) |
||||
p = p[4:] |
||||
p[0] = byte(paddingLength) |
||||
|
||||
// Payload.
|
||||
p = p[1:] |
||||
copy(p, packet) |
||||
|
||||
// Padding.
|
||||
p = p[len(packet):] |
||||
if _, err := io.ReadFull(rand, p); err != nil { |
||||
return err |
||||
} |
||||
|
||||
if c.mac != nil { |
||||
c.mac.Reset() |
||||
binary.BigEndian.PutUint32(c.seqNumBytes[:], seqNum) |
||||
c.mac.Write(c.seqNumBytes[:]) |
||||
c.mac.Write(c.packetData) |
||||
// The MAC is now appended into the capacity reserved for it earlier.
|
||||
c.packetData = c.mac.Sum(c.packetData) |
||||
} |
||||
|
||||
c.encrypter.CryptBlocks(c.packetData[:encLength], c.packetData[:encLength]) |
||||
|
||||
if _, err := w.Write(c.packetData); err != nil { |
||||
return err |
||||
} |
||||
|
||||
return nil |
||||
} |
||||
@ -1,127 +0,0 @@ |
||||
// 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 ( |
||||
"bytes" |
||||
"crypto" |
||||
"crypto/aes" |
||||
"crypto/rand" |
||||
"testing" |
||||
) |
||||
|
||||
func TestDefaultCiphersExist(t *testing.T) { |
||||
for _, cipherAlgo := range supportedCiphers { |
||||
if _, ok := cipherModes[cipherAlgo]; !ok { |
||||
t.Errorf("default cipher %q is unknown", cipherAlgo) |
||||
} |
||||
} |
||||
} |
||||
|
||||
func TestPacketCiphers(t *testing.T) { |
||||
// Still test aes128cbc cipher althought it's commented out.
|
||||
cipherModes[aes128cbcID] = &streamCipherMode{16, aes.BlockSize, 0, nil} |
||||
defer delete(cipherModes, aes128cbcID) |
||||
|
||||
for cipher := range cipherModes { |
||||
kr := &kexResult{Hash: crypto.SHA1} |
||||
algs := directionAlgorithms{ |
||||
Cipher: cipher, |
||||
MAC: "hmac-sha1", |
||||
Compression: "none", |
||||
} |
||||
client, err := newPacketCipher(clientKeys, algs, kr) |
||||
if err != nil { |
||||
t.Errorf("newPacketCipher(client, %q): %v", cipher, err) |
||||
continue |
||||
} |
||||
server, err := newPacketCipher(clientKeys, algs, kr) |
||||
if err != nil { |
||||
t.Errorf("newPacketCipher(client, %q): %v", cipher, err) |
||||
continue |
||||
} |
||||
|
||||
want := "bla bla" |
||||
input := []byte(want) |
||||
buf := &bytes.Buffer{} |
||||
if err := client.writePacket(0, buf, rand.Reader, input); err != nil { |
||||
t.Errorf("writePacket(%q): %v", cipher, err) |
||||
continue |
||||
} |
||||
|
||||
packet, err := server.readPacket(0, buf) |
||||
if err != nil { |
||||
t.Errorf("readPacket(%q): %v", cipher, err) |
||||
continue |
||||
} |
||||
|
||||
if string(packet) != want { |
||||
t.Errorf("roundtrip(%q): got %q, want %q", cipher, packet, want) |
||||
} |
||||
} |
||||
} |
||||
|
||||
func TestCBCOracleCounterMeasure(t *testing.T) { |
||||
cipherModes[aes128cbcID] = &streamCipherMode{16, aes.BlockSize, 0, nil} |
||||
defer delete(cipherModes, aes128cbcID) |
||||
|
||||
kr := &kexResult{Hash: crypto.SHA1} |
||||
algs := directionAlgorithms{ |
||||
Cipher: aes128cbcID, |
||||
MAC: "hmac-sha1", |
||||
Compression: "none", |
||||
} |
||||
client, err := newPacketCipher(clientKeys, algs, kr) |
||||
if err != nil { |
||||
t.Fatalf("newPacketCipher(client): %v", err) |
||||
} |
||||
|
||||
want := "bla bla" |
||||
input := []byte(want) |
||||
buf := &bytes.Buffer{} |
||||
if err := client.writePacket(0, buf, rand.Reader, input); err != nil { |
||||
t.Errorf("writePacket: %v", err) |
||||
} |
||||
|
||||
packetSize := buf.Len() |
||||
buf.Write(make([]byte, 2*maxPacket)) |
||||
|
||||
// We corrupt each byte, but this usually will only test the
|
||||
// 'packet too large' or 'MAC failure' cases.
|
||||
lastRead := -1 |
||||
for i := 0; i < packetSize; i++ { |
||||
server, err := newPacketCipher(clientKeys, algs, kr) |
||||
if err != nil { |
||||
t.Fatalf("newPacketCipher(client): %v", err) |
||||
} |
||||
|
||||
fresh := &bytes.Buffer{} |
||||
fresh.Write(buf.Bytes()) |
||||
fresh.Bytes()[i] ^= 0x01 |
||||
|
||||
before := fresh.Len() |
||||
_, err = server.readPacket(0, fresh) |
||||
if err == nil { |
||||
t.Errorf("corrupt byte %d: readPacket succeeded ", i) |
||||
continue |
||||
} |
||||
if _, ok := err.(cbcError); !ok { |
||||
t.Errorf("corrupt byte %d: got %v (%T), want cbcError", i, err, err) |
||||
continue |
||||
} |
||||
|
||||
after := fresh.Len() |
||||
bytesRead := before - after |
||||
if bytesRead < maxPacket { |
||||
t.Errorf("corrupt byte %d: read %d bytes, want more than %d", i, bytesRead, maxPacket) |
||||
continue |
||||
} |
||||
|
||||
if i > 0 && bytesRead != lastRead { |
||||
t.Errorf("corrupt byte %d: read %d bytes, want %d bytes read", i, bytesRead, lastRead) |
||||
} |
||||
lastRead = bytesRead |
||||
} |
||||
} |
||||
@ -1,213 +0,0 @@ |
||||
// 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 ( |
||||
"errors" |
||||
"fmt" |
||||
"net" |
||||
"sync" |
||||
) |
||||
|
||||
// Client implements a traditional SSH client that supports shells,
|
||||
// subprocesses, port forwarding and tunneled dialing.
|
||||
type Client struct { |
||||
Conn |
||||
|
||||
forwards forwardList // forwarded tcpip connections from the remote side
|
||||
mu sync.Mutex |
||||
channelHandlers map[string]chan NewChannel |
||||
} |
||||
|
||||
// HandleChannelOpen returns a channel on which NewChannel requests
|
||||
// for the given type are sent. If the type already is being handled,
|
||||
// nil is returned. The channel is closed when the connection is closed.
|
||||
func (c *Client) HandleChannelOpen(channelType string) <-chan NewChannel { |
||||
c.mu.Lock() |
||||
defer c.mu.Unlock() |
||||
if c.channelHandlers == nil { |
||||
// The SSH channel has been closed.
|
||||
c := make(chan NewChannel) |
||||
close(c) |
||||
return c |
||||
} |
||||
|
||||
ch := c.channelHandlers[channelType] |
||||
if ch != nil { |
||||
return nil |
||||
} |
||||
|
||||
ch = make(chan NewChannel, 16) |
||||
c.channelHandlers[channelType] = ch |
||||
return ch |
||||
} |
||||
|
||||
// NewClient creates a Client on top of the given connection.
|
||||
func NewClient(c Conn, chans <-chan NewChannel, reqs <-chan *Request) *Client { |
||||
conn := &Client{ |
||||
Conn: c, |
||||
channelHandlers: make(map[string]chan NewChannel, 1), |
||||
} |
||||
|
||||
go conn.handleGlobalRequests(reqs) |
||||
go conn.handleChannelOpens(chans) |
||||
go func() { |
||||
conn.Wait() |
||||
conn.forwards.closeAll() |
||||
}() |
||||
go conn.forwards.handleChannels(conn.HandleChannelOpen("forwarded-tcpip")) |
||||
return conn |
||||
} |
||||
|
||||
// NewClientConn establishes an authenticated SSH connection using c
|
||||
// as the underlying transport. The Request and NewChannel channels
|
||||
// must be serviced or the connection will hang.
|
||||
func NewClientConn(c net.Conn, addr string, config *ClientConfig) (Conn, <-chan NewChannel, <-chan *Request, error) { |
||||
fullConf := *config |
||||
fullConf.SetDefaults() |
||||
conn := &connection{ |
||||
sshConn: sshConn{conn: c}, |
||||
} |
||||
|
||||
if err := conn.clientHandshake(addr, &fullConf); err != nil { |
||||
c.Close() |
||||
return nil, nil, nil, fmt.Errorf("ssh: handshake failed: %v", err) |
||||
} |
||||
conn.mux = newMux(conn.transport) |
||||
return conn, conn.mux.incomingChannels, conn.mux.incomingRequests, nil |
||||
} |
||||
|
||||
// clientHandshake performs the client side key exchange. See RFC 4253 Section
|
||||
// 7.
|
||||
func (c *connection) clientHandshake(dialAddress string, config *ClientConfig) error { |
||||
if config.ClientVersion != "" { |
||||
c.clientVersion = []byte(config.ClientVersion) |
||||
} else { |
||||
c.clientVersion = []byte(packageVersion) |
||||
} |
||||
var err error |
||||
c.serverVersion, err = exchangeVersions(c.sshConn.conn, c.clientVersion) |
||||
if err != nil { |
||||
return err |
||||
} |
||||
|
||||
c.transport = newClientTransport( |
||||
newTransport(c.sshConn.conn, config.Rand, true /* is client */), |
||||
c.clientVersion, c.serverVersion, config, dialAddress, c.sshConn.RemoteAddr()) |
||||
if err := c.transport.requestKeyChange(); err != nil { |
||||
return err |
||||
} |
||||
|
||||
if packet, err := c.transport.readPacket(); err != nil { |
||||
return err |
||||
} else if packet[0] != msgNewKeys { |
||||
return unexpectedMessageError(msgNewKeys, packet[0]) |
||||
} |
||||
|
||||
// We just did the key change, so the session ID is established.
|
||||
c.sessionID = c.transport.getSessionID() |
||||
|
||||
return c.clientAuthenticate(config) |
||||
} |
||||
|
||||
// verifyHostKeySignature verifies the host key obtained in the key
|
||||
// exchange.
|
||||
func verifyHostKeySignature(hostKey PublicKey, result *kexResult) error { |
||||
sig, rest, ok := parseSignatureBody(result.Signature) |
||||
if len(rest) > 0 || !ok { |
||||
return errors.New("ssh: signature parse error") |
||||
} |
||||
|
||||
return hostKey.Verify(result.H, sig) |
||||
} |
||||
|
||||
// NewSession opens a new Session for this client. (A session is a remote
|
||||
// execution of a program.)
|
||||
func (c *Client) NewSession() (*Session, error) { |
||||
ch, in, err := c.OpenChannel("session", nil) |
||||
if err != nil { |
||||
return nil, err |
||||
} |
||||
return newSession(ch, in) |
||||
} |
||||
|
||||
func (c *Client) handleGlobalRequests(incoming <-chan *Request) { |
||||
for r := range incoming { |
||||
// This handles keepalive messages and matches
|
||||
// the behaviour of OpenSSH.
|
||||
r.Reply(false, nil) |
||||
} |
||||
} |
||||
|
||||
// handleChannelOpens channel open messages from the remote side.
|
||||
func (c *Client) handleChannelOpens(in <-chan NewChannel) { |
||||
for ch := range in { |
||||
c.mu.Lock() |
||||
handler := c.channelHandlers[ch.ChannelType()] |
||||
c.mu.Unlock() |
||||
|
||||
if handler != nil { |
||||
handler <- ch |
||||
} else { |
||||
ch.Reject(UnknownChannelType, fmt.Sprintf("unknown channel type: %v", ch.ChannelType())) |
||||
} |
||||
} |
||||
|
||||
c.mu.Lock() |
||||
for _, ch := range c.channelHandlers { |
||||
close(ch) |
||||
} |
||||
c.channelHandlers = nil |
||||
c.mu.Unlock() |
||||
} |
||||
|
||||
// Dial starts a client connection to the given SSH server. It is a
|
||||
// convenience function that connects to the given network address,
|
||||
// initiates the SSH handshake, and then sets up a Client. For access
|
||||
// to incoming channels and requests, use net.Dial with NewClientConn
|
||||
// instead.
|
||||
func Dial(network, addr string, config *ClientConfig) (*Client, error) { |
||||
conn, err := net.Dial(network, addr) |
||||
if err != nil { |
||||
return nil, err |
||||
} |
||||
c, chans, reqs, err := NewClientConn(conn, addr, config) |
||||
if err != nil { |
||||
return nil, err |
||||
} |
||||
return NewClient(c, chans, reqs), nil |
||||
} |
||||
|
||||
// A ClientConfig structure is used to configure a Client. It must not be
|
||||
// modified after having been passed to an SSH function.
|
||||
type ClientConfig struct { |
||||
// Config contains configuration that is shared between clients and
|
||||
// servers.
|
||||
Config |
||||
|
||||
// User contains the username to authenticate as.
|
||||
User string |
||||
|
||||
// Auth contains possible authentication methods to use with the
|
||||
// server. Only the first instance of a particular RFC 4252 method will
|
||||
// be used during authentication.
|
||||
Auth []AuthMethod |
||||
|
||||
// HostKeyCallback, if not nil, is called during the cryptographic
|
||||
// handshake to validate the server's host key. A nil HostKeyCallback
|
||||
// implies that all host keys are accepted.
|
||||
HostKeyCallback func(hostname string, remote net.Addr, key PublicKey) error |
||||
|
||||
// ClientVersion contains the version identification string that will
|
||||
// be used for the connection. If empty, a reasonable default is used.
|
||||
ClientVersion string |
||||
|
||||
// HostKeyAlgorithms lists the key types that the client will
|
||||
// accept from the server as host key, in order of
|
||||
// preference. If empty, a reasonable default is used. Any
|
||||
// string returned from PublicKey.Type method may be used, or
|
||||
// any of the CertAlgoXxxx and KeyAlgoXxxx constants.
|
||||
HostKeyAlgorithms []string |
||||
} |
||||
@ -1,441 +0,0 @@ |
||||
// 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 ( |
||||
"bytes" |
||||
"errors" |
||||
"fmt" |
||||
"io" |
||||
) |
||||
|
||||
// clientAuthenticate authenticates with the remote server. See RFC 4252.
|
||||
func (c *connection) clientAuthenticate(config *ClientConfig) error { |
||||
// initiate user auth session
|
||||
if err := c.transport.writePacket(Marshal(&serviceRequestMsg{serviceUserAuth})); err != nil { |
||||
return err |
||||
} |
||||
packet, err := c.transport.readPacket() |
||||
if err != nil { |
||||
return err |
||||
} |
||||
var serviceAccept serviceAcceptMsg |
||||
if err := Unmarshal(packet, &serviceAccept); err != nil { |
||||
return err |
||||
} |
||||
|
||||
// during the authentication phase the client first attempts the "none" method
|
||||
// then any untried methods suggested by the server.
|
||||
tried := make(map[string]bool) |
||||
var lastMethods []string |
||||
for auth := AuthMethod(new(noneAuth)); auth != nil; { |
||||
ok, methods, err := auth.auth(c.transport.getSessionID(), config.User, c.transport, config.Rand) |
||||
if err != nil { |
||||
return err |
||||
} |
||||
if ok { |
||||
// success
|
||||
return nil |
||||
} |
||||
tried[auth.method()] = true |
||||
if methods == nil { |
||||
methods = lastMethods |
||||
} |
||||
lastMethods = methods |
||||
|
||||
auth = nil |
||||
|
||||
findNext: |
||||
for _, a := range config.Auth { |
||||
candidateMethod := a.method() |
||||
if tried[candidateMethod] { |
||||
continue |
||||
} |
||||
for _, meth := range methods { |
||||
if meth == candidateMethod { |
||||
auth = a |
||||
break findNext |
||||
} |
||||
} |
||||
} |
||||
} |
||||
return fmt.Errorf("ssh: unable to authenticate, attempted methods %v, no supported methods remain", keys(tried)) |
||||
} |
||||
|
||||
func keys(m map[string]bool) []string { |
||||
s := make([]string, 0, len(m)) |
||||
|
||||
for key := range m { |
||||
s = append(s, key) |
||||
} |
||||
return s |
||||
} |
||||
|
||||
// An AuthMethod represents an instance of an RFC 4252 authentication method.
|
||||
type AuthMethod interface { |
||||
// auth authenticates user over transport t.
|
||||
// Returns true if authentication is successful.
|
||||
// If authentication is not successful, a []string of alternative
|
||||
// method names is returned. If the slice is nil, it will be ignored
|
||||
// and the previous set of possible methods will be reused.
|
||||
auth(session []byte, user string, p packetConn, rand io.Reader) (bool, []string, error) |
||||
|
||||
// method returns the RFC 4252 method name.
|
||||
method() string |
||||
} |
||||
|
||||
// "none" authentication, RFC 4252 section 5.2.
|
||||
type noneAuth int |
||||
|
||||
func (n *noneAuth) auth(session []byte, user string, c packetConn, rand io.Reader) (bool, []string, error) { |
||||
if err := c.writePacket(Marshal(&userAuthRequestMsg{ |
||||
User: user, |
||||
Service: serviceSSH, |
||||
Method: "none", |
||||
})); err != nil { |
||||
return false, nil, err |
||||
} |
||||
|
||||
return handleAuthResponse(c) |
||||
} |
||||
|
||||
func (n *noneAuth) method() string { |
||||
return "none" |
||||
} |
||||
|
||||
// passwordCallback is an AuthMethod that fetches the password through
|
||||
// a function call, e.g. by prompting the user.
|
||||
type passwordCallback func() (password string, err error) |
||||
|
||||
func (cb passwordCallback) auth(session []byte, user string, c packetConn, rand io.Reader) (bool, []string, error) { |
||||
type passwordAuthMsg struct { |
||||
User string `sshtype:"50"` |
||||
Service string |
||||
Method string |
||||
Reply bool |
||||
Password string |
||||
} |
||||
|
||||
pw, err := cb() |
||||
// REVIEW NOTE: is there a need to support skipping a password attempt?
|
||||
// The program may only find out that the user doesn't have a password
|
||||
// when prompting.
|
||||
if err != nil { |
||||
return false, nil, err |
||||
} |
||||
|
||||
if err := c.writePacket(Marshal(&passwordAuthMsg{ |
||||
User: user, |
||||
Service: serviceSSH, |
||||
Method: cb.method(), |
||||
Reply: false, |
||||
Password: pw, |
||||
})); err != nil { |
||||
return false, nil, err |
||||
} |
||||
|
||||
return handleAuthResponse(c) |
||||
} |
||||
|
||||
func (cb passwordCallback) method() string { |
||||
return "password" |
||||
} |
||||
|
||||
// Password returns an AuthMethod using the given password.
|
||||
func Password(secret string) AuthMethod { |
||||
return passwordCallback(func() (string, error) { return secret, nil }) |
||||
} |
||||
|
||||
// PasswordCallback returns an AuthMethod that uses a callback for
|
||||
// fetching a password.
|
||||
func PasswordCallback(prompt func() (secret string, err error)) AuthMethod { |
||||
return passwordCallback(prompt) |
||||
} |
||||
|
||||
type publickeyAuthMsg struct { |
||||
User string `sshtype:"50"` |
||||
Service string |
||||
Method string |
||||
// HasSig indicates to the receiver packet that the auth request is signed and
|
||||
// should be used for authentication of the request.
|
||||
HasSig bool |
||||
Algoname string |
||||
PubKey []byte |
||||
// Sig is tagged with "rest" so Marshal will exclude it during
|
||||
// validateKey
|
||||
Sig []byte `ssh:"rest"` |
||||
} |
||||
|
||||
// publicKeyCallback is an AuthMethod that uses a set of key
|
||||
// pairs for authentication.
|
||||
type publicKeyCallback func() ([]Signer, error) |
||||
|
||||
func (cb publicKeyCallback) method() string { |
||||
return "publickey" |
||||
} |
||||
|
||||
func (cb publicKeyCallback) auth(session []byte, user string, c packetConn, rand io.Reader) (bool, []string, error) { |
||||
// Authentication is performed in two stages. The first stage sends an
|
||||
// enquiry to test if each key is acceptable to the remote. The second
|
||||
// stage attempts to authenticate with the valid keys obtained in the
|
||||
// first stage.
|
||||
|
||||
signers, err := cb() |
||||
if err != nil { |
||||
return false, nil, err |
||||
} |
||||
var validKeys []Signer |
||||
for _, signer := range signers { |
||||
if ok, err := validateKey(signer.PublicKey(), user, c); ok { |
||||
validKeys = append(validKeys, signer) |
||||
} else { |
||||
if err != nil { |
||||
return false, nil, err |
||||
} |
||||
} |
||||
} |
||||
|
||||
// methods that may continue if this auth is not successful.
|
||||
var methods []string |
||||
for _, signer := range validKeys { |
||||
pub := signer.PublicKey() |
||||
|
||||
pubKey := pub.Marshal() |
||||
sign, err := signer.Sign(rand, buildDataSignedForAuth(session, userAuthRequestMsg{ |
||||
User: user, |
||||
Service: serviceSSH, |
||||
Method: cb.method(), |
||||
}, []byte(pub.Type()), pubKey)) |
||||
if err != nil { |
||||
return false, nil, err |
||||
} |
||||
|
||||
// manually wrap the serialized signature in a string
|
||||
s := Marshal(sign) |
||||
sig := make([]byte, stringLength(len(s))) |
||||
marshalString(sig, s) |
||||
msg := publickeyAuthMsg{ |
||||
User: user, |
||||
Service: serviceSSH, |
||||
Method: cb.method(), |
||||
HasSig: true, |
||||
Algoname: pub.Type(), |
||||
PubKey: pubKey, |
||||
Sig: sig, |
||||
} |
||||
p := Marshal(&msg) |
||||
if err := c.writePacket(p); err != nil { |
||||
return false, nil, err |
||||
} |
||||
var success bool |
||||
success, methods, err = handleAuthResponse(c) |
||||
if err != nil { |
||||
return false, nil, err |
||||
} |
||||
if success { |
||||
return success, methods, err |
||||
} |
||||
} |
||||
return false, methods, nil |
||||
} |
||||
|
||||
// validateKey validates the key provided is acceptable to the server.
|
||||
func validateKey(key PublicKey, user string, c packetConn) (bool, error) { |
||||
pubKey := key.Marshal() |
||||
msg := publickeyAuthMsg{ |
||||
User: user, |
||||
Service: serviceSSH, |
||||
Method: "publickey", |
||||
HasSig: false, |
||||
Algoname: key.Type(), |
||||
PubKey: pubKey, |
||||
} |
||||
if err := c.writePacket(Marshal(&msg)); err != nil { |
||||
return false, err |
||||
} |
||||
|
||||
return confirmKeyAck(key, c) |
||||
} |
||||
|
||||
func confirmKeyAck(key PublicKey, c packetConn) (bool, error) { |
||||
pubKey := key.Marshal() |
||||
algoname := key.Type() |
||||
|
||||
for { |
||||
packet, err := c.readPacket() |
||||
if err != nil { |
||||
return false, err |
||||
} |
||||
switch packet[0] { |
||||
case msgUserAuthBanner: |
||||
// TODO(gpaul): add callback to present the banner to the user
|
||||
case msgUserAuthPubKeyOk: |
||||
var msg userAuthPubKeyOkMsg |
||||
if err := Unmarshal(packet, &msg); err != nil { |
||||
return false, err |
||||
} |
||||
if msg.Algo != algoname || !bytes.Equal(msg.PubKey, pubKey) { |
||||
return false, nil |
||||
} |
||||
return true, nil |
||||
case msgUserAuthFailure: |
||||
return false, nil |
||||
default: |
||||
return false, unexpectedMessageError(msgUserAuthSuccess, packet[0]) |
||||
} |
||||
} |
||||
} |
||||
|
||||
// PublicKeys returns an AuthMethod that uses the given key
|
||||
// pairs.
|
||||
func PublicKeys(signers ...Signer) AuthMethod { |
||||
return publicKeyCallback(func() ([]Signer, error) { return signers, nil }) |
||||
} |
||||
|
||||
// PublicKeysCallback returns an AuthMethod that runs the given
|
||||
// function to obtain a list of key pairs.
|
||||
func PublicKeysCallback(getSigners func() (signers []Signer, err error)) AuthMethod { |
||||
return publicKeyCallback(getSigners) |
||||
} |
||||
|
||||
// handleAuthResponse returns whether the preceding authentication request succeeded
|
||||
// along with a list of remaining authentication methods to try next and
|
||||
// an error if an unexpected response was received.
|
||||
func handleAuthResponse(c packetConn) (bool, []string, error) { |
||||
for { |
||||
packet, err := c.readPacket() |
||||
if err != nil { |
||||
return false, nil, err |
||||
} |
||||
|
||||
switch packet[0] { |
||||
case msgUserAuthBanner: |
||||
// TODO: add callback to present the banner to the user
|
||||
case msgUserAuthFailure: |
||||
var msg userAuthFailureMsg |
||||
if err := Unmarshal(packet, &msg); err != nil { |
||||
return false, nil, err |
||||
} |
||||
return false, msg.Methods, nil |
||||
case msgUserAuthSuccess: |
||||
return true, nil, nil |
||||
case msgDisconnect: |
||||
return false, nil, io.EOF |
||||
default: |
||||
return false, nil, unexpectedMessageError(msgUserAuthSuccess, packet[0]) |
||||
} |
||||
} |
||||
} |
||||
|
||||
// KeyboardInteractiveChallenge should print questions, optionally
|
||||
// disabling echoing (e.g. for passwords), and return all the answers.
|
||||
// Challenge may be called multiple times in a single session. After
|
||||
// successful authentication, the server may send a challenge with no
|
||||
// questions, for which the user and instruction messages should be
|
||||
// printed. RFC 4256 section 3.3 details how the UI should behave for
|
||||
// both CLI and GUI environments.
|
||||
type KeyboardInteractiveChallenge func(user, instruction string, questions []string, echos []bool) (answers []string, err error) |
||||
|
||||
// KeyboardInteractive returns a AuthMethod using a prompt/response
|
||||
// sequence controlled by the server.
|
||||
func KeyboardInteractive(challenge KeyboardInteractiveChallenge) AuthMethod { |
||||
return challenge |
||||
} |
||||
|
||||
func (cb KeyboardInteractiveChallenge) method() string { |
||||
return "keyboard-interactive" |
||||
} |
||||
|
||||
func (cb KeyboardInteractiveChallenge) auth(session []byte, user string, c packetConn, rand io.Reader) (bool, []string, error) { |
||||
type initiateMsg struct { |
||||
User string `sshtype:"50"` |
||||
Service string |
||||
Method string |
||||
Language string |
||||
Submethods string |
||||
} |
||||
|
||||
if err := c.writePacket(Marshal(&initiateMsg{ |
||||
User: user, |
||||
Service: serviceSSH, |
||||
Method: "keyboard-interactive", |
||||
})); err != nil { |
||||
return false, nil, err |
||||
} |
||||
|
||||
for { |
||||
packet, err := c.readPacket() |
||||
if err != nil { |
||||
return false, nil, err |
||||
} |
||||
|
||||
// like handleAuthResponse, but with less options.
|
||||
switch packet[0] { |
||||
case msgUserAuthBanner: |
||||
// TODO: Print banners during userauth.
|
||||
continue |
||||
case msgUserAuthInfoRequest: |
||||
// OK
|
||||
case msgUserAuthFailure: |
||||
var msg userAuthFailureMsg |
||||
if err := Unmarshal(packet, &msg); err != nil { |
||||
return false, nil, err |
||||
} |
||||
return false, msg.Methods, nil |
||||
case msgUserAuthSuccess: |
||||
return true, nil, nil |
||||
default: |
||||
return false, nil, unexpectedMessageError(msgUserAuthInfoRequest, packet[0]) |
||||
} |
||||
|
||||
var msg userAuthInfoRequestMsg |
||||
if err := Unmarshal(packet, &msg); err != nil { |
||||
return false, nil, err |
||||
} |
||||
|
||||
// Manually unpack the prompt/echo pairs.
|
||||
rest := msg.Prompts |
||||
var prompts []string |
||||
var echos []bool |
||||
for i := 0; i < int(msg.NumPrompts); i++ { |
||||
prompt, r, ok := parseString(rest) |
||||
if !ok || len(r) == 0 { |
||||
return false, nil, errors.New("ssh: prompt format error") |
||||
} |
||||
prompts = append(prompts, string(prompt)) |
||||
echos = append(echos, r[0] != 0) |
||||
rest = r[1:] |
||||
} |
||||
|
||||
if len(rest) != 0 { |
||||
return false, nil, errors.New("ssh: extra data following keyboard-interactive pairs") |
||||
} |
||||
|
||||
answers, err := cb(msg.User, msg.Instruction, prompts, echos) |
||||
if err != nil { |
||||
return false, nil, err |
||||
} |
||||
|
||||
if len(answers) != len(prompts) { |
||||
return false, nil, errors.New("ssh: not enough answers from keyboard-interactive callback") |
||||
} |
||||
responseLength := 1 + 4 |
||||
for _, a := range answers { |
||||
responseLength += stringLength(len(a)) |
||||
} |
||||
serialized := make([]byte, responseLength) |
||||
p := serialized |
||||
p[0] = msgUserAuthInfoResponse |
||||
p = p[1:] |
||||
p = marshalUint32(p, uint32(len(answers))) |
||||
for _, a := range answers { |
||||
p = marshalString(p, []byte(a)) |
||||
} |
||||
|
||||
if err := c.writePacket(serialized); err != nil { |
||||
return false, nil, err |
||||
} |
||||
} |
||||
} |
||||
@ -1,393 +0,0 @@ |
||||
// 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 ( |
||||
"bytes" |
||||
"crypto/rand" |
||||
"errors" |
||||
"fmt" |
||||
"strings" |
||||
"testing" |
||||
) |
||||
|
||||
type keyboardInteractive map[string]string |
||||
|
||||
func (cr keyboardInteractive) Challenge(user string, instruction string, questions []string, echos []bool) ([]string, error) { |
||||
var answers []string |
||||
for _, q := range questions { |
||||
answers = append(answers, cr[q]) |
||||
} |
||||
return answers, nil |
||||
} |
||||
|
||||
// reused internally by tests
|
||||
var clientPassword = "tiger" |
||||
|
||||
// tryAuth runs a handshake with a given config against an SSH server
|
||||
// with config serverConfig
|
||||
func tryAuth(t *testing.T, config *ClientConfig) error { |
||||
c1, c2, err := netPipe() |
||||
if err != nil { |
||||
t.Fatalf("netPipe: %v", err) |
||||
} |
||||
defer c1.Close() |
||||
defer c2.Close() |
||||
|
||||
certChecker := CertChecker{ |
||||
IsAuthority: func(k PublicKey) bool { |
||||
return bytes.Equal(k.Marshal(), testPublicKeys["ecdsa"].Marshal()) |
||||
}, |
||||
UserKeyFallback: func(conn ConnMetadata, key PublicKey) (*Permissions, error) { |
||||
if conn.User() == "testuser" && bytes.Equal(key.Marshal(), testPublicKeys["rsa"].Marshal()) { |
||||
return nil, nil |
||||
} |
||||
|
||||
return nil, fmt.Errorf("pubkey for %q not acceptable", conn.User()) |
||||
}, |
||||
IsRevoked: func(c *Certificate) bool { |
||||
return c.Serial == 666 |
||||
}, |
||||
} |
||||
|
||||
serverConfig := &ServerConfig{ |
||||
PasswordCallback: func(conn ConnMetadata, pass []byte) (*Permissions, error) { |
||||
if conn.User() == "testuser" && string(pass) == clientPassword { |
||||
return nil, nil |
||||
} |
||||
return nil, errors.New("password auth failed") |
||||
}, |
||||
PublicKeyCallback: certChecker.Authenticate, |
||||
KeyboardInteractiveCallback: func(conn ConnMetadata, challenge KeyboardInteractiveChallenge) (*Permissions, error) { |
||||
ans, err := challenge("user", |
||||
"instruction", |
||||
[]string{"question1", "question2"}, |
||||
[]bool{true, true}) |
||||
if err != nil { |
||||
return nil, err |
||||
} |
||||
ok := conn.User() == "testuser" && ans[0] == "answer1" && ans[1] == "answer2" |
||||
if ok { |
||||
challenge("user", "motd", nil, nil) |
||||
return nil, nil |
||||
} |
||||
return nil, errors.New("keyboard-interactive failed") |
||||
}, |
||||
AuthLogCallback: func(conn ConnMetadata, method string, err error) { |
||||
t.Logf("user %q, method %q: %v", conn.User(), method, err) |
||||
}, |
||||
} |
||||
serverConfig.AddHostKey(testSigners["rsa"]) |
||||
|
||||
go newServer(c1, serverConfig) |
||||
_, _, _, err = NewClientConn(c2, "", config) |
||||
return err |
||||
} |
||||
|
||||
func TestClientAuthPublicKey(t *testing.T) { |
||||
config := &ClientConfig{ |
||||
User: "testuser", |
||||
Auth: []AuthMethod{ |
||||
PublicKeys(testSigners["rsa"]), |
||||
}, |
||||
} |
||||
if err := tryAuth(t, config); err != nil { |
||||
t.Fatalf("unable to dial remote side: %s", err) |
||||
} |
||||
} |
||||
|
||||
func TestAuthMethodPassword(t *testing.T) { |
||||
config := &ClientConfig{ |
||||
User: "testuser", |
||||
Auth: []AuthMethod{ |
||||
Password(clientPassword), |
||||
}, |
||||
} |
||||
|
||||
if err := tryAuth(t, config); err != nil { |
||||
t.Fatalf("unable to dial remote side: %s", err) |
||||
} |
||||
} |
||||
|
||||
func TestAuthMethodFallback(t *testing.T) { |
||||
var passwordCalled bool |
||||
config := &ClientConfig{ |
||||
User: "testuser", |
||||
Auth: []AuthMethod{ |
||||
PublicKeys(testSigners["rsa"]), |
||||
PasswordCallback( |
||||
func() (string, error) { |
||||
passwordCalled = true |
||||
return "WRONG", nil |
||||
}), |
||||
}, |
||||
} |
||||
|
||||
if err := tryAuth(t, config); err != nil { |
||||
t.Fatalf("unable to dial remote side: %s", err) |
||||
} |
||||
|
||||
if passwordCalled { |
||||
t.Errorf("password auth tried before public-key auth.") |
||||
} |
||||
} |
||||
|
||||
func TestAuthMethodWrongPassword(t *testing.T) { |
||||
config := &ClientConfig{ |
||||
User: "testuser", |
||||
Auth: []AuthMethod{ |
||||
Password("wrong"), |
||||
PublicKeys(testSigners["rsa"]), |
||||
}, |
||||
} |
||||
|
||||
if err := tryAuth(t, config); err != nil { |
||||
t.Fatalf("unable to dial remote side: %s", err) |
||||
} |
||||
} |
||||
|
||||
func TestAuthMethodKeyboardInteractive(t *testing.T) { |
||||
answers := keyboardInteractive(map[string]string{ |
||||
"question1": "answer1", |
||||
"question2": "answer2", |
||||
}) |
||||
config := &ClientConfig{ |
||||
User: "testuser", |
||||
Auth: []AuthMethod{ |
||||
KeyboardInteractive(answers.Challenge), |
||||
}, |
||||
} |
||||
|
||||
if err := tryAuth(t, config); err != nil { |
||||
t.Fatalf("unable to dial remote side: %s", err) |
||||
} |
||||
} |
||||
|
||||
func TestAuthMethodWrongKeyboardInteractive(t *testing.T) { |
||||
answers := keyboardInteractive(map[string]string{ |
||||
"question1": "answer1", |
||||
"question2": "WRONG", |
||||
}) |
||||
config := &ClientConfig{ |
||||
User: "testuser", |
||||
Auth: []AuthMethod{ |
||||
KeyboardInteractive(answers.Challenge), |
||||
}, |
||||
} |
||||
|
||||
if err := tryAuth(t, config); err == nil { |
||||
t.Fatalf("wrong answers should not have authenticated with KeyboardInteractive") |
||||
} |
||||
} |
||||
|
||||
// the mock server will only authenticate ssh-rsa keys
|
||||
func TestAuthMethodInvalidPublicKey(t *testing.T) { |
||||
config := &ClientConfig{ |
||||
User: "testuser", |
||||
Auth: []AuthMethod{ |
||||
PublicKeys(testSigners["dsa"]), |
||||
}, |
||||
} |
||||
|
||||
if err := tryAuth(t, config); err == nil { |
||||
t.Fatalf("dsa private key should not have authenticated with rsa public key") |
||||
} |
||||
} |
||||
|
||||
// the client should authenticate with the second key
|
||||
func TestAuthMethodRSAandDSA(t *testing.T) { |
||||
config := &ClientConfig{ |
||||
User: "testuser", |
||||
Auth: []AuthMethod{ |
||||
PublicKeys(testSigners["dsa"], testSigners["rsa"]), |
||||
}, |
||||
} |
||||
if err := tryAuth(t, config); err != nil { |
||||
t.Fatalf("client could not authenticate with rsa key: %v", err) |
||||
} |
||||
} |
||||
|
||||
func TestClientHMAC(t *testing.T) { |
||||
for _, mac := range supportedMACs { |
||||
config := &ClientConfig{ |
||||
User: "testuser", |
||||
Auth: []AuthMethod{ |
||||
PublicKeys(testSigners["rsa"]), |
||||
}, |
||||
Config: Config{ |
||||
MACs: []string{mac}, |
||||
}, |
||||
} |
||||
if err := tryAuth(t, config); err != nil { |
||||
t.Fatalf("client could not authenticate with mac algo %s: %v", mac, err) |
||||
} |
||||
} |
||||
} |
||||
|
||||
// issue 4285.
|
||||
func TestClientUnsupportedCipher(t *testing.T) { |
||||
config := &ClientConfig{ |
||||
User: "testuser", |
||||
Auth: []AuthMethod{ |
||||
PublicKeys(), |
||||
}, |
||||
Config: Config{ |
||||
Ciphers: []string{"aes128-cbc"}, // not currently supported
|
||||
}, |
||||
} |
||||
if err := tryAuth(t, config); err == nil { |
||||
t.Errorf("expected no ciphers in common") |
||||
} |
||||
} |
||||
|
||||
func TestClientUnsupportedKex(t *testing.T) { |
||||
config := &ClientConfig{ |
||||
User: "testuser", |
||||
Auth: []AuthMethod{ |
||||
PublicKeys(), |
||||
}, |
||||
Config: Config{ |
||||
KeyExchanges: []string{"diffie-hellman-group-exchange-sha256"}, // not currently supported
|
||||
}, |
||||
} |
||||
if err := tryAuth(t, config); err == nil || !strings.Contains(err.Error(), "common algorithm") { |
||||
t.Errorf("got %v, expected 'common algorithm'", err) |
||||
} |
||||
} |
||||
|
||||
func TestClientLoginCert(t *testing.T) { |
||||
cert := &Certificate{ |
||||
Key: testPublicKeys["rsa"], |
||||
ValidBefore: CertTimeInfinity, |
||||
CertType: UserCert, |
||||
} |
||||
cert.SignCert(rand.Reader, testSigners["ecdsa"]) |
||||
certSigner, err := NewCertSigner(cert, testSigners["rsa"]) |
||||
if err != nil { |
||||
t.Fatalf("NewCertSigner: %v", err) |
||||
} |
||||
|
||||
clientConfig := &ClientConfig{ |
||||
User: "user", |
||||
} |
||||
clientConfig.Auth = append(clientConfig.Auth, PublicKeys(certSigner)) |
||||
|
||||
t.Log("should succeed") |
||||
if err := tryAuth(t, clientConfig); err != nil { |
||||
t.Errorf("cert login failed: %v", err) |
||||
} |
||||
|
||||
t.Log("corrupted signature") |
||||
cert.Signature.Blob[0]++ |
||||
if err := tryAuth(t, clientConfig); err == nil { |
||||
t.Errorf("cert login passed with corrupted sig") |
||||
} |
||||
|
||||
t.Log("revoked") |
||||
cert.Serial = 666 |
||||
cert.SignCert(rand.Reader, testSigners["ecdsa"]) |
||||
if err := tryAuth(t, clientConfig); err == nil { |
||||
t.Errorf("revoked cert login succeeded") |
||||
} |
||||
cert.Serial = 1 |
||||
|
||||
t.Log("sign with wrong key") |
||||
cert.SignCert(rand.Reader, testSigners["dsa"]) |
||||
if err := tryAuth(t, clientConfig); err == nil { |
||||
t.Errorf("cert login passed with non-authoritive key") |
||||
} |
||||
|
||||
t.Log("host cert") |
||||
cert.CertType = HostCert |
||||
cert.SignCert(rand.Reader, testSigners["ecdsa"]) |
||||
if err := tryAuth(t, clientConfig); err == nil { |
||||
t.Errorf("cert login passed with wrong type") |
||||
} |
||||
cert.CertType = UserCert |
||||
|
||||
t.Log("principal specified") |
||||
cert.ValidPrincipals = []string{"user"} |
||||
cert.SignCert(rand.Reader, testSigners["ecdsa"]) |
||||
if err := tryAuth(t, clientConfig); err != nil { |
||||
t.Errorf("cert login failed: %v", err) |
||||
} |
||||
|
||||
t.Log("wrong principal specified") |
||||
cert.ValidPrincipals = []string{"fred"} |
||||
cert.SignCert(rand.Reader, testSigners["ecdsa"]) |
||||
if err := tryAuth(t, clientConfig); err == nil { |
||||
t.Errorf("cert login passed with wrong principal") |
||||
} |
||||
cert.ValidPrincipals = nil |
||||
|
||||
t.Log("added critical option") |
||||
cert.CriticalOptions = map[string]string{"root-access": "yes"} |
||||
cert.SignCert(rand.Reader, testSigners["ecdsa"]) |
||||
if err := tryAuth(t, clientConfig); err == nil { |
||||
t.Errorf("cert login passed with unrecognized critical option") |
||||
} |
||||
|
||||
t.Log("allowed source address") |
||||
cert.CriticalOptions = map[string]string{"source-address": "127.0.0.42/24"} |
||||
cert.SignCert(rand.Reader, testSigners["ecdsa"]) |
||||
if err := tryAuth(t, clientConfig); err != nil { |
||||
t.Errorf("cert login with source-address failed: %v", err) |
||||
} |
||||
|
||||
t.Log("disallowed source address") |
||||
cert.CriticalOptions = map[string]string{"source-address": "127.0.0.42"} |
||||
cert.SignCert(rand.Reader, testSigners["ecdsa"]) |
||||
if err := tryAuth(t, clientConfig); err == nil { |
||||
t.Errorf("cert login with source-address succeeded") |
||||
} |
||||
} |
||||
|
||||
func testPermissionsPassing(withPermissions bool, t *testing.T) { |
||||
serverConfig := &ServerConfig{ |
||||
PublicKeyCallback: func(conn ConnMetadata, key PublicKey) (*Permissions, error) { |
||||
if conn.User() == "nopermissions" { |
||||
return nil, nil |
||||
} else { |
||||
return &Permissions{}, nil |
||||
} |
||||
}, |
||||
} |
||||
serverConfig.AddHostKey(testSigners["rsa"]) |
||||
|
||||
clientConfig := &ClientConfig{ |
||||
Auth: []AuthMethod{ |
||||
PublicKeys(testSigners["rsa"]), |
||||
}, |
||||
} |
||||
if withPermissions { |
||||
clientConfig.User = "permissions" |
||||
} else { |
||||
clientConfig.User = "nopermissions" |
||||
} |
||||
|
||||
c1, c2, err := netPipe() |
||||
if err != nil { |
||||
t.Fatalf("netPipe: %v", err) |
||||
} |
||||
defer c1.Close() |
||||
defer c2.Close() |
||||
|
||||
go NewClientConn(c2, "", clientConfig) |
||||
serverConn, err := newServer(c1, serverConfig) |
||||
if err != nil { |
||||
t.Fatal(err) |
||||
} |
||||
if p := serverConn.Permissions; (p != nil) != withPermissions { |
||||
t.Fatalf("withPermissions is %t, but Permissions object is %#v", withPermissions, p) |
||||
} |
||||
} |
||||
|
||||
func TestPermissionsPassing(t *testing.T) { |
||||
testPermissionsPassing(true, t) |
||||
} |
||||
|
||||
func TestNoPermissionsPassing(t *testing.T) { |
||||
testPermissionsPassing(false, t) |
||||
} |
||||
@ -1,39 +0,0 @@ |
||||
// Copyright 2014 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 ( |
||||
"net" |
||||
"testing" |
||||
) |
||||
|
||||
func testClientVersion(t *testing.T, config *ClientConfig, expected string) { |
||||
clientConn, serverConn := net.Pipe() |
||||
defer clientConn.Close() |
||||
receivedVersion := make(chan string, 1) |
||||
go func() { |
||||
version, err := readVersion(serverConn) |
||||
if err != nil { |
||||
receivedVersion <- "" |
||||
} else { |
||||
receivedVersion <- string(version) |
||||
} |
||||
serverConn.Close() |
||||
}() |
||||
NewClientConn(clientConn, "", config) |
||||
actual := <-receivedVersion |
||||
if actual != expected { |
||||
t.Fatalf("got %s; want %s", actual, expected) |
||||
} |
||||
} |
||||
|
||||
func TestCustomClientVersion(t *testing.T) { |
||||
version := "Test-Client-Version-0.0" |
||||
testClientVersion(t, &ClientConfig{ClientVersion: version}, version) |
||||
} |
||||
|
||||
func TestDefaultClientVersion(t *testing.T) { |
||||
testClientVersion(t, &ClientConfig{}, packageVersion) |
||||
} |
||||
@ -1,354 +0,0 @@ |
||||
// 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" |
||||
"fmt" |
||||
"io" |
||||
"sync" |
||||
|
||||
_ "crypto/sha1" |
||||
_ "crypto/sha256" |
||||
_ "crypto/sha512" |
||||
) |
||||
|
||||
// These are string constants in the SSH protocol.
|
||||
const ( |
||||
compressionNone = "none" |
||||
serviceUserAuth = "ssh-userauth" |
||||
serviceSSH = "ssh-connection" |
||||
) |
||||
|
||||
// supportedCiphers specifies the supported ciphers in preference order.
|
||||
var supportedCiphers = []string{ |
||||
"aes128-ctr", "aes192-ctr", "aes256-ctr", |
||||
"aes128-gcm@openssh.com", |
||||
"arcfour256", "arcfour128", |
||||
} |
||||
|
||||
// supportedKexAlgos specifies the supported key-exchange algorithms in
|
||||
// preference order.
|
||||
var supportedKexAlgos = []string{ |
||||
kexAlgoCurve25519SHA256, |
||||
// P384 and P521 are not constant-time yet, but since we don't
|
||||
// reuse ephemeral keys, using them for ECDH should be OK.
|
||||
kexAlgoECDH256, kexAlgoECDH384, kexAlgoECDH521, |
||||
kexAlgoDH14SHA1, kexAlgoDH1SHA1, |
||||
} |
||||
|
||||
// supportedKexAlgos specifies the supported host-key algorithms (i.e. methods
|
||||
// of authenticating servers) in preference order.
|
||||
var supportedHostKeyAlgos = []string{ |
||||
CertAlgoRSAv01, CertAlgoDSAv01, CertAlgoECDSA256v01, |
||||
CertAlgoECDSA384v01, CertAlgoECDSA521v01, |
||||
|
||||
KeyAlgoECDSA256, KeyAlgoECDSA384, KeyAlgoECDSA521, |
||||
KeyAlgoRSA, KeyAlgoDSA, |
||||
} |
||||
|
||||
// supportedMACs specifies a default set of MAC algorithms in preference order.
|
||||
// This is based on RFC 4253, section 6.4, but with hmac-md5 variants removed
|
||||
// because they have reached the end of their useful life.
|
||||
var supportedMACs = []string{ |
||||
"hmac-sha2-256", "hmac-sha1", "hmac-sha1-96", |
||||
} |
||||
|
||||
var supportedCompressions = []string{compressionNone} |
||||
|
||||
// hashFuncs keeps the mapping of supported algorithms to their respective
|
||||
// hashes needed for signature verification.
|
||||
var hashFuncs = map[string]crypto.Hash{ |
||||
KeyAlgoRSA: crypto.SHA1, |
||||
KeyAlgoDSA: crypto.SHA1, |
||||
KeyAlgoECDSA256: crypto.SHA256, |
||||
KeyAlgoECDSA384: crypto.SHA384, |
||||
KeyAlgoECDSA521: crypto.SHA512, |
||||
CertAlgoRSAv01: crypto.SHA1, |
||||
CertAlgoDSAv01: crypto.SHA1, |
||||
CertAlgoECDSA256v01: crypto.SHA256, |
||||
CertAlgoECDSA384v01: crypto.SHA384, |
||||
CertAlgoECDSA521v01: crypto.SHA512, |
||||
} |
||||
|
||||
// unexpectedMessageError results when the SSH message that we received didn't
|
||||
// match what we wanted.
|
||||
func unexpectedMessageError(expected, got uint8) error { |
||||
return fmt.Errorf("ssh: unexpected message type %d (expected %d)", got, expected) |
||||
} |
||||
|
||||
// parseError results from a malformed SSH message.
|
||||
func parseError(tag uint8) error { |
||||
return fmt.Errorf("ssh: parse error in message type %d", tag) |
||||
} |
||||
|
||||
func findCommon(what string, client []string, server []string) (common string, err error) { |
||||
for _, c := range client { |
||||
for _, s := range server { |
||||
if c == s { |
||||
return c, nil |
||||
} |
||||
} |
||||
} |
||||
return "", fmt.Errorf("ssh: no common algorithm for %s; client offered: %v, server offered: %v", what, client, server) |
||||
} |
||||
|
||||
type directionAlgorithms struct { |
||||
Cipher string |
||||
MAC string |
||||
Compression string |
||||
} |
||||
|
||||
type algorithms struct { |
||||
kex string |
||||
hostKey string |
||||
w directionAlgorithms |
||||
r directionAlgorithms |
||||
} |
||||
|
||||
func findAgreedAlgorithms(clientKexInit, serverKexInit *kexInitMsg) (algs *algorithms, err error) { |
||||
result := &algorithms{} |
||||
|
||||
result.kex, err = findCommon("key exchange", clientKexInit.KexAlgos, serverKexInit.KexAlgos) |
||||
if err != nil { |
||||
return |
||||
} |
||||
|
||||
result.hostKey, err = findCommon("host key", clientKexInit.ServerHostKeyAlgos, serverKexInit.ServerHostKeyAlgos) |
||||
if err != nil { |
||||
return |
||||
} |
||||
|
||||
result.w.Cipher, err = findCommon("client to server cipher", clientKexInit.CiphersClientServer, serverKexInit.CiphersClientServer) |
||||
if err != nil { |
||||
return |
||||
} |
||||
|
||||
result.r.Cipher, err = findCommon("server to client cipher", clientKexInit.CiphersServerClient, serverKexInit.CiphersServerClient) |
||||
if err != nil { |
||||
return |
||||
} |
||||
|
||||
result.w.MAC, err = findCommon("client to server MAC", clientKexInit.MACsClientServer, serverKexInit.MACsClientServer) |
||||
if err != nil { |
||||
return |
||||
} |
||||
|
||||
result.r.MAC, err = findCommon("server to client MAC", clientKexInit.MACsServerClient, serverKexInit.MACsServerClient) |
||||
if err != nil { |
||||
return |
||||
} |
||||
|
||||
result.w.Compression, err = findCommon("client to server compression", clientKexInit.CompressionClientServer, serverKexInit.CompressionClientServer) |
||||
if err != nil { |
||||
return |
||||
} |
||||
|
||||
result.r.Compression, err = findCommon("server to client compression", clientKexInit.CompressionServerClient, serverKexInit.CompressionServerClient) |
||||
if err != nil { |
||||
return |
||||
} |
||||
|
||||
return result, nil |
||||
} |
||||
|
||||
// If rekeythreshold is too small, we can't make any progress sending
|
||||
// stuff.
|
||||
const minRekeyThreshold uint64 = 256 |
||||
|
||||
// Config contains configuration data common to both ServerConfig and
|
||||
// ClientConfig.
|
||||
type Config struct { |
||||
// Rand provides the source of entropy for cryptographic
|
||||
// primitives. If Rand is nil, the cryptographic random reader
|
||||
// in package crypto/rand will be used.
|
||||
Rand io.Reader |
||||
|
||||
// The maximum number of bytes sent or received after which a
|
||||
// new key is negotiated. It must be at least 256. If
|
||||
// unspecified, 1 gigabyte is used.
|
||||
RekeyThreshold uint64 |
||||
|
||||
// The allowed key exchanges algorithms. If unspecified then a
|
||||
// default set of algorithms is used.
|
||||
KeyExchanges []string |
||||
|
||||
// The allowed cipher algorithms. If unspecified then a sensible
|
||||
// default is used.
|
||||
Ciphers []string |
||||
|
||||
// The allowed MAC algorithms. If unspecified then a sensible default
|
||||
// is used.
|
||||
MACs []string |
||||
} |
||||
|
||||
// SetDefaults sets sensible values for unset fields in config. This is
|
||||
// exported for testing: Configs passed to SSH functions are copied and have
|
||||
// default values set automatically.
|
||||
func (c *Config) SetDefaults() { |
||||
if c.Rand == nil { |
||||
c.Rand = rand.Reader |
||||
} |
||||
if c.Ciphers == nil { |
||||
c.Ciphers = supportedCiphers |
||||
} |
||||
var ciphers []string |
||||
for _, c := range c.Ciphers { |
||||
if cipherModes[c] != nil { |
||||
// reject the cipher if we have no cipherModes definition
|
||||
ciphers = append(ciphers, c) |
||||
} |
||||
} |
||||
c.Ciphers = ciphers |
||||
|
||||
if c.KeyExchanges == nil { |
||||
c.KeyExchanges = supportedKexAlgos |
||||
} |
||||
|
||||
if c.MACs == nil { |
||||
c.MACs = supportedMACs |
||||
} |
||||
|
||||
if c.RekeyThreshold == 0 { |
||||
// RFC 4253, section 9 suggests rekeying after 1G.
|
||||
c.RekeyThreshold = 1 << 30 |
||||
} |
||||
if c.RekeyThreshold < minRekeyThreshold { |
||||
c.RekeyThreshold = minRekeyThreshold |
||||
} |
||||
} |
||||
|
||||
// buildDataSignedForAuth returns the data that is signed in order to prove
|
||||
// possession of a private key. See RFC 4252, section 7.
|
||||
func buildDataSignedForAuth(sessionId []byte, req userAuthRequestMsg, algo, pubKey []byte) []byte { |
||||
data := struct { |
||||
Session []byte |
||||
Type byte |
||||
User string |
||||
Service string |
||||
Method string |
||||
Sign bool |
||||
Algo []byte |
||||
PubKey []byte |
||||
}{ |
||||
sessionId, |
||||
msgUserAuthRequest, |
||||
req.User, |
||||
req.Service, |
||||
req.Method, |
||||
true, |
||||
algo, |
||||
pubKey, |
||||
} |
||||
return Marshal(data) |
||||
} |
||||
|
||||
func appendU16(buf []byte, n uint16) []byte { |
||||
return append(buf, byte(n>>8), byte(n)) |
||||
} |
||||
|
||||
func appendU32(buf []byte, n uint32) []byte { |
||||
return append(buf, byte(n>>24), byte(n>>16), byte(n>>8), byte(n)) |
||||
} |
||||
|
||||
func appendU64(buf []byte, n uint64) []byte { |
||||
return append(buf, |
||||
byte(n>>56), byte(n>>48), byte(n>>40), byte(n>>32), |
||||
byte(n>>24), byte(n>>16), byte(n>>8), byte(n)) |
||||
} |
||||
|
||||
func appendInt(buf []byte, n int) []byte { |
||||
return appendU32(buf, uint32(n)) |
||||
} |
||||
|
||||
func appendString(buf []byte, s string) []byte { |
||||
buf = appendU32(buf, uint32(len(s))) |
||||
buf = append(buf, s...) |
||||
return buf |
||||
} |
||||
|
||||
func appendBool(buf []byte, b bool) []byte { |
||||
if b { |
||||
return append(buf, 1) |
||||
} |
||||
return append(buf, 0) |
||||
} |
||||
|
||||
// newCond is a helper to hide the fact that there is no usable zero
|
||||
// value for sync.Cond.
|
||||
func newCond() *sync.Cond { return sync.NewCond(new(sync.Mutex)) } |
||||
|
||||
// window represents the buffer available to clients
|
||||
// wishing to write to a channel.
|
||||
type window struct { |
||||
*sync.Cond |
||||
win uint32 // RFC 4254 5.2 says the window size can grow to 2^32-1
|
||||
writeWaiters int |
||||
closed bool |
||||
} |
||||
|
||||
// add adds win to the amount of window available
|
||||
// for consumers.
|
||||
func (w *window) add(win uint32) bool { |
||||
// a zero sized window adjust is a noop.
|
||||
if win == 0 { |
||||
return true |
||||
} |
||||
w.L.Lock() |
||||
if w.win+win < win { |
||||
w.L.Unlock() |
||||
return false |
||||
} |
||||
w.win += win |
||||
// It is unusual that multiple goroutines would be attempting to reserve
|
||||
// window space, but not guaranteed. Use broadcast to notify all waiters
|
||||
// that additional window is available.
|
||||
w.Broadcast() |
||||
w.L.Unlock() |
||||
return true |
||||
} |
||||
|
||||
// close sets the window to closed, so all reservations fail
|
||||
// immediately.
|
||||
func (w *window) close() { |
||||
w.L.Lock() |
||||
w.closed = true |
||||
w.Broadcast() |
||||
w.L.Unlock() |
||||
} |
||||
|
||||
// reserve reserves win from the available window capacity.
|
||||
// If no capacity remains, reserve will block. reserve may
|
||||
// return less than requested.
|
||||
func (w *window) reserve(win uint32) (uint32, error) { |
||||
var err error |
||||
w.L.Lock() |
||||
w.writeWaiters++ |
||||
w.Broadcast() |
||||
for w.win == 0 && !w.closed { |
||||
w.Wait() |
||||
} |
||||
w.writeWaiters-- |
||||
if w.win < win { |
||||
win = w.win |
||||
} |
||||
w.win -= win |
||||
if w.closed { |
||||
err = io.EOF |
||||
} |
||||
w.L.Unlock() |
||||
return win, err |
||||
} |
||||
|
||||
// waitWriterBlocked waits until some goroutine is blocked for further
|
||||
// writes. It is used in tests only.
|
||||
func (w *window) waitWriterBlocked() { |
||||
w.Cond.L.Lock() |
||||
for w.writeWaiters == 0 { |
||||
w.Cond.Wait() |
||||
} |
||||
w.Cond.L.Unlock() |
||||
} |
||||
@ -1,144 +0,0 @@ |
||||
// Copyright 2013 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 ( |
||||
"fmt" |
||||
"net" |
||||
) |
||||
|
||||
// OpenChannelError is returned if the other side rejects an
|
||||
// OpenChannel request.
|
||||
type OpenChannelError struct { |
||||
Reason RejectionReason |
||||
Message string |
||||
} |
||||
|
||||
func (e *OpenChannelError) Error() string { |
||||
return fmt.Sprintf("ssh: rejected: %s (%s)", e.Reason, e.Message) |
||||
} |
||||
|
||||
// ConnMetadata holds metadata for the connection.
|
||||
type ConnMetadata interface { |
||||
// User returns the user ID for this connection.
|
||||
// It is empty if no authentication is used.
|
||||
User() string |
||||
|
||||
// SessionID returns the sesson hash, also denoted by H.
|
||||
SessionID() []byte |
||||
|
||||
// ClientVersion returns the client's version string as hashed
|
||||
// into the session ID.
|
||||
ClientVersion() []byte |
||||
|
||||
// ServerVersion returns the server's version string as hashed
|
||||
// into the session ID.
|
||||
ServerVersion() []byte |
||||
|
||||
// RemoteAddr returns the remote address for this connection.
|
||||
RemoteAddr() net.Addr |
||||
|
||||
// LocalAddr returns the local address for this connection.
|
||||
LocalAddr() net.Addr |
||||
} |
||||
|
||||
// Conn represents an SSH connection for both server and client roles.
|
||||
// Conn is the basis for implementing an application layer, such
|
||||
// as ClientConn, which implements the traditional shell access for
|
||||
// clients.
|
||||
type Conn interface { |
||||
ConnMetadata |
||||
|
||||
// SendRequest sends a global request, and returns the
|
||||
// reply. If wantReply is true, it returns the response status
|
||||
// and payload. See also RFC4254, section 4.
|
||||
SendRequest(name string, wantReply bool, payload []byte) (bool, []byte, error) |
||||
|
||||
// OpenChannel tries to open an channel. If the request is
|
||||
// rejected, it returns *OpenChannelError. On success it returns
|
||||
// the SSH Channel and a Go channel for incoming, out-of-band
|
||||
// requests. The Go channel must be serviced, or the
|
||||
// connection will hang.
|
||||
OpenChannel(name string, data []byte) (Channel, <-chan *Request, error) |
||||
|
||||
// Close closes the underlying network connection
|
||||
Close() error |
||||
|
||||
// Wait blocks until the connection has shut down, and returns the
|
||||
// error causing the shutdown.
|
||||
Wait() error |
||||
|
||||
// TODO(hanwen): consider exposing:
|
||||
// RequestKeyChange
|
||||
// Disconnect
|
||||
} |
||||
|
||||
// DiscardRequests consumes and rejects all requests from the
|
||||
// passed-in channel.
|
||||
func DiscardRequests(in <-chan *Request) { |
||||
for req := range in { |
||||
if req.WantReply { |
||||
req.Reply(false, nil) |
||||
} |
||||
} |
||||
} |
||||
|
||||
// A connection represents an incoming connection.
|
||||
type connection struct { |
||||
transport *handshakeTransport |
||||
sshConn |
||||
|
||||
// The connection protocol.
|
||||
*mux |
||||
} |
||||
|
||||
func (c *connection) Close() error { |
||||
return c.sshConn.conn.Close() |
||||
} |
||||
|
||||
// sshconn provides net.Conn metadata, but disallows direct reads and
|
||||
// writes.
|
||||
type sshConn struct { |
||||
conn net.Conn |
||||
|
||||
user string |
||||
sessionID []byte |
||||
clientVersion []byte |
||||
serverVersion []byte |
||||
} |
||||
|
||||
func dup(src []byte) []byte { |
||||
dst := make([]byte, len(src)) |
||||
copy(dst, src) |
||||
return dst |
||||
} |
||||
|
||||
func (c *sshConn) User() string { |
||||
return c.user |
||||
} |
||||
|
||||
func (c *sshConn) RemoteAddr() net.Addr { |
||||
return c.conn.RemoteAddr() |
||||
} |
||||
|
||||
func (c *sshConn) Close() error { |
||||
return c.conn.Close() |
||||
} |
||||
|
||||
func (c *sshConn) LocalAddr() net.Addr { |
||||
return c.conn.LocalAddr() |
||||
} |
||||
|
||||
func (c *sshConn) SessionID() []byte { |
||||
return dup(c.sessionID) |
||||
} |
||||
|
||||
func (c *sshConn) ClientVersion() []byte { |
||||
return dup(c.clientVersion) |
||||
} |
||||
|
||||
func (c *sshConn) ServerVersion() []byte { |
||||
return dup(c.serverVersion) |
||||
} |
||||
@ -1,18 +0,0 @@ |
||||
// 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 implements an SSH client and server. |
||||
|
||||
SSH is a transport security protocol, an authentication protocol and a |
||||
family of application protocols. The most typical application level |
||||
protocol is a remote shell and this is specifically implemented. However, |
||||
the multiplexed nature of SSH is exposed to users that wish to support |
||||
others. |
||||
|
||||
References: |
||||
[PROTOCOL.certkeys]: http://cvsweb.openbsd.org/cgi-bin/cvsweb/src/usr.bin/ssh/PROTOCOL.certkeys?rev=HEAD
|
||||
[SSH-PARAMETERS]: http://www.iana.org/assignments/ssh-parameters/ssh-parameters.xml#ssh-parameters-1
|
||||
*/ |
||||
package ssh |
||||
@ -1,211 +0,0 @@ |
||||
// 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_test |
||||
|
||||
import ( |
||||
"bytes" |
||||
"fmt" |
||||
"io/ioutil" |
||||
"log" |
||||
"net" |
||||
"net/http" |
||||
|
||||
"github.com/gogits/gogs/modules/crypto/ssh" |
||||
"github.com/gogits/gogs/modules/crypto/ssh/terminal" |
||||
) |
||||
|
||||
func ExampleNewServerConn() { |
||||
// An SSH server is represented by a ServerConfig, which holds
|
||||
// certificate details and handles authentication of ServerConns.
|
||||
config := &ssh.ServerConfig{ |
||||
PasswordCallback: func(c ssh.ConnMetadata, pass []byte) (*ssh.Permissions, error) { |
||||
// Should use constant-time compare (or better, salt+hash) in
|
||||
// a production setting.
|
||||
if c.User() == "testuser" && string(pass) == "tiger" { |
||||
return nil, nil |
||||
} |
||||
return nil, fmt.Errorf("password rejected for %q", c.User()) |
||||
}, |
||||
} |
||||
|
||||
privateBytes, err := ioutil.ReadFile("id_rsa") |
||||
if err != nil { |
||||
panic("Failed to load private key") |
||||
} |
||||
|
||||
private, err := ssh.ParsePrivateKey(privateBytes) |
||||
if err != nil { |
||||
panic("Failed to parse private key") |
||||
} |
||||
|
||||
config.AddHostKey(private) |
||||
|
||||
// Once a ServerConfig has been configured, connections can be
|
||||
// accepted.
|
||||
listener, err := net.Listen("tcp", "0.0.0.0:2022") |
||||
if err != nil { |
||||
panic("failed to listen for connection") |
||||
} |
||||
nConn, err := listener.Accept() |
||||
if err != nil { |
||||
panic("failed to accept incoming connection") |
||||
} |
||||
|
||||
// Before use, a handshake must be performed on the incoming
|
||||
// net.Conn.
|
||||
_, chans, reqs, err := ssh.NewServerConn(nConn, config) |
||||
if err != nil { |
||||
panic("failed to handshake") |
||||
} |
||||
// The incoming Request channel must be serviced.
|
||||
go ssh.DiscardRequests(reqs) |
||||
|
||||
// Service the incoming Channel channel.
|
||||
for newChannel := range chans { |
||||
// Channels have a type, depending on the application level
|
||||
// protocol intended. In the case of a shell, the type is
|
||||
// "session" and ServerShell may be used to present a simple
|
||||
// terminal interface.
|
||||
if newChannel.ChannelType() != "session" { |
||||
newChannel.Reject(ssh.UnknownChannelType, "unknown channel type") |
||||
continue |
||||
} |
||||
channel, requests, err := newChannel.Accept() |
||||
if err != nil { |
||||
panic("could not accept channel.") |
||||
} |
||||
|
||||
// Sessions have out-of-band requests such as "shell",
|
||||
// "pty-req" and "env". Here we handle only the
|
||||
// "shell" request.
|
||||
go func(in <-chan *ssh.Request) { |
||||
for req := range in { |
||||
ok := false |
||||
switch req.Type { |
||||
case "shell": |
||||
ok = true |
||||
if len(req.Payload) > 0 { |
||||
// We don't accept any
|
||||
// commands, only the
|
||||
// default shell.
|
||||
ok = false |
||||
} |
||||
} |
||||
req.Reply(ok, nil) |
||||
} |
||||
}(requests) |
||||
|
||||
term := terminal.NewTerminal(channel, "> ") |
||||
|
||||
go func() { |
||||
defer channel.Close() |
||||
for { |
||||
line, err := term.ReadLine() |
||||
if err != nil { |
||||
break |
||||
} |
||||
fmt.Println(line) |
||||
} |
||||
}() |
||||
} |
||||
} |
||||
|
||||
func ExampleDial() { |
||||
// An SSH client is represented with a ClientConn. Currently only
|
||||
// the "password" authentication method is supported.
|
||||
//
|
||||
// To authenticate with the remote server you must pass at least one
|
||||
// implementation of AuthMethod via the Auth field in ClientConfig.
|
||||
config := &ssh.ClientConfig{ |
||||
User: "username", |
||||
Auth: []ssh.AuthMethod{ |
||||
ssh.Password("yourpassword"), |
||||
}, |
||||
} |
||||
client, err := ssh.Dial("tcp", "yourserver.com:22", config) |
||||
if err != nil { |
||||
panic("Failed to dial: " + err.Error()) |
||||
} |
||||
|
||||
// Each ClientConn can support multiple interactive sessions,
|
||||
// represented by a Session.
|
||||
session, err := client.NewSession() |
||||
if err != nil { |
||||
panic("Failed to create session: " + err.Error()) |
||||
} |
||||
defer session.Close() |
||||
|
||||
// Once a Session is created, you can execute a single command on
|
||||
// the remote side using the Run method.
|
||||
var b bytes.Buffer |
||||
session.Stdout = &b |
||||
if err := session.Run("/usr/bin/whoami"); err != nil { |
||||
panic("Failed to run: " + err.Error()) |
||||
} |
||||
fmt.Println(b.String()) |
||||
} |
||||
|
||||
func ExampleClient_Listen() { |
||||
config := &ssh.ClientConfig{ |
||||
User: "username", |
||||
Auth: []ssh.AuthMethod{ |
||||
ssh.Password("password"), |
||||
}, |
||||
} |
||||
// Dial your ssh server.
|
||||
conn, err := ssh.Dial("tcp", "localhost:22", config) |
||||
if err != nil { |
||||
log.Fatalf("unable to connect: %s", err) |
||||
} |
||||
defer conn.Close() |
||||
|
||||
// Request the remote side to open port 8080 on all interfaces.
|
||||
l, err := conn.Listen("tcp", "0.0.0.0:8080") |
||||
if err != nil { |
||||
log.Fatalf("unable to register tcp forward: %v", err) |
||||
} |
||||
defer l.Close() |
||||
|
||||
// Serve HTTP with your SSH server acting as a reverse proxy.
|
||||
http.Serve(l, http.HandlerFunc(func(resp http.ResponseWriter, req *http.Request) { |
||||
fmt.Fprintf(resp, "Hello world!\n") |
||||
})) |
||||
} |
||||
|
||||
func ExampleSession_RequestPty() { |
||||
// Create client config
|
||||
config := &ssh.ClientConfig{ |
||||
User: "username", |
||||
Auth: []ssh.AuthMethod{ |
||||
ssh.Password("password"), |
||||
}, |
||||
} |
||||
// Connect to ssh server
|
||||
conn, err := ssh.Dial("tcp", "localhost:22", config) |
||||
if err != nil { |
||||
log.Fatalf("unable to connect: %s", err) |
||||
} |
||||
defer conn.Close() |
||||
// Create a session
|
||||
session, err := conn.NewSession() |
||||
if err != nil { |
||||
log.Fatalf("unable to create session: %s", err) |
||||
} |
||||
defer session.Close() |
||||
// Set up terminal modes
|
||||
modes := ssh.TerminalModes{ |
||||
ssh.ECHO: 0, // disable echoing
|
||||
ssh.TTY_OP_ISPEED: 14400, // input speed = 14.4kbaud
|
||||
ssh.TTY_OP_OSPEED: 14400, // output speed = 14.4kbaud
|
||||
} |
||||
// Request pseudo terminal
|
||||
if err := session.RequestPty("xterm", 80, 40, modes); err != nil { |
||||
log.Fatalf("request for pseudo terminal failed: %s", err) |
||||
} |
||||
// Start remote shell
|
||||
if err := session.Shell(); err != nil { |
||||
log.Fatalf("failed to start shell: %s", err) |
||||
} |
||||
} |
||||
@ -1,412 +0,0 @@ |
||||
// Copyright 2013 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/rand" |
||||
"errors" |
||||
"fmt" |
||||
"io" |
||||
"log" |
||||
"net" |
||||
"sync" |
||||
) |
||||
|
||||
// debugHandshake, if set, prints messages sent and received. Key
|
||||
// exchange messages are printed as if DH were used, so the debug
|
||||
// messages are wrong when using ECDH.
|
||||
const debugHandshake = false |
||||
|
||||
// keyingTransport is a packet based transport that supports key
|
||||
// changes. It need not be thread-safe. It should pass through
|
||||
// msgNewKeys in both directions.
|
||||
type keyingTransport interface { |
||||
packetConn |
||||
|
||||
// prepareKeyChange sets up a key change. The key change for a
|
||||
// direction will be effected if a msgNewKeys message is sent
|
||||
// or received.
|
||||
prepareKeyChange(*algorithms, *kexResult) error |
||||
|
||||
// getSessionID returns the session ID. prepareKeyChange must
|
||||
// have been called once.
|
||||
getSessionID() []byte |
||||
} |
||||
|
||||
// rekeyingTransport is the interface of handshakeTransport that we
|
||||
// (internally) expose to ClientConn and ServerConn.
|
||||
type rekeyingTransport interface { |
||||
packetConn |
||||
|
||||
// requestKeyChange asks the remote side to change keys. All
|
||||
// writes are blocked until the key change succeeds, which is
|
||||
// signaled by reading a msgNewKeys.
|
||||
requestKeyChange() error |
||||
|
||||
// getSessionID returns the session ID. This is only valid
|
||||
// after the first key change has completed.
|
||||
getSessionID() []byte |
||||
} |
||||
|
||||
// handshakeTransport implements rekeying on top of a keyingTransport
|
||||
// and offers a thread-safe writePacket() interface.
|
||||
type handshakeTransport struct { |
||||
conn keyingTransport |
||||
config *Config |
||||
|
||||
serverVersion []byte |
||||
clientVersion []byte |
||||
|
||||
// hostKeys is non-empty if we are the server. In that case,
|
||||
// it contains all host keys that can be used to sign the
|
||||
// connection.
|
||||
hostKeys []Signer |
||||
|
||||
// hostKeyAlgorithms is non-empty if we are the client. In that case,
|
||||
// we accept these key types from the server as host key.
|
||||
hostKeyAlgorithms []string |
||||
|
||||
// On read error, incoming is closed, and readError is set.
|
||||
incoming chan []byte |
||||
readError error |
||||
|
||||
// data for host key checking
|
||||
hostKeyCallback func(hostname string, remote net.Addr, key PublicKey) error |
||||
dialAddress string |
||||
remoteAddr net.Addr |
||||
|
||||
readSinceKex uint64 |
||||
|
||||
// Protects the writing side of the connection
|
||||
mu sync.Mutex |
||||
cond *sync.Cond |
||||
sentInitPacket []byte |
||||
sentInitMsg *kexInitMsg |
||||
writtenSinceKex uint64 |
||||
writeError error |
||||
} |
||||
|
||||
func newHandshakeTransport(conn keyingTransport, config *Config, clientVersion, serverVersion []byte) *handshakeTransport { |
||||
t := &handshakeTransport{ |
||||
conn: conn, |
||||
serverVersion: serverVersion, |
||||
clientVersion: clientVersion, |
||||
incoming: make(chan []byte, 16), |
||||
config: config, |
||||
} |
||||
t.cond = sync.NewCond(&t.mu) |
||||
return t |
||||
} |
||||
|
||||
func newClientTransport(conn keyingTransport, clientVersion, serverVersion []byte, config *ClientConfig, dialAddr string, addr net.Addr) *handshakeTransport { |
||||
t := newHandshakeTransport(conn, &config.Config, clientVersion, serverVersion) |
||||
t.dialAddress = dialAddr |
||||
t.remoteAddr = addr |
||||
t.hostKeyCallback = config.HostKeyCallback |
||||
if config.HostKeyAlgorithms != nil { |
||||
t.hostKeyAlgorithms = config.HostKeyAlgorithms |
||||
} else { |
||||
t.hostKeyAlgorithms = supportedHostKeyAlgos |
||||
} |
||||
go t.readLoop() |
||||
return t |
||||
} |
||||
|
||||
func newServerTransport(conn keyingTransport, clientVersion, serverVersion []byte, config *ServerConfig) *handshakeTransport { |
||||
t := newHandshakeTransport(conn, &config.Config, clientVersion, serverVersion) |
||||
t.hostKeys = config.hostKeys |
||||
go t.readLoop() |
||||
return t |
||||
} |
||||
|
||||
func (t *handshakeTransport) getSessionID() []byte { |
||||
return t.conn.getSessionID() |
||||
} |
||||
|
||||
func (t *handshakeTransport) id() string { |
||||
if len(t.hostKeys) > 0 { |
||||
return "server" |
||||
} |
||||
return "client" |
||||
} |
||||
|
||||
func (t *handshakeTransport) readPacket() ([]byte, error) { |
||||
p, ok := <-t.incoming |
||||
if !ok { |
||||
return nil, t.readError |
||||
} |
||||
return p, nil |
||||
} |
||||
|
||||
func (t *handshakeTransport) readLoop() { |
||||
for { |
||||
p, err := t.readOnePacket() |
||||
if err != nil { |
||||
t.readError = err |
||||
close(t.incoming) |
||||
break |
||||
} |
||||
if p[0] == msgIgnore || p[0] == msgDebug { |
||||
continue |
||||
} |
||||
t.incoming <- p |
||||
} |
||||
|
||||
// If we can't read, declare the writing part dead too.
|
||||
t.mu.Lock() |
||||
defer t.mu.Unlock() |
||||
if t.writeError == nil { |
||||
t.writeError = t.readError |
||||
} |
||||
t.cond.Broadcast() |
||||
} |
||||
|
||||
func (t *handshakeTransport) readOnePacket() ([]byte, error) { |
||||
if t.readSinceKex > t.config.RekeyThreshold { |
||||
if err := t.requestKeyChange(); err != nil { |
||||
return nil, err |
||||
} |
||||
} |
||||
|
||||
p, err := t.conn.readPacket() |
||||
if err != nil { |
||||
return nil, err |
||||
} |
||||
|
||||
t.readSinceKex += uint64(len(p)) |
||||
if debugHandshake { |
||||
msg, err := decode(p) |
||||
log.Printf("%s got %T %v (%v)", t.id(), msg, msg, err) |
||||
} |
||||
if p[0] != msgKexInit { |
||||
return p, nil |
||||
} |
||||
err = t.enterKeyExchange(p) |
||||
|
||||
t.mu.Lock() |
||||
if err != nil { |
||||
// drop connection
|
||||
t.conn.Close() |
||||
t.writeError = err |
||||
} |
||||
|
||||
if debugHandshake { |
||||
log.Printf("%s exited key exchange, err %v", t.id(), err) |
||||
} |
||||
|
||||
// Unblock writers.
|
||||
t.sentInitMsg = nil |
||||
t.sentInitPacket = nil |
||||
t.cond.Broadcast() |
||||
t.writtenSinceKex = 0 |
||||
t.mu.Unlock() |
||||
|
||||
if err != nil { |
||||
return nil, err |
||||
} |
||||
|
||||
t.readSinceKex = 0 |
||||
return []byte{msgNewKeys}, nil |
||||
} |
||||
|
||||
// sendKexInit sends a key change message, and returns the message
|
||||
// that was sent. After initiating the key change, all writes will be
|
||||
// blocked until the change is done, and a failed key change will
|
||||
// close the underlying transport. This function is safe for
|
||||
// concurrent use by multiple goroutines.
|
||||
func (t *handshakeTransport) sendKexInit() (*kexInitMsg, []byte, error) { |
||||
t.mu.Lock() |
||||
defer t.mu.Unlock() |
||||
return t.sendKexInitLocked() |
||||
} |
||||
|
||||
func (t *handshakeTransport) requestKeyChange() error { |
||||
_, _, err := t.sendKexInit() |
||||
return err |
||||
} |
||||
|
||||
// sendKexInitLocked sends a key change message. t.mu must be locked
|
||||
// while this happens.
|
||||
func (t *handshakeTransport) sendKexInitLocked() (*kexInitMsg, []byte, error) { |
||||
// kexInits may be sent either in response to the other side,
|
||||
// or because our side wants to initiate a key change, so we
|
||||
// may have already sent a kexInit. In that case, don't send a
|
||||
// second kexInit.
|
||||
if t.sentInitMsg != nil { |
||||
return t.sentInitMsg, t.sentInitPacket, nil |
||||
} |
||||
msg := &kexInitMsg{ |
||||
KexAlgos: t.config.KeyExchanges, |
||||
CiphersClientServer: t.config.Ciphers, |
||||
CiphersServerClient: t.config.Ciphers, |
||||
MACsClientServer: t.config.MACs, |
||||
MACsServerClient: t.config.MACs, |
||||
CompressionClientServer: supportedCompressions, |
||||
CompressionServerClient: supportedCompressions, |
||||
} |
||||
io.ReadFull(rand.Reader, msg.Cookie[:]) |
||||
|
||||
if len(t.hostKeys) > 0 { |
||||
for _, k := range t.hostKeys { |
||||
msg.ServerHostKeyAlgos = append( |
||||
msg.ServerHostKeyAlgos, k.PublicKey().Type()) |
||||
} |
||||
} else { |
||||
msg.ServerHostKeyAlgos = t.hostKeyAlgorithms |
||||
} |
||||
packet := Marshal(msg) |
||||
|
||||
// writePacket destroys the contents, so save a copy.
|
||||
packetCopy := make([]byte, len(packet)) |
||||
copy(packetCopy, packet) |
||||
|
||||
if err := t.conn.writePacket(packetCopy); err != nil { |
||||
return nil, nil, err |
||||
} |
||||
|
||||
t.sentInitMsg = msg |
||||
t.sentInitPacket = packet |
||||
return msg, packet, nil |
||||
} |
||||
|
||||
func (t *handshakeTransport) writePacket(p []byte) error { |
||||
t.mu.Lock() |
||||
defer t.mu.Unlock() |
||||
|
||||
if t.writtenSinceKex > t.config.RekeyThreshold { |
||||
t.sendKexInitLocked() |
||||
} |
||||
for t.sentInitMsg != nil && t.writeError == nil { |
||||
t.cond.Wait() |
||||
} |
||||
if t.writeError != nil { |
||||
return t.writeError |
||||
} |
||||
t.writtenSinceKex += uint64(len(p)) |
||||
|
||||
switch p[0] { |
||||
case msgKexInit: |
||||
return errors.New("ssh: only handshakeTransport can send kexInit") |
||||
case msgNewKeys: |
||||
return errors.New("ssh: only handshakeTransport can send newKeys") |
||||
default: |
||||
return t.conn.writePacket(p) |
||||
} |
||||
} |
||||
|
||||
func (t *handshakeTransport) Close() error { |
||||
return t.conn.Close() |
||||
} |
||||
|
||||
// enterKeyExchange runs the key exchange.
|
||||
func (t *handshakeTransport) enterKeyExchange(otherInitPacket []byte) error { |
||||
if debugHandshake { |
||||
log.Printf("%s entered key exchange", t.id()) |
||||
} |
||||
myInit, myInitPacket, err := t.sendKexInit() |
||||
if err != nil { |
||||
return err |
||||
} |
||||
|
||||
otherInit := &kexInitMsg{} |
||||
if err := Unmarshal(otherInitPacket, otherInit); err != nil { |
||||
return err |
||||
} |
||||
|
||||
magics := handshakeMagics{ |
||||
clientVersion: t.clientVersion, |
||||
serverVersion: t.serverVersion, |
||||
clientKexInit: otherInitPacket, |
||||
serverKexInit: myInitPacket, |
||||
} |
||||
|
||||
clientInit := otherInit |
||||
serverInit := myInit |
||||
if len(t.hostKeys) == 0 { |
||||
clientInit = myInit |
||||
serverInit = otherInit |
||||
|
||||
magics.clientKexInit = myInitPacket |
||||
magics.serverKexInit = otherInitPacket |
||||
} |
||||
|
||||
algs, err := findAgreedAlgorithms(clientInit, serverInit) |
||||
if err != nil { |
||||
return err |
||||
} |
||||
|
||||
// We don't send FirstKexFollows, but we handle receiving it.
|
||||
if otherInit.FirstKexFollows && algs.kex != otherInit.KexAlgos[0] { |
||||
// other side sent a kex message for the wrong algorithm,
|
||||
// which we have to ignore.
|
||||
if _, err := t.conn.readPacket(); err != nil { |
||||
return err |
||||
} |
||||
} |
||||
|
||||
kex, ok := kexAlgoMap[algs.kex] |
||||
if !ok { |
||||
return fmt.Errorf("ssh: unexpected key exchange algorithm %v", algs.kex) |
||||
} |
||||
|
||||
var result *kexResult |
||||
if len(t.hostKeys) > 0 { |
||||
result, err = t.server(kex, algs, &magics) |
||||
} else { |
||||
result, err = t.client(kex, algs, &magics) |
||||
} |
||||
|
||||
if err != nil { |
||||
return err |
||||
} |
||||
|
||||
t.conn.prepareKeyChange(algs, result) |
||||
if err = t.conn.writePacket([]byte{msgNewKeys}); err != nil { |
||||
return err |
||||
} |
||||
if packet, err := t.conn.readPacket(); err != nil { |
||||
return err |
||||
} else if packet[0] != msgNewKeys { |
||||
return unexpectedMessageError(msgNewKeys, packet[0]) |
||||
} |
||||
return nil |
||||
} |
||||
|
||||
func (t *handshakeTransport) server(kex kexAlgorithm, algs *algorithms, magics *handshakeMagics) (*kexResult, error) { |
||||
var hostKey Signer |
||||
for _, k := range t.hostKeys { |
||||
if algs.hostKey == k.PublicKey().Type() { |
||||
hostKey = k |
||||
} |
||||
} |
||||
|
||||
r, err := kex.Server(t.conn, t.config.Rand, magics, hostKey) |
||||
return r, err |
||||
} |
||||
|
||||
func (t *handshakeTransport) client(kex kexAlgorithm, algs *algorithms, magics *handshakeMagics) (*kexResult, error) { |
||||
result, err := kex.Client(t.conn, t.config.Rand, magics) |
||||
if err != nil { |
||||
return nil, err |
||||
} |
||||
|
||||
hostKey, err := ParsePublicKey(result.HostKey) |
||||
if err != nil { |
||||
return nil, err |
||||
} |
||||
|
||||
if err := verifyHostKeySignature(hostKey, result); err != nil { |
||||
return nil, err |
||||
} |
||||
|
||||
if t.hostKeyCallback != nil { |
||||
err = t.hostKeyCallback(t.dialAddress, t.remoteAddr, hostKey) |
||||
if err != nil { |
||||
return nil, err |
||||
} |
||||
} |
||||
|
||||
return result, nil |
||||
} |
||||
@ -1,415 +0,0 @@ |
||||
// Copyright 2013 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 ( |
||||
"bytes" |
||||
"crypto/rand" |
||||
"errors" |
||||
"fmt" |
||||
"net" |
||||
"runtime" |
||||
"strings" |
||||
"sync" |
||||
"testing" |
||||
) |
||||
|
||||
type testChecker struct { |
||||
calls []string |
||||
} |
||||
|
||||
func (t *testChecker) Check(dialAddr string, addr net.Addr, key PublicKey) error { |
||||
if dialAddr == "bad" { |
||||
return fmt.Errorf("dialAddr is bad") |
||||
} |
||||
|
||||
if tcpAddr, ok := addr.(*net.TCPAddr); !ok || tcpAddr == nil { |
||||
return fmt.Errorf("testChecker: got %T want *net.TCPAddr", addr) |
||||
} |
||||
|
||||
t.calls = append(t.calls, fmt.Sprintf("%s %v %s %x", dialAddr, addr, key.Type(), key.Marshal())) |
||||
|
||||
return nil |
||||
} |
||||
|
||||
// netPipe is analogous to net.Pipe, but it uses a real net.Conn, and
|
||||
// therefore is buffered (net.Pipe deadlocks if both sides start with
|
||||
// a write.)
|
||||
func netPipe() (net.Conn, net.Conn, error) { |
||||
listener, err := net.Listen("tcp", "127.0.0.1:0") |
||||
if err != nil { |
||||
return nil, nil, err |
||||
} |
||||
defer listener.Close() |
||||
c1, err := net.Dial("tcp", listener.Addr().String()) |
||||
if err != nil { |
||||
return nil, nil, err |
||||
} |
||||
|
||||
c2, err := listener.Accept() |
||||
if err != nil { |
||||
c1.Close() |
||||
return nil, nil, err |
||||
} |
||||
|
||||
return c1, c2, nil |
||||
} |
||||
|
||||
func handshakePair(clientConf *ClientConfig, addr string) (client *handshakeTransport, server *handshakeTransport, err error) { |
||||
a, b, err := netPipe() |
||||
if err != nil { |
||||
return nil, nil, err |
||||
} |
||||
|
||||
trC := newTransport(a, rand.Reader, true) |
||||
trS := newTransport(b, rand.Reader, false) |
||||
clientConf.SetDefaults() |
||||
|
||||
v := []byte("version") |
||||
client = newClientTransport(trC, v, v, clientConf, addr, a.RemoteAddr()) |
||||
|
||||
serverConf := &ServerConfig{} |
||||
serverConf.AddHostKey(testSigners["ecdsa"]) |
||||
serverConf.AddHostKey(testSigners["rsa"]) |
||||
serverConf.SetDefaults() |
||||
server = newServerTransport(trS, v, v, serverConf) |
||||
|
||||
return client, server, nil |
||||
} |
||||
|
||||
func TestHandshakeBasic(t *testing.T) { |
||||
if runtime.GOOS == "plan9" { |
||||
t.Skip("see golang.org/issue/7237") |
||||
} |
||||
checker := &testChecker{} |
||||
trC, trS, err := handshakePair(&ClientConfig{HostKeyCallback: checker.Check}, "addr") |
||||
if err != nil { |
||||
t.Fatalf("handshakePair: %v", err) |
||||
} |
||||
|
||||
defer trC.Close() |
||||
defer trS.Close() |
||||
|
||||
go func() { |
||||
// Client writes a bunch of stuff, and does a key
|
||||
// change in the middle. This should not confuse the
|
||||
// handshake in progress
|
||||
for i := 0; i < 10; i++ { |
||||
p := []byte{msgRequestSuccess, byte(i)} |
||||
if err := trC.writePacket(p); err != nil { |
||||
t.Fatalf("sendPacket: %v", err) |
||||
} |
||||
if i == 5 { |
||||
// halfway through, we request a key change.
|
||||
_, _, err := trC.sendKexInit() |
||||
if err != nil { |
||||
t.Fatalf("sendKexInit: %v", err) |
||||
} |
||||
} |
||||
} |
||||
trC.Close() |
||||
}() |
||||
|
||||
// Server checks that client messages come in cleanly
|
||||
i := 0 |
||||
for { |
||||
p, err := trS.readPacket() |
||||
if err != nil { |
||||
break |
||||
} |
||||
if p[0] == msgNewKeys { |
||||
continue |
||||
} |
||||
want := []byte{msgRequestSuccess, byte(i)} |
||||
if bytes.Compare(p, want) != 0 { |
||||
t.Errorf("message %d: got %q, want %q", i, p, want) |
||||
} |
||||
i++ |
||||
} |
||||
if i != 10 { |
||||
t.Errorf("received %d messages, want 10.", i) |
||||
} |
||||
|
||||
// If all went well, we registered exactly 1 key change.
|
||||
if len(checker.calls) != 1 { |
||||
t.Fatalf("got %d host key checks, want 1", len(checker.calls)) |
||||
} |
||||
|
||||
pub := testSigners["ecdsa"].PublicKey() |
||||
want := fmt.Sprintf("%s %v %s %x", "addr", trC.remoteAddr, pub.Type(), pub.Marshal()) |
||||
if want != checker.calls[0] { |
||||
t.Errorf("got %q want %q for host key check", checker.calls[0], want) |
||||
} |
||||
} |
||||
|
||||
func TestHandshakeError(t *testing.T) { |
||||
checker := &testChecker{} |
||||
trC, trS, err := handshakePair(&ClientConfig{HostKeyCallback: checker.Check}, "bad") |
||||
if err != nil { |
||||
t.Fatalf("handshakePair: %v", err) |
||||
} |
||||
defer trC.Close() |
||||
defer trS.Close() |
||||
|
||||
// send a packet
|
||||
packet := []byte{msgRequestSuccess, 42} |
||||
if err := trC.writePacket(packet); err != nil { |
||||
t.Errorf("writePacket: %v", err) |
||||
} |
||||
|
||||
// Now request a key change.
|
||||
_, _, err = trC.sendKexInit() |
||||
if err != nil { |
||||
t.Errorf("sendKexInit: %v", err) |
||||
} |
||||
|
||||
// the key change will fail, and afterwards we can't write.
|
||||
if err := trC.writePacket([]byte{msgRequestSuccess, 43}); err == nil { |
||||
t.Errorf("writePacket after botched rekey succeeded.") |
||||
} |
||||
|
||||
readback, err := trS.readPacket() |
||||
if err != nil { |
||||
t.Fatalf("server closed too soon: %v", err) |
||||
} |
||||
if bytes.Compare(readback, packet) != 0 { |
||||
t.Errorf("got %q want %q", readback, packet) |
||||
} |
||||
readback, err = trS.readPacket() |
||||
if err == nil { |
||||
t.Errorf("got a message %q after failed key change", readback) |
||||
} |
||||
} |
||||
|
||||
func TestHandshakeTwice(t *testing.T) { |
||||
checker := &testChecker{} |
||||
trC, trS, err := handshakePair(&ClientConfig{HostKeyCallback: checker.Check}, "addr") |
||||
if err != nil { |
||||
t.Fatalf("handshakePair: %v", err) |
||||
} |
||||
|
||||
defer trC.Close() |
||||
defer trS.Close() |
||||
|
||||
// send a packet
|
||||
packet := make([]byte, 5) |
||||
packet[0] = msgRequestSuccess |
||||
if err := trC.writePacket(packet); err != nil { |
||||
t.Errorf("writePacket: %v", err) |
||||
} |
||||
|
||||
// Now request a key change.
|
||||
_, _, err = trC.sendKexInit() |
||||
if err != nil { |
||||
t.Errorf("sendKexInit: %v", err) |
||||
} |
||||
|
||||
// Send another packet. Use a fresh one, since writePacket destroys.
|
||||
packet = make([]byte, 5) |
||||
packet[0] = msgRequestSuccess |
||||
if err := trC.writePacket(packet); err != nil { |
||||
t.Errorf("writePacket: %v", err) |
||||
} |
||||
|
||||
// 2nd key change.
|
||||
_, _, err = trC.sendKexInit() |
||||
if err != nil { |
||||
t.Errorf("sendKexInit: %v", err) |
||||
} |
||||
|
||||
packet = make([]byte, 5) |
||||
packet[0] = msgRequestSuccess |
||||
if err := trC.writePacket(packet); err != nil { |
||||
t.Errorf("writePacket: %v", err) |
||||
} |
||||
|
||||
packet = make([]byte, 5) |
||||
packet[0] = msgRequestSuccess |
||||
for i := 0; i < 5; i++ { |
||||
msg, err := trS.readPacket() |
||||
if err != nil { |
||||
t.Fatalf("server closed too soon: %v", err) |
||||
} |
||||
if msg[0] == msgNewKeys { |
||||
continue |
||||
} |
||||
|
||||
if bytes.Compare(msg, packet) != 0 { |
||||
t.Errorf("packet %d: got %q want %q", i, msg, packet) |
||||
} |
||||
} |
||||
if len(checker.calls) != 2 { |
||||
t.Errorf("got %d key changes, want 2", len(checker.calls)) |
||||
} |
||||
} |
||||
|
||||
func TestHandshakeAutoRekeyWrite(t *testing.T) { |
||||
checker := &testChecker{} |
||||
clientConf := &ClientConfig{HostKeyCallback: checker.Check} |
||||
clientConf.RekeyThreshold = 500 |
||||
trC, trS, err := handshakePair(clientConf, "addr") |
||||
if err != nil { |
||||
t.Fatalf("handshakePair: %v", err) |
||||
} |
||||
defer trC.Close() |
||||
defer trS.Close() |
||||
|
||||
for i := 0; i < 5; i++ { |
||||
packet := make([]byte, 251) |
||||
packet[0] = msgRequestSuccess |
||||
if err := trC.writePacket(packet); err != nil { |
||||
t.Errorf("writePacket: %v", err) |
||||
} |
||||
} |
||||
|
||||
j := 0 |
||||
for ; j < 5; j++ { |
||||
_, err := trS.readPacket() |
||||
if err != nil { |
||||
break |
||||
} |
||||
} |
||||
|
||||
if j != 5 { |
||||
t.Errorf("got %d, want 5 messages", j) |
||||
} |
||||
|
||||
if len(checker.calls) != 2 { |
||||
t.Errorf("got %d key changes, wanted 2", len(checker.calls)) |
||||
} |
||||
} |
||||
|
||||
type syncChecker struct { |
||||
called chan int |
||||
} |
||||
|
||||
func (t *syncChecker) Check(dialAddr string, addr net.Addr, key PublicKey) error { |
||||
t.called <- 1 |
||||
return nil |
||||
} |
||||
|
||||
func TestHandshakeAutoRekeyRead(t *testing.T) { |
||||
sync := &syncChecker{make(chan int, 2)} |
||||
clientConf := &ClientConfig{ |
||||
HostKeyCallback: sync.Check, |
||||
} |
||||
clientConf.RekeyThreshold = 500 |
||||
|
||||
trC, trS, err := handshakePair(clientConf, "addr") |
||||
if err != nil { |
||||
t.Fatalf("handshakePair: %v", err) |
||||
} |
||||
defer trC.Close() |
||||
defer trS.Close() |
||||
|
||||
packet := make([]byte, 501) |
||||
packet[0] = msgRequestSuccess |
||||
if err := trS.writePacket(packet); err != nil { |
||||
t.Fatalf("writePacket: %v", err) |
||||
} |
||||
// While we read out the packet, a key change will be
|
||||
// initiated.
|
||||
if _, err := trC.readPacket(); err != nil { |
||||
t.Fatalf("readPacket(client): %v", err) |
||||
} |
||||
|
||||
<-sync.called |
||||
} |
||||
|
||||
// errorKeyingTransport generates errors after a given number of
|
||||
// read/write operations.
|
||||
type errorKeyingTransport struct { |
||||
packetConn |
||||
readLeft, writeLeft int |
||||
} |
||||
|
||||
func (n *errorKeyingTransport) prepareKeyChange(*algorithms, *kexResult) error { |
||||
return nil |
||||
} |
||||
func (n *errorKeyingTransport) getSessionID() []byte { |
||||
return nil |
||||
} |
||||
|
||||
func (n *errorKeyingTransport) writePacket(packet []byte) error { |
||||
if n.writeLeft == 0 { |
||||
n.Close() |
||||
return errors.New("barf") |
||||
} |
||||
|
||||
n.writeLeft-- |
||||
return n.packetConn.writePacket(packet) |
||||
} |
||||
|
||||
func (n *errorKeyingTransport) readPacket() ([]byte, error) { |
||||
if n.readLeft == 0 { |
||||
n.Close() |
||||
return nil, errors.New("barf") |
||||
} |
||||
|
||||
n.readLeft-- |
||||
return n.packetConn.readPacket() |
||||
} |
||||
|
||||
func TestHandshakeErrorHandlingRead(t *testing.T) { |
||||
for i := 0; i < 20; i++ { |
||||
testHandshakeErrorHandlingN(t, i, -1) |
||||
} |
||||
} |
||||
|
||||
func TestHandshakeErrorHandlingWrite(t *testing.T) { |
||||
for i := 0; i < 20; i++ { |
||||
testHandshakeErrorHandlingN(t, -1, i) |
||||
} |
||||
} |
||||
|
||||
// testHandshakeErrorHandlingN runs handshakes, injecting errors. If
|
||||
// handshakeTransport deadlocks, the go runtime will detect it and
|
||||
// panic.
|
||||
func testHandshakeErrorHandlingN(t *testing.T, readLimit, writeLimit int) { |
||||
msg := Marshal(&serviceRequestMsg{strings.Repeat("x", int(minRekeyThreshold)/4)}) |
||||
|
||||
a, b := memPipe() |
||||
defer a.Close() |
||||
defer b.Close() |
||||
|
||||
key := testSigners["ecdsa"] |
||||
serverConf := Config{RekeyThreshold: minRekeyThreshold} |
||||
serverConf.SetDefaults() |
||||
serverConn := newHandshakeTransport(&errorKeyingTransport{a, readLimit, writeLimit}, &serverConf, []byte{'a'}, []byte{'b'}) |
||||
serverConn.hostKeys = []Signer{key} |
||||
go serverConn.readLoop() |
||||
|
||||
clientConf := Config{RekeyThreshold: 10 * minRekeyThreshold} |
||||
clientConf.SetDefaults() |
||||
clientConn := newHandshakeTransport(&errorKeyingTransport{b, -1, -1}, &clientConf, []byte{'a'}, []byte{'b'}) |
||||
clientConn.hostKeyAlgorithms = []string{key.PublicKey().Type()} |
||||
go clientConn.readLoop() |
||||
|
||||
var wg sync.WaitGroup |
||||
wg.Add(4) |
||||
|
||||
for _, hs := range []packetConn{serverConn, clientConn} { |
||||
go func(c packetConn) { |
||||
for { |
||||
err := c.writePacket(msg) |
||||
if err != nil { |
||||
break |
||||
} |
||||
} |
||||
wg.Done() |
||||
}(hs) |
||||
go func(c packetConn) { |
||||
for { |
||||
_, err := c.readPacket() |
||||
if err != nil { |
||||
break |
||||
} |
||||
} |
||||
wg.Done() |
||||
}(hs) |
||||
} |
||||
|
||||
wg.Wait() |
||||
} |
||||
@ -1,526 +0,0 @@ |
||||
// Copyright 2013 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/ecdsa" |
||||
"crypto/elliptic" |
||||
"crypto/subtle" |
||||
"crypto/rand" |
||||
"errors" |
||||
"io" |
||||
"math/big" |
||||
|
||||
"golang.org/x/crypto/curve25519" |
||||
) |
||||
|
||||
const ( |
||||
kexAlgoDH1SHA1 = "diffie-hellman-group1-sha1" |
||||
kexAlgoDH14SHA1 = "diffie-hellman-group14-sha1" |
||||
kexAlgoECDH256 = "ecdh-sha2-nistp256" |
||||
kexAlgoECDH384 = "ecdh-sha2-nistp384" |
||||
kexAlgoECDH521 = "ecdh-sha2-nistp521" |
||||
kexAlgoCurve25519SHA256 = "curve25519-sha256@libssh.org" |
||||
) |
||||
|
||||
// kexResult captures the outcome of a key exchange.
|
||||
type kexResult struct { |
||||
// Session hash. See also RFC 4253, section 8.
|
||||
H []byte |
||||
|
||||
// Shared secret. See also RFC 4253, section 8.
|
||||
K []byte |
||||
|
||||
// Host key as hashed into H.
|
||||
HostKey []byte |
||||
|
||||
// Signature of H.
|
||||
Signature []byte |
||||
|
||||
// A cryptographic hash function that matches the security
|
||||
// level of the key exchange algorithm. It is used for
|
||||
// calculating H, and for deriving keys from H and K.
|
||||
Hash crypto.Hash |
||||
|
||||
// The session ID, which is the first H computed. This is used
|
||||
// to signal data inside transport.
|
||||
SessionID []byte |
||||
} |
||||
|
||||
// handshakeMagics contains data that is always included in the
|
||||
// session hash.
|
||||
type handshakeMagics struct { |
||||
clientVersion, serverVersion []byte |
||||
clientKexInit, serverKexInit []byte |
||||
} |
||||
|
||||
func (m *handshakeMagics) write(w io.Writer) { |
||||
writeString(w, m.clientVersion) |
||||
writeString(w, m.serverVersion) |
||||
writeString(w, m.clientKexInit) |
||||
writeString(w, m.serverKexInit) |
||||
} |
||||
|
||||
// kexAlgorithm abstracts different key exchange algorithms.
|
||||
type kexAlgorithm interface { |
||||
// Server runs server-side key agreement, signing the result
|
||||
// with a hostkey.
|
||||
Server(p packetConn, rand io.Reader, magics *handshakeMagics, s Signer) (*kexResult, error) |
||||
|
||||
// Client runs the client-side key agreement. Caller is
|
||||
// responsible for verifying the host key signature.
|
||||
Client(p packetConn, rand io.Reader, magics *handshakeMagics) (*kexResult, error) |
||||
} |
||||
|
||||
// dhGroup is a multiplicative group suitable for implementing Diffie-Hellman key agreement.
|
||||
type dhGroup struct { |
||||
g, p *big.Int |
||||
} |
||||
|
||||
func (group *dhGroup) diffieHellman(theirPublic, myPrivate *big.Int) (*big.Int, error) { |
||||
if theirPublic.Sign() <= 0 || theirPublic.Cmp(group.p) >= 0 { |
||||
return nil, errors.New("ssh: DH parameter out of bounds") |
||||
} |
||||
return new(big.Int).Exp(theirPublic, myPrivate, group.p), nil |
||||
} |
||||
|
||||
func (group *dhGroup) Client(c packetConn, randSource io.Reader, magics *handshakeMagics) (*kexResult, error) { |
||||
hashFunc := crypto.SHA1 |
||||
|
||||
x, err := rand.Int(randSource, group.p) |
||||
if err != nil { |
||||
return nil, err |
||||
} |
||||
X := new(big.Int).Exp(group.g, x, group.p) |
||||
kexDHInit := kexDHInitMsg{ |
||||
X: X, |
||||
} |
||||
if err := c.writePacket(Marshal(&kexDHInit)); err != nil { |
||||
return nil, err |
||||
} |
||||
|
||||
packet, err := c.readPacket() |
||||
if err != nil { |
||||
return nil, err |
||||
} |
||||
|
||||
var kexDHReply kexDHReplyMsg |
||||
if err = Unmarshal(packet, &kexDHReply); err != nil { |
||||
return nil, err |
||||
} |
||||
|
||||
kInt, err := group.diffieHellman(kexDHReply.Y, x) |
||||
if err != nil { |
||||
return nil, err |
||||
} |
||||
|
||||
h := hashFunc.New() |
||||
magics.write(h) |
||||
writeString(h, kexDHReply.HostKey) |
||||
writeInt(h, X) |
||||
writeInt(h, kexDHReply.Y) |
||||
K := make([]byte, intLength(kInt)) |
||||
marshalInt(K, kInt) |
||||
h.Write(K) |
||||
|
||||
return &kexResult{ |
||||
H: h.Sum(nil), |
||||
K: K, |
||||
HostKey: kexDHReply.HostKey, |
||||
Signature: kexDHReply.Signature, |
||||
Hash: crypto.SHA1, |
||||
}, nil |
||||
} |
||||
|
||||
func (group *dhGroup) Server(c packetConn, randSource io.Reader, magics *handshakeMagics, priv Signer) (result *kexResult, err error) { |
||||
hashFunc := crypto.SHA1 |
||||
packet, err := c.readPacket() |
||||
if err != nil { |
||||
return |
||||
} |
||||
var kexDHInit kexDHInitMsg |
||||
if err = Unmarshal(packet, &kexDHInit); err != nil { |
||||
return |
||||
} |
||||
|
||||
y, err := rand.Int(randSource, group.p) |
||||
if err != nil { |
||||
return |
||||
} |
||||
|
||||
Y := new(big.Int).Exp(group.g, y, group.p) |
||||
kInt, err := group.diffieHellman(kexDHInit.X, y) |
||||
if err != nil { |
||||
return nil, err |
||||
} |
||||
|
||||
hostKeyBytes := priv.PublicKey().Marshal() |
||||
|
||||
h := hashFunc.New() |
||||
magics.write(h) |
||||
writeString(h, hostKeyBytes) |
||||
writeInt(h, kexDHInit.X) |
||||
writeInt(h, Y) |
||||
|
||||
K := make([]byte, intLength(kInt)) |
||||
marshalInt(K, kInt) |
||||
h.Write(K) |
||||
|
||||
H := h.Sum(nil) |
||||
|
||||
// H is already a hash, but the hostkey signing will apply its
|
||||
// own key-specific hash algorithm.
|
||||
sig, err := signAndMarshal(priv, randSource, H) |
||||
if err != nil { |
||||
return nil, err |
||||
} |
||||
|
||||
kexDHReply := kexDHReplyMsg{ |
||||
HostKey: hostKeyBytes, |
||||
Y: Y, |
||||
Signature: sig, |
||||
} |
||||
packet = Marshal(&kexDHReply) |
||||
|
||||
err = c.writePacket(packet) |
||||
return &kexResult{ |
||||
H: H, |
||||
K: K, |
||||
HostKey: hostKeyBytes, |
||||
Signature: sig, |
||||
Hash: crypto.SHA1, |
||||
}, nil |
||||
} |
||||
|
||||
// ecdh performs Elliptic Curve Diffie-Hellman key exchange as
|
||||
// described in RFC 5656, section 4.
|
||||
type ecdh struct { |
||||
curve elliptic.Curve |
||||
} |
||||
|
||||
func (kex *ecdh) Client(c packetConn, rand io.Reader, magics *handshakeMagics) (*kexResult, error) { |
||||
ephKey, err := ecdsa.GenerateKey(kex.curve, rand) |
||||
if err != nil { |
||||
return nil, err |
||||
} |
||||
|
||||
kexInit := kexECDHInitMsg{ |
||||
ClientPubKey: elliptic.Marshal(kex.curve, ephKey.PublicKey.X, ephKey.PublicKey.Y), |
||||
} |
||||
|
||||
serialized := Marshal(&kexInit) |
||||
if err := c.writePacket(serialized); err != nil { |
||||
return nil, err |
||||
} |
||||
|
||||
packet, err := c.readPacket() |
||||
if err != nil { |
||||
return nil, err |
||||
} |
||||
|
||||
var reply kexECDHReplyMsg |
||||
if err = Unmarshal(packet, &reply); err != nil { |
||||
return nil, err |
||||
} |
||||
|
||||
x, y, err := unmarshalECKey(kex.curve, reply.EphemeralPubKey) |
||||
if err != nil { |
||||
return nil, err |
||||
} |
||||
|
||||
// generate shared secret
|
||||
secret, _ := kex.curve.ScalarMult(x, y, ephKey.D.Bytes()) |
||||
|
||||
h := ecHash(kex.curve).New() |
||||
magics.write(h) |
||||
writeString(h, reply.HostKey) |
||||
writeString(h, kexInit.ClientPubKey) |
||||
writeString(h, reply.EphemeralPubKey) |
||||
K := make([]byte, intLength(secret)) |
||||
marshalInt(K, secret) |
||||
h.Write(K) |
||||
|
||||
return &kexResult{ |
||||
H: h.Sum(nil), |
||||
K: K, |
||||
HostKey: reply.HostKey, |
||||
Signature: reply.Signature, |
||||
Hash: ecHash(kex.curve), |
||||
}, nil |
||||
} |
||||
|
||||
// unmarshalECKey parses and checks an EC key.
|
||||
func unmarshalECKey(curve elliptic.Curve, pubkey []byte) (x, y *big.Int, err error) { |
||||
x, y = elliptic.Unmarshal(curve, pubkey) |
||||
if x == nil { |
||||
return nil, nil, errors.New("ssh: elliptic.Unmarshal failure") |
||||
} |
||||
if !validateECPublicKey(curve, x, y) { |
||||
return nil, nil, errors.New("ssh: public key not on curve") |
||||
} |
||||
return x, y, nil |
||||
} |
||||
|
||||
// validateECPublicKey checks that the point is a valid public key for
|
||||
// the given curve. See [SEC1], 3.2.2
|
||||
func validateECPublicKey(curve elliptic.Curve, x, y *big.Int) bool { |
||||
if x.Sign() == 0 && y.Sign() == 0 { |
||||
return false |
||||
} |
||||
|
||||
if x.Cmp(curve.Params().P) >= 0 { |
||||
return false |
||||
} |
||||
|
||||
if y.Cmp(curve.Params().P) >= 0 { |
||||
return false |
||||
} |
||||
|
||||
if !curve.IsOnCurve(x, y) { |
||||
return false |
||||
} |
||||
|
||||
// We don't check if N * PubKey == 0, since
|
||||
//
|
||||
// - the NIST curves have cofactor = 1, so this is implicit.
|
||||
// (We don't foresee an implementation that supports non NIST
|
||||
// curves)
|
||||
//
|
||||
// - for ephemeral keys, we don't need to worry about small
|
||||
// subgroup attacks.
|
||||
return true |
||||
} |
||||
|
||||
func (kex *ecdh) Server(c packetConn, rand io.Reader, magics *handshakeMagics, priv Signer) (result *kexResult, err error) { |
||||
packet, err := c.readPacket() |
||||
if err != nil { |
||||
return nil, err |
||||
} |
||||
|
||||
var kexECDHInit kexECDHInitMsg |
||||
if err = Unmarshal(packet, &kexECDHInit); err != nil { |
||||
return nil, err |
||||
} |
||||
|
||||
clientX, clientY, err := unmarshalECKey(kex.curve, kexECDHInit.ClientPubKey) |
||||
if err != nil { |
||||
return nil, err |
||||
} |
||||
|
||||
// We could cache this key across multiple users/multiple
|
||||
// connection attempts, but the benefit is small. OpenSSH
|
||||
// generates a new key for each incoming connection.
|
||||
ephKey, err := ecdsa.GenerateKey(kex.curve, rand) |
||||
if err != nil { |
||||
return nil, err |
||||
} |
||||
|
||||
hostKeyBytes := priv.PublicKey().Marshal() |
||||
|
||||
serializedEphKey := elliptic.Marshal(kex.curve, ephKey.PublicKey.X, ephKey.PublicKey.Y) |
||||
|
||||
// generate shared secret
|
||||
secret, _ := kex.curve.ScalarMult(clientX, clientY, ephKey.D.Bytes()) |
||||
|
||||
h := ecHash(kex.curve).New() |
||||
magics.write(h) |
||||
writeString(h, hostKeyBytes) |
||||
writeString(h, kexECDHInit.ClientPubKey) |
||||
writeString(h, serializedEphKey) |
||||
|
||||
K := make([]byte, intLength(secret)) |
||||
marshalInt(K, secret) |
||||
h.Write(K) |
||||
|
||||
H := h.Sum(nil) |
||||
|
||||
// H is already a hash, but the hostkey signing will apply its
|
||||
// own key-specific hash algorithm.
|
||||
sig, err := signAndMarshal(priv, rand, H) |
||||
if err != nil { |
||||
return nil, err |
||||
} |
||||
|
||||
reply := kexECDHReplyMsg{ |
||||
EphemeralPubKey: serializedEphKey, |
||||
HostKey: hostKeyBytes, |
||||
Signature: sig, |
||||
} |
||||
|
||||
serialized := Marshal(&reply) |
||||
if err := c.writePacket(serialized); err != nil { |
||||
return nil, err |
||||
} |
||||
|
||||
return &kexResult{ |
||||
H: H, |
||||
K: K, |
||||
HostKey: reply.HostKey, |
||||
Signature: sig, |
||||
Hash: ecHash(kex.curve), |
||||
}, nil |
||||
} |
||||
|
||||
var kexAlgoMap = map[string]kexAlgorithm{} |
||||
|
||||
func init() { |
||||
// This is the group called diffie-hellman-group1-sha1 in RFC
|
||||
// 4253 and Oakley Group 2 in RFC 2409.
|
||||
p, _ := new(big.Int).SetString("FFFFFFFFFFFFFFFFC90FDAA22168C234C4C6628B80DC1CD129024E088A67CC74020BBEA63B139B22514A08798E3404DDEF9519B3CD3A431B302B0A6DF25F14374FE1356D6D51C245E485B576625E7EC6F44C42E9A637ED6B0BFF5CB6F406B7EDEE386BFB5A899FA5AE9F24117C4B1FE649286651ECE65381FFFFFFFFFFFFFFFF", 16) |
||||
kexAlgoMap[kexAlgoDH1SHA1] = &dhGroup{ |
||||
g: new(big.Int).SetInt64(2), |
||||
p: p, |
||||
} |
||||
|
||||
// This is the group called diffie-hellman-group14-sha1 in RFC
|
||||
// 4253 and Oakley Group 14 in RFC 3526.
|
||||
p, _ = new(big.Int).SetString("FFFFFFFFFFFFFFFFC90FDAA22168C234C4C6628B80DC1CD129024E088A67CC74020BBEA63B139B22514A08798E3404DDEF9519B3CD3A431B302B0A6DF25F14374FE1356D6D51C245E485B576625E7EC6F44C42E9A637ED6B0BFF5CB6F406B7EDEE386BFB5A899FA5AE9F24117C4B1FE649286651ECE45B3DC2007CB8A163BF0598DA48361C55D39A69163FA8FD24CF5F83655D23DCA3AD961C62F356208552BB9ED529077096966D670C354E4ABC9804F1746C08CA18217C32905E462E36CE3BE39E772C180E86039B2783A2EC07A28FB5C55DF06F4C52C9DE2BCBF6955817183995497CEA956AE515D2261898FA051015728E5A8AACAA68FFFFFFFFFFFFFFFF", 16) |
||||
|
||||
kexAlgoMap[kexAlgoDH14SHA1] = &dhGroup{ |
||||
g: new(big.Int).SetInt64(2), |
||||
p: p, |
||||
} |
||||
|
||||
kexAlgoMap[kexAlgoECDH521] = &ecdh{elliptic.P521()} |
||||
kexAlgoMap[kexAlgoECDH384] = &ecdh{elliptic.P384()} |
||||
kexAlgoMap[kexAlgoECDH256] = &ecdh{elliptic.P256()} |
||||
kexAlgoMap[kexAlgoCurve25519SHA256] = &curve25519sha256{} |
||||
} |
||||
|
||||
// curve25519sha256 implements the curve25519-sha256@libssh.org key
|
||||
// agreement protocol, as described in
|
||||
// https://git.libssh.org/projects/libssh.git/tree/doc/curve25519-sha256@libssh.org.txt
|
||||
type curve25519sha256 struct{} |
||||
|
||||
type curve25519KeyPair struct { |
||||
priv [32]byte |
||||
pub [32]byte |
||||
} |
||||
|
||||
func (kp *curve25519KeyPair) generate(rand io.Reader) error { |
||||
if _, err := io.ReadFull(rand, kp.priv[:]); err != nil { |
||||
return err |
||||
} |
||||
curve25519.ScalarBaseMult(&kp.pub, &kp.priv) |
||||
return nil |
||||
} |
||||
|
||||
// curve25519Zeros is just an array of 32 zero bytes so that we have something
|
||||
// convenient to compare against in order to reject curve25519 points with the
|
||||
// wrong order.
|
||||
var curve25519Zeros [32]byte |
||||
|
||||
func (kex *curve25519sha256) Client(c packetConn, rand io.Reader, magics *handshakeMagics) (*kexResult, error) { |
||||
var kp curve25519KeyPair |
||||
if err := kp.generate(rand); err != nil { |
||||
return nil, err |
||||
} |
||||
if err := c.writePacket(Marshal(&kexECDHInitMsg{kp.pub[:]})); err != nil { |
||||
return nil, err |
||||
} |
||||
|
||||
packet, err := c.readPacket() |
||||
if err != nil { |
||||
return nil, err |
||||
} |
||||
|
||||
var reply kexECDHReplyMsg |
||||
if err = Unmarshal(packet, &reply); err != nil { |
||||
return nil, err |
||||
} |
||||
if len(reply.EphemeralPubKey) != 32 { |
||||
return nil, errors.New("ssh: peer's curve25519 public value has wrong length") |
||||
} |
||||
|
||||
var servPub, secret [32]byte |
||||
copy(servPub[:], reply.EphemeralPubKey) |
||||
curve25519.ScalarMult(&secret, &kp.priv, &servPub) |
||||
if subtle.ConstantTimeCompare(secret[:], curve25519Zeros[:]) == 1 { |
||||
return nil, errors.New("ssh: peer's curve25519 public value has wrong order") |
||||
} |
||||
|
||||
h := crypto.SHA256.New() |
||||
magics.write(h) |
||||
writeString(h, reply.HostKey) |
||||
writeString(h, kp.pub[:]) |
||||
writeString(h, reply.EphemeralPubKey) |
||||
|
||||
kInt := new(big.Int).SetBytes(secret[:]) |
||||
K := make([]byte, intLength(kInt)) |
||||
marshalInt(K, kInt) |
||||
h.Write(K) |
||||
|
||||
return &kexResult{ |
||||
H: h.Sum(nil), |
||||
K: K, |
||||
HostKey: reply.HostKey, |
||||
Signature: reply.Signature, |
||||
Hash: crypto.SHA256, |
||||
}, nil |
||||
} |
||||
|
||||
func (kex *curve25519sha256) Server(c packetConn, rand io.Reader, magics *handshakeMagics, priv Signer) (result *kexResult, err error) { |
||||
packet, err := c.readPacket() |
||||
if err != nil { |
||||
return |
||||
} |
||||
var kexInit kexECDHInitMsg |
||||
if err = Unmarshal(packet, &kexInit); err != nil { |
||||
return |
||||
} |
||||
|
||||
if len(kexInit.ClientPubKey) != 32 { |
||||
return nil, errors.New("ssh: peer's curve25519 public value has wrong length") |
||||
} |
||||
|
||||
var kp curve25519KeyPair |
||||
if err := kp.generate(rand); err != nil { |
||||
return nil, err |
||||
} |
||||
|
||||
var clientPub, secret [32]byte |
||||
copy(clientPub[:], kexInit.ClientPubKey) |
||||
curve25519.ScalarMult(&secret, &kp.priv, &clientPub) |
||||
if subtle.ConstantTimeCompare(secret[:], curve25519Zeros[:]) == 1 { |
||||
return nil, errors.New("ssh: peer's curve25519 public value has wrong order") |
||||
} |
||||
|
||||
hostKeyBytes := priv.PublicKey().Marshal() |
||||
|
||||
h := crypto.SHA256.New() |
||||
magics.write(h) |
||||
writeString(h, hostKeyBytes) |
||||
writeString(h, kexInit.ClientPubKey) |
||||
writeString(h, kp.pub[:]) |
||||
|
||||
kInt := new(big.Int).SetBytes(secret[:]) |
||||
K := make([]byte, intLength(kInt)) |
||||
marshalInt(K, kInt) |
||||
h.Write(K) |
||||
|
||||
H := h.Sum(nil) |
||||
|
||||
sig, err := signAndMarshal(priv, rand, H) |
||||
if err != nil { |
||||
return nil, err |
||||
} |
||||
|
||||
reply := kexECDHReplyMsg{ |
||||
EphemeralPubKey: kp.pub[:], |
||||
HostKey: hostKeyBytes, |
||||
Signature: sig, |
||||
} |
||||
if err := c.writePacket(Marshal(&reply)); err != nil { |
||||
return nil, err |
||||
} |
||||
return &kexResult{ |
||||
H: H, |
||||
K: K, |
||||
HostKey: hostKeyBytes, |
||||
Signature: sig, |
||||
Hash: crypto.SHA256, |
||||
}, nil |
||||
} |
||||
@ -1,50 +0,0 @@ |
||||
// Copyright 2013 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 |
||||
|
||||
// Key exchange tests.
|
||||
|
||||
import ( |
||||
"crypto/rand" |
||||
"reflect" |
||||
"testing" |
||||
) |
||||
|
||||
func TestKexes(t *testing.T) { |
||||
type kexResultErr struct { |
||||
result *kexResult |
||||
err error |
||||
} |
||||
|
||||
for name, kex := range kexAlgoMap { |
||||
a, b := memPipe() |
||||
|
||||
s := make(chan kexResultErr, 1) |
||||
c := make(chan kexResultErr, 1) |
||||
var magics handshakeMagics |
||||
go func() { |
||||
r, e := kex.Client(a, rand.Reader, &magics) |
||||
a.Close() |
||||
c <- kexResultErr{r, e} |
||||
}() |
||||
go func() { |
||||
r, e := kex.Server(b, rand.Reader, &magics, testSigners["ecdsa"]) |
||||
b.Close() |
||||
s <- kexResultErr{r, e} |
||||
}() |
||||
|
||||
clientRes := <-c |
||||
serverRes := <-s |
||||
if clientRes.err != nil { |
||||
t.Errorf("client: %v", clientRes.err) |
||||
} |
||||
if serverRes.err != nil { |
||||
t.Errorf("server: %v", serverRes.err) |
||||
} |
||||
if !reflect.DeepEqual(clientRes.result, serverRes.result) { |
||||
t.Errorf("kex %q: mismatch %#v, %#v", name, clientRes.result, serverRes.result) |
||||
} |
||||
} |
||||
} |
||||
@ -1,628 +0,0 @@ |
||||
// Copyright 2012 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 ( |
||||
"bytes" |
||||
"crypto" |
||||
"crypto/dsa" |
||||
"crypto/ecdsa" |
||||
"crypto/elliptic" |
||||
"crypto/rsa" |
||||
"crypto/x509" |
||||
"encoding/asn1" |
||||
"encoding/base64" |
||||
"encoding/pem" |
||||
"errors" |
||||
"fmt" |
||||
"io" |
||||
"math/big" |
||||
) |
||||
|
||||
// These constants represent the algorithm names for key types supported by this
|
||||
// package.
|
||||
const ( |
||||
KeyAlgoRSA = "ssh-rsa" |
||||
KeyAlgoDSA = "ssh-dss" |
||||
KeyAlgoECDSA256 = "ecdsa-sha2-nistp256" |
||||
KeyAlgoECDSA384 = "ecdsa-sha2-nistp384" |
||||
KeyAlgoECDSA521 = "ecdsa-sha2-nistp521" |
||||
) |
||||
|
||||
// parsePubKey parses a public key of the given algorithm.
|
||||
// Use ParsePublicKey for keys with prepended algorithm.
|
||||
func parsePubKey(in []byte, algo string) (pubKey PublicKey, rest []byte, err error) { |
||||
switch algo { |
||||
case KeyAlgoRSA: |
||||
return parseRSA(in) |
||||
case KeyAlgoDSA: |
||||
return parseDSA(in) |
||||
case KeyAlgoECDSA256, KeyAlgoECDSA384, KeyAlgoECDSA521: |
||||
return parseECDSA(in) |
||||
case CertAlgoRSAv01, CertAlgoDSAv01, CertAlgoECDSA256v01, CertAlgoECDSA384v01, CertAlgoECDSA521v01: |
||||
cert, err := parseCert(in, certToPrivAlgo(algo)) |
||||
if err != nil { |
||||
return nil, nil, err |
||||
} |
||||
return cert, nil, nil |
||||
} |
||||
return nil, nil, fmt.Errorf("ssh: unknown key algorithm: %v", err) |
||||
} |
||||
|
||||
// parseAuthorizedKey parses a public key in OpenSSH authorized_keys format
|
||||
// (see sshd(8) manual page) once the options and key type fields have been
|
||||
// removed.
|
||||
func parseAuthorizedKey(in []byte) (out PublicKey, comment string, err error) { |
||||
in = bytes.TrimSpace(in) |
||||
|
||||
i := bytes.IndexAny(in, " \t") |
||||
if i == -1 { |
||||
i = len(in) |
||||
} |
||||
base64Key := in[:i] |
||||
|
||||
key := make([]byte, base64.StdEncoding.DecodedLen(len(base64Key))) |
||||
n, err := base64.StdEncoding.Decode(key, base64Key) |
||||
if err != nil { |
||||
return nil, "", err |
||||
} |
||||
key = key[:n] |
||||
out, err = ParsePublicKey(key) |
||||
if err != nil { |
||||
return nil, "", err |
||||
} |
||||
comment = string(bytes.TrimSpace(in[i:])) |
||||
return out, comment, nil |
||||
} |
||||
|
||||
// ParseAuthorizedKeys parses a public key from an authorized_keys
|
||||
// file used in OpenSSH according to the sshd(8) manual page.
|
||||
func ParseAuthorizedKey(in []byte) (out PublicKey, comment string, options []string, rest []byte, err error) { |
||||
for len(in) > 0 { |
||||
end := bytes.IndexByte(in, '\n') |
||||
if end != -1 { |
||||
rest = in[end+1:] |
||||
in = in[:end] |
||||
} else { |
||||
rest = nil |
||||
} |
||||
|
||||
end = bytes.IndexByte(in, '\r') |
||||
if end != -1 { |
||||
in = in[:end] |
||||
} |
||||
|
||||
in = bytes.TrimSpace(in) |
||||
if len(in) == 0 || in[0] == '#' { |
||||
in = rest |
||||
continue |
||||
} |
||||
|
||||
i := bytes.IndexAny(in, " \t") |
||||
if i == -1 { |
||||
in = rest |
||||
continue |
||||
} |
||||
|
||||
if out, comment, err = parseAuthorizedKey(in[i:]); err == nil { |
||||
return out, comment, options, rest, nil |
||||
} |
||||
|
||||
// No key type recognised. Maybe there's an options field at
|
||||
// the beginning.
|
||||
var b byte |
||||
inQuote := false |
||||
var candidateOptions []string |
||||
optionStart := 0 |
||||
for i, b = range in { |
||||
isEnd := !inQuote && (b == ' ' || b == '\t') |
||||
if (b == ',' && !inQuote) || isEnd { |
||||
if i-optionStart > 0 { |
||||
candidateOptions = append(candidateOptions, string(in[optionStart:i])) |
||||
} |
||||
optionStart = i + 1 |
||||
} |
||||
if isEnd { |
||||
break |
||||
} |
||||
if b == '"' && (i == 0 || (i > 0 && in[i-1] != '\\')) { |
||||
inQuote = !inQuote |
||||
} |
||||
} |
||||
for i < len(in) && (in[i] == ' ' || in[i] == '\t') { |
||||
i++ |
||||
} |
||||
if i == len(in) { |
||||
// Invalid line: unmatched quote
|
||||
in = rest |
||||
continue |
||||
} |
||||
|
||||
in = in[i:] |
||||
i = bytes.IndexAny(in, " \t") |
||||
if i == -1 { |
||||
in = rest |
||||
continue |
||||
} |
||||
|
||||
if out, comment, err = parseAuthorizedKey(in[i:]); err == nil { |
||||
options = candidateOptions |
||||
return out, comment, options, rest, nil |
||||
} |
||||
|
||||
in = rest |
||||
continue |
||||
} |
||||
|
||||
return nil, "", nil, nil, errors.New("ssh: no key found") |
||||
} |
||||
|
||||
// ParsePublicKey parses an SSH public key formatted for use in
|
||||
// the SSH wire protocol according to RFC 4253, section 6.6.
|
||||
func ParsePublicKey(in []byte) (out PublicKey, err error) { |
||||
algo, in, ok := parseString(in) |
||||
if !ok { |
||||
return nil, errShortRead |
||||
} |
||||
var rest []byte |
||||
out, rest, err = parsePubKey(in, string(algo)) |
||||
if len(rest) > 0 { |
||||
return nil, errors.New("ssh: trailing junk in public key") |
||||
} |
||||
|
||||
return out, err |
||||
} |
||||
|
||||
// MarshalAuthorizedKey serializes key for inclusion in an OpenSSH
|
||||
// authorized_keys file. The return value ends with newline.
|
||||
func MarshalAuthorizedKey(key PublicKey) []byte { |
||||
b := &bytes.Buffer{} |
||||
b.WriteString(key.Type()) |
||||
b.WriteByte(' ') |
||||
e := base64.NewEncoder(base64.StdEncoding, b) |
||||
e.Write(key.Marshal()) |
||||
e.Close() |
||||
b.WriteByte('\n') |
||||
return b.Bytes() |
||||
} |
||||
|
||||
// PublicKey is an abstraction of different types of public keys.
|
||||
type PublicKey interface { |
||||
// Type returns the key's type, e.g. "ssh-rsa".
|
||||
Type() string |
||||
|
||||
// Marshal returns the serialized key data in SSH wire format,
|
||||
// with the name prefix.
|
||||
Marshal() []byte |
||||
|
||||
// Verify that sig is a signature on the given data using this
|
||||
// key. This function will hash the data appropriately first.
|
||||
Verify(data []byte, sig *Signature) error |
||||
} |
||||
|
||||
// A Signer can create signatures that verify against a public key.
|
||||
type Signer interface { |
||||
// PublicKey returns an associated PublicKey instance.
|
||||
PublicKey() PublicKey |
||||
|
||||
// Sign returns raw signature for the given data. This method
|
||||
// will apply the hash specified for the keytype to the data.
|
||||
Sign(rand io.Reader, data []byte) (*Signature, error) |
||||
} |
||||
|
||||
type rsaPublicKey rsa.PublicKey |
||||
|
||||
func (r *rsaPublicKey) Type() string { |
||||
return "ssh-rsa" |
||||
} |
||||
|
||||
// parseRSA parses an RSA key according to RFC 4253, section 6.6.
|
||||
func parseRSA(in []byte) (out PublicKey, rest []byte, err error) { |
||||
var w struct { |
||||
E *big.Int |
||||
N *big.Int |
||||
Rest []byte `ssh:"rest"` |
||||
} |
||||
if err := Unmarshal(in, &w); err != nil { |
||||
return nil, nil, err |
||||
} |
||||
|
||||
if w.E.BitLen() > 24 { |
||||
return nil, nil, errors.New("ssh: exponent too large") |
||||
} |
||||
e := w.E.Int64() |
||||
if e < 3 || e&1 == 0 { |
||||
return nil, nil, errors.New("ssh: incorrect exponent") |
||||
} |
||||
|
||||
var key rsa.PublicKey |
||||
key.E = int(e) |
||||
key.N = w.N |
||||
return (*rsaPublicKey)(&key), w.Rest, nil |
||||
} |
||||
|
||||
func (r *rsaPublicKey) Marshal() []byte { |
||||
e := new(big.Int).SetInt64(int64(r.E)) |
||||
wirekey := struct { |
||||
Name string |
||||
E *big.Int |
||||
N *big.Int |
||||
}{ |
||||
KeyAlgoRSA, |
||||
e, |
||||
r.N, |
||||
} |
||||
return Marshal(&wirekey) |
||||
} |
||||
|
||||
func (r *rsaPublicKey) Verify(data []byte, sig *Signature) error { |
||||
if sig.Format != r.Type() { |
||||
return fmt.Errorf("ssh: signature type %s for key type %s", sig.Format, r.Type()) |
||||
} |
||||
h := crypto.SHA1.New() |
||||
h.Write(data) |
||||
digest := h.Sum(nil) |
||||
return rsa.VerifyPKCS1v15((*rsa.PublicKey)(r), crypto.SHA1, digest, sig.Blob) |
||||
} |
||||
|
||||
type rsaPrivateKey struct { |
||||
*rsa.PrivateKey |
||||
} |
||||
|
||||
func (r *rsaPrivateKey) PublicKey() PublicKey { |
||||
return (*rsaPublicKey)(&r.PrivateKey.PublicKey) |
||||
} |
||||
|
||||
func (r *rsaPrivateKey) Sign(rand io.Reader, data []byte) (*Signature, error) { |
||||
h := crypto.SHA1.New() |
||||
h.Write(data) |
||||
digest := h.Sum(nil) |
||||
blob, err := rsa.SignPKCS1v15(rand, r.PrivateKey, crypto.SHA1, digest) |
||||
if err != nil { |
||||
return nil, err |
||||
} |
||||
return &Signature{ |
||||
Format: r.PublicKey().Type(), |
||||
Blob: blob, |
||||
}, nil |
||||
} |
||||
|
||||
type dsaPublicKey dsa.PublicKey |
||||
|
||||
func (r *dsaPublicKey) Type() string { |
||||
return "ssh-dss" |
||||
} |
||||
|
||||
// parseDSA parses an DSA key according to RFC 4253, section 6.6.
|
||||
func parseDSA(in []byte) (out PublicKey, rest []byte, err error) { |
||||
var w struct { |
||||
P, Q, G, Y *big.Int |
||||
Rest []byte `ssh:"rest"` |
||||
} |
||||
if err := Unmarshal(in, &w); err != nil { |
||||
return nil, nil, err |
||||
} |
||||
|
||||
key := &dsaPublicKey{ |
||||
Parameters: dsa.Parameters{ |
||||
P: w.P, |
||||
Q: w.Q, |
||||
G: w.G, |
||||
}, |
||||
Y: w.Y, |
||||
} |
||||
return key, w.Rest, nil |
||||
} |
||||
|
||||
func (k *dsaPublicKey) Marshal() []byte { |
||||
w := struct { |
||||
Name string |
||||
P, Q, G, Y *big.Int |
||||
}{ |
||||
k.Type(), |
||||
k.P, |
||||
k.Q, |
||||
k.G, |
||||
k.Y, |
||||
} |
||||
|
||||
return Marshal(&w) |
||||
} |
||||
|
||||
func (k *dsaPublicKey) Verify(data []byte, sig *Signature) error { |
||||
if sig.Format != k.Type() { |
||||
return fmt.Errorf("ssh: signature type %s for key type %s", sig.Format, k.Type()) |
||||
} |
||||
h := crypto.SHA1.New() |
||||
h.Write(data) |
||||
digest := h.Sum(nil) |
||||
|
||||
// Per RFC 4253, section 6.6,
|
||||
// The value for 'dss_signature_blob' is encoded as a string containing
|
||||
// r, followed by s (which are 160-bit integers, without lengths or
|
||||
// padding, unsigned, and in network byte order).
|
||||
// For DSS purposes, sig.Blob should be exactly 40 bytes in length.
|
||||
if len(sig.Blob) != 40 { |
||||
return errors.New("ssh: DSA signature parse error") |
||||
} |
||||
r := new(big.Int).SetBytes(sig.Blob[:20]) |
||||
s := new(big.Int).SetBytes(sig.Blob[20:]) |
||||
if dsa.Verify((*dsa.PublicKey)(k), digest, r, s) { |
||||
return nil |
||||
} |
||||
return errors.New("ssh: signature did not verify") |
||||
} |
||||
|
||||
type dsaPrivateKey struct { |
||||
*dsa.PrivateKey |
||||
} |
||||
|
||||
func (k *dsaPrivateKey) PublicKey() PublicKey { |
||||
return (*dsaPublicKey)(&k.PrivateKey.PublicKey) |
||||
} |
||||
|
||||
func (k *dsaPrivateKey) Sign(rand io.Reader, data []byte) (*Signature, error) { |
||||
h := crypto.SHA1.New() |
||||
h.Write(data) |
||||
digest := h.Sum(nil) |
||||
r, s, err := dsa.Sign(rand, k.PrivateKey, digest) |
||||
if err != nil { |
||||
return nil, err |
||||
} |
||||
|
||||
sig := make([]byte, 40) |
||||
rb := r.Bytes() |
||||
sb := s.Bytes() |
||||
|
||||
copy(sig[20-len(rb):20], rb) |
||||
copy(sig[40-len(sb):], sb) |
||||
|
||||
return &Signature{ |
||||
Format: k.PublicKey().Type(), |
||||
Blob: sig, |
||||
}, nil |
||||
} |
||||
|
||||
type ecdsaPublicKey ecdsa.PublicKey |
||||
|
||||
func (key *ecdsaPublicKey) Type() string { |
||||
return "ecdsa-sha2-" + key.nistID() |
||||
} |
||||
|
||||
func (key *ecdsaPublicKey) nistID() string { |
||||
switch key.Params().BitSize { |
||||
case 256: |
||||
return "nistp256" |
||||
case 384: |
||||
return "nistp384" |
||||
case 521: |
||||
return "nistp521" |
||||
} |
||||
panic("ssh: unsupported ecdsa key size") |
||||
} |
||||
|
||||
func supportedEllipticCurve(curve elliptic.Curve) bool { |
||||
return curve == elliptic.P256() || curve == elliptic.P384() || curve == elliptic.P521() |
||||
} |
||||
|
||||
// ecHash returns the hash to match the given elliptic curve, see RFC
|
||||
// 5656, section 6.2.1
|
||||
func ecHash(curve elliptic.Curve) crypto.Hash { |
||||
bitSize := curve.Params().BitSize |
||||
switch { |
||||
case bitSize <= 256: |
||||
return crypto.SHA256 |
||||
case bitSize <= 384: |
||||
return crypto.SHA384 |
||||
} |
||||
return crypto.SHA512 |
||||
} |
||||
|
||||
// parseECDSA parses an ECDSA key according to RFC 5656, section 3.1.
|
||||
func parseECDSA(in []byte) (out PublicKey, rest []byte, err error) { |
||||
var w struct { |
||||
Curve string |
||||
KeyBytes []byte |
||||
Rest []byte `ssh:"rest"` |
||||
} |
||||
|
||||
if err := Unmarshal(in, &w); err != nil { |
||||
return nil, nil, err |
||||
} |
||||
|
||||
key := new(ecdsa.PublicKey) |
||||
|
||||
switch w.Curve { |
||||
case "nistp256": |
||||
key.Curve = elliptic.P256() |
||||
case "nistp384": |
||||
key.Curve = elliptic.P384() |
||||
case "nistp521": |
||||
key.Curve = elliptic.P521() |
||||
default: |
||||
return nil, nil, errors.New("ssh: unsupported curve") |
||||
} |
||||
|
||||
key.X, key.Y = elliptic.Unmarshal(key.Curve, w.KeyBytes) |
||||
if key.X == nil || key.Y == nil { |
||||
return nil, nil, errors.New("ssh: invalid curve point") |
||||
} |
||||
return (*ecdsaPublicKey)(key), w.Rest, nil |
||||
} |
||||
|
||||
func (key *ecdsaPublicKey) Marshal() []byte { |
||||
// See RFC 5656, section 3.1.
|
||||
keyBytes := elliptic.Marshal(key.Curve, key.X, key.Y) |
||||
w := struct { |
||||
Name string |
||||
ID string |
||||
Key []byte |
||||
}{ |
||||
key.Type(), |
||||
key.nistID(), |
||||
keyBytes, |
||||
} |
||||
|
||||
return Marshal(&w) |
||||
} |
||||
|
||||
func (key *ecdsaPublicKey) Verify(data []byte, sig *Signature) error { |
||||
if sig.Format != key.Type() { |
||||
return fmt.Errorf("ssh: signature type %s for key type %s", sig.Format, key.Type()) |
||||
} |
||||
|
||||
h := ecHash(key.Curve).New() |
||||
h.Write(data) |
||||
digest := h.Sum(nil) |
||||
|
||||
// Per RFC 5656, section 3.1.2,
|
||||
// The ecdsa_signature_blob value has the following specific encoding:
|
||||
// mpint r
|
||||
// mpint s
|
||||
var ecSig struct { |
||||
R *big.Int |
||||
S *big.Int |
||||
} |
||||
|
||||
if err := Unmarshal(sig.Blob, &ecSig); err != nil { |
||||
return err |
||||
} |
||||
|
||||
if ecdsa.Verify((*ecdsa.PublicKey)(key), digest, ecSig.R, ecSig.S) { |
||||
return nil |
||||
} |
||||
return errors.New("ssh: signature did not verify") |
||||
} |
||||
|
||||
type ecdsaPrivateKey struct { |
||||
*ecdsa.PrivateKey |
||||
} |
||||
|
||||
func (k *ecdsaPrivateKey) PublicKey() PublicKey { |
||||
return (*ecdsaPublicKey)(&k.PrivateKey.PublicKey) |
||||
} |
||||
|
||||
func (k *ecdsaPrivateKey) Sign(rand io.Reader, data []byte) (*Signature, error) { |
||||
h := ecHash(k.PrivateKey.PublicKey.Curve).New() |
||||
h.Write(data) |
||||
digest := h.Sum(nil) |
||||
r, s, err := ecdsa.Sign(rand, k.PrivateKey, digest) |
||||
if err != nil { |
||||
return nil, err |
||||
} |
||||
|
||||
sig := make([]byte, intLength(r)+intLength(s)) |
||||
rest := marshalInt(sig, r) |
||||
marshalInt(rest, s) |
||||
return &Signature{ |
||||
Format: k.PublicKey().Type(), |
||||
Blob: sig, |
||||
}, nil |
||||
} |
||||
|
||||
// NewSignerFromKey takes a pointer to rsa, dsa or ecdsa PrivateKey
|
||||
// returns a corresponding Signer instance. EC keys should use P256,
|
||||
// P384 or P521.
|
||||
func NewSignerFromKey(k interface{}) (Signer, error) { |
||||
var sshKey Signer |
||||
switch t := k.(type) { |
||||
case *rsa.PrivateKey: |
||||
sshKey = &rsaPrivateKey{t} |
||||
case *dsa.PrivateKey: |
||||
sshKey = &dsaPrivateKey{t} |
||||
case *ecdsa.PrivateKey: |
||||
if !supportedEllipticCurve(t.Curve) { |
||||
return nil, errors.New("ssh: only P256, P384 and P521 EC keys are supported.") |
||||
} |
||||
|
||||
sshKey = &ecdsaPrivateKey{t} |
||||
default: |
||||
return nil, fmt.Errorf("ssh: unsupported key type %T", k) |
||||
} |
||||
return sshKey, nil |
||||
} |
||||
|
||||
// NewPublicKey takes a pointer to rsa, dsa or ecdsa PublicKey
|
||||
// and returns a corresponding ssh PublicKey instance. EC keys should use P256, P384 or P521.
|
||||
func NewPublicKey(k interface{}) (PublicKey, error) { |
||||
var sshKey PublicKey |
||||
switch t := k.(type) { |
||||
case *rsa.PublicKey: |
||||
sshKey = (*rsaPublicKey)(t) |
||||
case *ecdsa.PublicKey: |
||||
if !supportedEllipticCurve(t.Curve) { |
||||
return nil, errors.New("ssh: only P256, P384 and P521 EC keys are supported.") |
||||
} |
||||
sshKey = (*ecdsaPublicKey)(t) |
||||
case *dsa.PublicKey: |
||||
sshKey = (*dsaPublicKey)(t) |
||||
default: |
||||
return nil, fmt.Errorf("ssh: unsupported key type %T", k) |
||||
} |
||||
return sshKey, nil |
||||
} |
||||
|
||||
// ParsePrivateKey returns a Signer from a PEM encoded private key. It supports
|
||||
// the same keys as ParseRawPrivateKey.
|
||||
func ParsePrivateKey(pemBytes []byte) (Signer, error) { |
||||
key, err := ParseRawPrivateKey(pemBytes) |
||||
if err != nil { |
||||
return nil, err |
||||
} |
||||
|
||||
return NewSignerFromKey(key) |
||||
} |
||||
|
||||
// ParseRawPrivateKey returns a private key from a PEM encoded private key. It
|
||||
// supports RSA (PKCS#1), DSA (OpenSSL), and ECDSA private keys.
|
||||
func ParseRawPrivateKey(pemBytes []byte) (interface{}, error) { |
||||
block, _ := pem.Decode(pemBytes) |
||||
if block == nil { |
||||
return nil, errors.New("ssh: no key found") |
||||
} |
||||
|
||||
switch block.Type { |
||||
case "RSA PRIVATE KEY": |
||||
return x509.ParsePKCS1PrivateKey(block.Bytes) |
||||
case "EC PRIVATE KEY": |
||||
return x509.ParseECPrivateKey(block.Bytes) |
||||
case "DSA PRIVATE KEY": |
||||
return ParseDSAPrivateKey(block.Bytes) |
||||
default: |
||||
return nil, fmt.Errorf("ssh: unsupported key type %q", block.Type) |
||||
} |
||||
} |
||||
|
||||
// ParseDSAPrivateKey returns a DSA private key from its ASN.1 DER encoding, as
|
||||
// specified by the OpenSSL DSA man page.
|
||||
func ParseDSAPrivateKey(der []byte) (*dsa.PrivateKey, error) { |
||||
var k struct { |
||||
Version int |
||||
P *big.Int |
||||
Q *big.Int |
||||
G *big.Int |
||||
Priv *big.Int |
||||
Pub *big.Int |
||||
} |
||||
rest, err := asn1.Unmarshal(der, &k) |
||||
if err != nil { |
||||
return nil, errors.New("ssh: failed to parse DSA key: " + err.Error()) |
||||
} |
||||
if len(rest) > 0 { |
||||
return nil, errors.New("ssh: garbage after DSA key") |
||||
} |
||||
|
||||
return &dsa.PrivateKey{ |
||||
PublicKey: dsa.PublicKey{ |
||||
Parameters: dsa.Parameters{ |
||||
P: k.P, |
||||
Q: k.Q, |
||||
G: k.G, |
||||
}, |
||||
Y: k.Priv, |
||||
}, |
||||
X: k.Pub, |
||||
}, nil |
||||
} |
||||
@ -1,306 +0,0 @@ |
||||
// Copyright 2014 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 ( |
||||
"bytes" |
||||
"crypto/dsa" |
||||
"crypto/ecdsa" |
||||
"crypto/elliptic" |
||||
"crypto/rand" |
||||
"crypto/rsa" |
||||
"encoding/base64" |
||||
"fmt" |
||||
"reflect" |
||||
"strings" |
||||
"testing" |
||||
|
||||
"github.com/gogits/gogs/modules/crypto/ssh/testdata" |
||||
) |
||||
|
||||
func rawKey(pub PublicKey) interface{} { |
||||
switch k := pub.(type) { |
||||
case *rsaPublicKey: |
||||
return (*rsa.PublicKey)(k) |
||||
case *dsaPublicKey: |
||||
return (*dsa.PublicKey)(k) |
||||
case *ecdsaPublicKey: |
||||
return (*ecdsa.PublicKey)(k) |
||||
case *Certificate: |
||||
return k |
||||
} |
||||
panic("unknown key type") |
||||
} |
||||
|
||||
func TestKeyMarshalParse(t *testing.T) { |
||||
for _, priv := range testSigners { |
||||
pub := priv.PublicKey() |
||||
roundtrip, err := ParsePublicKey(pub.Marshal()) |
||||
if err != nil { |
||||
t.Errorf("ParsePublicKey(%T): %v", pub, err) |
||||
} |
||||
|
||||
k1 := rawKey(pub) |
||||
k2 := rawKey(roundtrip) |
||||
|
||||
if !reflect.DeepEqual(k1, k2) { |
||||
t.Errorf("got %#v in roundtrip, want %#v", k2, k1) |
||||
} |
||||
} |
||||
} |
||||
|
||||
func TestUnsupportedCurves(t *testing.T) { |
||||
raw, err := ecdsa.GenerateKey(elliptic.P224(), rand.Reader) |
||||
if err != nil { |
||||
t.Fatalf("GenerateKey: %v", err) |
||||
} |
||||
|
||||
if _, err = NewSignerFromKey(raw); err == nil || !strings.Contains(err.Error(), "only P256") { |
||||
t.Fatalf("NewPrivateKey should not succeed with P224, got: %v", err) |
||||
} |
||||
|
||||
if _, err = NewPublicKey(&raw.PublicKey); err == nil || !strings.Contains(err.Error(), "only P256") { |
||||
t.Fatalf("NewPublicKey should not succeed with P224, got: %v", err) |
||||
} |
||||
} |
||||
|
||||
func TestNewPublicKey(t *testing.T) { |
||||
for _, k := range testSigners { |
||||
raw := rawKey(k.PublicKey()) |
||||
// Skip certificates, as NewPublicKey does not support them.
|
||||
if _, ok := raw.(*Certificate); ok { |
||||
continue |
||||
} |
||||
pub, err := NewPublicKey(raw) |
||||
if err != nil { |
||||
t.Errorf("NewPublicKey(%#v): %v", raw, err) |
||||
} |
||||
if !reflect.DeepEqual(k.PublicKey(), pub) { |
||||
t.Errorf("NewPublicKey(%#v) = %#v, want %#v", raw, pub, k.PublicKey()) |
||||
} |
||||
} |
||||
} |
||||
|
||||
func TestKeySignVerify(t *testing.T) { |
||||
for _, priv := range testSigners { |
||||
pub := priv.PublicKey() |
||||
|
||||
data := []byte("sign me") |
||||
sig, err := priv.Sign(rand.Reader, data) |
||||
if err != nil { |
||||
t.Fatalf("Sign(%T): %v", priv, err) |
||||
} |
||||
|
||||
if err := pub.Verify(data, sig); err != nil { |
||||
t.Errorf("publicKey.Verify(%T): %v", priv, err) |
||||
} |
||||
sig.Blob[5]++ |
||||
if err := pub.Verify(data, sig); err == nil { |
||||
t.Errorf("publicKey.Verify on broken sig did not fail") |
||||
} |
||||
} |
||||
} |
||||
|
||||
func TestParseRSAPrivateKey(t *testing.T) { |
||||
key := testPrivateKeys["rsa"] |
||||
|
||||
rsa, ok := key.(*rsa.PrivateKey) |
||||
if !ok { |
||||
t.Fatalf("got %T, want *rsa.PrivateKey", rsa) |
||||
} |
||||
|
||||
if err := rsa.Validate(); err != nil { |
||||
t.Errorf("Validate: %v", err) |
||||
} |
||||
} |
||||
|
||||
func TestParseECPrivateKey(t *testing.T) { |
||||
key := testPrivateKeys["ecdsa"] |
||||
|
||||
ecKey, ok := key.(*ecdsa.PrivateKey) |
||||
if !ok { |
||||
t.Fatalf("got %T, want *ecdsa.PrivateKey", ecKey) |
||||
} |
||||
|
||||
if !validateECPublicKey(ecKey.Curve, ecKey.X, ecKey.Y) { |
||||
t.Fatalf("public key does not validate.") |
||||
} |
||||
} |
||||
|
||||
func TestParseDSA(t *testing.T) { |
||||
// We actually exercise the ParsePrivateKey codepath here, as opposed to
|
||||
// using the ParseRawPrivateKey+NewSignerFromKey path that testdata_test.go
|
||||
// uses.
|
||||
s, err := ParsePrivateKey(testdata.PEMBytes["dsa"]) |
||||
if err != nil { |
||||
t.Fatalf("ParsePrivateKey returned error: %s", err) |
||||
} |
||||
|
||||
data := []byte("sign me") |
||||
sig, err := s.Sign(rand.Reader, data) |
||||
if err != nil { |
||||
t.Fatalf("dsa.Sign: %v", err) |
||||
} |
||||
|
||||
if err := s.PublicKey().Verify(data, sig); err != nil { |
||||
t.Errorf("Verify failed: %v", err) |
||||
} |
||||
} |
||||
|
||||
// Tests for authorized_keys parsing.
|
||||
|
||||
// getTestKey returns a public key, and its base64 encoding.
|
||||
func getTestKey() (PublicKey, string) { |
||||
k := testPublicKeys["rsa"] |
||||
|
||||
b := &bytes.Buffer{} |
||||
e := base64.NewEncoder(base64.StdEncoding, b) |
||||
e.Write(k.Marshal()) |
||||
e.Close() |
||||
|
||||
return k, b.String() |
||||
} |
||||
|
||||
func TestMarshalParsePublicKey(t *testing.T) { |
||||
pub, pubSerialized := getTestKey() |
||||
line := fmt.Sprintf("%s %s user@host", pub.Type(), pubSerialized) |
||||
|
||||
authKeys := MarshalAuthorizedKey(pub) |
||||
actualFields := strings.Fields(string(authKeys)) |
||||
if len(actualFields) == 0 { |
||||
t.Fatalf("failed authKeys: %v", authKeys) |
||||
} |
||||
|
||||
// drop the comment
|
||||
expectedFields := strings.Fields(line)[0:2] |
||||
|
||||
if !reflect.DeepEqual(actualFields, expectedFields) { |
||||
t.Errorf("got %v, expected %v", actualFields, expectedFields) |
||||
} |
||||
|
||||
actPub, _, _, _, err := ParseAuthorizedKey([]byte(line)) |
||||
if err != nil { |
||||
t.Fatalf("cannot parse %v: %v", line, err) |
||||
} |
||||
if !reflect.DeepEqual(actPub, pub) { |
||||
t.Errorf("got %v, expected %v", actPub, pub) |
||||
} |
||||
} |
||||
|
||||
type authResult struct { |
||||
pubKey PublicKey |
||||
options []string |
||||
comments string |
||||
rest string |
||||
ok bool |
||||
} |
||||
|
||||
func testAuthorizedKeys(t *testing.T, authKeys []byte, expected []authResult) { |
||||
rest := authKeys |
||||
var values []authResult |
||||
for len(rest) > 0 { |
||||
var r authResult |
||||
var err error |
||||
r.pubKey, r.comments, r.options, rest, err = ParseAuthorizedKey(rest) |
||||
r.ok = (err == nil) |
||||
t.Log(err) |
||||
r.rest = string(rest) |
||||
values = append(values, r) |
||||
} |
||||
|
||||
if !reflect.DeepEqual(values, expected) { |
||||
t.Errorf("got %#v, expected %#v", values, expected) |
||||
} |
||||
} |
||||
|
||||
func TestAuthorizedKeyBasic(t *testing.T) { |
||||
pub, pubSerialized := getTestKey() |
||||
line := "ssh-rsa " + pubSerialized + " user@host" |
||||
testAuthorizedKeys(t, []byte(line), |
||||
[]authResult{ |
||||
{pub, nil, "user@host", "", true}, |
||||
}) |
||||
} |
||||
|
||||
func TestAuth(t *testing.T) { |
||||
pub, pubSerialized := getTestKey() |
||||
authWithOptions := []string{ |
||||
`# comments to ignore before any keys...`, |
||||
``, |
||||
`env="HOME=/home/root",no-port-forwarding ssh-rsa ` + pubSerialized + ` user@host`, |
||||
`# comments to ignore, along with a blank line`, |
||||
``, |
||||
`env="HOME=/home/root2" ssh-rsa ` + pubSerialized + ` user2@host2`, |
||||
``, |
||||
`# more comments, plus a invalid entry`, |
||||
`ssh-rsa data-that-will-not-parse user@host3`, |
||||
} |
||||
for _, eol := range []string{"\n", "\r\n"} { |
||||
authOptions := strings.Join(authWithOptions, eol) |
||||
rest2 := strings.Join(authWithOptions[3:], eol) |
||||
rest3 := strings.Join(authWithOptions[6:], eol) |
||||
testAuthorizedKeys(t, []byte(authOptions), []authResult{ |
||||
{pub, []string{`env="HOME=/home/root"`, "no-port-forwarding"}, "user@host", rest2, true}, |
||||
{pub, []string{`env="HOME=/home/root2"`}, "user2@host2", rest3, true}, |
||||
{nil, nil, "", "", false}, |
||||
}) |
||||
} |
||||
} |
||||
|
||||
func TestAuthWithQuotedSpaceInEnv(t *testing.T) { |
||||
pub, pubSerialized := getTestKey() |
||||
authWithQuotedSpaceInEnv := []byte(`env="HOME=/home/root dir",no-port-forwarding ssh-rsa ` + pubSerialized + ` user@host`) |
||||
testAuthorizedKeys(t, []byte(authWithQuotedSpaceInEnv), []authResult{ |
||||
{pub, []string{`env="HOME=/home/root dir"`, "no-port-forwarding"}, "user@host", "", true}, |
||||
}) |
||||
} |
||||
|
||||
func TestAuthWithQuotedCommaInEnv(t *testing.T) { |
||||
pub, pubSerialized := getTestKey() |
||||
authWithQuotedCommaInEnv := []byte(`env="HOME=/home/root,dir",no-port-forwarding ssh-rsa ` + pubSerialized + ` user@host`) |
||||
testAuthorizedKeys(t, []byte(authWithQuotedCommaInEnv), []authResult{ |
||||
{pub, []string{`env="HOME=/home/root,dir"`, "no-port-forwarding"}, "user@host", "", true}, |
||||
}) |
||||
} |
||||
|
||||
func TestAuthWithQuotedQuoteInEnv(t *testing.T) { |
||||
pub, pubSerialized := getTestKey() |
||||
authWithQuotedQuoteInEnv := []byte(`env="HOME=/home/\"root dir",no-port-forwarding` + "\t" + `ssh-rsa` + "\t" + pubSerialized + ` user@host`) |
||||
authWithDoubleQuotedQuote := []byte(`no-port-forwarding,env="HOME=/home/ \"root dir\"" ssh-rsa ` + pubSerialized + "\t" + `user@host`) |
||||
testAuthorizedKeys(t, []byte(authWithQuotedQuoteInEnv), []authResult{ |
||||
{pub, []string{`env="HOME=/home/\"root dir"`, "no-port-forwarding"}, "user@host", "", true}, |
||||
}) |
||||
|
||||
testAuthorizedKeys(t, []byte(authWithDoubleQuotedQuote), []authResult{ |
||||
{pub, []string{"no-port-forwarding", `env="HOME=/home/ \"root dir\""`}, "user@host", "", true}, |
||||
}) |
||||
} |
||||
|
||||
func TestAuthWithInvalidSpace(t *testing.T) { |
||||
_, pubSerialized := getTestKey() |
||||
authWithInvalidSpace := []byte(`env="HOME=/home/root dir", no-port-forwarding ssh-rsa ` + pubSerialized + ` user@host |
||||
#more to follow but still no valid keys`) |
||||
testAuthorizedKeys(t, []byte(authWithInvalidSpace), []authResult{ |
||||
{nil, nil, "", "", false}, |
||||
}) |
||||
} |
||||
|
||||
func TestAuthWithMissingQuote(t *testing.T) { |
||||
pub, pubSerialized := getTestKey() |
||||
authWithMissingQuote := []byte(`env="HOME=/home/root,no-port-forwarding ssh-rsa ` + pubSerialized + ` user@host |
||||
env="HOME=/home/root",shared-control ssh-rsa ` + pubSerialized + ` user@host`) |
||||
|
||||
testAuthorizedKeys(t, []byte(authWithMissingQuote), []authResult{ |
||||
{pub, []string{`env="HOME=/home/root"`, `shared-control`}, "user@host", "", true}, |
||||
}) |
||||
} |
||||
|
||||
func TestInvalidEntry(t *testing.T) { |
||||
authInvalid := []byte(`ssh-rsa`) |
||||
_, _, _, _, err := ParseAuthorizedKey(authInvalid) |
||||
if err == nil { |
||||
t.Errorf("got valid entry for %q", authInvalid) |
||||
} |
||||
} |
||||
@ -1,57 +0,0 @@ |
||||
// Copyright 2012 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 |
||||
|
||||
// Message authentication support
|
||||
|
||||
import ( |
||||
"crypto/hmac" |
||||
"crypto/sha1" |
||||
"crypto/sha256" |
||||
"hash" |
||||
) |
||||
|
||||
type macMode struct { |
||||
keySize int |
||||
new func(key []byte) hash.Hash |
||||
} |
||||
|
||||
// truncatingMAC wraps around a hash.Hash and truncates the output digest to
|
||||
// a given size.
|
||||
type truncatingMAC struct { |
||||
length int |
||||
hmac hash.Hash |
||||
} |
||||
|
||||
func (t truncatingMAC) Write(data []byte) (int, error) { |
||||
return t.hmac.Write(data) |
||||
} |
||||
|
||||
func (t truncatingMAC) Sum(in []byte) []byte { |
||||
out := t.hmac.Sum(in) |
||||
return out[:len(in)+t.length] |
||||
} |
||||
|
||||
func (t truncatingMAC) Reset() { |
||||
t.hmac.Reset() |
||||
} |
||||
|
||||
func (t truncatingMAC) Size() int { |
||||
return t.length |
||||
} |
||||
|
||||
func (t truncatingMAC) BlockSize() int { return t.hmac.BlockSize() } |
||||
|
||||
var macModes = map[string]*macMode{ |
||||
"hmac-sha2-256": {32, func(key []byte) hash.Hash { |
||||
return hmac.New(sha256.New, key) |
||||
}}, |
||||
"hmac-sha1": {20, func(key []byte) hash.Hash { |
||||
return hmac.New(sha1.New, key) |
||||
}}, |
||||
"hmac-sha1-96": {20, func(key []byte) hash.Hash { |
||||
return truncatingMAC{12, hmac.New(sha1.New, key)} |
||||
}}, |
||||
} |
||||
@ -1,110 +0,0 @@ |
||||
// Copyright 2013 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 ( |
||||
"io" |
||||
"sync" |
||||
"testing" |
||||
) |
||||
|
||||
// An in-memory packetConn. It is safe to call Close and writePacket
|
||||
// from different goroutines.
|
||||
type memTransport struct { |
||||
eof bool |
||||
pending [][]byte |
||||
write *memTransport |
||||
sync.Mutex |
||||
*sync.Cond |
||||
} |
||||
|
||||
func (t *memTransport) readPacket() ([]byte, error) { |
||||
t.Lock() |
||||
defer t.Unlock() |
||||
for { |
||||
if len(t.pending) > 0 { |
||||
r := t.pending[0] |
||||
t.pending = t.pending[1:] |
||||
return r, nil |
||||
} |
||||
if t.eof { |
||||
return nil, io.EOF |
||||
} |
||||
t.Cond.Wait() |
||||
} |
||||
} |
||||
|
||||
func (t *memTransport) closeSelf() error { |
||||
t.Lock() |
||||
defer t.Unlock() |
||||
if t.eof { |
||||
return io.EOF |
||||
} |
||||
t.eof = true |
||||
t.Cond.Broadcast() |
||||
return nil |
||||
} |
||||
|
||||
func (t *memTransport) Close() error { |
||||
err := t.write.closeSelf() |
||||
t.closeSelf() |
||||
return err |
||||
} |
||||
|
||||
func (t *memTransport) writePacket(p []byte) error { |
||||
t.write.Lock() |
||||
defer t.write.Unlock() |
||||
if t.write.eof { |
||||
return io.EOF |
||||
} |
||||
c := make([]byte, len(p)) |
||||
copy(c, p) |
||||
t.write.pending = append(t.write.pending, c) |
||||
t.write.Cond.Signal() |
||||
return nil |
||||
} |
||||
|
||||
func memPipe() (a, b packetConn) { |
||||
t1 := memTransport{} |
||||
t2 := memTransport{} |
||||
t1.write = &t2 |
||||
t2.write = &t1 |
||||
t1.Cond = sync.NewCond(&t1.Mutex) |
||||
t2.Cond = sync.NewCond(&t2.Mutex) |
||||
return &t1, &t2 |
||||
} |
||||
|
||||
func TestMemPipe(t *testing.T) { |
||||
a, b := memPipe() |
||||
if err := a.writePacket([]byte{42}); err != nil { |
||||
t.Fatalf("writePacket: %v", err) |
||||
} |
||||
if err := a.Close(); err != nil { |
||||
t.Fatal("Close: ", err) |
||||
} |
||||
p, err := b.readPacket() |
||||
if err != nil { |
||||
t.Fatal("readPacket: ", err) |
||||
} |
||||
if len(p) != 1 || p[0] != 42 { |
||||
t.Fatalf("got %v, want {42}", p) |
||||
} |
||||
p, err = b.readPacket() |
||||
if err != io.EOF { |
||||
t.Fatalf("got %v, %v, want EOF", p, err) |
||||
} |
||||
} |
||||
|
||||
func TestDoubleClose(t *testing.T) { |
||||
a, _ := memPipe() |
||||
err := a.Close() |
||||
if err != nil { |
||||
t.Errorf("Close: %v", err) |
||||
} |
||||
err = a.Close() |
||||
if err != io.EOF { |
||||
t.Errorf("expect EOF on double close.") |
||||
} |
||||
} |
||||
@ -1,725 +0,0 @@ |
||||
// 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 ( |
||||
"bytes" |
||||
"encoding/binary" |
||||
"errors" |
||||
"fmt" |
||||
"io" |
||||
"math/big" |
||||
"reflect" |
||||
"strconv" |
||||
) |
||||
|
||||
// These are SSH message type numbers. They are scattered around several
|
||||
// documents but many were taken from [SSH-PARAMETERS].
|
||||
const ( |
||||
msgIgnore = 2 |
||||
msgUnimplemented = 3 |
||||
msgDebug = 4 |
||||
msgNewKeys = 21 |
||||
|
||||
// Standard authentication messages
|
||||
msgUserAuthSuccess = 52 |
||||
msgUserAuthBanner = 53 |
||||
) |
||||
|
||||
// SSH messages:
|
||||
//
|
||||
// These structures mirror the wire format of the corresponding SSH messages.
|
||||
// They are marshaled using reflection with the marshal and unmarshal functions
|
||||
// in this file. The only wrinkle is that a final member of type []byte with a
|
||||
// ssh tag of "rest" receives the remainder of a packet when unmarshaling.
|
||||
|
||||
// See RFC 4253, section 11.1.
|
||||
const msgDisconnect = 1 |
||||
|
||||
// disconnectMsg is the message that signals a disconnect. It is also
|
||||
// the error type returned from mux.Wait()
|
||||
type disconnectMsg struct { |
||||
Reason uint32 `sshtype:"1"` |
||||
Message string |
||||
Language string |
||||
} |
||||
|
||||
func (d *disconnectMsg) Error() string { |
||||
return fmt.Sprintf("ssh: disconnect reason %d: %s", d.Reason, d.Message) |
||||
} |
||||
|
||||
// See RFC 4253, section 7.1.
|
||||
const msgKexInit = 20 |
||||
|
||||
type kexInitMsg struct { |
||||
Cookie [16]byte `sshtype:"20"` |
||||
KexAlgos []string |
||||
ServerHostKeyAlgos []string |
||||
CiphersClientServer []string |
||||
CiphersServerClient []string |
||||
MACsClientServer []string |
||||
MACsServerClient []string |
||||
CompressionClientServer []string |
||||
CompressionServerClient []string |
||||
LanguagesClientServer []string |
||||
LanguagesServerClient []string |
||||
FirstKexFollows bool |
||||
Reserved uint32 |
||||
} |
||||
|
||||
// See RFC 4253, section 8.
|
||||
|
||||
// Diffie-Helman
|
||||
const msgKexDHInit = 30 |
||||
|
||||
type kexDHInitMsg struct { |
||||
X *big.Int `sshtype:"30"` |
||||
} |
||||
|
||||
const msgKexECDHInit = 30 |
||||
|
||||
type kexECDHInitMsg struct { |
||||
ClientPubKey []byte `sshtype:"30"` |
||||
} |
||||
|
||||
const msgKexECDHReply = 31 |
||||
|
||||
type kexECDHReplyMsg struct { |
||||
HostKey []byte `sshtype:"31"` |
||||
EphemeralPubKey []byte |
||||
Signature []byte |
||||
} |
||||
|
||||
const msgKexDHReply = 31 |
||||
|
||||
type kexDHReplyMsg struct { |
||||
HostKey []byte `sshtype:"31"` |
||||
Y *big.Int |
||||
Signature []byte |
||||
} |
||||
|
||||
// See RFC 4253, section 10.
|
||||
const msgServiceRequest = 5 |
||||
|
||||
type serviceRequestMsg struct { |
||||
Service string `sshtype:"5"` |
||||
} |
||||
|
||||
// See RFC 4253, section 10.
|
||||
const msgServiceAccept = 6 |
||||
|
||||
type serviceAcceptMsg struct { |
||||
Service string `sshtype:"6"` |
||||
} |
||||
|
||||
// See RFC 4252, section 5.
|
||||
const msgUserAuthRequest = 50 |
||||
|
||||
type userAuthRequestMsg struct { |
||||
User string `sshtype:"50"` |
||||
Service string |
||||
Method string |
||||
Payload []byte `ssh:"rest"` |
||||
} |
||||
|
||||
// See RFC 4252, section 5.1
|
||||
const msgUserAuthFailure = 51 |
||||
|
||||
type userAuthFailureMsg struct { |
||||
Methods []string `sshtype:"51"` |
||||
PartialSuccess bool |
||||
} |
||||
|
||||
// See RFC 4256, section 3.2
|
||||
const msgUserAuthInfoRequest = 60 |
||||
const msgUserAuthInfoResponse = 61 |
||||
|
||||
type userAuthInfoRequestMsg struct { |
||||
User string `sshtype:"60"` |
||||
Instruction string |
||||
DeprecatedLanguage string |
||||
NumPrompts uint32 |
||||
Prompts []byte `ssh:"rest"` |
||||
} |
||||
|
||||
// See RFC 4254, section 5.1.
|
||||
const msgChannelOpen = 90 |
||||
|
||||
type channelOpenMsg struct { |
||||
ChanType string `sshtype:"90"` |
||||
PeersId uint32 |
||||
PeersWindow uint32 |
||||
MaxPacketSize uint32 |
||||
TypeSpecificData []byte `ssh:"rest"` |
||||
} |
||||
|
||||
const msgChannelExtendedData = 95 |
||||
const msgChannelData = 94 |
||||
|
||||
// See RFC 4254, section 5.1.
|
||||
const msgChannelOpenConfirm = 91 |
||||
|
||||
type channelOpenConfirmMsg struct { |
||||
PeersId uint32 `sshtype:"91"` |
||||
MyId uint32 |
||||
MyWindow uint32 |
||||
MaxPacketSize uint32 |
||||
TypeSpecificData []byte `ssh:"rest"` |
||||
} |
||||
|
||||
// See RFC 4254, section 5.1.
|
||||
const msgChannelOpenFailure = 92 |
||||
|
||||
type channelOpenFailureMsg struct { |
||||
PeersId uint32 `sshtype:"92"` |
||||
Reason RejectionReason |
||||
Message string |
||||
Language string |
||||
} |
||||
|
||||
const msgChannelRequest = 98 |
||||
|
||||
type channelRequestMsg struct { |
||||
PeersId uint32 `sshtype:"98"` |
||||
Request string |
||||
WantReply bool |
||||
RequestSpecificData []byte `ssh:"rest"` |
||||
} |
||||
|
||||
// See RFC 4254, section 5.4.
|
||||
const msgChannelSuccess = 99 |
||||
|
||||
type channelRequestSuccessMsg struct { |
||||
PeersId uint32 `sshtype:"99"` |
||||
} |
||||
|
||||
// See RFC 4254, section 5.4.
|
||||
const msgChannelFailure = 100 |
||||
|
||||
type channelRequestFailureMsg struct { |
||||
PeersId uint32 `sshtype:"100"` |
||||
} |
||||
|
||||
// See RFC 4254, section 5.3
|
||||
const msgChannelClose = 97 |
||||
|
||||
type channelCloseMsg struct { |
||||
PeersId uint32 `sshtype:"97"` |
||||
} |
||||
|
||||
// See RFC 4254, section 5.3
|
||||
const msgChannelEOF = 96 |
||||
|
||||
type channelEOFMsg struct { |
||||
PeersId uint32 `sshtype:"96"` |
||||
} |
||||
|
||||
// See RFC 4254, section 4
|
||||
const msgGlobalRequest = 80 |
||||
|
||||
type globalRequestMsg struct { |
||||
Type string `sshtype:"80"` |
||||
WantReply bool |
||||
Data []byte `ssh:"rest"` |
||||
} |
||||
|
||||
// See RFC 4254, section 4
|
||||
const msgRequestSuccess = 81 |
||||
|
||||
type globalRequestSuccessMsg struct { |
||||
Data []byte `ssh:"rest" sshtype:"81"` |
||||
} |
||||
|
||||
// See RFC 4254, section 4
|
||||
const msgRequestFailure = 82 |
||||
|
||||
type globalRequestFailureMsg struct { |
||||
Data []byte `ssh:"rest" sshtype:"82"` |
||||
} |
||||
|
||||
// See RFC 4254, section 5.2
|
||||
const msgChannelWindowAdjust = 93 |
||||
|
||||
type windowAdjustMsg struct { |
||||
PeersId uint32 `sshtype:"93"` |
||||
AdditionalBytes uint32 |
||||
} |
||||
|
||||
// See RFC 4252, section 7
|
||||
const msgUserAuthPubKeyOk = 60 |
||||
|
||||
type userAuthPubKeyOkMsg struct { |
||||
Algo string `sshtype:"60"` |
||||
PubKey []byte |
||||
} |
||||
|
||||
// typeTag returns the type byte for the given type. The type should
|
||||
// be struct.
|
||||
func typeTag(structType reflect.Type) byte { |
||||
var tag byte |
||||
var tagStr string |
||||
tagStr = structType.Field(0).Tag.Get("sshtype") |
||||
i, err := strconv.Atoi(tagStr) |
||||
if err == nil { |
||||
tag = byte(i) |
||||
} |
||||
return tag |
||||
} |
||||
|
||||
func fieldError(t reflect.Type, field int, problem string) error { |
||||
if problem != "" { |
||||
problem = ": " + problem |
||||
} |
||||
return fmt.Errorf("ssh: unmarshal error for field %s of type %s%s", t.Field(field).Name, t.Name(), problem) |
||||
} |
||||
|
||||
var errShortRead = errors.New("ssh: short read") |
||||
|
||||
// Unmarshal parses data in SSH wire format into a structure. The out
|
||||
// argument should be a pointer to struct. If the first member of the
|
||||
// struct has the "sshtype" tag set to a number in decimal, the packet
|
||||
// must start that number. In case of error, Unmarshal returns a
|
||||
// ParseError or UnexpectedMessageError.
|
||||
func Unmarshal(data []byte, out interface{}) error { |
||||
v := reflect.ValueOf(out).Elem() |
||||
structType := v.Type() |
||||
expectedType := typeTag(structType) |
||||
if len(data) == 0 { |
||||
return parseError(expectedType) |
||||
} |
||||
if expectedType > 0 { |
||||
if data[0] != expectedType { |
||||
return unexpectedMessageError(expectedType, data[0]) |
||||
} |
||||
data = data[1:] |
||||
} |
||||
|
||||
var ok bool |
||||
for i := 0; i < v.NumField(); i++ { |
||||
field := v.Field(i) |
||||
t := field.Type() |
||||
switch t.Kind() { |
||||
case reflect.Bool: |
||||
if len(data) < 1 { |
||||
return errShortRead |
||||
} |
||||
field.SetBool(data[0] != 0) |
||||
data = data[1:] |
||||
case reflect.Array: |
||||
if t.Elem().Kind() != reflect.Uint8 { |
||||
return fieldError(structType, i, "array of unsupported type") |
||||
} |
||||
if len(data) < t.Len() { |
||||
return errShortRead |
||||
} |
||||
for j, n := 0, t.Len(); j < n; j++ { |
||||
field.Index(j).Set(reflect.ValueOf(data[j])) |
||||
} |
||||
data = data[t.Len():] |
||||
case reflect.Uint64: |
||||
var u64 uint64 |
||||
if u64, data, ok = parseUint64(data); !ok { |
||||
return errShortRead |
||||
} |
||||
field.SetUint(u64) |
||||
case reflect.Uint32: |
||||
var u32 uint32 |
||||
if u32, data, ok = parseUint32(data); !ok { |
||||
return errShortRead |
||||
} |
||||
field.SetUint(uint64(u32)) |
||||
case reflect.Uint8: |
||||
if len(data) < 1 { |
||||
return errShortRead |
||||
} |
||||
field.SetUint(uint64(data[0])) |
||||
data = data[1:] |
||||
case reflect.String: |
||||
var s []byte |
||||
if s, data, ok = parseString(data); !ok { |
||||
return fieldError(structType, i, "") |
||||
} |
||||
field.SetString(string(s)) |
||||
case reflect.Slice: |
||||
switch t.Elem().Kind() { |
||||
case reflect.Uint8: |
||||
if structType.Field(i).Tag.Get("ssh") == "rest" { |
||||
field.Set(reflect.ValueOf(data)) |
||||
data = nil |
||||
} else { |
||||
var s []byte |
||||
if s, data, ok = parseString(data); !ok { |
||||
return errShortRead |
||||
} |
||||
field.Set(reflect.ValueOf(s)) |
||||
} |
||||
case reflect.String: |
||||
var nl []string |
||||
if nl, data, ok = parseNameList(data); !ok { |
||||
return errShortRead |
||||
} |
||||
field.Set(reflect.ValueOf(nl)) |
||||
default: |
||||
return fieldError(structType, i, "slice of unsupported type") |
||||
} |
||||
case reflect.Ptr: |
||||
if t == bigIntType { |
||||
var n *big.Int |
||||
if n, data, ok = parseInt(data); !ok { |
||||
return errShortRead |
||||
} |
||||
field.Set(reflect.ValueOf(n)) |
||||
} else { |
||||
return fieldError(structType, i, "pointer to unsupported type") |
||||
} |
||||
default: |
||||
return fieldError(structType, i, "unsupported type") |
||||
} |
||||
} |
||||
|
||||
if len(data) != 0 { |
||||
return parseError(expectedType) |
||||
} |
||||
|
||||
return nil |
||||
} |
||||
|
||||
// Marshal serializes the message in msg to SSH wire format. The msg
|
||||
// argument should be a struct or pointer to struct. If the first
|
||||
// member has the "sshtype" tag set to a number in decimal, that
|
||||
// number is prepended to the result. If the last of member has the
|
||||
// "ssh" tag set to "rest", its contents are appended to the output.
|
||||
func Marshal(msg interface{}) []byte { |
||||
out := make([]byte, 0, 64) |
||||
return marshalStruct(out, msg) |
||||
} |
||||
|
||||
func marshalStruct(out []byte, msg interface{}) []byte { |
||||
v := reflect.Indirect(reflect.ValueOf(msg)) |
||||
msgType := typeTag(v.Type()) |
||||
if msgType > 0 { |
||||
out = append(out, msgType) |
||||
} |
||||
|
||||
for i, n := 0, v.NumField(); i < n; i++ { |
||||
field := v.Field(i) |
||||
switch t := field.Type(); t.Kind() { |
||||
case reflect.Bool: |
||||
var v uint8 |
||||
if field.Bool() { |
||||
v = 1 |
||||
} |
||||
out = append(out, v) |
||||
case reflect.Array: |
||||
if t.Elem().Kind() != reflect.Uint8 { |
||||
panic(fmt.Sprintf("array of non-uint8 in field %d: %T", i, field.Interface())) |
||||
} |
||||
for j, l := 0, t.Len(); j < l; j++ { |
||||
out = append(out, uint8(field.Index(j).Uint())) |
||||
} |
||||
case reflect.Uint32: |
||||
out = appendU32(out, uint32(field.Uint())) |
||||
case reflect.Uint64: |
||||
out = appendU64(out, uint64(field.Uint())) |
||||
case reflect.Uint8: |
||||
out = append(out, uint8(field.Uint())) |
||||
case reflect.String: |
||||
s := field.String() |
||||
out = appendInt(out, len(s)) |
||||
out = append(out, s...) |
||||
case reflect.Slice: |
||||
switch t.Elem().Kind() { |
||||
case reflect.Uint8: |
||||
if v.Type().Field(i).Tag.Get("ssh") != "rest" { |
||||
out = appendInt(out, field.Len()) |
||||
} |
||||
out = append(out, field.Bytes()...) |
||||
case reflect.String: |
||||
offset := len(out) |
||||
out = appendU32(out, 0) |
||||
if n := field.Len(); n > 0 { |
||||
for j := 0; j < n; j++ { |
||||
f := field.Index(j) |
||||
if j != 0 { |
||||
out = append(out, ',') |
||||
} |
||||
out = append(out, f.String()...) |
||||
} |
||||
// overwrite length value
|
||||
binary.BigEndian.PutUint32(out[offset:], uint32(len(out)-offset-4)) |
||||
} |
||||
default: |
||||
panic(fmt.Sprintf("slice of unknown type in field %d: %T", i, field.Interface())) |
||||
} |
||||
case reflect.Ptr: |
||||
if t == bigIntType { |
||||
var n *big.Int |
||||
nValue := reflect.ValueOf(&n) |
||||
nValue.Elem().Set(field) |
||||
needed := intLength(n) |
||||
oldLength := len(out) |
||||
|
||||
if cap(out)-len(out) < needed { |
||||
newOut := make([]byte, len(out), 2*(len(out)+needed)) |
||||
copy(newOut, out) |
||||
out = newOut |
||||
} |
||||
out = out[:oldLength+needed] |
||||
marshalInt(out[oldLength:], n) |
||||
} else { |
||||
panic(fmt.Sprintf("pointer to unknown type in field %d: %T", i, field.Interface())) |
||||
} |
||||
} |
||||
} |
||||
|
||||
return out |
||||
} |
||||
|
||||
var bigOne = big.NewInt(1) |
||||
|
||||
func parseString(in []byte) (out, rest []byte, ok bool) { |
||||
if len(in) < 4 { |
||||
return |
||||
} |
||||
length := binary.BigEndian.Uint32(in) |
||||
in = in[4:] |
||||
if uint32(len(in)) < length { |
||||
return |
||||
} |
||||
out = in[:length] |
||||
rest = in[length:] |
||||
ok = true |
||||
return |
||||
} |
||||
|
||||
var ( |
||||
comma = []byte{','} |
||||
emptyNameList = []string{} |
||||
) |
||||
|
||||
func parseNameList(in []byte) (out []string, rest []byte, ok bool) { |
||||
contents, rest, ok := parseString(in) |
||||
if !ok { |
||||
return |
||||
} |
||||
if len(contents) == 0 { |
||||
out = emptyNameList |
||||
return |
||||
} |
||||
parts := bytes.Split(contents, comma) |
||||
out = make([]string, len(parts)) |
||||
for i, part := range parts { |
||||
out[i] = string(part) |
||||
} |
||||
return |
||||
} |
||||
|
||||
func parseInt(in []byte) (out *big.Int, rest []byte, ok bool) { |
||||
contents, rest, ok := parseString(in) |
||||
if !ok { |
||||
return |
||||
} |
||||
out = new(big.Int) |
||||
|
||||
if len(contents) > 0 && contents[0]&0x80 == 0x80 { |
||||
// This is a negative number
|
||||
notBytes := make([]byte, len(contents)) |
||||
for i := range notBytes { |
||||
notBytes[i] = ^contents[i] |
||||
} |
||||
out.SetBytes(notBytes) |
||||
out.Add(out, bigOne) |
||||
out.Neg(out) |
||||
} else { |
||||
// Positive number
|
||||
out.SetBytes(contents) |
||||
} |
||||
ok = true |
||||
return |
||||
} |
||||
|
||||
func parseUint32(in []byte) (uint32, []byte, bool) { |
||||
if len(in) < 4 { |
||||
return 0, nil, false |
||||
} |
||||
return binary.BigEndian.Uint32(in), in[4:], true |
||||
} |
||||
|
||||
func parseUint64(in []byte) (uint64, []byte, bool) { |
||||
if len(in) < 8 { |
||||
return 0, nil, false |
||||
} |
||||
return binary.BigEndian.Uint64(in), in[8:], true |
||||
} |
||||
|
||||
func intLength(n *big.Int) int { |
||||
length := 4 /* length bytes */ |
||||
if n.Sign() < 0 { |
||||
nMinus1 := new(big.Int).Neg(n) |
||||
nMinus1.Sub(nMinus1, bigOne) |
||||
bitLen := nMinus1.BitLen() |
||||
if bitLen%8 == 0 { |
||||
// The number will need 0xff padding
|
||||
length++ |
||||
} |
||||
length += (bitLen + 7) / 8 |
||||
} else if n.Sign() == 0 { |
||||
// A zero is the zero length string
|
||||
} else { |
||||
bitLen := n.BitLen() |
||||
if bitLen%8 == 0 { |
||||
// The number will need 0x00 padding
|
||||
length++ |
||||
} |
||||
length += (bitLen + 7) / 8 |
||||
} |
||||
|
||||
return length |
||||
} |
||||
|
||||
func marshalUint32(to []byte, n uint32) []byte { |
||||
binary.BigEndian.PutUint32(to, n) |
||||
return to[4:] |
||||
} |
||||
|
||||
func marshalUint64(to []byte, n uint64) []byte { |
||||
binary.BigEndian.PutUint64(to, n) |
||||
return to[8:] |
||||
} |
||||
|
||||
func marshalInt(to []byte, n *big.Int) []byte { |
||||
lengthBytes := to |
||||
to = to[4:] |
||||
length := 0 |
||||
|
||||
if n.Sign() < 0 { |
||||
// A negative number has to be converted to two's-complement
|
||||
// form. So we'll subtract 1 and invert. If the
|
||||
// most-significant-bit isn't set then we'll need to pad the
|
||||
// beginning with 0xff in order to keep the number negative.
|
||||
nMinus1 := new(big.Int).Neg(n) |
||||
nMinus1.Sub(nMinus1, bigOne) |
||||
bytes := nMinus1.Bytes() |
||||
for i := range bytes { |
||||
bytes[i] ^= 0xff |
||||
} |
||||
if len(bytes) == 0 || bytes[0]&0x80 == 0 { |
||||
to[0] = 0xff |
||||
to = to[1:] |
||||
length++ |
||||
} |
||||
nBytes := copy(to, bytes) |
||||
to = to[nBytes:] |
||||
length += nBytes |
||||
} else if n.Sign() == 0 { |
||||
// A zero is the zero length string
|
||||
} else { |
||||
bytes := n.Bytes() |
||||
if len(bytes) > 0 && bytes[0]&0x80 != 0 { |
||||
// We'll have to pad this with a 0x00 in order to
|
||||
// stop it looking like a negative number.
|
||||
to[0] = 0 |
||||
to = to[1:] |
||||
length++ |
||||
} |
||||
nBytes := copy(to, bytes) |
||||
to = to[nBytes:] |
||||
length += nBytes |
||||
} |
||||
|
||||
lengthBytes[0] = byte(length >> 24) |
||||
lengthBytes[1] = byte(length >> 16) |
||||
lengthBytes[2] = byte(length >> 8) |
||||
lengthBytes[3] = byte(length) |
||||
return to |
||||
} |
||||
|
||||
func writeInt(w io.Writer, n *big.Int) { |
||||
length := intLength(n) |
||||
buf := make([]byte, length) |
||||
marshalInt(buf, n) |
||||
w.Write(buf) |
||||
} |
||||
|
||||
func writeString(w io.Writer, s []byte) { |
||||
var lengthBytes [4]byte |
||||
lengthBytes[0] = byte(len(s) >> 24) |
||||
lengthBytes[1] = byte(len(s) >> 16) |
||||
lengthBytes[2] = byte(len(s) >> 8) |
||||
lengthBytes[3] = byte(len(s)) |
||||
w.Write(lengthBytes[:]) |
||||
w.Write(s) |
||||
} |
||||
|
||||
func stringLength(n int) int { |
||||
return 4 + n |
||||
} |
||||
|
||||
func marshalString(to []byte, s []byte) []byte { |
||||
to[0] = byte(len(s) >> 24) |
||||
to[1] = byte(len(s) >> 16) |
||||
to[2] = byte(len(s) >> 8) |
||||
to[3] = byte(len(s)) |
||||
to = to[4:] |
||||
copy(to, s) |
||||
return to[len(s):] |
||||
} |
||||
|
||||
var bigIntType = reflect.TypeOf((*big.Int)(nil)) |
||||
|
||||
// Decode a packet into its corresponding message.
|
||||
func decode(packet []byte) (interface{}, error) { |
||||
var msg interface{} |
||||
switch packet[0] { |
||||
case msgDisconnect: |
||||
msg = new(disconnectMsg) |
||||
case msgServiceRequest: |
||||
msg = new(serviceRequestMsg) |
||||
case msgServiceAccept: |
||||
msg = new(serviceAcceptMsg) |
||||
case msgKexInit: |
||||
msg = new(kexInitMsg) |
||||
case msgKexDHInit: |
||||
msg = new(kexDHInitMsg) |
||||
case msgKexDHReply: |
||||
msg = new(kexDHReplyMsg) |
||||
case msgUserAuthRequest: |
||||
msg = new(userAuthRequestMsg) |
||||
case msgUserAuthFailure: |
||||
msg = new(userAuthFailureMsg) |
||||
case msgUserAuthPubKeyOk: |
||||
msg = new(userAuthPubKeyOkMsg) |
||||
case msgGlobalRequest: |
||||
msg = new(globalRequestMsg) |
||||
case msgRequestSuccess: |
||||
msg = new(globalRequestSuccessMsg) |
||||
case msgRequestFailure: |
||||
msg = new(globalRequestFailureMsg) |
||||
case msgChannelOpen: |
||||
msg = new(channelOpenMsg) |
||||
case msgChannelOpenConfirm: |
||||
msg = new(channelOpenConfirmMsg) |
||||
case msgChannelOpenFailure: |
||||
msg = new(channelOpenFailureMsg) |
||||
case msgChannelWindowAdjust: |
||||
msg = new(windowAdjustMsg) |
||||
case msgChannelEOF: |
||||
msg = new(channelEOFMsg) |
||||
case msgChannelClose: |
||||
msg = new(channelCloseMsg) |
||||
case msgChannelRequest: |
||||
msg = new(channelRequestMsg) |
||||
case msgChannelSuccess: |
||||
msg = new(channelRequestSuccessMsg) |
||||
case msgChannelFailure: |
||||
msg = new(channelRequestFailureMsg) |
||||
default: |
||||
return nil, unexpectedMessageError(0, packet[0]) |
||||
} |
||||
if err := Unmarshal(packet, msg); err != nil { |
||||
return nil, err |
||||
} |
||||
return msg, nil |
||||
} |
||||
@ -1,254 +0,0 @@ |
||||
// 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 ( |
||||
"bytes" |
||||
"math/big" |
||||
"math/rand" |
||||
"reflect" |
||||
"testing" |
||||
"testing/quick" |
||||
) |
||||
|
||||
var intLengthTests = []struct { |
||||
val, length int |
||||
}{ |
||||
{0, 4 + 0}, |
||||
{1, 4 + 1}, |
||||
{127, 4 + 1}, |
||||
{128, 4 + 2}, |
||||
{-1, 4 + 1}, |
||||
} |
||||
|
||||
func TestIntLength(t *testing.T) { |
||||
for _, test := range intLengthTests { |
||||
v := new(big.Int).SetInt64(int64(test.val)) |
||||
length := intLength(v) |
||||
if length != test.length { |
||||
t.Errorf("For %d, got length %d but expected %d", test.val, length, test.length) |
||||
} |
||||
} |
||||
} |
||||
|
||||
type msgAllTypes struct { |
||||
Bool bool `sshtype:"21"` |
||||
Array [16]byte |
||||
Uint64 uint64 |
||||
Uint32 uint32 |
||||
Uint8 uint8 |
||||
String string |
||||
Strings []string |
||||
Bytes []byte |
||||
Int *big.Int |
||||
Rest []byte `ssh:"rest"` |
||||
} |
||||
|
||||
func (t *msgAllTypes) Generate(rand *rand.Rand, size int) reflect.Value { |
||||
m := &msgAllTypes{} |
||||
m.Bool = rand.Intn(2) == 1 |
||||
randomBytes(m.Array[:], rand) |
||||
m.Uint64 = uint64(rand.Int63n(1<<63 - 1)) |
||||
m.Uint32 = uint32(rand.Intn((1 << 31) - 1)) |
||||
m.Uint8 = uint8(rand.Intn(1 << 8)) |
||||
m.String = string(m.Array[:]) |
||||
m.Strings = randomNameList(rand) |
||||
m.Bytes = m.Array[:] |
||||
m.Int = randomInt(rand) |
||||
m.Rest = m.Array[:] |
||||
return reflect.ValueOf(m) |
||||
} |
||||
|
||||
func TestMarshalUnmarshal(t *testing.T) { |
||||
rand := rand.New(rand.NewSource(0)) |
||||
iface := &msgAllTypes{} |
||||
ty := reflect.ValueOf(iface).Type() |
||||
|
||||
n := 100 |
||||
if testing.Short() { |
||||
n = 5 |
||||
} |
||||
for j := 0; j < n; j++ { |
||||
v, ok := quick.Value(ty, rand) |
||||
if !ok { |
||||
t.Errorf("failed to create value") |
||||
break |
||||
} |
||||
|
||||
m1 := v.Elem().Interface() |
||||
m2 := iface |
||||
|
||||
marshaled := Marshal(m1) |
||||
if err := Unmarshal(marshaled, m2); err != nil { |
||||
t.Errorf("Unmarshal %#v: %s", m1, err) |
||||
break |
||||
} |
||||
|
||||
if !reflect.DeepEqual(v.Interface(), m2) { |
||||
t.Errorf("got: %#v\nwant:%#v\n%x", m2, m1, marshaled) |
||||
break |
||||
} |
||||
} |
||||
} |
||||
|
||||
func TestUnmarshalEmptyPacket(t *testing.T) { |
||||
var b []byte |
||||
var m channelRequestSuccessMsg |
||||
if err := Unmarshal(b, &m); err == nil { |
||||
t.Fatalf("unmarshal of empty slice succeeded") |
||||
} |
||||
} |
||||
|
||||
func TestUnmarshalUnexpectedPacket(t *testing.T) { |
||||
type S struct { |
||||
I uint32 `sshtype:"43"` |
||||
S string |
||||
B bool |
||||
} |
||||
|
||||
s := S{11, "hello", true} |
||||
packet := Marshal(s) |
||||
packet[0] = 42 |
||||
roundtrip := S{} |
||||
err := Unmarshal(packet, &roundtrip) |
||||
if err == nil { |
||||
t.Fatal("expected error, not nil") |
||||
} |
||||
} |
||||
|
||||
func TestMarshalPtr(t *testing.T) { |
||||
s := struct { |
||||
S string |
||||
}{"hello"} |
||||
|
||||
m1 := Marshal(s) |
||||
m2 := Marshal(&s) |
||||
if !bytes.Equal(m1, m2) { |
||||
t.Errorf("got %q, want %q for marshaled pointer", m2, m1) |
||||
} |
||||
} |
||||
|
||||
func TestBareMarshalUnmarshal(t *testing.T) { |
||||
type S struct { |
||||
I uint32 |
||||
S string |
||||
B bool |
||||
} |
||||
|
||||
s := S{42, "hello", true} |
||||
packet := Marshal(s) |
||||
roundtrip := S{} |
||||
Unmarshal(packet, &roundtrip) |
||||
|
||||
if !reflect.DeepEqual(s, roundtrip) { |
||||
t.Errorf("got %#v, want %#v", roundtrip, s) |
||||
} |
||||
} |
||||
|
||||
func TestBareMarshal(t *testing.T) { |
||||
type S2 struct { |
||||
I uint32 |
||||
} |
||||
s := S2{42} |
||||
packet := Marshal(s) |
||||
i, rest, ok := parseUint32(packet) |
||||
if len(rest) > 0 || !ok { |
||||
t.Errorf("parseInt(%q): parse error", packet) |
||||
} |
||||
if i != s.I { |
||||
t.Errorf("got %d, want %d", i, s.I) |
||||
} |
||||
} |
||||
|
||||
func TestUnmarshalShortKexInitPacket(t *testing.T) { |
||||
// This used to panic.
|
||||
// Issue 11348
|
||||
packet := []byte{0x14, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0xff, 0xff, 0xff, 0xff} |
||||
kim := &kexInitMsg{} |
||||
if err := Unmarshal(packet, kim); err == nil { |
||||
t.Error("truncated packet unmarshaled without error") |
||||
} |
||||
} |
||||
|
||||
func randomBytes(out []byte, rand *rand.Rand) { |
||||
for i := 0; i < len(out); i++ { |
||||
out[i] = byte(rand.Int31()) |
||||
} |
||||
} |
||||
|
||||
func randomNameList(rand *rand.Rand) []string { |
||||
ret := make([]string, rand.Int31()&15) |
||||
for i := range ret { |
||||
s := make([]byte, 1+(rand.Int31()&15)) |
||||
for j := range s { |
||||
s[j] = 'a' + uint8(rand.Int31()&15) |
||||
} |
||||
ret[i] = string(s) |
||||
} |
||||
return ret |
||||
} |
||||
|
||||
func randomInt(rand *rand.Rand) *big.Int { |
||||
return new(big.Int).SetInt64(int64(int32(rand.Uint32()))) |
||||
} |
||||
|
||||
func (*kexInitMsg) Generate(rand *rand.Rand, size int) reflect.Value { |
||||
ki := &kexInitMsg{} |
||||
randomBytes(ki.Cookie[:], rand) |
||||
ki.KexAlgos = randomNameList(rand) |
||||
ki.ServerHostKeyAlgos = randomNameList(rand) |
||||
ki.CiphersClientServer = randomNameList(rand) |
||||
ki.CiphersServerClient = randomNameList(rand) |
||||
ki.MACsClientServer = randomNameList(rand) |
||||
ki.MACsServerClient = randomNameList(rand) |
||||
ki.CompressionClientServer = randomNameList(rand) |
||||
ki.CompressionServerClient = randomNameList(rand) |
||||
ki.LanguagesClientServer = randomNameList(rand) |
||||
ki.LanguagesServerClient = randomNameList(rand) |
||||
if rand.Int31()&1 == 1 { |
||||
ki.FirstKexFollows = true |
||||
} |
||||
return reflect.ValueOf(ki) |
||||
} |
||||
|
||||
func (*kexDHInitMsg) Generate(rand *rand.Rand, size int) reflect.Value { |
||||
dhi := &kexDHInitMsg{} |
||||
dhi.X = randomInt(rand) |
||||
return reflect.ValueOf(dhi) |
||||
} |
||||
|
||||
var ( |
||||
_kexInitMsg = new(kexInitMsg).Generate(rand.New(rand.NewSource(0)), 10).Elem().Interface() |
||||
_kexDHInitMsg = new(kexDHInitMsg).Generate(rand.New(rand.NewSource(0)), 10).Elem().Interface() |
||||
|
||||
_kexInit = Marshal(_kexInitMsg) |
||||
_kexDHInit = Marshal(_kexDHInitMsg) |
||||
) |
||||
|
||||
func BenchmarkMarshalKexInitMsg(b *testing.B) { |
||||
for i := 0; i < b.N; i++ { |
||||
Marshal(_kexInitMsg) |
||||
} |
||||
} |
||||
|
||||
func BenchmarkUnmarshalKexInitMsg(b *testing.B) { |
||||
m := new(kexInitMsg) |
||||
for i := 0; i < b.N; i++ { |
||||
Unmarshal(_kexInit, m) |
||||
} |
||||
} |
||||
|
||||
func BenchmarkMarshalKexDHInitMsg(b *testing.B) { |
||||
for i := 0; i < b.N; i++ { |
||||
Marshal(_kexDHInitMsg) |
||||
} |
||||
} |
||||
|
||||
func BenchmarkUnmarshalKexDHInitMsg(b *testing.B) { |
||||
m := new(kexDHInitMsg) |
||||
for i := 0; i < b.N; i++ { |
||||
Unmarshal(_kexDHInit, m) |
||||
} |
||||
} |
||||
@ -1,356 +0,0 @@ |
||||
// Copyright 2013 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 ( |
||||
"encoding/binary" |
||||
"fmt" |
||||
"io" |
||||
"log" |
||||
"sync" |
||||
"sync/atomic" |
||||
) |
||||
|
||||
// debugMux, if set, causes messages in the connection protocol to be
|
||||
// logged.
|
||||
const debugMux = false |
||||
|
||||
// chanList is a thread safe channel list.
|
||||
type chanList struct { |
||||
// protects concurrent access to chans
|
||||
sync.Mutex |
||||
|
||||
// chans are indexed by the local id of the channel, which the
|
||||
// other side should send in the PeersId field.
|
||||
chans []*channel |
||||
|
||||
// This is a debugging aid: it offsets all IDs by this
|
||||
// amount. This helps distinguish otherwise identical
|
||||
// server/client muxes
|
||||
offset uint32 |
||||
} |
||||
|
||||
// Assigns a channel ID to the given channel.
|
||||
func (c *chanList) add(ch *channel) uint32 { |
||||
c.Lock() |
||||
defer c.Unlock() |
||||
for i := range c.chans { |
||||
if c.chans[i] == nil { |
||||
c.chans[i] = ch |
||||
return uint32(i) + c.offset |
||||
} |
||||
} |
||||
c.chans = append(c.chans, ch) |
||||
return uint32(len(c.chans)-1) + c.offset |
||||
} |
||||
|
||||
// getChan returns the channel for the given ID.
|
||||
func (c *chanList) getChan(id uint32) *channel { |
||||
id -= c.offset |
||||
|
||||
c.Lock() |
||||
defer c.Unlock() |
||||
if id < uint32(len(c.chans)) { |
||||
return c.chans[id] |
||||
} |
||||
return nil |
||||
} |
||||
|
||||
func (c *chanList) remove(id uint32) { |
||||
id -= c.offset |
||||
c.Lock() |
||||
if id < uint32(len(c.chans)) { |
||||
c.chans[id] = nil |
||||
} |
||||
c.Unlock() |
||||
} |
||||
|
||||
// dropAll forgets all channels it knows, returning them in a slice.
|
||||
func (c *chanList) dropAll() []*channel { |
||||
c.Lock() |
||||
defer c.Unlock() |
||||
var r []*channel |
||||
|
||||
for _, ch := range c.chans { |
||||
if ch == nil { |
||||
continue |
||||
} |
||||
r = append(r, ch) |
||||
} |
||||
c.chans = nil |
||||
return r |
||||
} |
||||
|
||||
// mux represents the state for the SSH connection protocol, which
|
||||
// multiplexes many channels onto a single packet transport.
|
||||
type mux struct { |
||||
conn packetConn |
||||
chanList chanList |
||||
|
||||
incomingChannels chan NewChannel |
||||
|
||||
globalSentMu sync.Mutex |
||||
globalResponses chan interface{} |
||||
incomingRequests chan *Request |
||||
|
||||
errCond *sync.Cond |
||||
err error |
||||
} |
||||
|
||||
// When debugging, each new chanList instantiation has a different
|
||||
// offset.
|
||||
var globalOff uint32 |
||||
|
||||
func (m *mux) Wait() error { |
||||
m.errCond.L.Lock() |
||||
defer m.errCond.L.Unlock() |
||||
for m.err == nil { |
||||
m.errCond.Wait() |
||||
} |
||||
return m.err |
||||
} |
||||
|
||||
// newMux returns a mux that runs over the given connection.
|
||||
func newMux(p packetConn) *mux { |
||||
m := &mux{ |
||||
conn: p, |
||||
incomingChannels: make(chan NewChannel, 16), |
||||
globalResponses: make(chan interface{}, 1), |
||||
incomingRequests: make(chan *Request, 16), |
||||
errCond: newCond(), |
||||
} |
||||
if debugMux { |
||||
m.chanList.offset = atomic.AddUint32(&globalOff, 1) |
||||
} |
||||
|
||||
go m.loop() |
||||
return m |
||||
} |
||||
|
||||
func (m *mux) sendMessage(msg interface{}) error { |
||||
p := Marshal(msg) |
||||
return m.conn.writePacket(p) |
||||
} |
||||
|
||||
func (m *mux) SendRequest(name string, wantReply bool, payload []byte) (bool, []byte, error) { |
||||
if wantReply { |
||||
m.globalSentMu.Lock() |
||||
defer m.globalSentMu.Unlock() |
||||
} |
||||
|
||||
if err := m.sendMessage(globalRequestMsg{ |
||||
Type: name, |
||||
WantReply: wantReply, |
||||
Data: payload, |
||||
}); err != nil { |
||||
return false, nil, err |
||||
} |
||||
|
||||
if !wantReply { |
||||
return false, nil, nil |
||||
} |
||||
|
||||
msg, ok := <-m.globalResponses |
||||
if !ok { |
||||
return false, nil, io.EOF |
||||
} |
||||
switch msg := msg.(type) { |
||||
case *globalRequestFailureMsg: |
||||
return false, msg.Data, nil |
||||
case *globalRequestSuccessMsg: |
||||
return true, msg.Data, nil |
||||
default: |
||||
return false, nil, fmt.Errorf("ssh: unexpected response to request: %#v", msg) |
||||
} |
||||
} |
||||
|
||||
// ackRequest must be called after processing a global request that
|
||||
// has WantReply set.
|
||||
func (m *mux) ackRequest(ok bool, data []byte) error { |
||||
if ok { |
||||
return m.sendMessage(globalRequestSuccessMsg{Data: data}) |
||||
} |
||||
return m.sendMessage(globalRequestFailureMsg{Data: data}) |
||||
} |
||||
|
||||
// TODO(hanwen): Disconnect is a transport layer message. We should
|
||||
// probably send and receive Disconnect somewhere in the transport
|
||||
// code.
|
||||
|
||||
// Disconnect sends a disconnect message.
|
||||
func (m *mux) Disconnect(reason uint32, message string) error { |
||||
return m.sendMessage(disconnectMsg{ |
||||
Reason: reason, |
||||
Message: message, |
||||
}) |
||||
} |
||||
|
||||
func (m *mux) Close() error { |
||||
return m.conn.Close() |
||||
} |
||||
|
||||
// loop runs the connection machine. It will process packets until an
|
||||
// error is encountered. To synchronize on loop exit, use mux.Wait.
|
||||
func (m *mux) loop() { |
||||
var err error |
||||
for err == nil { |
||||
err = m.onePacket() |
||||
} |
||||
|
||||
for _, ch := range m.chanList.dropAll() { |
||||
ch.close() |
||||
} |
||||
|
||||
close(m.incomingChannels) |
||||
close(m.incomingRequests) |
||||
close(m.globalResponses) |
||||
|
||||
m.conn.Close() |
||||
|
||||
m.errCond.L.Lock() |
||||
m.err = err |
||||
m.errCond.Broadcast() |
||||
m.errCond.L.Unlock() |
||||
|
||||
if debugMux { |
||||
log.Println("loop exit", err) |
||||
} |
||||
} |
||||
|
||||
// onePacket reads and processes one packet.
|
||||
func (m *mux) onePacket() error { |
||||
packet, err := m.conn.readPacket() |
||||
if err != nil { |
||||
return err |
||||
} |
||||
|
||||
if debugMux { |
||||
if packet[0] == msgChannelData || packet[0] == msgChannelExtendedData { |
||||
log.Printf("decoding(%d): data packet - %d bytes", m.chanList.offset, len(packet)) |
||||
} else { |
||||
p, _ := decode(packet) |
||||
log.Printf("decoding(%d): %d %#v - %d bytes", m.chanList.offset, packet[0], p, len(packet)) |
||||
} |
||||
} |
||||
|
||||
switch packet[0] { |
||||
case msgNewKeys: |
||||
// Ignore notification of key change.
|
||||
return nil |
||||
case msgDisconnect: |
||||
return m.handleDisconnect(packet) |
||||
case msgChannelOpen: |
||||
return m.handleChannelOpen(packet) |
||||
case msgGlobalRequest, msgRequestSuccess, msgRequestFailure: |
||||
return m.handleGlobalPacket(packet) |
||||
} |
||||
|
||||
// assume a channel packet.
|
||||
if len(packet) < 5 { |
||||
return parseError(packet[0]) |
||||
} |
||||
id := binary.BigEndian.Uint32(packet[1:]) |
||||
ch := m.chanList.getChan(id) |
||||
if ch == nil { |
||||
return fmt.Errorf("ssh: invalid channel %d", id) |
||||
} |
||||
|
||||
return ch.handlePacket(packet) |
||||
} |
||||
|
||||
func (m *mux) handleDisconnect(packet []byte) error { |
||||
var d disconnectMsg |
||||
if err := Unmarshal(packet, &d); err != nil { |
||||
return err |
||||
} |
||||
|
||||
if debugMux { |
||||
log.Printf("caught disconnect: %v", d) |
||||
} |
||||
return &d |
||||
} |
||||
|
||||
func (m *mux) handleGlobalPacket(packet []byte) error { |
||||
msg, err := decode(packet) |
||||
if err != nil { |
||||
return err |
||||
} |
||||
|
||||
switch msg := msg.(type) { |
||||
case *globalRequestMsg: |
||||
m.incomingRequests <- &Request{ |
||||
Type: msg.Type, |
||||
WantReply: msg.WantReply, |
||||
Payload: msg.Data, |
||||
mux: m, |
||||
} |
||||
case *globalRequestSuccessMsg, *globalRequestFailureMsg: |
||||
m.globalResponses <- msg |
||||
default: |
||||
panic(fmt.Sprintf("not a global message %#v", msg)) |
||||
} |
||||
|
||||
return nil |
||||
} |
||||
|
||||
// handleChannelOpen schedules a channel to be Accept()ed.
|
||||
func (m *mux) handleChannelOpen(packet []byte) error { |
||||
var msg channelOpenMsg |
||||
if err := Unmarshal(packet, &msg); err != nil { |
||||
return err |
||||
} |
||||
|
||||
if msg.MaxPacketSize < minPacketLength || msg.MaxPacketSize > 1<<31 { |
||||
failMsg := channelOpenFailureMsg{ |
||||
PeersId: msg.PeersId, |
||||
Reason: ConnectionFailed, |
||||
Message: "invalid request", |
||||
Language: "en_US.UTF-8", |
||||
} |
||||
return m.sendMessage(failMsg) |
||||
} |
||||
|
||||
c := m.newChannel(msg.ChanType, channelInbound, msg.TypeSpecificData) |
||||
c.remoteId = msg.PeersId |
||||
c.maxRemotePayload = msg.MaxPacketSize |
||||
c.remoteWin.add(msg.PeersWindow) |
||||
m.incomingChannels <- c |
||||
return nil |
||||
} |
||||
|
||||
func (m *mux) OpenChannel(chanType string, extra []byte) (Channel, <-chan *Request, error) { |
||||
ch, err := m.openChannel(chanType, extra) |
||||
if err != nil { |
||||
return nil, nil, err |
||||
} |
||||
|
||||
return ch, ch.incomingRequests, nil |
||||
} |
||||
|
||||
func (m *mux) openChannel(chanType string, extra []byte) (*channel, error) { |
||||
ch := m.newChannel(chanType, channelOutbound, extra) |
||||
|
||||
ch.maxIncomingPayload = channelMaxPacket |
||||
|
||||
open := channelOpenMsg{ |
||||
ChanType: chanType, |
||||
PeersWindow: ch.myWindow, |
||||
MaxPacketSize: ch.maxIncomingPayload, |
||||
TypeSpecificData: extra, |
||||
PeersId: ch.localId, |
||||
} |
||||
if err := m.sendMessage(open); err != nil { |
||||
return nil, err |
||||
} |
||||
|
||||
switch msg := (<-ch.msg).(type) { |
||||
case *channelOpenConfirmMsg: |
||||
return ch, nil |
||||
case *channelOpenFailureMsg: |
||||
return nil, &OpenChannelError{msg.Reason, msg.Message} |
||||
default: |
||||
return nil, fmt.Errorf("ssh: unexpected packet in response to channel open: %T", msg) |
||||
} |
||||
} |
||||
@ -1,525 +0,0 @@ |
||||
// Copyright 2013 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 ( |
||||
"io" |
||||
"io/ioutil" |
||||
"sync" |
||||
"testing" |
||||
) |
||||
|
||||
func muxPair() (*mux, *mux) { |
||||
a, b := memPipe() |
||||
|
||||
s := newMux(a) |
||||
c := newMux(b) |
||||
|
||||
return s, c |
||||
} |
||||
|
||||
// Returns both ends of a channel, and the mux for the the 2nd
|
||||
// channel.
|
||||
func channelPair(t *testing.T) (*channel, *channel, *mux) { |
||||
c, s := muxPair() |
||||
|
||||
res := make(chan *channel, 1) |
||||
go func() { |
||||
newCh, ok := <-s.incomingChannels |
||||
if !ok { |
||||
t.Fatalf("No incoming channel") |
||||
} |
||||
if newCh.ChannelType() != "chan" { |
||||
t.Fatalf("got type %q want chan", newCh.ChannelType()) |
||||
} |
||||
ch, _, err := newCh.Accept() |
||||
if err != nil { |
||||
t.Fatalf("Accept %v", err) |
||||
} |
||||
res <- ch.(*channel) |
||||
}() |
||||
|
||||
ch, err := c.openChannel("chan", nil) |
||||
if err != nil { |
||||
t.Fatalf("OpenChannel: %v", err) |
||||
} |
||||
|
||||
return <-res, ch, c |
||||
} |
||||
|
||||
// Test that stderr and stdout can be addressed from different
|
||||
// goroutines. This is intended for use with the race detector.
|
||||
func TestMuxChannelExtendedThreadSafety(t *testing.T) { |
||||
writer, reader, mux := channelPair(t) |
||||
defer writer.Close() |
||||
defer reader.Close() |
||||
defer mux.Close() |
||||
|
||||
var wr, rd sync.WaitGroup |
||||
magic := "hello world" |
||||
|
||||
wr.Add(2) |
||||
go func() { |
||||
io.WriteString(writer, magic) |
||||
wr.Done() |
||||
}() |
||||
go func() { |
||||
io.WriteString(writer.Stderr(), magic) |
||||
wr.Done() |
||||
}() |
||||
|
||||
rd.Add(2) |
||||
go func() { |
||||
c, err := ioutil.ReadAll(reader) |
||||
if string(c) != magic { |
||||
t.Fatalf("stdout read got %q, want %q (error %s)", c, magic, err) |
||||
} |
||||
rd.Done() |
||||
}() |
||||
go func() { |
||||
c, err := ioutil.ReadAll(reader.Stderr()) |
||||
if string(c) != magic { |
||||
t.Fatalf("stderr read got %q, want %q (error %s)", c, magic, err) |
||||
} |
||||
rd.Done() |
||||
}() |
||||
|
||||
wr.Wait() |
||||
writer.CloseWrite() |
||||
rd.Wait() |
||||
} |
||||
|
||||
func TestMuxReadWrite(t *testing.T) { |
||||
s, c, mux := channelPair(t) |
||||
defer s.Close() |
||||
defer c.Close() |
||||
defer mux.Close() |
||||
|
||||
magic := "hello world" |
||||
magicExt := "hello stderr" |
||||
go func() { |
||||
_, err := s.Write([]byte(magic)) |
||||
if err != nil { |
||||
t.Fatalf("Write: %v", err) |
||||
} |
||||
_, err = s.Extended(1).Write([]byte(magicExt)) |
||||
if err != nil { |
||||
t.Fatalf("Write: %v", err) |
||||
} |
||||
err = s.Close() |
||||
if err != nil { |
||||
t.Fatalf("Close: %v", err) |
||||
} |
||||
}() |
||||
|
||||
var buf [1024]byte |
||||
n, err := c.Read(buf[:]) |
||||
if err != nil { |
||||
t.Fatalf("server Read: %v", err) |
||||
} |
||||
got := string(buf[:n]) |
||||
if got != magic { |
||||
t.Fatalf("server: got %q want %q", got, magic) |
||||
} |
||||
|
||||
n, err = c.Extended(1).Read(buf[:]) |
||||
if err != nil { |
||||
t.Fatalf("server Read: %v", err) |
||||
} |
||||
|
||||
got = string(buf[:n]) |
||||
if got != magicExt { |
||||
t.Fatalf("server: got %q want %q", got, magic) |
||||
} |
||||
} |
||||
|
||||
func TestMuxChannelOverflow(t *testing.T) { |
||||
reader, writer, mux := channelPair(t) |
||||
defer reader.Close() |
||||
defer writer.Close() |
||||
defer mux.Close() |
||||
|
||||
wDone := make(chan int, 1) |
||||
go func() { |
||||
if _, err := writer.Write(make([]byte, channelWindowSize)); err != nil { |
||||
t.Errorf("could not fill window: %v", err) |
||||
} |
||||
writer.Write(make([]byte, 1)) |
||||
wDone <- 1 |
||||
}() |
||||
writer.remoteWin.waitWriterBlocked() |
||||
|
||||
// Send 1 byte.
|
||||
packet := make([]byte, 1+4+4+1) |
||||
packet[0] = msgChannelData |
||||
marshalUint32(packet[1:], writer.remoteId) |
||||
marshalUint32(packet[5:], uint32(1)) |
||||
packet[9] = 42 |
||||
|
||||
if err := writer.mux.conn.writePacket(packet); err != nil { |
||||
t.Errorf("could not send packet") |
||||
} |
||||
if _, err := reader.SendRequest("hello", true, nil); err == nil { |
||||
t.Errorf("SendRequest succeeded.") |
||||
} |
||||
<-wDone |
||||
} |
||||
|
||||
func TestMuxChannelCloseWriteUnblock(t *testing.T) { |
||||
reader, writer, mux := channelPair(t) |
||||
defer reader.Close() |
||||
defer writer.Close() |
||||
defer mux.Close() |
||||
|
||||
wDone := make(chan int, 1) |
||||
go func() { |
||||
if _, err := writer.Write(make([]byte, channelWindowSize)); err != nil { |
||||
t.Errorf("could not fill window: %v", err) |
||||
} |
||||
if _, err := writer.Write(make([]byte, 1)); err != io.EOF { |
||||
t.Errorf("got %v, want EOF for unblock write", err) |
||||
} |
||||
wDone <- 1 |
||||
}() |
||||
|
||||
writer.remoteWin.waitWriterBlocked() |
||||
reader.Close() |
||||
<-wDone |
||||
} |
||||
|
||||
func TestMuxConnectionCloseWriteUnblock(t *testing.T) { |
||||
reader, writer, mux := channelPair(t) |
||||
defer reader.Close() |
||||
defer writer.Close() |
||||
defer mux.Close() |
||||
|
||||
wDone := make(chan int, 1) |
||||
go func() { |
||||
if _, err := writer.Write(make([]byte, channelWindowSize)); err != nil { |
||||
t.Errorf("could not fill window: %v", err) |
||||
} |
||||
if _, err := writer.Write(make([]byte, 1)); err != io.EOF { |
||||
t.Errorf("got %v, want EOF for unblock write", err) |
||||
} |
||||
wDone <- 1 |
||||
}() |
||||
|
||||
writer.remoteWin.waitWriterBlocked() |
||||
mux.Close() |
||||
<-wDone |
||||
} |
||||
|
||||
func TestMuxReject(t *testing.T) { |
||||
client, server := muxPair() |
||||
defer server.Close() |
||||
defer client.Close() |
||||
|
||||
go func() { |
||||
ch, ok := <-server.incomingChannels |
||||
if !ok { |
||||
t.Fatalf("Accept") |
||||
} |
||||
if ch.ChannelType() != "ch" || string(ch.ExtraData()) != "extra" { |
||||
t.Fatalf("unexpected channel: %q, %q", ch.ChannelType(), ch.ExtraData()) |
||||
} |
||||
ch.Reject(RejectionReason(42), "message") |
||||
}() |
||||
|
||||
ch, err := client.openChannel("ch", []byte("extra")) |
||||
if ch != nil { |
||||
t.Fatal("openChannel not rejected") |
||||
} |
||||
|
||||
ocf, ok := err.(*OpenChannelError) |
||||
if !ok { |
||||
t.Errorf("got %#v want *OpenChannelError", err) |
||||
} else if ocf.Reason != 42 || ocf.Message != "message" { |
||||
t.Errorf("got %#v, want {Reason: 42, Message: %q}", ocf, "message") |
||||
} |
||||
|
||||
want := "ssh: rejected: unknown reason 42 (message)" |
||||
if err.Error() != want { |
||||
t.Errorf("got %q, want %q", err.Error(), want) |
||||
} |
||||
} |
||||
|
||||
func TestMuxChannelRequest(t *testing.T) { |
||||
client, server, mux := channelPair(t) |
||||
defer server.Close() |
||||
defer client.Close() |
||||
defer mux.Close() |
||||
|
||||
var received int |
||||
var wg sync.WaitGroup |
||||
wg.Add(1) |
||||
go func() { |
||||
for r := range server.incomingRequests { |
||||
received++ |
||||
r.Reply(r.Type == "yes", nil) |
||||
} |
||||
wg.Done() |
||||
}() |
||||
_, err := client.SendRequest("yes", false, nil) |
||||
if err != nil { |
||||
t.Fatalf("SendRequest: %v", err) |
||||
} |
||||
ok, err := client.SendRequest("yes", true, nil) |
||||
if err != nil { |
||||
t.Fatalf("SendRequest: %v", err) |
||||
} |
||||
|
||||
if !ok { |
||||
t.Errorf("SendRequest(yes): %v", ok) |
||||
|
||||
} |
||||
|
||||
ok, err = client.SendRequest("no", true, nil) |
||||
if err != nil { |
||||
t.Fatalf("SendRequest: %v", err) |
||||
} |
||||
if ok { |
||||
t.Errorf("SendRequest(no): %v", ok) |
||||
|
||||
} |
||||
|
||||
client.Close() |
||||
wg.Wait() |
||||
|
||||
if received != 3 { |
||||
t.Errorf("got %d requests, want %d", received, 3) |
||||
} |
||||
} |
||||
|
||||
func TestMuxGlobalRequest(t *testing.T) { |
||||
clientMux, serverMux := muxPair() |
||||
defer serverMux.Close() |
||||
defer clientMux.Close() |
||||
|
||||
var seen bool |
||||
go func() { |
||||
for r := range serverMux.incomingRequests { |
||||
seen = seen || r.Type == "peek" |
||||
if r.WantReply { |
||||
err := r.Reply(r.Type == "yes", |
||||
append([]byte(r.Type), r.Payload...)) |
||||
if err != nil { |
||||
t.Errorf("AckRequest: %v", err) |
||||
} |
||||
} |
||||
} |
||||
}() |
||||
|
||||
_, _, err := clientMux.SendRequest("peek", false, nil) |
||||
if err != nil { |
||||
t.Errorf("SendRequest: %v", err) |
||||
} |
||||
|
||||
ok, data, err := clientMux.SendRequest("yes", true, []byte("a")) |
||||
if !ok || string(data) != "yesa" || err != nil { |
||||
t.Errorf("SendRequest(\"yes\", true, \"a\"): %v %v %v", |
||||
ok, data, err) |
||||
} |
||||
if ok, data, err := clientMux.SendRequest("yes", true, []byte("a")); !ok || string(data) != "yesa" || err != nil { |
||||
t.Errorf("SendRequest(\"yes\", true, \"a\"): %v %v %v", |
||||
ok, data, err) |
||||
} |
||||
|
||||
if ok, data, err := clientMux.SendRequest("no", true, []byte("a")); ok || string(data) != "noa" || err != nil { |
||||
t.Errorf("SendRequest(\"no\", true, \"a\"): %v %v %v", |
||||
ok, data, err) |
||||
} |
||||
|
||||
clientMux.Disconnect(0, "") |
||||
if !seen { |
||||
t.Errorf("never saw 'peek' request") |
||||
} |
||||
} |
||||
|
||||
func TestMuxGlobalRequestUnblock(t *testing.T) { |
||||
clientMux, serverMux := muxPair() |
||||
defer serverMux.Close() |
||||
defer clientMux.Close() |
||||
|
||||
result := make(chan error, 1) |
||||
go func() { |
||||
_, _, err := clientMux.SendRequest("hello", true, nil) |
||||
result <- err |
||||
}() |
||||
|
||||
<-serverMux.incomingRequests |
||||
serverMux.conn.Close() |
||||
err := <-result |
||||
|
||||
if err != io.EOF { |
||||
t.Errorf("want EOF, got %v", io.EOF) |
||||
} |
||||
} |
||||
|
||||
func TestMuxChannelRequestUnblock(t *testing.T) { |
||||
a, b, connB := channelPair(t) |
||||
defer a.Close() |
||||
defer b.Close() |
||||
defer connB.Close() |
||||
|
||||
result := make(chan error, 1) |
||||
go func() { |
||||
_, err := a.SendRequest("hello", true, nil) |
||||
result <- err |
||||
}() |
||||
|
||||
<-b.incomingRequests |
||||
connB.conn.Close() |
||||
err := <-result |
||||
|
||||
if err != io.EOF { |
||||
t.Errorf("want EOF, got %v", err) |
||||
} |
||||
} |
||||
|
||||
func TestMuxDisconnect(t *testing.T) { |
||||
a, b := muxPair() |
||||
defer a.Close() |
||||
defer b.Close() |
||||
|
||||
go func() { |
||||
for r := range b.incomingRequests { |
||||
r.Reply(true, nil) |
||||
} |
||||
}() |
||||
|
||||
a.Disconnect(42, "whatever") |
||||
ok, _, err := a.SendRequest("hello", true, nil) |
||||
if ok || err == nil { |
||||
t.Errorf("got reply after disconnecting") |
||||
} |
||||
err = b.Wait() |
||||
if d, ok := err.(*disconnectMsg); !ok || d.Reason != 42 { |
||||
t.Errorf("got %#v, want disconnectMsg{Reason:42}", err) |
||||
} |
||||
} |
||||
|
||||
func TestMuxCloseChannel(t *testing.T) { |
||||
r, w, mux := channelPair(t) |
||||
defer mux.Close() |
||||
defer r.Close() |
||||
defer w.Close() |
||||
|
||||
result := make(chan error, 1) |
||||
go func() { |
||||
var b [1024]byte |
||||
_, err := r.Read(b[:]) |
||||
result <- err |
||||
}() |
||||
if err := w.Close(); err != nil { |
||||
t.Errorf("w.Close: %v", err) |
||||
} |
||||
|
||||
if _, err := w.Write([]byte("hello")); err != io.EOF { |
||||
t.Errorf("got err %v, want io.EOF after Close", err) |
||||
} |
||||
|
||||
if err := <-result; err != io.EOF { |
||||
t.Errorf("got %v (%T), want io.EOF", err, err) |
||||
} |
||||
} |
||||
|
||||
func TestMuxCloseWriteChannel(t *testing.T) { |
||||
r, w, mux := channelPair(t) |
||||
defer mux.Close() |
||||
|
||||
result := make(chan error, 1) |
||||
go func() { |
||||
var b [1024]byte |
||||
_, err := r.Read(b[:]) |
||||
result <- err |
||||
}() |
||||
if err := w.CloseWrite(); err != nil { |
||||
t.Errorf("w.CloseWrite: %v", err) |
||||
} |
||||
|
||||
if _, err := w.Write([]byte("hello")); err != io.EOF { |
||||
t.Errorf("got err %v, want io.EOF after CloseWrite", err) |
||||
} |
||||
|
||||
if err := <-result; err != io.EOF { |
||||
t.Errorf("got %v (%T), want io.EOF", err, err) |
||||
} |
||||
} |
||||
|
||||
func TestMuxInvalidRecord(t *testing.T) { |
||||
a, b := muxPair() |
||||
defer a.Close() |
||||
defer b.Close() |
||||
|
||||
packet := make([]byte, 1+4+4+1) |
||||
packet[0] = msgChannelData |
||||
marshalUint32(packet[1:], 29348723 /* invalid channel id */) |
||||
marshalUint32(packet[5:], 1) |
||||
packet[9] = 42 |
||||
|
||||
a.conn.writePacket(packet) |
||||
go a.SendRequest("hello", false, nil) |
||||
// 'a' wrote an invalid packet, so 'b' has exited.
|
||||
req, ok := <-b.incomingRequests |
||||
if ok { |
||||
t.Errorf("got request %#v after receiving invalid packet", req) |
||||
} |
||||
} |
||||
|
||||
func TestZeroWindowAdjust(t *testing.T) { |
||||
a, b, mux := channelPair(t) |
||||
defer a.Close() |
||||
defer b.Close() |
||||
defer mux.Close() |
||||
|
||||
go func() { |
||||
io.WriteString(a, "hello") |
||||
// bogus adjust.
|
||||
a.sendMessage(windowAdjustMsg{}) |
||||
io.WriteString(a, "world") |
||||
a.Close() |
||||
}() |
||||
|
||||
want := "helloworld" |
||||
c, _ := ioutil.ReadAll(b) |
||||
if string(c) != want { |
||||
t.Errorf("got %q want %q", c, want) |
||||
} |
||||
} |
||||
|
||||
func TestMuxMaxPacketSize(t *testing.T) { |
||||
a, b, mux := channelPair(t) |
||||
defer a.Close() |
||||
defer b.Close() |
||||
defer mux.Close() |
||||
|
||||
large := make([]byte, a.maxRemotePayload+1) |
||||
packet := make([]byte, 1+4+4+1+len(large)) |
||||
packet[0] = msgChannelData |
||||
marshalUint32(packet[1:], a.remoteId) |
||||
marshalUint32(packet[5:], uint32(len(large))) |
||||
packet[9] = 42 |
||||
|
||||
if err := a.mux.conn.writePacket(packet); err != nil { |
||||
t.Errorf("could not send packet") |
||||
} |
||||
|
||||
go a.SendRequest("hello", false, nil) |
||||
|
||||
_, ok := <-b.incomingRequests |
||||
if ok { |
||||
t.Errorf("connection still alive after receiving large packet.") |
||||
} |
||||
} |
||||
|
||||
// Don't ship code with debug=true.
|
||||
func TestDebug(t *testing.T) { |
||||
if debugMux { |
||||
t.Error("mux debug switched on") |
||||
} |
||||
if debugHandshake { |
||||
t.Error("handshake debug switched on") |
||||
} |
||||
} |
||||
@ -1,493 +0,0 @@ |
||||
// 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 ( |
||||
"bytes" |
||||
"errors" |
||||
"fmt" |
||||
"io" |
||||
"net" |
||||
) |
||||
|
||||
// The Permissions type holds fine-grained permissions that are
|
||||
// specific to a user or a specific authentication method for a
|
||||
// user. Permissions, except for "source-address", must be enforced in
|
||||
// the server application layer, after successful authentication. The
|
||||
// Permissions are passed on in ServerConn so a server implementation
|
||||
// can honor them.
|
||||
type Permissions struct { |
||||
// Critical options restrict default permissions. Common
|
||||
// restrictions are "source-address" and "force-command". If
|
||||
// the server cannot enforce the restriction, or does not
|
||||
// recognize it, the user should not authenticate.
|
||||
CriticalOptions map[string]string |
||||
|
||||
// Extensions are extra functionality that the server may
|
||||
// offer on authenticated connections. Common extensions are
|
||||
// "permit-agent-forwarding", "permit-X11-forwarding". Lack of
|
||||
// support for an extension does not preclude authenticating a
|
||||
// user.
|
||||
Extensions map[string]string |
||||
} |
||||
|
||||
// ServerConfig holds server specific configuration data.
|
||||
type ServerConfig struct { |
||||
// Config contains configuration shared between client and server.
|
||||
Config |
||||
|
||||
hostKeys []Signer |
||||
|
||||
// NoClientAuth is true if clients are allowed to connect without
|
||||
// authenticating.
|
||||
NoClientAuth bool |
||||
|
||||
// PasswordCallback, if non-nil, is called when a user
|
||||
// attempts to authenticate using a password.
|
||||
PasswordCallback func(conn ConnMetadata, password []byte) (*Permissions, error) |
||||
|
||||
// PublicKeyCallback, if non-nil, is called when a client attempts public
|
||||
// key authentication. It must return true if the given public key is
|
||||
// valid for the given user. For example, see CertChecker.Authenticate.
|
||||
PublicKeyCallback func(conn ConnMetadata, key PublicKey) (*Permissions, error) |
||||
|
||||
// KeyboardInteractiveCallback, if non-nil, is called when
|
||||
// keyboard-interactive authentication is selected (RFC
|
||||
// 4256). The client object's Challenge function should be
|
||||
// used to query the user. The callback may offer multiple
|
||||
// Challenge rounds. To avoid information leaks, the client
|
||||
// should be presented a challenge even if the user is
|
||||
// unknown.
|
||||
KeyboardInteractiveCallback func(conn ConnMetadata, client KeyboardInteractiveChallenge) (*Permissions, error) |
||||
|
||||
// AuthLogCallback, if non-nil, is called to log all authentication
|
||||
// attempts.
|
||||
AuthLogCallback func(conn ConnMetadata, method string, err error) |
||||
|
||||
// ServerVersion is the version identification string to
|
||||
// announce in the public handshake.
|
||||
// If empty, a reasonable default is used.
|
||||
ServerVersion string |
||||
} |
||||
|
||||
// AddHostKey adds a private key as a host key. If an existing host
|
||||
// key exists with the same algorithm, it is overwritten. Each server
|
||||
// config must have at least one host key.
|
||||
func (s *ServerConfig) AddHostKey(key Signer) { |
||||
for i, k := range s.hostKeys { |
||||
if k.PublicKey().Type() == key.PublicKey().Type() { |
||||
s.hostKeys[i] = key |
||||
return |
||||
} |
||||
} |
||||
|
||||
s.hostKeys = append(s.hostKeys, key) |
||||
} |
||||
|
||||
// cachedPubKey contains the results of querying whether a public key is
|
||||
// acceptable for a user.
|
||||
type cachedPubKey struct { |
||||
user string |
||||
pubKeyData []byte |
||||
result error |
||||
perms *Permissions |
||||
} |
||||
|
||||
const maxCachedPubKeys = 16 |
||||
|
||||
// pubKeyCache caches tests for public keys. Since SSH clients
|
||||
// will query whether a public key is acceptable before attempting to
|
||||
// authenticate with it, we end up with duplicate queries for public
|
||||
// key validity. The cache only applies to a single ServerConn.
|
||||
type pubKeyCache struct { |
||||
keys []cachedPubKey |
||||
} |
||||
|
||||
// get returns the result for a given user/algo/key tuple.
|
||||
func (c *pubKeyCache) get(user string, pubKeyData []byte) (cachedPubKey, bool) { |
||||
for _, k := range c.keys { |
||||
if k.user == user && bytes.Equal(k.pubKeyData, pubKeyData) { |
||||
return k, true |
||||
} |
||||
} |
||||
return cachedPubKey{}, false |
||||
} |
||||
|
||||
// add adds the given tuple to the cache.
|
||||
func (c *pubKeyCache) add(candidate cachedPubKey) { |
||||
if len(c.keys) < maxCachedPubKeys { |
||||
c.keys = append(c.keys, candidate) |
||||
} |
||||
} |
||||
|
||||
// ServerConn is an authenticated SSH connection, as seen from the
|
||||
// server
|
||||
type ServerConn struct { |
||||
Conn |
||||
|
||||
// If the succeeding authentication callback returned a
|
||||
// non-nil Permissions pointer, it is stored here.
|
||||
Permissions *Permissions |
||||
} |
||||
|
||||
// NewServerConn starts a new SSH server with c as the underlying
|
||||
// transport. It starts with a handshake and, if the handshake is
|
||||
// unsuccessful, it closes the connection and returns an error. The
|
||||
// Request and NewChannel channels must be serviced, or the connection
|
||||
// will hang.
|
||||
func NewServerConn(c net.Conn, config *ServerConfig) (*ServerConn, <-chan NewChannel, <-chan *Request, error) { |
||||
fullConf := *config |
||||
fullConf.SetDefaults() |
||||
s := &connection{ |
||||
sshConn: sshConn{conn: c}, |
||||
} |
||||
perms, err := s.serverHandshake(&fullConf) |
||||
if err != nil { |
||||
c.Close() |
||||
return nil, nil, nil, err |
||||
} |
||||
return &ServerConn{s, perms}, s.mux.incomingChannels, s.mux.incomingRequests, nil |
||||
} |
||||
|
||||
// signAndMarshal signs the data with the appropriate algorithm,
|
||||
// and serializes the result in SSH wire format.
|
||||
func signAndMarshal(k Signer, rand io.Reader, data []byte) ([]byte, error) { |
||||
sig, err := k.Sign(rand, data) |
||||
if err != nil { |
||||
return nil, err |
||||
} |
||||
|
||||
return Marshal(sig), nil |
||||
} |
||||
|
||||
// handshake performs key exchange and user authentication.
|
||||
func (s *connection) serverHandshake(config *ServerConfig) (*Permissions, error) { |
||||
if len(config.hostKeys) == 0 { |
||||
return nil, errors.New("ssh: server has no host keys") |
||||
} |
||||
|
||||
if !config.NoClientAuth && config.PasswordCallback == nil && config.PublicKeyCallback == nil && config.KeyboardInteractiveCallback == nil { |
||||
return nil, errors.New("ssh: no authentication methods configured but NoClientAuth is also false") |
||||
} |
||||
|
||||
if config.ServerVersion != "" { |
||||
s.serverVersion = []byte(config.ServerVersion) |
||||
} else { |
||||
s.serverVersion = []byte(packageVersion) |
||||
} |
||||
var err error |
||||
s.clientVersion, err = exchangeVersions(s.sshConn.conn, s.serverVersion) |
||||
if err != nil { |
||||
return nil, err |
||||
} |
||||
|
||||
tr := newTransport(s.sshConn.conn, config.Rand, false /* not client */) |
||||
s.transport = newServerTransport(tr, s.clientVersion, s.serverVersion, config) |
||||
|
||||
if err := s.transport.requestKeyChange(); err != nil { |
||||
return nil, err |
||||
} |
||||
|
||||
if packet, err := s.transport.readPacket(); err != nil { |
||||
return nil, err |
||||
} else if packet[0] != msgNewKeys { |
||||
return nil, unexpectedMessageError(msgNewKeys, packet[0]) |
||||
} |
||||
|
||||
// We just did the key change, so the session ID is established.
|
||||
s.sessionID = s.transport.getSessionID() |
||||
|
||||
var packet []byte |
||||
if packet, err = s.transport.readPacket(); err != nil { |
||||
return nil, err |
||||
} |
||||
|
||||
var serviceRequest serviceRequestMsg |
||||
if err = Unmarshal(packet, &serviceRequest); err != nil { |
||||
return nil, err |
||||
} |
||||
if serviceRequest.Service != serviceUserAuth { |
||||
return nil, errors.New("ssh: requested service '" + serviceRequest.Service + "' before authenticating") |
||||
} |
||||
serviceAccept := serviceAcceptMsg{ |
||||
Service: serviceUserAuth, |
||||
} |
||||
if err := s.transport.writePacket(Marshal(&serviceAccept)); err != nil { |
||||
return nil, err |
||||
} |
||||
|
||||
perms, err := s.serverAuthenticate(config) |
||||
if err != nil { |
||||
return nil, err |
||||
} |
||||
s.mux = newMux(s.transport) |
||||
return perms, err |
||||
} |
||||
|
||||
func isAcceptableAlgo(algo string) bool { |
||||
switch algo { |
||||
case KeyAlgoRSA, KeyAlgoDSA, KeyAlgoECDSA256, KeyAlgoECDSA384, KeyAlgoECDSA521, |
||||
CertAlgoRSAv01, CertAlgoDSAv01, CertAlgoECDSA256v01, CertAlgoECDSA384v01, CertAlgoECDSA521v01: |
||||
return true |
||||
} |
||||
return false |
||||
} |
||||
|
||||
func checkSourceAddress(addr net.Addr, sourceAddr string) error { |
||||
if addr == nil { |
||||
return errors.New("ssh: no address known for client, but source-address match required") |
||||
} |
||||
|
||||
tcpAddr, ok := addr.(*net.TCPAddr) |
||||
if !ok { |
||||
return fmt.Errorf("ssh: remote address %v is not an TCP address when checking source-address match", addr) |
||||
} |
||||
|
||||
if allowedIP := net.ParseIP(sourceAddr); allowedIP != nil { |
||||
if bytes.Equal(allowedIP, tcpAddr.IP) { |
||||
return nil |
||||
} |
||||
} else { |
||||
_, ipNet, err := net.ParseCIDR(sourceAddr) |
||||
if err != nil { |
||||
return fmt.Errorf("ssh: error parsing source-address restriction %q: %v", sourceAddr, err) |
||||
} |
||||
|
||||
if ipNet.Contains(tcpAddr.IP) { |
||||
return nil |
||||
} |
||||
} |
||||
|
||||
return fmt.Errorf("ssh: remote address %v is not allowed because of source-address restriction", addr) |
||||
} |
||||
|
||||
func (s *connection) serverAuthenticate(config *ServerConfig) (*Permissions, error) { |
||||
var err error |
||||
var cache pubKeyCache |
||||
var perms *Permissions |
||||
|
||||
userAuthLoop: |
||||
for { |
||||
var userAuthReq userAuthRequestMsg |
||||
if packet, err := s.transport.readPacket(); err != nil { |
||||
return nil, err |
||||
} else if err = Unmarshal(packet, &userAuthReq); err != nil { |
||||
return nil, err |
||||
} |
||||
|
||||
if userAuthReq.Service != serviceSSH { |
||||
return nil, errors.New("ssh: client attempted to negotiate for unknown service: " + userAuthReq.Service) |
||||
} |
||||
|
||||
s.user = userAuthReq.User |
||||
perms = nil |
||||
authErr := errors.New("no auth passed yet") |
||||
|
||||
switch userAuthReq.Method { |
||||
case "none": |
||||
if config.NoClientAuth { |
||||
s.user = "" |
||||
authErr = nil |
||||
} |
||||
case "password": |
||||
if config.PasswordCallback == nil { |
||||
authErr = errors.New("ssh: password auth not configured") |
||||
break |
||||
} |
||||
payload := userAuthReq.Payload |
||||
if len(payload) < 1 || payload[0] != 0 { |
||||
return nil, parseError(msgUserAuthRequest) |
||||
} |
||||
payload = payload[1:] |
||||
password, payload, ok := parseString(payload) |
||||
if !ok || len(payload) > 0 { |
||||
return nil, parseError(msgUserAuthRequest) |
||||
} |
||||
|
||||
perms, authErr = config.PasswordCallback(s, password) |
||||
case "keyboard-interactive": |
||||
if config.KeyboardInteractiveCallback == nil { |
||||
authErr = errors.New("ssh: keyboard-interactive auth not configubred") |
||||
break |
||||
} |
||||
|
||||
prompter := &sshClientKeyboardInteractive{s} |
||||
perms, authErr = config.KeyboardInteractiveCallback(s, prompter.Challenge) |
||||
case "publickey": |
||||
if config.PublicKeyCallback == nil { |
||||
authErr = errors.New("ssh: publickey auth not configured") |
||||
break |
||||
} |
||||
payload := userAuthReq.Payload |
||||
if len(payload) < 1 { |
||||
return nil, parseError(msgUserAuthRequest) |
||||
} |
||||
isQuery := payload[0] == 0 |
||||
payload = payload[1:] |
||||
algoBytes, payload, ok := parseString(payload) |
||||
if !ok { |
||||
return nil, parseError(msgUserAuthRequest) |
||||
} |
||||
algo := string(algoBytes) |
||||
if !isAcceptableAlgo(algo) { |
||||
authErr = fmt.Errorf("ssh: algorithm %q not accepted", algo) |
||||
break |
||||
} |
||||
|
||||
pubKeyData, payload, ok := parseString(payload) |
||||
if !ok { |
||||
return nil, parseError(msgUserAuthRequest) |
||||
} |
||||
|
||||
pubKey, err := ParsePublicKey(pubKeyData) |
||||
if err != nil { |
||||
return nil, err |
||||
} |
||||
|
||||
candidate, ok := cache.get(s.user, pubKeyData) |
||||
if !ok { |
||||
candidate.user = s.user |
||||
candidate.pubKeyData = pubKeyData |
||||
candidate.perms, candidate.result = config.PublicKeyCallback(s, pubKey) |
||||
if candidate.result == nil && candidate.perms != nil && candidate.perms.CriticalOptions != nil && candidate.perms.CriticalOptions[sourceAddressCriticalOption] != "" { |
||||
candidate.result = checkSourceAddress( |
||||
s.RemoteAddr(), |
||||
candidate.perms.CriticalOptions[sourceAddressCriticalOption]) |
||||
} |
||||
cache.add(candidate) |
||||
} |
||||
|
||||
if isQuery { |
||||
// The client can query if the given public key
|
||||
// would be okay.
|
||||
if len(payload) > 0 { |
||||
return nil, parseError(msgUserAuthRequest) |
||||
} |
||||
|
||||
if candidate.result == nil { |
||||
okMsg := userAuthPubKeyOkMsg{ |
||||
Algo: algo, |
||||
PubKey: pubKeyData, |
||||
} |
||||
if err = s.transport.writePacket(Marshal(&okMsg)); err != nil { |
||||
return nil, err |
||||
} |
||||
continue userAuthLoop |
||||
} |
||||
authErr = candidate.result |
||||
} else { |
||||
sig, payload, ok := parseSignature(payload) |
||||
if !ok || len(payload) > 0 { |
||||
return nil, parseError(msgUserAuthRequest) |
||||
} |
||||
// Ensure the public key algo and signature algo
|
||||
// are supported. Compare the private key
|
||||
// algorithm name that corresponds to algo with
|
||||
// sig.Format. This is usually the same, but
|
||||
// for certs, the names differ.
|
||||
if !isAcceptableAlgo(sig.Format) { |
||||
break |
||||
} |
||||
signedData := buildDataSignedForAuth(s.transport.getSessionID(), userAuthReq, algoBytes, pubKeyData) |
||||
|
||||
if err := pubKey.Verify(signedData, sig); err != nil { |
||||
return nil, err |
||||
} |
||||
|
||||
authErr = candidate.result |
||||
perms = candidate.perms |
||||
} |
||||
default: |
||||
authErr = fmt.Errorf("ssh: unknown method %q", userAuthReq.Method) |
||||
} |
||||
|
||||
if config.AuthLogCallback != nil { |
||||
config.AuthLogCallback(s, userAuthReq.Method, authErr) |
||||
} |
||||
|
||||
if authErr == nil { |
||||
break userAuthLoop |
||||
} |
||||
|
||||
var failureMsg userAuthFailureMsg |
||||
if config.PasswordCallback != nil { |
||||
failureMsg.Methods = append(failureMsg.Methods, "password") |
||||
} |
||||
if config.PublicKeyCallback != nil { |
||||
failureMsg.Methods = append(failureMsg.Methods, "publickey") |
||||
} |
||||
if config.KeyboardInteractiveCallback != nil { |
||||
failureMsg.Methods = append(failureMsg.Methods, "keyboard-interactive") |
||||
} |
||||
|
||||
if len(failureMsg.Methods) == 0 { |
||||
return nil, errors.New("ssh: no authentication methods configured but NoClientAuth is also false") |
||||
} |
||||
|
||||
if err = s.transport.writePacket(Marshal(&failureMsg)); err != nil { |
||||
return nil, err |
||||
} |
||||
} |
||||
|
||||
if err = s.transport.writePacket([]byte{msgUserAuthSuccess}); err != nil { |
||||
return nil, err |
||||
} |
||||
return perms, nil |
||||
} |
||||
|
||||
// sshClientKeyboardInteractive implements a ClientKeyboardInteractive by
|
||||
// asking the client on the other side of a ServerConn.
|
||||
type sshClientKeyboardInteractive struct { |
||||
*connection |
||||
} |
||||
|
||||
func (c *sshClientKeyboardInteractive) Challenge(user, instruction string, questions []string, echos []bool) (answers []string, err error) { |
||||
if len(questions) != len(echos) { |
||||
return nil, errors.New("ssh: echos and questions must have equal length") |
||||
} |
||||
|
||||
var prompts []byte |
||||
for i := range questions { |
||||
prompts = appendString(prompts, questions[i]) |
||||
prompts = appendBool(prompts, echos[i]) |
||||
} |
||||
|
||||
if err := c.transport.writePacket(Marshal(&userAuthInfoRequestMsg{ |
||||
Instruction: instruction, |
||||
NumPrompts: uint32(len(questions)), |
||||
Prompts: prompts, |
||||
})); err != nil { |
||||
return nil, err |
||||
} |
||||
|
||||
packet, err := c.transport.readPacket() |
||||
if err != nil { |
||||
return nil, err |
||||
} |
||||
if packet[0] != msgUserAuthInfoResponse { |
||||
return nil, unexpectedMessageError(msgUserAuthInfoResponse, packet[0]) |
||||
} |
||||
packet = packet[1:] |
||||
|
||||
n, packet, ok := parseUint32(packet) |
||||
if !ok || int(n) != len(questions) { |
||||
return nil, parseError(msgUserAuthInfoResponse) |
||||
} |
||||
|
||||
for i := uint32(0); i < n; i++ { |
||||
ans, rest, ok := parseString(packet) |
||||
if !ok { |
||||
return nil, parseError(msgUserAuthInfoResponse) |
||||
} |
||||
|
||||
answers = append(answers, string(ans)) |
||||
packet = rest |
||||
} |
||||
if len(packet) != 0 { |
||||
return nil, errors.New("ssh: junk at end of message") |
||||
} |
||||
|
||||
return answers, nil |
||||
} |
||||
@ -1,605 +0,0 @@ |
||||
// 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 |
||||
|
||||
// Session implements an interactive session described in
|
||||
// "RFC 4254, section 6".
|
||||
|
||||
import ( |
||||
"bytes" |
||||
"errors" |
||||
"fmt" |
||||
"io" |
||||
"io/ioutil" |
||||
"sync" |
||||
) |
||||
|
||||
type Signal string |
||||
|
||||
// POSIX signals as listed in RFC 4254 Section 6.10.
|
||||
const ( |
||||
SIGABRT Signal = "ABRT" |
||||
SIGALRM Signal = "ALRM" |
||||
SIGFPE Signal = "FPE" |
||||
SIGHUP Signal = "HUP" |
||||
SIGILL Signal = "ILL" |
||||
SIGINT Signal = "INT" |
||||
SIGKILL Signal = "KILL" |
||||
SIGPIPE Signal = "PIPE" |
||||
SIGQUIT Signal = "QUIT" |
||||
SIGSEGV Signal = "SEGV" |
||||
SIGTERM Signal = "TERM" |
||||
SIGUSR1 Signal = "USR1" |
||||
SIGUSR2 Signal = "USR2" |
||||
) |
||||
|
||||
var signals = map[Signal]int{ |
||||
SIGABRT: 6, |
||||
SIGALRM: 14, |
||||
SIGFPE: 8, |
||||
SIGHUP: 1, |
||||
SIGILL: 4, |
||||
SIGINT: 2, |
||||
SIGKILL: 9, |
||||
SIGPIPE: 13, |
||||
SIGQUIT: 3, |
||||
SIGSEGV: 11, |
||||
SIGTERM: 15, |
||||
} |
||||
|
||||
type TerminalModes map[uint8]uint32 |
||||
|
||||
// POSIX terminal mode flags as listed in RFC 4254 Section 8.
|
||||
const ( |
||||
tty_OP_END = 0 |
||||
VINTR = 1 |
||||
VQUIT = 2 |
||||
VERASE = 3 |
||||
VKILL = 4 |
||||
VEOF = 5 |
||||
VEOL = 6 |
||||
VEOL2 = 7 |
||||
VSTART = 8 |
||||
VSTOP = 9 |
||||
VSUSP = 10 |
||||
VDSUSP = 11 |
||||
VREPRINT = 12 |
||||
VWERASE = 13 |
||||
VLNEXT = 14 |
||||
VFLUSH = 15 |
||||
VSWTCH = 16 |
||||
VSTATUS = 17 |
||||
VDISCARD = 18 |
||||
IGNPAR = 30 |
||||
PARMRK = 31 |
||||
INPCK = 32 |
||||
ISTRIP = 33 |
||||
INLCR = 34 |
||||
IGNCR = 35 |
||||
ICRNL = 36 |
||||
IUCLC = 37 |
||||
IXON = 38 |
||||
IXANY = 39 |
||||
IXOFF = 40 |
||||
IMAXBEL = 41 |
||||
ISIG = 50 |
||||
ICANON = 51 |
||||
XCASE = 52 |
||||
ECHO = 53 |
||||
ECHOE = 54 |
||||
ECHOK = 55 |
||||
ECHONL = 56 |
||||
NOFLSH = 57 |
||||
TOSTOP = 58 |
||||
IEXTEN = 59 |
||||
ECHOCTL = 60 |
||||
ECHOKE = 61 |
||||
PENDIN = 62 |
||||
OPOST = 70 |
||||
OLCUC = 71 |
||||
ONLCR = 72 |
||||
OCRNL = 73 |
||||
ONOCR = 74 |
||||
ONLRET = 75 |
||||
CS7 = 90 |
||||
CS8 = 91 |
||||
PARENB = 92 |
||||
PARODD = 93 |
||||
TTY_OP_ISPEED = 128 |
||||
TTY_OP_OSPEED = 129 |
||||
) |
||||
|
||||
// A Session represents a connection to a remote command or shell.
|
||||
type Session struct { |
||||
// Stdin specifies the remote process's standard input.
|
||||
// If Stdin is nil, the remote process reads from an empty
|
||||
// bytes.Buffer.
|
||||
Stdin io.Reader |
||||
|
||||
// Stdout and Stderr specify the remote process's standard
|
||||
// output and error.
|
||||
//
|
||||
// If either is nil, Run connects the corresponding file
|
||||
// descriptor to an instance of ioutil.Discard. There is a
|
||||
// fixed amount of buffering that is shared for the two streams.
|
||||
// If either blocks it may eventually cause the remote
|
||||
// command to block.
|
||||
Stdout io.Writer |
||||
Stderr io.Writer |
||||
|
||||
ch Channel // the channel backing this session
|
||||
started bool // true once Start, Run or Shell is invoked.
|
||||
copyFuncs []func() error |
||||
errors chan error // one send per copyFunc
|
||||
|
||||
// true if pipe method is active
|
||||
stdinpipe, stdoutpipe, stderrpipe bool |
||||
|
||||
// stdinPipeWriter is non-nil if StdinPipe has not been called
|
||||
// and Stdin was specified by the user; it is the write end of
|
||||
// a pipe connecting Session.Stdin to the stdin channel.
|
||||
stdinPipeWriter io.WriteCloser |
||||
|
||||
exitStatus chan error |
||||
} |
||||
|
||||
// SendRequest sends an out-of-band channel request on the SSH channel
|
||||
// underlying the session.
|
||||
func (s *Session) SendRequest(name string, wantReply bool, payload []byte) (bool, error) { |
||||
return s.ch.SendRequest(name, wantReply, payload) |
||||
} |
||||
|
||||
func (s *Session) Close() error { |
||||
return s.ch.Close() |
||||
} |
||||
|
||||
// RFC 4254 Section 6.4.
|
||||
type setenvRequest struct { |
||||
Name string |
||||
Value string |
||||
} |
||||
|
||||
// Setenv sets an environment variable that will be applied to any
|
||||
// command executed by Shell or Run.
|
||||
func (s *Session) Setenv(name, value string) error { |
||||
msg := setenvRequest{ |
||||
Name: name, |
||||
Value: value, |
||||
} |
||||
ok, err := s.ch.SendRequest("env", true, Marshal(&msg)) |
||||
if err == nil && !ok { |
||||
err = errors.New("ssh: setenv failed") |
||||
} |
||||
return err |
||||
} |
||||
|
||||
// RFC 4254 Section 6.2.
|
||||
type ptyRequestMsg struct { |
||||
Term string |
||||
Columns uint32 |
||||
Rows uint32 |
||||
Width uint32 |
||||
Height uint32 |
||||
Modelist string |
||||
} |
||||
|
||||
// RequestPty requests the association of a pty with the session on the remote host.
|
||||
func (s *Session) RequestPty(term string, h, w int, termmodes TerminalModes) error { |
||||
var tm []byte |
||||
for k, v := range termmodes { |
||||
kv := struct { |
||||
Key byte |
||||
Val uint32 |
||||
}{k, v} |
||||
|
||||
tm = append(tm, Marshal(&kv)...) |
||||
} |
||||
tm = append(tm, tty_OP_END) |
||||
req := ptyRequestMsg{ |
||||
Term: term, |
||||
Columns: uint32(w), |
||||
Rows: uint32(h), |
||||
Width: uint32(w * 8), |
||||
Height: uint32(h * 8), |
||||
Modelist: string(tm), |
||||
} |
||||
ok, err := s.ch.SendRequest("pty-req", true, Marshal(&req)) |
||||
if err == nil && !ok { |
||||
err = errors.New("ssh: pty-req failed") |
||||
} |
||||
return err |
||||
} |
||||
|
||||
// RFC 4254 Section 6.5.
|
||||
type subsystemRequestMsg struct { |
||||
Subsystem string |
||||
} |
||||
|
||||
// RequestSubsystem requests the association of a subsystem with the session on the remote host.
|
||||
// A subsystem is a predefined command that runs in the background when the ssh session is initiated
|
||||
func (s *Session) RequestSubsystem(subsystem string) error { |
||||
msg := subsystemRequestMsg{ |
||||
Subsystem: subsystem, |
||||
} |
||||
ok, err := s.ch.SendRequest("subsystem", true, Marshal(&msg)) |
||||
if err == nil && !ok { |
||||
err = errors.New("ssh: subsystem request failed") |
||||
} |
||||
return err |
||||
} |
||||
|
||||
// RFC 4254 Section 6.9.
|
||||
type signalMsg struct { |
||||
Signal string |
||||
} |
||||
|
||||
// Signal sends the given signal to the remote process.
|
||||
// sig is one of the SIG* constants.
|
||||
func (s *Session) Signal(sig Signal) error { |
||||
msg := signalMsg{ |
||||
Signal: string(sig), |
||||
} |
||||
|
||||
_, err := s.ch.SendRequest("signal", false, Marshal(&msg)) |
||||
return err |
||||
} |
||||
|
||||
// RFC 4254 Section 6.5.
|
||||
type execMsg struct { |
||||
Command string |
||||
} |
||||
|
||||
// Start runs cmd on the remote host. Typically, the remote
|
||||
// server passes cmd to the shell for interpretation.
|
||||
// A Session only accepts one call to Run, Start or Shell.
|
||||
func (s *Session) Start(cmd string) error { |
||||
if s.started { |
||||
return errors.New("ssh: session already started") |
||||
} |
||||
req := execMsg{ |
||||
Command: cmd, |
||||
} |
||||
|
||||
ok, err := s.ch.SendRequest("exec", true, Marshal(&req)) |
||||
if err == nil && !ok { |
||||
err = fmt.Errorf("ssh: command %v failed", cmd) |
||||
} |
||||
if err != nil { |
||||
return err |
||||
} |
||||
return s.start() |
||||
} |
||||
|
||||
// Run runs cmd on the remote host. Typically, the remote
|
||||
// server passes cmd to the shell for interpretation.
|
||||
// A Session only accepts one call to Run, Start, Shell, Output,
|
||||
// or CombinedOutput.
|
||||
//
|
||||
// The returned error is nil if the command runs, has no problems
|
||||
// copying stdin, stdout, and stderr, and exits with a zero exit
|
||||
// status.
|
||||
//
|
||||
// If the command fails to run or doesn't complete successfully, the
|
||||
// error is of type *ExitError. Other error types may be
|
||||
// returned for I/O problems.
|
||||
func (s *Session) Run(cmd string) error { |
||||
err := s.Start(cmd) |
||||
if err != nil { |
||||
return err |
||||
} |
||||
return s.Wait() |
||||
} |
||||
|
||||
// Output runs cmd on the remote host and returns its standard output.
|
||||
func (s *Session) Output(cmd string) ([]byte, error) { |
||||
if s.Stdout != nil { |
||||
return nil, errors.New("ssh: Stdout already set") |
||||
} |
||||
var b bytes.Buffer |
||||
s.Stdout = &b |
||||
err := s.Run(cmd) |
||||
return b.Bytes(), err |
||||
} |
||||
|
||||
type singleWriter struct { |
||||
b bytes.Buffer |
||||
mu sync.Mutex |
||||
} |
||||
|
||||
func (w *singleWriter) Write(p []byte) (int, error) { |
||||
w.mu.Lock() |
||||
defer w.mu.Unlock() |
||||
return w.b.Write(p) |
||||
} |
||||
|
||||
// CombinedOutput runs cmd on the remote host and returns its combined
|
||||
// standard output and standard error.
|
||||
func (s *Session) CombinedOutput(cmd string) ([]byte, error) { |
||||
if s.Stdout != nil { |
||||
return nil, errors.New("ssh: Stdout already set") |
||||
} |
||||
if s.Stderr != nil { |
||||
return nil, errors.New("ssh: Stderr already set") |
||||
} |
||||
var b singleWriter |
||||
s.Stdout = &b |
||||
s.Stderr = &b |
||||
err := s.Run(cmd) |
||||
return b.b.Bytes(), err |
||||
} |
||||
|
||||
// Shell starts a login shell on the remote host. A Session only
|
||||
// accepts one call to Run, Start, Shell, Output, or CombinedOutput.
|
||||
func (s *Session) Shell() error { |
||||
if s.started { |
||||
return errors.New("ssh: session already started") |
||||
} |
||||
|
||||
ok, err := s.ch.SendRequest("shell", true, nil) |
||||
if err == nil && !ok { |
||||
return fmt.Errorf("ssh: cound not start shell") |
||||
} |
||||
if err != nil { |
||||
return err |
||||
} |
||||
return s.start() |
||||
} |
||||
|
||||
func (s *Session) start() error { |
||||
s.started = true |
||||
|
||||
type F func(*Session) |
||||
for _, setupFd := range []F{(*Session).stdin, (*Session).stdout, (*Session).stderr} { |
||||
setupFd(s) |
||||
} |
||||
|
||||
s.errors = make(chan error, len(s.copyFuncs)) |
||||
for _, fn := range s.copyFuncs { |
||||
go func(fn func() error) { |
||||
s.errors <- fn() |
||||
}(fn) |
||||
} |
||||
return nil |
||||
} |
||||
|
||||
// Wait waits for the remote command to exit.
|
||||
//
|
||||
// The returned error is nil if the command runs, has no problems
|
||||
// copying stdin, stdout, and stderr, and exits with a zero exit
|
||||
// status.
|
||||
//
|
||||
// If the command fails to run or doesn't complete successfully, the
|
||||
// error is of type *ExitError. Other error types may be
|
||||
// returned for I/O problems.
|
||||
func (s *Session) Wait() error { |
||||
if !s.started { |
||||
return errors.New("ssh: session not started") |
||||
} |
||||
waitErr := <-s.exitStatus |
||||
|
||||
if s.stdinPipeWriter != nil { |
||||
s.stdinPipeWriter.Close() |
||||
} |
||||
var copyError error |
||||
for _ = range s.copyFuncs { |
||||
if err := <-s.errors; err != nil && copyError == nil { |
||||
copyError = err |
||||
} |
||||
} |
||||
if waitErr != nil { |
||||
return waitErr |
||||
} |
||||
return copyError |
||||
} |
||||
|
||||
func (s *Session) wait(reqs <-chan *Request) error { |
||||
wm := Waitmsg{status: -1} |
||||
// Wait for msg channel to be closed before returning.
|
||||
for msg := range reqs { |
||||
switch msg.Type { |
||||
case "exit-status": |
||||
d := msg.Payload |
||||
wm.status = int(d[0])<<24 | int(d[1])<<16 | int(d[2])<<8 | int(d[3]) |
||||
case "exit-signal": |
||||
var sigval struct { |
||||
Signal string |
||||
CoreDumped bool |
||||
Error string |
||||
Lang string |
||||
} |
||||
if err := Unmarshal(msg.Payload, &sigval); err != nil { |
||||
return err |
||||
} |
||||
|
||||
// Must sanitize strings?
|
||||
wm.signal = sigval.Signal |
||||
wm.msg = sigval.Error |
||||
wm.lang = sigval.Lang |
||||
default: |
||||
// This handles keepalives and matches
|
||||
// OpenSSH's behaviour.
|
||||
if msg.WantReply { |
||||
msg.Reply(false, nil) |
||||
} |
||||
} |
||||
} |
||||
if wm.status == 0 { |
||||
return nil |
||||
} |
||||
if wm.status == -1 { |
||||
// exit-status was never sent from server
|
||||
if wm.signal == "" { |
||||
return errors.New("wait: remote command exited without exit status or exit signal") |
||||
} |
||||
wm.status = 128 |
||||
if _, ok := signals[Signal(wm.signal)]; ok { |
||||
wm.status += signals[Signal(wm.signal)] |
||||
} |
||||
} |
||||
return &ExitError{wm} |
||||
} |
||||
|
||||
func (s *Session) stdin() { |
||||
if s.stdinpipe { |
||||
return |
||||
} |
||||
var stdin io.Reader |
||||
if s.Stdin == nil { |
||||
stdin = new(bytes.Buffer) |
||||
} else { |
||||
r, w := io.Pipe() |
||||
go func() { |
||||
_, err := io.Copy(w, s.Stdin) |
||||
w.CloseWithError(err) |
||||
}() |
||||
stdin, s.stdinPipeWriter = r, w |
||||
} |
||||
s.copyFuncs = append(s.copyFuncs, func() error { |
||||
_, err := io.Copy(s.ch, stdin) |
||||
if err1 := s.ch.CloseWrite(); err == nil && err1 != io.EOF { |
||||
err = err1 |
||||
} |
||||
return err |
||||
}) |
||||
} |
||||
|
||||
func (s *Session) stdout() { |
||||
if s.stdoutpipe { |
||||
return |
||||
} |
||||
if s.Stdout == nil { |
||||
s.Stdout = ioutil.Discard |
||||
} |
||||
s.copyFuncs = append(s.copyFuncs, func() error { |
||||
_, err := io.Copy(s.Stdout, s.ch) |
||||
return err |
||||
}) |
||||
} |
||||
|
||||
func (s *Session) stderr() { |
||||
if s.stderrpipe { |
||||
return |
||||
} |
||||
if s.Stderr == nil { |
||||
s.Stderr = ioutil.Discard |
||||
} |
||||
s.copyFuncs = append(s.copyFuncs, func() error { |
||||
_, err := io.Copy(s.Stderr, s.ch.Stderr()) |
||||
return err |
||||
}) |
||||
} |
||||
|
||||
// sessionStdin reroutes Close to CloseWrite.
|
||||
type sessionStdin struct { |
||||
io.Writer |
||||
ch Channel |
||||
} |
||||
|
||||
func (s *sessionStdin) Close() error { |
||||
return s.ch.CloseWrite() |
||||
} |
||||
|
||||
// StdinPipe returns a pipe that will be connected to the
|
||||
// remote command's standard input when the command starts.
|
||||
func (s *Session) StdinPipe() (io.WriteCloser, error) { |
||||
if s.Stdin != nil { |
||||
return nil, errors.New("ssh: Stdin already set") |
||||
} |
||||
if s.started { |
||||
return nil, errors.New("ssh: StdinPipe after process started") |
||||
} |
||||
s.stdinpipe = true |
||||
return &sessionStdin{s.ch, s.ch}, nil |
||||
} |
||||
|
||||
// StdoutPipe returns a pipe that will be connected to the
|
||||
// remote command's standard output when the command starts.
|
||||
// There is a fixed amount of buffering that is shared between
|
||||
// stdout and stderr streams. If the StdoutPipe reader is
|
||||
// not serviced fast enough it may eventually cause the
|
||||
// remote command to block.
|
||||
func (s *Session) StdoutPipe() (io.Reader, error) { |
||||
if s.Stdout != nil { |
||||
return nil, errors.New("ssh: Stdout already set") |
||||
} |
||||
if s.started { |
||||
return nil, errors.New("ssh: StdoutPipe after process started") |
||||
} |
||||
s.stdoutpipe = true |
||||
return s.ch, nil |
||||
} |
||||
|
||||
// StderrPipe returns a pipe that will be connected to the
|
||||
// remote command's standard error when the command starts.
|
||||
// There is a fixed amount of buffering that is shared between
|
||||
// stdout and stderr streams. If the StderrPipe reader is
|
||||
// not serviced fast enough it may eventually cause the
|
||||
// remote command to block.
|
||||
func (s *Session) StderrPipe() (io.Reader, error) { |
||||
if s.Stderr != nil { |
||||
return nil, errors.New("ssh: Stderr already set") |
||||
} |
||||
if s.started { |
||||
return nil, errors.New("ssh: StderrPipe after process started") |
||||
} |
||||
s.stderrpipe = true |
||||
return s.ch.Stderr(), nil |
||||
} |
||||
|
||||
// newSession returns a new interactive session on the remote host.
|
||||
func newSession(ch Channel, reqs <-chan *Request) (*Session, error) { |
||||
s := &Session{ |
||||
ch: ch, |
||||
} |
||||
s.exitStatus = make(chan error, 1) |
||||
go func() { |
||||
s.exitStatus <- s.wait(reqs) |
||||
}() |
||||
|
||||
return s, nil |
||||
} |
||||
|
||||
// An ExitError reports unsuccessful completion of a remote command.
|
||||
type ExitError struct { |
||||
Waitmsg |
||||
} |
||||
|
||||
func (e *ExitError) Error() string { |
||||
return e.Waitmsg.String() |
||||
} |
||||
|
||||
// Waitmsg stores the information about an exited remote command
|
||||
// as reported by Wait.
|
||||
type Waitmsg struct { |
||||
status int |
||||
signal string |
||||
msg string |
||||
lang string |
||||
} |
||||
|
||||
// ExitStatus returns the exit status of the remote command.
|
||||
func (w Waitmsg) ExitStatus() int { |
||||
return w.status |
||||
} |
||||
|
||||
// Signal returns the exit signal of the remote command if
|
||||
// it was terminated violently.
|
||||
func (w Waitmsg) Signal() string { |
||||
return w.signal |
||||
} |
||||
|
||||
// Msg returns the exit message given by the remote command
|
||||
func (w Waitmsg) Msg() string { |
||||
return w.msg |
||||
} |
||||
|
||||
// Lang returns the language tag. See RFC 3066
|
||||
func (w Waitmsg) Lang() string { |
||||
return w.lang |
||||
} |
||||
|
||||
func (w Waitmsg) String() string { |
||||
return fmt.Sprintf("Process exited with: %v. Reason was: %v (%v)", w.status, w.msg, w.signal) |
||||
} |
||||
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in new issue