2. 程式人生 > >如何在騰訊雲平臺裡搭建vpn連線本地區域網

如何在騰訊雲平臺裡搭建vpn連線本地區域網

阿新 • • 發佈：2019-02-11

最近需要使用騰訊雲平臺，瞭解了一番之後發現cvm必須使用它所指定的代理後使用ssh登入，另外ssh登入的時候還需要一個動態密碼，這樣對運維來說很不方便，於是就想弄個vpn將cvm和線下環境弄到一個局域網裡。這樣就有個問題了，openvpn的伺服器放在哪裡，測試了一下發現cvm只能進不能出，也即不能直接訪問外網，除非是有請求進來。於是顯然cvm只能做伺服器了，但是新問題又來了，cvm做伺服器的話tcp協議要求對應用層協議進行改造，必須傳一個tgw的頭，這就讓人鬱悶了，難道去修改openvpn的程式碼嗎？這顯然不行，於是就想幹脆寫個proxy得了，它的原理很簡單，作為一個透明代理，唯一的不同是，當它作為客戶端時，會在連線建立後立即向伺服器傳送一個tgw頭；當它作為伺服器時，會將連線建立後收到的tgw頭幹掉，當這些事情作完之後它就是一個純粹的透明代理了。這樣的程式不難寫，用golang一會就可以寫一個，下面是寫完的程式

