Page MenuHomePhabricator
Files F136205

main.go
No OneTemporary
Actions

main.go
View Options

package main
import (
"strings"
"os"
"fmt"
"io"
"net"
"log"
"encoding/base64"
"golang.org/x/crypto/ssh"
"golang.org/x/crypto/ssh/agent"
)
type Endpoint struct {
Host string
Port int
}
func KeyPrint(dialAddr string, addr net.Addr, key ssh.PublicKey) error {
fmt.Printf("%s %s %s\n", strings.Split(dialAddr, ":")[0], key.Type(), base64.StdEncoding.EncodeToString(key.Marshal()))
return nil
}
func (endpoint *Endpoint) String() string {
return fmt.Sprintf("%s:%d", endpoint.Host, endpoint.Port)
}
type SSHtunnel struct {
Local *Endpoint
Server *Endpoint
Remote *Endpoint
Config *ssh.ClientConfig
}
func (tunnel *SSHtunnel) Start() error {
listener, err := net.Listen("tcp", tunnel.Local.String())
if err != nil {
return err
}
defer listener.Close()
for {
conn, err := listener.Accept()
if err != nil {
return err
}
go tunnel.forward(conn)
}
}
func (tunnel *SSHtunnel) forward(localConn net.Conn) {
serverConn, err := ssh.Dial("tcp", tunnel.Server.String(), tunnel.Config)
if err != nil {
fmt.Printf("Server dial error: %s\n", err)
return
}
remoteConn, err := serverConn.Dial("tcp", tunnel.Remote.String())
if err != nil {
fmt.Printf("Remote dial error: %s\n", err)
return
}
copyConn:=func(writer, reader net.Conn) {
_, err:= io.Copy(writer, reader)
if err != nil {
fmt.Printf("io.Copy error: %s", err)
}
}
go copyConn(localConn, remoteConn)
go copyConn(remoteConn, localConn)
}
func SSHAgent() ssh.AuthMethod {
if sshAgent, err := net.Dial("unix", os.Getenv("SSH_AUTH_SOCK")); err == nil {
return ssh.PublicKeysCallback(agent.NewClient(sshAgent).Signers)
}
return nil
}
func check(e error) {
if e != nil {
panic(e)
}
}
func main() {
fout, err := os.OpenFile("C:\\Projects\\sshtunnel\\sshtunnel_log.log", os.O_RDWR | os.O_CREATE | os.O_APPEND, 0666)
check(err)
log.SetOutput(fout)
localHostName, err := os.Hostname()
check(err)
localEndpoint := &Endpoint{
Host: localHostName,
Port: 27013,
}
log.Println( "Host:", localEndpoint.Host, "Port:" , localEndpoint.Port)
serverEndpoint := &Endpoint{
Host: "ubuntu.cse.unr.edu",
Port: 22,
}
log.Println( "Host:", serverEndpoint.Host, "Port:" , serverEndpoint.Port)
remoteEndpoint := &Endpoint{
Host: "motherbrain.unr.edu",
Port: 27013,
}
log.Println( "Host:", remoteEndpoint.Host, "Port:" , remoteEndpoint.Port)
sshConfig := &ssh.ClientConfig{
User: "",
HostKeyCallback: KeyPrint,
Auth: []ssh.AuthMethod{
ssh.Password(""),
},
}
tunnel := &SSHtunnel{
Config: sshConfig,
Local: localEndpoint,
Server: serverEndpoint,
Remote: remoteEndpoint,
}
var currentNetworkHardwareName string
interfaces, _ := net.Interfaces()
for _, interf := range interfaces {
if addrs, err := interf.Addrs(); err == nil {
for index, addr := range addrs {
log.Println("[", index, "]", interf.Name, ">", addr)
log.Println("Use name : ", interf.Name)
currentNetworkHardwareName = interf.Name
}
}
}
// extract the hardware information base on the interface name
// capture above
netInterface, err := net.InterfaceByName(currentNetworkHardwareName)
check(err)
log.Println(netInterface)
name := netInterface.Name
macAddress := netInterface.HardwareAddr
log.Println("Hardware name : ", name)
log.Println("MAC address : ", macAddress)
tunnel.Start()
fout.Close()
}

File Metadata

Mime Type
text/x-c
Expires
Tue, Feb 25, 10:18 AM (1 d, 19 h)
Storage Engine
blob
Storage Format
Raw Data
Storage Handle
15161
Default Alt Text
main.go (3 KB)

Event Timeline