Beispiel #1
0
func StartServer(ip string, keyFile string, credentialsChan CredentialsChan) error {
	// The PasswordCallback always returns false. The supplied credentials get
	// passed to the specified callback for further processing.
	config := &ssh.ServerConfig{
		PasswordCallback: func(conn *ssh.ServerConn, user, pass string) bool {
			credentialsChan <- &Credentials{user, pass}
			return false
		},
	}

	// Read the server's private key
	pemBytes, err := ioutil.ReadFile(keyFile)
	if err != nil {
		return err
	}
	if err = config.SetRSAPrivateKey(pemBytes); err != nil {
		return err
	}

	// set up listener
	listener, err := ssh.Listen("tcp", ip, config)
	if err != nil {
		return err
	}

	go processConnections(listener)

	return nil
}
Beispiel #2
0
func main() {
	// An SSH server is represented by a ServerConfig, which holds
	// certificate details and handles authentication of ServerConns.
	config := &ssh.ServerConfig{
		PasswordCallback: func(conn *ssh.ServerConn, user, pass string) bool {
			return user == "testuser" && pass == "tiger"
		},
	}

	pemBytes, err := ioutil.ReadFile("id_rsa")
	if err != nil {
		panic("Failed to load private key")
	}
	if err = config.SetRSAPrivateKey(pemBytes); err != nil {
		panic("Failed to parse private key")
	}

	// Once a ServerConfig has been configured, connections can be
	// accepted.
	listener, err := ssh.Listen("tcp", "0.0.0.0:2022", config)
	if err != nil {
		panic("failed to listen for connection")
	}
	for {
		sConn, err := listener.Accept()
		if err != nil {
			panic("failed to accept incoming connection")
		}
		go handleUser(sConn)
	}
}
Beispiel #3
0
func Open(config *ssh.ServerConfig) *ssh.Listener {
	conn, err := ssh.Listen("tcp", ":8765", config)
	if err != nil {
		log.Fatal("Failed to listen for connection")
	}
	return conn
}
Beispiel #4
0
func newServer(c *gc.C) *sshServer {
	private, _, err := ssh.GenerateKey("test-server")
	c.Assert(err, gc.IsNil)
	key, err := cryptossh.ParsePrivateKey([]byte(private))
	c.Assert(err, gc.IsNil)
	server := &sshServer{
		cfg: &cryptossh.ServerConfig{},
	}
	server.cfg.AddHostKey(key)
	server.Listener, err = cryptossh.Listen("tcp", "127.0.0.1:0", server.cfg)
	c.Assert(err, gc.IsNil)
	return server
}
Beispiel #5
0
func main() {
	// Config parse
	file, err := os.Open("./conf.json")
	if err != nil {
		log.Fatal("Error opening config file")
	}
	decoder := json.NewDecoder(file)
	decoder.Decode(&conf)
	// An SSH server is represented by a ServerConfig, which holds
	// certificate details and handles authentication of ServerConns.
	config := &ssh.ServerConfig{
		PasswordCallback: func(conn *ssh.ServerConn, user, pass string) bool {
			notify(newAttacker(conn, user, pass))
			return false
		},
	}

	pemBytes, err := ioutil.ReadFile("rsa.key")
	if err != nil {
		log.Fatal("Failed to load private key:", err)
	}
	if err = config.SetRSAPrivateKey(pemBytes); err != nil {
		log.Fatal("Failed to parse private key:", err)
	}

	// Once a ServerConfig has been configured, connections can be
	// accepted.
	conn, err := ssh.Listen("tcp", "0.0.0.0:2022", config)
	if err != nil {
		log.Fatal("failed to listen for connection")
	}
	for {
		// A ServerConn multiplexes several channels, which must
		// themselves be Accepted.
		log.Println("accept")
		sConn, err := conn.Accept()
		attacker := newAttacker(sConn, "", "")
		if err != nil {
			notify(attacker)
			log.Println("failed to accept incoming connection")
			continue
		}
		if err := sConn.Handshake(); err != nil {
			notify(attacker)
			log.Println("failed to handshake")
			continue
		}
		go handleServerConn(sConn)
	}
}
Beispiel #6
0
func newMockLineServer(t *testing.T) string {
	l, err := ssh.Listen("tcp", "127.0.0.1:0", serverConfig)
	if err != nil {
		t.Fatalf("unable to newMockAuthServer: %s", err)
	}
	go func() {
		defer l.Close()
		c, err := l.Accept()
		if err != nil {
			t.Errorf("Unable to accept incoming connection: %v", err)
			return
		}

		if err := c.Handshake(); err != nil {
			// not Errorf because this is expected to
			// fail for some tests.
			t.Logf("Handshaking error: %v", err)
			return
		}

		t.Log("Accepted SSH connection")
		defer c.Close()

		channel, err := c.Accept()
		if err != nil {
			t.Errorf("Unable to accept a channel: %s", err)
			return
		}

		// Just go in a loop now accepting things... we need to
		// do this to handle packets for SSH.
		go func() {
			c.Accept()
		}()

		channel.Accept()
		t.Log("Accepted channel")
		defer channel.Close()
	}()
	return l.Addr().String()
}
Beispiel #7
0
func configDial(t *testing.T, b *serverBehavior) net.Conn {
	l, err := ssh.Listen("tcp", "127.0.0.1:0", serverConfig)
	if err != nil {
		t.Fatal("unable to listen:", err)
	}
	go func() {
		defer l.Close()
		conn, err := l.Accept()
		if err != nil {
			t.Error("unable to accept:", err)
			return
		}
		defer conn.Close()
		if err := conn.Handshake(); err != nil {
			t.Error("unable to handshake:", err)
			return
		}
		for {
			time.Sleep(b.sessionDelay)
			ch, err := conn.Accept()
			if err == io.EOF {
				return
			}
			if err != nil {
				t.Error("unable to accept:", err)
				return
			}
			ch.Accept()
			ch.Close()
		}
	}()
	c, err := net.Dial("tcp", l.Addr().String())
	if err != nil {
		t.Fatal("unable to dial test server:", err)
	}
	return c
}
Beispiel #8
0
func main() {
	// An SSH server is represented by a ServerConfig, which holds
	// certificate details and handles authentication of ServerConns.
	config := &ssh.ServerConfig{
		PasswordCallback: func(conn *ssh.ServerConn, user, pass string) bool {
			return user == "testuser" && pass == "tiger"
		},
	}

	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 := ssh.Listen("tcp", "0.0.0.0:2022", config)
	if err != nil {
		panic("failed to listen for connection")
	}
	sConn, err := listener.Accept()
	if err != nil {
		panic("failed to accept incoming connection")
	}
	if err := sConn.Handshake(); err != nil {
		panic("failed to handshake")
	}

	// A ServerConn multiplexes several channels, which must
	// themselves be Accepted.
	for {
		// Accept reads from the connection, demultiplexes packets
		// to their corresponding channels and returns when a new
		// channel request is seen. Some goroutine must always be
		// calling Accept; otherwise no messages will be forwarded
		// to the channels.
		channel, err := sConn.Accept()
		if err != nil {
			panic("error from Accept")
		}

		// 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 channel.ChannelType() != "session" {
			channel.Reject(ssh.UnknownChannelType, "unknown channel type")
			continue
		}
		channel.Accept()

		term := terminal.NewTerminal(channel, "> ")
		serverTerm := &ssh.ServerTerminal{
			Term:    term,
			Channel: channel,
		}
		go func() {
			defer channel.Close()
			for {
				line, err := serverTerm.ReadLine()
				if err != nil {
					break
				}
				fmt.Println(line)
			}
		}()
	}
}