[plain] view plaincopyprint?
  1. package main  
  2. import (  
  3.     "flag"  
  4.     "fmt"  
  5.     "log"  
  6.     "net"  
  7.     "time"  
  8. )  
  9. // 配置引數  
  10. type TConfig struct {  
  11.     targetAddr  string //目標地址，比如app12345.qzoneapp.com:80  
  12.     sourceAddr  string //源地址，即本地監聽的地址  
  13.     logFile     string //日誌檔案地址  
  14.     actAsServer bool   //是否作為伺服器，如果是的話，需要將targetAddr裡的引數發給tgw  
  15.     bufferSize  int  
  16. }  
  17. var (  
  18.     gConfig     TConfig  
  19.     gTargetAddr *net.TCPAddr  
  20.     gSourceAddr *net.TCPAddr  
  21. )  
  22. const (  
  23.     TGW_PREFIX           = "tgw_l7_forward"  
  24.     TGW_HEADER_SIZE      = 1024 * 4  
  25.     TGW_HEADER_SEG_COUNT = 3  
  26. )  
  27. //初始化引數  
  28. func initArgs() bool {  
  29.     flag.StringVar(&gConfig.targetAddr, "t", ":54321", "目標地址，比如app12345.qzoneapp.com:80")  
  30.     flag.StringVar(&gConfig.sourceAddr, "s", ":12345", "本地的監聽地址，比如192.168.1.200:8080")  
  31.     //flag.StringVar(&gConfig.logFile, "l", "/tmp/tgwProxy.log", "日誌輸出地址")  
  32.     flag.BoolVar(&gConfig.actAsServer, "a", false, "是否作為伺服器，如果是的話，需要將targetAddr裡的引數發給tgw")  
  33.     flag.IntVar(&gConfig.bufferSize, "b", 1024*1024, "快取大小")  
  34.     flag.Parse()  
  35.     var err error  
  36.     gSourceAddr, err = net.ResolveTCPAddr("tcp4", gConfig.sourceAddr)  
  37.     if err != nil {  
  38.         fmt.Printf("resolve tcp address:%s failed:%s\n", gConfig.sourceAddr, err.Error())  
  39.         return false  
  40.     }  
  41.     gTargetAddr, err = net.ResolveTCPAddr("tcp4", gConfig.targetAddr)  
  42.     if err != nil {  
  43.         fmt.Printf("resolve tcp address:%s failed:%s\n", gConfig.targetAddr, err.Error())  
  44.         return false  
  45.     }  
  46.     if gConfig.bufferSize < 1 {  
  47.         fmt.Printf("buffer size:%d is too small\n", gConfig.bufferSize)  
  48.         return false  
  49.     }  
  50.     return true  
  51. }  
  52. //初始化伺服器  
  53. func runServer() {  
  54.     listener, err := net.ListenTCP("tcp4", gSourceAddr)  
  55.     if err != nil {  
  56.         fmt.Printf("listen on tcp address:%s failed:%s\n", gConfig.sourceAddr, err.Error())  
  57.         return  
  58.     }  
  59.     log.Printf("server started")  
  60.     for {  
  61.         conn, err := listener.AcceptTCP()  
  62.         if err != nil {  
  63.             log.Printf("accept tcp connection failed:%s", err.Error())  
  64.             time.Sleep(1000000000)  
  65.         }  
  66.         log.Printf("get one connection")  
  67.         conn.SetKeepAlive(true)  
  68.         conn.SetNoDelay(true)  
  69.         if gConfig.actAsServer {  
  70.             go doServer(conn)  
  71.         } else {  
  72.             go doClient(conn)  
  73.         }  
  74.     }  
  75. }  
  76. //將所有資料寫入連線中  
  77. func writeAllData(conn net.Conn, buffer []byte) error {  
  78.     offset := 0  
  79.     length := len(buffer)  
  80.     for offset < length {  
  81.         bytes, err := conn.Write(buffer[offset:length])  
  82.         if err != nil {  
  83.             log.Printf("write to target:%s failed:%s", conn.RemoteAddr().String(), err.Error())  
  84.             return err  
  85.         }  
  86.         offset += bytes  
  87.     }  
  88.     //log.Printf("write %d bytes to connection", offset)  
  89.     return nil  
  90. }  
  91. //處理伺服器事務  
  92. func doServer(conn net.Conn) {  
  93.     defer handlePanic()  
  94.     //去掉tgw的頭  
  95.     buffer := make([]byte, TGW_HEADER_SIZE)  
  96.     length, err := conn.Read(buffer)  
  97.     if err != nil {  
  98.         log.Printf("read from client failed:%s", err.Error())  
  99.         return  
  100.     }  
  101.     segCount := 0  
  102.     for i := 1; i < length; i++ {  
  103.         if buffer[i] == '\n' && buffer[i-1] == '\r' {  
  104.             segCount++  
  105.             if segCount == TGW_HEADER_SEG_COUNT {  
  106.                 buffer = buffer[i+1 : length]  
  107.                 break  
  108.             }  
  109.         }  
  110.     }  
  111.     if segCount < TGW_HEADER_SEG_COUNT {  
  112.         log.Printf("invalid tgw header:%s", string(buffer[0:length]))  
  113.         return  
  114.     }  
  115.     targetConn, err := net.DialTCP("tcp4", nil, gTargetAddr)  
  116.     if err != nil {  
  117.         log.Printf("connect to target:%s failed:%s", gTargetAddr.String(), err.Error())  
  118.         return  
  119.     }  
  120.     log.Printf("connect to server:%s succeed", gTargetAddr.String())  
  121.     //寫剩下的欄位  
  122.     err = writeAllData(targetConn, buffer)  
  123.     if err != nil {  
  124.         return  
  125.     }  
  126.     //源請求到目標連線，即寫請求  
  127.     go proxyTransfer(conn, targetConn)  
  128.     //目標響應到源連線，即寫響應  
  129.     go proxyTransfer(targetConn, conn)  
  130. }  
  131. //將從sourceConn中讀到的資料寫給targetConn  
  132. func proxyTransfer(sourceConn net.Conn, targetConn net.Conn) {  
  133.     defer handlePanic()  
  134.     buffer := make([]byte, gConfig.bufferSize)  
  135.     for {  
  136.         length, err := sourceConn.Read(buffer)  
  137.         if err != nil {  
  138.             log.Printf("read from source:%s failed:%s", sourceConn.RemoteAddr().String(), err.Error())  
  139.             targetConn.Close()  
  140.             return  
  141.         }  
  142.         //log.Printf("read %d bytes from source connection", length)  
  143.         err = writeAllData(targetConn, buffer[0:length])  
  144.         if err != nil {  
  145.             targetConn.Close()  
  146.             return  
  147.         }  
  148.     }  
  149. }  
  150. //處理客戶端事務  
  151. func doClient(conn net.Conn) {  
  152.     defer handlePanic()  
  153.     //建立連線到目錄地址  
  154.     targetConn, err := net.DialTCP("tcp4", nil, gTargetAddr)  
  155.     if err != nil {  
  156.         log.Printf("connect to target:%s failed:%s", gTargetAddr.String(), err.Error())  
  157.         return  
  158.     }  
  159.     log.Printf("connect to server:%s succeed", gTargetAddr.String())  
  160.     //加上tgw的頭  
  161.     tgwHeader := TGW_PREFIX + "\r\nHost:" + gConfig.targetAddr + "\r\n\r\n"  
  162.     log.Printf("send tgwHeader:%s to server:%s", tgwHeader, gTargetAddr.String())  
  163.     buffer := []byte(tgwHeader)  
  164.     err = writeAllData(targetConn, buffer)  
  165.     if err != nil {  
  166.         return  
  167.     }  
  168.     //源請求到目標連線，即寫請求  
  169.     go proxyTransfer(conn, targetConn)  
  170.     //目標響應到源連線，即寫響應  
  171.     go proxyTransfer(targetConn, conn)  
  172. }  
  173. //初始化日誌  
  174. func initLogger() bool {  
  175.     log.SetFlags(log.Ldate | log.Lshortfile | log.Lmicroseconds | log.Ltime)  
  176.     log.Printf("logger init")  
  177.     return true  
  178. }  
  179. func handlePanic() {  
  180.     err := recover()  
  181.     if err != nil {  
  182.         log.Printf("uncaught panic:%s", err.(error).Error())  
  183.     }  
  184. }  
  185. func main() {  
  186.     if !initArgs() || !initLogger() {  
  187.         return  
  188.     }  
  189.     runServer()  
  190. }  
