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. 【Laravel】 常用的artisan命令

    全局篇 查看artisan命令php artisanphp artisan list 查看某个帮助命令php artisan help make:model 查看laravel版本php artisa ...

  2. el-checkbox实现全选与单选

    实现目的:实现全选与多选,点击确定的时候获取每个值的id传给后台 1.HTML <el-checkbox v-model="checkAll" @change="h ...

  3. 人脸识别和手势识别应用(face++)开发

    基础认识 本项目使用的是face++平台,人脸识别+手势识别双确认显示. python编程,代码简介,方便扩展. 该项目适用于Windows系统和Linux系统,但必须安装相应的模块,其中包括 l  ...

  4. 吃货联盟订餐系统 源代码 Java初级小项目

    咳咳,今天博主给大家写一个小的项目:吃货联盟订餐系统.博主不是大神(互联网架构师的路上ing),也是小白一个,不过是刚入门的小白^_^.项目功能也很简单:只是模拟日常的订餐流程呦,所以有错误以及功能不 ...

  5. Spring Boot 系列

    https://www.cnblogs.com/magicalSam/p/7189421.html

  6. 如何运用Linux进行查看tomcat日志

    第一步:进入tomcat目录下的logs.cd home /tomcat/logs 第二步:运行并查看日志:tail -f catalina.out 第三步:想终止查看:ctrl +c退出 第四步:比 ...

  7. pythonic context manager知多少

    Context Managers 是我最喜欢的 python feature 之一,在恰当的时机使用 context manager 使代码更加简洁.清晰,更加安全,复用性更好,更加 pythonic ...

  8. 46道Linux面试题送给你(后续会不断更新)

    绝对路径用什么符号表示? 当前目录.上层目录用什么表示?主目录用什么表示? 切换目录用什么命令? 答案: # 绝对路径: 如/etc/init.d # 当前目录和上层目录: ./ ../ # 主目录: ...

  9. HttPclient 以post方式发送json

    使用HttpClient 以POST的形式发送json字符串 步骤: 1.url .parameters 2.创建httpClient对象 3.创建HttpPost对象 4.为post对象设置参数 5 ...

  10. Animate.css的使用(基本使用附css文件下载地址)

    animate.css下载地址: https://pan.baidu.com/s/18ceucCU1loYiGo5OCOkJBg 最新下载地址: http://www.haorooms.com/upl ...