开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > Telnet服务器 > 查看源码
socks.cs
资源名称：Terminal_Control_jan_2009.zip　[点击查看]
上传用户：szltgg
上传日期：2019-05-16
资源大小：604k
文件大小：10k
源码类别：

Telnet服务器

开发平台：

C#

socks.cs：源码内容
  1. /*
  2. * Copyright (c) 2005 Poderosa Project, All Rights Reserved.
  3. * $Id: socks.cs,v 1.2 2005/04/20 08:45:46 okajima Exp $
  4. */
  5. using System;
  6. using System.Text;
  7. using System.Text.RegularExpressions;
  8. using System.Diagnostics;
  9. using System.IO;
  10. using System.Net;
  11. using System.Net.Sockets;
  13. namespace Poderosa.Communication
  14. {
  15. public class Socks {
  16. private int _version;
  17. private string _serverName;
  18. private short _serverPort;
  19. private string _account;
  20. private string _password;
  21. private string _destName;       //_destName, _destAddress偼偳偪傜偐偺傒巊梡
  22. private string _excludingNetworks;
  23. private IPAddress _destAddress;
  24. private short  _destPort;
  26. public Socks() {
  27. _version = 5;
  28. }
  29. public int Version {
  30. get {
  31. return _version;
  32. }
  33. set {
  34. if(value!=5 && value!=4) throw new IOException("Wrong SOCKS version");
  35. _version = value;
  36. }
  37. }
  38. public string Account {
  39. get {
  40. return _account;
  41. }
  42. set {
  43. _account = value;
  44. }
  45. }
  46. public string Password {
  47. get {
  48. return _password;
  49. }
  50. set {
  51. _password = value;
  52. }
  53. }
  54. public string DestName {
  55. get {
  56. return _destName;
  57. }
  58. set {
  59. _destName = value;
  60. }
  61. }
  62. public IPAddress DestAddress {
  63. get {
  64. return _destAddress;
  65. }
  66. set {
  67. _destAddress = value;
  68. }
  69. }
  71. public short DestPort {
  72. get {
  73. return _destPort;
  74. }
  75. set {
  76. _destPort = value;
  77. }
  78. }
  80. public string ServerName {
  81. get {
  82. return _serverName;
  83. }
  84. set {
  85. _serverName = value;
  86. }
  87. }
  88. public short ServerPort {
  89. get {
  90. return _serverPort;
  91. }
  92. set {
  93. _serverPort = value;
  94. }
  95. }
  96. public string ExcludingNetworks {
  97. get {
  98. return _excludingNetworks;
  99. }
  100. set {
  101. _excludingNetworks = value;
  102. }
  103. }
  105. public void Connect(Socket s) {
  106. if(_version==4)
  107. ConnectBySocks4(s);
  108. else
  109. ConnectBySocks5(s);
  110. }  
  112. private void ConnectBySocks4(Socket s) {
  113. MemoryStream u = new MemoryStream();
  114. BinaryWriter wr = new BinaryWriter(u);
  115. wr.Write((byte)4);
  116. wr.Write((byte)1);
  117. wr.Write(IPAddress.HostToNetworkOrder(_destPort));
  118. if(_destAddress==null) { //host偑巜掕偝傟偨
  119. //埲壓偱傛偄偲巚偭偨偑丄偳偆傕摦偐側偄丅僾儘僩僐儖4a偲偄偆傗偮偑僒億乕僩偝傟偰偄側偄偺偐丠
  120. throw new IOException("The address is not specified.");
  121. /*
  122. wr.Write(IPAddress.HostToNetworkOrder(1));
  123. wr.Write(Encoding.ASCII.GetBytes(_account));
  124. wr.Write((byte)0); //null char
  125. wr.Write(Encoding.ASCII.GetBytes(_destName));
  126. wr.Write((byte)0);
  127. */
  128. }
  129. else {
  130. wr.Write(_destAddress.GetAddressBytes());
  131. wr.Write(Encoding.ASCII.GetBytes(_account));
  132. wr.Write((byte)0); //null char
  133. }
  134. wr.Close();
  135. byte[] payload = u.ToArray();
  136. s.Send(payload, 0, payload.Length, SocketFlags.None);
  138. byte[] response = new byte[8];
  139. s.Receive(response, 0, response.Length, SocketFlags.None);
  140. if(response[1]!=90)
  141. throw new IOException("SOCKS authentication failed.");
  142. /*
  143. #define SOCKS4_REP_SUCCEEDED 90  rquest granted (succeeded) 
  144. #define SOCKS4_REP_REJECTED 91  request rejected or failed
  145. #define SOCKS4_REP_IDENT_FAIL 92  cannot connect identd 
  146. #define SOCKS4_REP_USERID 93 user id not matched 
  147. */
  149. }
  151. private void ConnectBySocks5(Socket s) {
  152. byte[] first = new byte[] { 5,2,0,2 };
  153. s.Send(first, 0, 4, SocketFlags.None);
  154. //s.WriteByte((byte)5);
  155. //s.WriteByte((byte)2);
  156. //s.WriteByte((byte)0); //no auth
  157. //s.WriteByte((byte)2); //user/pass
  159. byte[] response = new byte[4];
  160. int r = s.Receive(response, 0, 2, SocketFlags.None);
  161. //Debug.WriteLine("[0] len="+r+" res="+response[1]);
  162. if(r!=2) throw new IOException("Failed to communicate with the SOCKS server.");
  163. if(response[0]!=5) throw new IOException(String.Format("The SOCKS server specified an unsupported authentication method [{0}].", response[0]));
  165. if(response[1]==0) {
  166. ; //no auth
  167. }
  168. else if(response[1]==2) {
  169. Sock5Auth(s);
  170. }
  171. else
  172. throw new IOException(String.Format("The SOCKS server specified an unsupported authentication method [{0}].", response[1]));
  175. MemoryStream u = new MemoryStream();
  176. BinaryWriter wr = new BinaryWriter(u);
  177. wr.Write((byte)5);
  178. wr.Write((byte)1); //command
  179. wr.Write((byte)0);
  180. if(_destAddress==null) {
  181. wr.Write((byte)3);
  182. wr.Write((byte)_destName.Length);
  183. wr.Write(Encoding.ASCII.GetBytes(_destName));
  184. }
  185. else {
  186. wr.Write((byte)1);
  187. wr.Write(_destAddress.GetAddressBytes());
  188. }
  189. wr.Write(IPAddress.HostToNetworkOrder(_destPort));
  190. wr.Close();
  191. byte[] payload = u.ToArray();
  192. s.Send(payload, 0, payload.Length, SocketFlags.None);
  194. r = s.Receive(response, 0, 4, SocketFlags.None);
  195. if(response[1]!=0)
  196. throw new IOException("Failed to communicate with the SOCKS server." + GetSocks5ErrorMessage(response[1]));
  198. //read addr and port
  199. if(response[3]==3) {
  200. byte[] t = new byte[1];
  201. s.Receive(t, 0, 1, SocketFlags.None);
  202. byte[] t2 = new byte[t[0]];
  203. s.Receive(t2, 0, t2.Length, SocketFlags.None);
  204. }
  205. else if(response[3]==1) {
  206. byte[] t = new byte[6];
  207. s.Receive(t, 0, 6, SocketFlags.None);
  208. }
  209. else
  210. throw new IOException("unexpected destination addr type " + response[3]);
  211. }
  213. private void Sock5Auth(Socket s) {
  214. MemoryStream u = new MemoryStream();
  215. u.WriteByte(1);
  216. byte[] t = Encoding.ASCII.GetBytes(_account);
  217. u.WriteByte((byte)t.Length);
  218. u.Write(t, 0, t.Length);
  219. t = Encoding.ASCII.GetBytes(_password);
  220. u.WriteByte((byte)t.Length);
  221. u.Write(t, 0, t.Length);
  222. byte[] payload = u.ToArray();
  223. s.Send(payload, 0, payload.Length, SocketFlags.None);
  225. byte[] response = new byte[2];
  226. int r = s.Receive(response, 0, 2, SocketFlags.None);
  227. if(r!=2 || response[1]!=0)
  228. throw new IOException("SOCKS authentication failed.");
  229. }
  231. private static string GetSocks5ErrorMessage(byte code) {
  232. /*
  233.              o  X'01' general SOCKS server failure
  234.              o  X'02' connection not allowed by ruleset
  235.              o  X'03' Network unreachable
  236.              o  X'04' Host unreachable
  237.              o  X'05' Connection refused
  238.              o  X'06' TTL expired
  239.              o  X'07' Command not supported
  240.              o  X'08' Address type not supported
  241.              o  X'09' to X'FF' unassigned
  242.  */
  243. switch(code) {
  244. case 1:
  245. return "SOCKS server error";
  246. case 2:
  247. return "The connection is not allowed.";
  248. case 3:
  249. return "Failed to reach the destination network.";
  250. case 4:
  251. return "Failed to reach the destination host.";
  252. case 5:
  253. return "The access is denied.";
  254. case 6:
  255. return "TTL is disposed.";
  256. case 7:
  257. return "The SOCKS command is not supported.";
  258. case 8:
  259. return "The type of address is not supported.";
  260. default:
  261. return String.Format("Unknown Code {0}", code);
  262. }
  263. }
  265. /*
  266. public static void Test() {
  267. TcpClient tcp = new TcpClient();
  268. tcp.Connect("akamatsu", 1080);
  269. Socks s = new Socks();
  270. s.Version = 5;
  271. s.DestName = "ume";
  272. //s.DestAddress = IPAddress.Parse("192.168.10.23");
  273. s.DestPort = 23;
  274. s.Account = "okajima";
  275. s.Password = "okajima";
  277. s.Connect(tcp.GetStream());
  278. }
  279. */
  280. }
  282. //V4/V6偦傟偧傟侾偮偺傾僪儗僗傪帩偪丄乽椉懳墳丄偨偩偟椉曽巊偊傞偲偒偼V6桪愭乿偲偄偆惈幙傪傕偮傛偆偵偡傞
  283. public class IPAddressSet {
  284. private IPAddress _v4Address;
  285. private IPAddress _v6Address;
  287. public IPAddressSet(string host) {
  288. //IPAddress[] t = Dns.GetHostByName(host).AddressList;
  289.             IPAddress[] t = Dns.GetHostEntry(host).AddressList;
  290. foreach(IPAddress a in t) {
  291. if(a.AddressFamily==AddressFamily.InterNetwork && _v4Address==null) _v4Address = a;
  292. else if(a.AddressFamily==AddressFamily.InterNetworkV6 && _v6Address==null) _v6Address = a;
  293. }
  294. }
  295. public IPAddressSet(IPAddress a) {
  296. if(a.AddressFamily==AddressFamily.InterNetwork) _v4Address = a;
  297. else if(a.AddressFamily==AddressFamily.InterNetworkV6) _v6Address = a;
  298. }
  299. public IPAddressSet(IPAddress v4, IPAddress v6) {
  300. _v4Address = v4;
  301. _v6Address = v6;
  302. }
  303. public IPAddress Primary {
  304. get {
  305. return _v6Address!=null? _v6Address : _v4Address;
  306. }
  307. }
  308. public IPAddress Secondary {
  309. get {
  310. return _v6Address!=null? _v4Address : null;
  311. }
  312. }
  313. }
  315. public class NetUtil {
  316. public static Socket ConnectTCPSocket(IPAddressSet addr, int port) {
  317. IPAddress primary = addr.Primary;
  318. if(primary==null) return null;
  320. Socket s = new Socket(primary.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
  321. try {
  322. s.Connect(new IPEndPoint(primary, port));
  323. return s;
  324. }
  325. catch(Exception ex) {
  326. IPAddress secondary = addr.Secondary;
  327. if(secondary==null) throw ex;
  328. s = new Socket(secondary.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
  329. s.Connect(new IPEndPoint(secondary, port));
  330. return s;
  331. }
  332. }
  334. public static bool IsNetworkAddress(string netaddress) {
  335. try {
  336. Regex re = new Regex("([\dA-Fa-f\.\:]+)/\d+");
  337. Match m = re.Match(netaddress);
  338. if(m.Length!=netaddress.Length || m.Index!=0) return false;
  340. //偐偭偙偑IP傾僪儗僗側傜OK
  341. string a = m.Groups[1].Value;
  342. IPAddress.Parse(a);
  343. return true;
  344. }
  345. catch(Exception) {
  346. return false;
  347. }
  348. }
  349. public static bool NetAddressIncludesIPAddress(string netaddress, IPAddress target) {
  350. int slash = netaddress.IndexOf('/');
  351. int bits = Int32.Parse(netaddress.Substring(slash+1));
  352. IPAddress net = IPAddress.Parse(netaddress.Substring(0, slash));
  353. if(net.AddressFamily!=target.AddressFamily) return false;
  355. byte[] bnet = net.GetAddressBytes();
  356. byte[] btarget = target.GetAddressBytes();
  357. Debug.Assert(bnet.Length==btarget.Length);
  359. for(int i=0; i<bnet.Length; i++) {
  360. byte b1 = bnet[i];
  361. byte b2 = btarget[i];
  362. if(bits<=0)
  363. return true;
  364. else if(bits>=8) {
  365. if(b1!=b2) return false;
  366. }
  367. else {
  368. b1 >>= (8 - bits);
  369. b2 >>= (8 - bits);
  370. if(b1!=b2) return false;
  371. }
  372. bits -= 8;
  373. }
  374. return true;
  375. }
  378. }
  379. }