package main

import (
	"flag"
	"fmt"
	"log"
	"net"
	"time"
)

// 配置引數
type TConfig struct {
	targetAddr  string //目標地址，比如app12345.qzoneapp.com:80
	sourceAddr  string //源地址，即本地監聽的地址
	logFile     string //日誌檔案地址
	actAsServer bool   //是否作為伺服器，如果是的話，需要將targetAddr裡的引數發給tgw
	bufferSize  int
}

var (
	gConfig     TConfig
	gTargetAddr *net.TCPAddr
	gSourceAddr *net.TCPAddr
)

const (
	TGW_PREFIX           = "tgw_l7_forward"
	TGW_HEADER_SIZE      = 1024 * 4
	TGW_HEADER_SEG_COUNT = 3
)

//初始化引數
func initArgs() bool {
	flag.StringVar(&gConfig.targetAddr, "t", ":54321", "目標地址，比如app12345.qzoneapp.com:80")
	flag.StringVar(&gConfig.sourceAddr, "s", ":12345", "本地的監聽地址，比如192.168.1.200:8080")
	//flag.StringVar(&gConfig.logFile, "l", "/tmp/tgwProxy.log", "日誌輸出地址")
	flag.BoolVar(&gConfig.actAsServer, "a", false, "是否作為伺服器，如果是的話，需要將targetAddr裡的引數發給tgw")
	flag.IntVar(&gConfig.bufferSize, "b", 1024*1024, "快取大小")
	flag.Parse()

	var err error
	gSourceAddr, err = net.ResolveTCPAddr("tcp4", gConfig.sourceAddr)
	if err != nil {
		fmt.Printf("resolve tcp address:%s failed:%s\n", gConfig.sourceAddr, err.Error())
		return false
	}

	gTargetAddr, err = net.ResolveTCPAddr("tcp4", gConfig.targetAddr)
	if err != nil {
		fmt.Printf("resolve tcp address:%s failed:%s\n", gConfig.targetAddr, err.Error())
		return false
	}

	if gConfig.bufferSize < 1 {
		fmt.Printf("buffer size:%d is too small\n", gConfig.bufferSize)
		return false
	}

	return true
}

