Building a TCP Proxy

Using io.Reader and io.Writer

Essentially all input/output(I/O).

package main

import (
"fmt"
"log"
"os"
) // FooReader defines an io.Reader to read from stdin.
type FooReader struct{} // Read reads data from stdin.
func (fooReader *FooReader) Read(b []byte) (int, error) {
fmt.Print("in > ")
return os.Stdin.Read(b)
} // FooWriter defines an io.Writer to write to Stdout.
type FooWriter struct{} // Write writes data to Stdout.
func (fooWriter *FooWriter) Write(b []byte) (int, error) {
fmt.Print("Out > ")
return os.Stdout.Write(b)
} func main() {
// Instantiate reader and writer.
var (
reader FooReader
writer FooWriter
) // Create buffer to hold input/output.
input := make([]byte, 4096) // Use reader to read input.
s, err := reader.Read(input)
if err != nil {
log.Fatalln("Unable to read data")
}
fmt.Printf("Read %d bytes from stdin\n", s) // Use writer to write output.
s, err = writer.Write(input)
if err != nil {
log.Fatalln("Unable to write data")
}
fmt.Printf("Wrote %d bytes to stdout\n", s)
}

  

Copy function in Go.

package main

import (
"fmt"
"io"
"log"
"os"
) // FooReader defines an io.Reader to read from stdin.
type FooReader struct{} // Read reads data from stdin.
func (fooReader *FooReader) Read(b []byte) (int, error) {
fmt.Print("in > ")
return os.Stdin.Read(b)
} // FooWriter defines an io.Writer to write to Stdout.
type FooWriter struct{} // Write writes data to Stdout.
func (fooWriter *FooWriter) Write(b []byte) (int, error) {
fmt.Print("Out > ")
return os.Stdout.Write(b)
} func main() {
// Instantiate reader and writer.
var (
reader FooReader
writer FooWriter
) if _, err := io.Copy(&writer, &reader); err != nil {
log.Fatalln("Unable to read/write data")
}
}

  

 Creating the Echo Server

Use net.Conn function in Go.

package main

import (
"io"
"log"
"net"
) // echo is a handler function that simply echoes received data.
func echo(conn net.Conn) {
defer conn.Close() // Create a buffer to store received data
b := make([]byte, 512)
for {
// Receive data via conn.Read into a buffer.
size, err := conn.Read(b[0:])
if err == io.EOF {
log.Println("Client disconnected")
break
}
if err != nil {
log.Println("Unexpected error")
break
}
log.Printf("Received %d bytes: %s\n", size, string(b)) //Send data via conn.Write.
log.Println("Writing data")
if _, err := conn.Write(b[0:size]); err != nil {
log.Fatalln("Unable to write data")
}
}
} func main() {
// Bind to TCP port 20080 on all interfaces.
listener, err := net.Listen("tcp", ":20080")
if err != nil {
log.Fatalln("Unable to bind to port")
}
log.Println("Listening on 0.0.0.0:20080")
for {
// Wait for connection, Create net.Conn on connection established.
conn, err := listener.Accept()
log.Println("Received connection")
if err != nil {
log.Fatalln("Unable to accept connection")
}
// Handle the connection. Using goroutine for concurrency.
go echo(conn)
}
}

Using Telnet as the connecting client:

The server produces the following standard output:

Improving the Code by Creating a Buffered Listener.

Use bufio package in GO.

// echo is a handler function that simply echoes received data.
func echo(conn net.Conn) {
defer conn.Close() reader := bufio.NewReader(conn)
s, err := reader.ReadString('\n')
if err != nil {
log.Fatalln("Unable to read data")
}
log.Printf("Read %d bytes: %s", len(s), s) log.Println("Writing data")
writer := bufio.NewWriter(conn)
if _, err := writer.WriteString(s); err != nil {
log.Fatalln("Unable to write data")
}
writer.Flush()
}

Or use io.Copy in Go.

// echo is a handler function that simply echoes received data.
func echo(conn net.Conn) {
defer conn.Close()
// Copy data from io.Reader to io.Writer via io.Copy().
if _, err := io.Copy(conn, conn); err != nil {
log.Fatalln("Unable to read/write data")
}
}

Proxying a TCP Client

It is useful for trying to circumvent restrictive egress controls or to leverage a system to bypass network segmentation.

package main

import (
"io"
"log"
"net"
) func handle(src net.Conn) {
dst, err := net.Dial("tcp", "destination.website:80")
if err != nil {
log.Fatalln("Unable to connect to our unreachable host")
}
defer dst.Close() // Run in goroutine to prevent io.Copy from blocking
go func() {
// Copy our source's output to the destination
if _, err := io.Copy(dst, src); err != nil {
log.Fatalln(err)
}
}()
// Copy our destination's output back to our source
if _, err := io.Copy(src, dst); err != nil {
log.Fatalln(err)
}
} func main() {
// Listen on local port 80
listener, err := net.Listen("tcp", ":80")
if err != nil {
log.Fatalln("Unable to bind to port")
} for {
conn, err := listener.Accept()
if err != nil {
log.Fatalln("Unable to accept connection")
}
go handle(conn)
}
}

 Replicating Netcat for Command Execution

The following feature is not included in standard Linux builds.

nc -lp  -e /bin/bash

Create it in GO!

Using PipeReader and PipeWriter allows you to

package main