//初始化伺服器
func runServer() {
	listener, err := net.ListenTCP("tcp4", gSourceAddr)
	if err != nil {
		fmt.Printf("listen on tcp address:%s failed:%s\n", gConfig.sourceAddr, err.Error())
		return
	}
	log.Printf("server started")
	for {
		conn, err := listener.AcceptTCP()
		if err != nil {
			log.Printf("accept tcp connection failed:%s", err.Error())
			time.Sleep(1000000000)
		}

		log.Printf("get one connection")
		conn.SetKeepAlive(true)
		conn.SetNoDelay(true)

		if gConfig.actAsServer {
			go doServer(conn)
		} else {
			go doClient(conn)
		}
	}
}

//將所有資料寫入連線中
func writeAllData(conn net.Conn, buffer []byte) error {
	offset := 0
	length := len(buffer)
	for offset < length {
		bytes, err := conn.Write(buffer[offset:length])
		if err != nil {
			log.Printf("write to target:%s failed:%s", conn.RemoteAddr().String(), err.Error())
			return err
		}
		offset += bytes
	}
	//log.Printf("write %d bytes to connection", offset)
	return nil
}

//處理伺服器事務
func doServer(conn net.Conn) {
	defer handlePanic()
	//去掉tgw的頭
	buffer := make([]byte, TGW_HEADER_SIZE)
	length, err := conn.Read(buffer)
	if err != nil {
		log.Printf("read from client failed:%s", err.Error())
		return
	}
	segCount := 0
	for i := 1; i < length; i++ {
		if buffer[i] == '\n' && buffer[i-1] == '\r' {
			segCount++
			if segCount == TGW_HEADER_SEG_COUNT {
				buffer = buffer[i+1 : length]
				break
			}
		}
	}

	if segCount < TGW_HEADER_SEG_COUNT {
		log.Printf("invalid tgw header:%s", string(buffer[0:length]))
		return
	}

	targetConn, err := net.DialTCP("tcp4", nil, gTargetAddr)
	if err != nil {
		log.Printf("connect to target:%s failed:%s", gTargetAddr.String(), err.Error())
		return
	}

	log.Printf("connect to server:%s succeed", gTargetAddr.String())

	//寫剩下的欄位
	err = writeAllData(targetConn, buffer)
	if err != nil {
		return
	}

	//源請求到目標連線，即寫請求
	go proxyTransfer(conn, targetConn)

	//目標響應到源連線，即寫響應
	go proxyTransfer(targetConn, conn)
}

//將從sourceConn中讀到的資料寫給targetConn
func proxyTransfer(sourceConn net.Conn, targetConn net.Conn) {
	defer handlePanic()
	buffer := make([]byte, gConfig.bufferSize)
	for {
		length, err := sourceConn.Read(buffer)
		if err != nil {
			log.Printf("read from source:%s failed:%s", sourceConn.RemoteAddr().String(), err.Error())
			targetConn.Close()
			return
		}
		//log.Printf("read %d bytes from source connection", length)

		err = writeAllData(targetConn, buffer[0:length])
		if err != nil {
			targetConn.Close()
			return
		}
	}
}

//處理客戶端事務
func doClient(conn net.Conn) {
	defer handlePanic()
	//建立連線到目錄地址
	targetConn, err := net.DialTCP("tcp4", nil, gTargetAddr)
	if err != nil {
		log.Printf("connect to target:%s failed:%s", gTargetAddr.String(), err.Error())
		return
	}

	log.Printf("connect to server:%s succeed", gTargetAddr.String())

	//加上tgw的頭
	tgwHeader := TGW_PREFIX + "\r\nHost:" + gConfig.targetAddr + "\r\n\r\n"
	log.Printf("send tgwHeader:%s to server:%s", tgwHeader, gTargetAddr.String())
	buffer := []byte(tgwHeader)
	err = writeAllData(targetConn, buffer)
	if err != nil {
		return
	}

	//源請求到目標連線，即寫請求
	go proxyTransfer(conn, targetConn)

	//目標響應到源連線，即寫響應
	go proxyTransfer(targetConn, conn)
}

//初始化日誌
func initLogger() bool {
	log.SetFlags(log.Ldate | log.Lshortfile | log.Lmicroseconds | log.Ltime)
	log.Printf("logger init")
	return true
}

func handlePanic() {
	err := recover()
	if err != nil {
		log.Printf("uncaught panic:%s", err.(error).Error())
	}
}

func main() {
	if !initArgs() || !initLogger() {
		return
	}
	runServer()
}

這樣的話，在cvm上啟動一個伺服器端，監聽到127.0.0.1:1179上，然後再在cvm上啟動一個proxy讓它代理到這個埠上，而外部埠則監聽到cvm的繫結埠上。

同樣的，在本地啟動一個proxy，讓它代理到cvm的繫結域名和埠上，然後openvpn客戶端連到代理的監聽埠上，這樣果然兩臺機器就弄到一個局域網裡了。

接下來你就只需要在cvm裡建一些”合適“的賬號就可以不用動態密碼直接像區域網一樣登入了。

相關推薦

如何在騰訊雲平臺裡搭建vpn連線本地區域網

最近需要使用騰訊雲平臺，瞭解了一番之後發現cvm必須使用它所指定的代理後使用ssh登入，另外ssh登入的時候還需要一個動態密碼，這樣對運維來說很不方便，於是就想弄個vpn將cvm和線下環境弄到一個局域網裡。這樣就有個問題了，openvpn的伺服器放在哪裡，測試了一下發現cvm只能進不能出，也即不能直接訪問外

騰訊雲：ubuntu搭建 FTP 文件服務

security pam erl 人的 列表 雲主機 swd lan oms 搭建 FTP 文件服務 安裝並啟動 FTP 服務 任務時間：5min ~ 10min 安裝 VSFTPD 使用 apt-get 安裝 vsftpd： sudo apt-get install

騰訊雲CentOS6.8搭建lnmp環境

lnmp環境 系統 pan 技術分享 pcre nmp ima style ges 一、安裝Ngnix 首先查看服務器系統的環境 　　　　 　　　　 　　　　 　　　　可以看出我的系統環境是（CentOS6.9 64位）　　 　　　2. 安裝pcre和

騰訊雲Centos7.3搭建LNMP環境的一次記錄

大小 ins 操作 技術 style repos release val 鏡像 1.修改系統鏡像源 為了使安裝速度更快,在這裏我選擇網易鏡像源:http://mirrors.163.com/.help/centos.html 參考上述網址說明 首先備份/etc/yum.re

騰訊雲的ftp搭建

xftp ets sta 問題 防火墻 ftp lis src file 一開始配置完後 發現用xftp鏈接登錄成功 但是列表無法列舉出來 然後又用力cmd、filezilla發現都是一個主動被動問題 pasv_enable=YES、pasv_min_port=60000、

騰訊雲 Ubuntu16.04 搭建Git 服務

  一．安裝Git伺服器所需軟體 1.安裝git-core, openssh-server, openssh-client三個軟體。git-core是git的核心軟體； openssh-server、openssh-client是伺服器和客戶端傳輸檔案通過ssh協議。 輸入：sudo

騰訊雲學生伺服器搭建個人網站（01）——配置web開發環境

最近突然想整個伺服器玩玩，百度了一下發現騰訊雲學生伺服器，完成學生認證之後一個月最低只要十塊錢就能玩起來，於是就買了一個，折騰了一天，算是在伺服器上搭建好了基本web開發環境（tomcat和jdk），並且也在伺服器上跑出了自己的第一個靜態網頁。下面詳細介紹環境的搭建過程。 首先需要說明的是，

騰訊雲CentOS7環境搭建（JDK、MySQL、Tomcat）

準備工作： JDK下載，連結：https://pan.baidu.com/s/18V-JxhPydNSHCaG_OuDNqg  提取碼：ctus  Toncat下載，連結：https://pan.baidu.com/s/1dOY0M8-wkrp0Do5NFWNs2g  提

騰訊雲+tipask快速搭建基於laravel的CMS網站