import (
"io"
"log"
"net"
"os/exec"
) func handle(conn net.Conn) { /*
* Explicitly calling /bin/sh and using -i for interactive mode
* so that we can use it for stdin and stdout.
* For Windows use exec.Command("cmd.exe")
*/
cmd := exec.Command("/bin/sh","-i")
rp, wp := io.Pipe()
// Set stdin to our connection
cmd.Stdin = conn
cmd.Stdout = wp
go io.Copy(conn, rp)
cmd.Run()
conn.Close()
} func main() {
listener, err := net.Listen("tcp", ":20080")
if err != nil {
log.Fatalln(err)
} for {
conn, err := listener.Accept()
if err != nil {
log.Fatalln(err)
}
go handle(conn)
}
}

  

Go Pentester - TCP Proxy的更多相关文章

  1. nginx tcp proxy 连接保持设置

    根据前文Nginx tcp proxy module试用的设置,在测试环境中发现tcp连接经常掉线.在该项目站点上找到一个issue,也谈论这件事情,不过别人用在web socket协议上. 其实就是 ...

  2. 基于nginx的TCP Proxy实现数据库读写分离

    nginx非常早就支持tcp proxy.可是一直不知道其使用,近期在nginx blog上看见了.一些实践者将其运用到数据库訪问的负载均衡以及实现读写分离,来提高数据库的吞吐量,这里我不会讲详细的搭 ...

  3. named piped tcp proxy 下载

    named piped tcp proxy 在某DN上面下载很麻烦,还要登录什么的,分享出来!希望大家支持 链接:https://pan.baidu.com/s/1fdJD6O0qb8_BkkrnMy ...

  4. Proxy Server源码及分析(TCP Proxy源码 Socket实现端口映射)

    版权声明:本文为博主原创文章,遵循 CC 4.0 by-sa 版权协议,转载请附上原文出处链接和本声明.本文链接:https://blog.csdn.net/u014530704/article/de ...

  5. Nginx TCP Proxy模块的编译安装

    这次用一个国内开发者在GitHub上的开源项目https://github.com/yaoweibin/nginx_tcp_proxy_module 我的系统已经安装了最新的Nginx,现在需要下载源 ...

  6. iodine免费上网——本质就是利用dns tunnel建立tcp,然后tcp proxy来实现通过访问虚拟dns0网卡来访问你的dns 授权server

    我的命令: server端: sudo iodined -P passwd -f -DD 10.0.0.100 abc.com client端(直连模式,-r表示使用xxx.abc.com的xxx来转 ...

  7. Go Pentester - TCP Scanner

    Simple Port Scanner with Golang Use Go‘s net package: net.Dial(network, address string) package main ...

  8. tcp转发

    Proxy.java package com.dc.tcp.proxy; import java.io.IOException; import java.net.ServerSocket; impor ...

  9. Linux 系统安全 抵御TCP的洪水

    抵御TCP的洪水 分类: LINUX tcp_syn_retries :INTEGER默认值是5对 于一个新建连接,内核要发送多少个 SYN 连接请求才决定放弃.不应该大于255,默认值是5,对应于1 ...

随机推荐

  1. Centos7 composer安装时 Warning: This development build of composer is over 60 days old. It is recommended to update it by running "/usr/bin/composer self-update" to get the latest version.

    emmm,其实就是想让你运行一下/usr/bin/composer self-update这个命令更新一下

  2. 基于SSM框架的新生报到可视化系统

    1.本课题的目的及意义 新生报到数据一直是困扰着各大高校的管理性问题,人数多.工作量大,这无疑是一个挑战,也因此加快了高校的信息化建设步伐.随着互联网的普及与发展,日常生活中人们接触到的数据正以惊人的 ...

  3. SLAM数据集序列图片如何批量处理

    SLAM数据集序列图片如何批量处理 原创:SLAM爬坑之行 引言:在SLAM学习过程中,有时候需要对大量的数据集比如TUM/KITTI等图片序列进行批量处理,这个时候需要用到opencv中的函数对图像 ...

  4. 学习python的基本了解

    1) 使用python打印信息,分别打印你的名字.年龄.爱好# print('wang,23,shopping')# 2)使用变量,分别打印你的名字.年龄.爱好# name='wang'# age=2 ...

  5. 112买卖股票的最佳时机II

    from typing import List# 这道题和上一题很类似,但有一些不同,每天都可以买入,或者卖出# 那么利润最大化,就是i + 1 天的价格比i天的价格高的时候买入# 然后在i + 1天 ...

  6. SQL语法LPAD和RPAD

    一.[LPAD左侧补齐] LPAD(str,len,padstr) LPAD(str,len,padstr) 返回字符串 str, 其左边由字符串padstr 填补到len 字符长度.假如str 的长 ...

  7. C#实现快速查找(递归,非递归)

    原文件: http://pan.baidu.com/share/link?shareid=2838344856&uk=3912660076 我英语很烂...哎,我正在努力... 效果图:

  8. 第 11 篇:基于 drf-haystack 的文章搜索接口

    作者:HelloGitHub-追梦人物 在 django 博客教程中,我们使用了 django-haystack 和 Elasticsearch 进行文章内容的搜索.django-haystack 默 ...

  9. WIN10有线网络反复断开解决方法

    最近家里台式机碰到一个奇怪的问题,开机之后有线网络就时断时续,右下角网络图标不停在小地球与小电脑之间切换.网上大概搜索了一下,貌似碰到这种问题的朋友不在少数,但大部分朋友碰到的都是无线网络居多.这里把 ...

  10. nodejs 获取当前路径的方法

    var path = require("path"); var url = path.resolve('./');