一、購買騰訊雲伺服器，服務市場->基礎環境->選擇WordPress平臺映象二、按照tipask教程安裝tipask官方教程地址https://wenda.tipask.com/article/22官方教程對新手不太友好，我整理如下：1.ftp上傳檔案雲伺服器映象

騰訊雲centos7 環境搭建 mysql安裝

版權宣告：本文為博主原創文章，未經博主允許不得轉載。    https://blog.csdn.net/paulowina/article/details/79890644 參考地址： https://www.cnblogs.com/lgqboke/p/6873734.

騰訊雲centos7 環境搭建 nginx安裝

版權宣告：本文為博主原創文章，未經博主允許不得轉載。    https://blog.csdn.net/paulowina/article/details/79894995 安裝 yum install nginx 1 安裝之後，可以檢視nginx的預設安裝目錄 [

騰訊雲java環境搭建完整流程

註冊登入騰訊雲，下載putty連線。jdk安裝輸入yum search jdk小貼士：yum可以理解為一個聯網的軟體管家，詳見Loaded plugins: fastestmirror, security Loading mirror speeds from cached h

【騰訊雲】自己搭建的騰訊雲伺服器JavaEE環境

轉載地址：https://www.cnblogs.com/qlqwjy/p/8727487.html 感覺很專業的樣子，還沒有看完，更沒有實踐，找個機會實踐一下。 0.安裝SSH登入 1.生成公鑰對 ssh-keygen -t rsa -P ''   -P表示密

騰訊雲centos7.2搭建mysql7.5

不太熟悉自動安裝mysql後的目錄結構,所以記錄下過程. 參考(非常好用): https://blog.csdn.net/a774630093/article/details/79270080 執行了 wget http://repo.mysql.com/mysql-community-release-el

騰訊雲伺服器MySQL配置遠端連線

1.在 Ubuntu 16.04 中，預設情況下，只有最新版本的 MySQL 包含在 APT 軟體包儲存庫中。 sudo apt-get update sudo apt-get install mysql-server 系統將提示您在安裝過程中建立 root

騰訊雲伺服器上搭建mysql 如何使雲資料庫能外網訪問

本人滁州學院大四狗（郵箱[email protected]），做畢業設計想用自己買的騰訊雲伺服器上搭建MySql資料庫，並且可以通過外網訪問。因為我要做個winform的應用程式用。下面說一說，如何讓自己的騰訊雲伺服器上的資料庫能通過外網訪問。 雲資

騰訊雲centos7 伺服器搭建（Java、MySQL、Tomcat環境配置）

最近由於需要上線一個網站，所以學習這麼搭建騰訊雲伺服器，對於linux之前真的很少接觸，最近慢慢學習如何慢慢linux。本部落格純屬個人筆記，供本人複習回顧。 搭建過程要感謝我的師弟，小亮亮，給了我騰訊雲伺服器的搭建部落格文章，參考了他的文章，自己照葫蘆畫瓢也開

騰訊雲centos系統遠端桌面連線不了

騰訊雲的windows系統可以直接開啟遠端桌面來連線，但是用centos系統的話，遠端桌面是連線不了的，這時你需要下載一個xShell工具，360軟體管家就有，先下載安裝，過程很簡單，傻瓜式下一步就可以。 然後來說一下如何用xShell工具連上咱們的伺服器。 1.先開啟下載好的xShell，

騰訊雲Windows伺服器搭建jsp專案

我用的是騰訊雲Windows tomcat+mysql+jdk 的環境。如果不是下的裝載好的環境，就需要自己搭建了，其他Windows下搭建也比較簡單，網上教程比較多。 配好環境，需要把專案打成.wa

騰訊雲Centos6.6搭建javaweb環境:mysql5.1+jdk1.7+tomcat6完整過程

近日，入手了個騰訊雲伺服器，想著linux穩定，就選擇了linux centos6.6系統，最新的是7.1，但是聽說6.6比較穩定，就選擇了6.6，下面把步驟貼出來，希望對大家有所幫助。 前期準備： 安裝centos6.6系統 在安裝系統時最好選用SSH