Dart实战——Socks5服务器

import 'dart:io';

import '../lib/socks5.dart';

const server_port = 8082;

void main() {
  print('socks5 service run on $server_port');
  startSocks5Server();
}

void startSocks5Server() async {
  RawServerSocket serverSocket =
      await RawServerSocket.bind(InternetAddress.anyIPv4, server_port);

  // 等待客户端socket连接
  await for (RawSocket socket in serverSocket) {
    Socks5Helper(socket);
  }
  serverSocket.close();
}

import 'dart:convert';
import 'dart:io';
import 'dart:async';
import 'dart:typed_data';

class Socks5Helper {
  RawSocket clientSocket;
  RawSocket targetSocket;

  // 是否完成了握手
  bool handshakeCompleted = false;
  // 是否建立了连接
  bool connCompleted = false;

  Socks5Helper(this.clientSocket) {
    // 监听Socks客户端的数据
    clientSocket.listen(
        (event) async {
          if (event == RawSocketEvent.read) {
            if (!handshakeCompleted) {
              // 没有完成握手
              handshakeCompleted = handshake();
            } else if (!connCompleted) {
              // 没有建立连接通道
              connCompleted = await createConnection();
            } else {
              if (targetSocket != null) {
                // 转发客户端的数据
                forward(clientSocket, targetSocket);
              }
            }
          }
        },
        onError: (e) => print("Socks5Helper onError:$e"),
        onDone: () {
          // 连接断开回调
          clientSocket?.close();
          targetSocket?.close();
        });
  }

  //1. socks5握手
  bool handshake() {
    // 从客户端socket中读取字节数据
    Uint8List bytes = clientSocket.read(clientSocket.available());
    ByteData bd = ByteData.sublistView(bytes);
    var req = HandShakeRequest.from(bd);

    if (req.verify()) {
      clientSocket.write(HandShakeResponse.from(0x00).toByte());
      return true;
    }
    return false;
  }

  //2. 建立连接
  Future<bool> createConnection() async {
    // 从客户端socket中读取字节数据
    Uint8List bytes = clientSocket.read(clientSocket.available());
    ByteData bd = ByteData.sublistView(bytes);

    var req = Socks5Request.from(bd);
    // 仅支持CONNECT方式
    if (req.cmd != 0x01) {
      print("only support CONNECT CMD=${req.cmd}");
      var res = Socks5Response.from(
          0x07, IPv4(InternetAddress.tryParse('127.0.0.1').rawAddress, 8082));
      clientSocket.write(res.toByte());
      clientSocket.close();
      return false;
    }

    try {
      // 获取目标服务器IP地址
      var addr = await req.getAddress();
      // 访问目标服务器，建立Sockets连接
      targetSocket = await RawSocket.connect(addr, req.dst.port,
          timeout: Duration(seconds: 15));

      print('${addr.host} => ${addr.address}');

      var res = Socks5Response.from(
          0x00, IPv4(targetSocket.address.rawAddress, targetSocket.port));

      clientSocket.write(res.toByte());

      // 第二阶段完成，设置目标服务器的监听
      targetSocket.listen(
          (event) {
            if (event == RawSocketEvent.read) {
              // 数据转发
              forward(targetSocket, clientSocket);
            }
          },
          onError: (e) => print("target socket error:$e"),
          onDone: () {
            clientSocket.close();
            targetSocket.close();
          });
      return true;
    } catch (e) {
      var res = Socks5Response.from(
          0x06, IPv4(InternetAddress.tryParse("127.0.0.1").rawAddress, 8082));
      clientSocket.write(res.toByte());
      clientSocket.close();

      var errorMsg = (await req.getAddress()).host + " => $e";
      print(errorMsg);
    }
    return false;
  }

  //3. 转发请求
  void forward(RawSocket input, RawSocket output) {
    // 从输入源读取
    var bytes = input.read(input.available());
    // 发送给目标
    output.write(bytes);
  }
}


/// 握手请求
class HandShakeRequest {
  int ver;
  int nmethods;
  Uint8List methods;

  HandShakeRequest.from(ByteData blob) {
    ver = blob.getUint8(0);
    nmethods = blob.getUint8(1);
    if (nmethods > 0) {
      methods = blob.buffer.asUint8List(2, nmethods);
    }
  }

  // 验证(暂未实现，空架子)
  bool verify() {
    if (ver != 0x05) {
      print("version is not supported");
      return false;
    }

    for (var it in methods) {
      if (it == 0x00) {
        return true;
      }
    }

    print("verification method is not supported");
    return false;
  }
}

/// 握手响应
class HandShakeResponse {
  int ver = 0x05;
  int method;

  HandShakeResponse.from(this.method);

  Uint8List toByte() {
    ByteData bd = ByteData(2);
    bd.setUint8(0, ver);
    bd.setUint8(1, method);
    return bd.buffer.asUint8List();
  }
}

/// 协商请求
class Socks5Request {
  int ver;
  int cmd;
  int rsv;
  int atyp;

  Dst dst;

  Socks5Request.from(ByteData blob) {
    ver = blob.getUint8(0);
    cmd = blob.getUint8(1);
    rsv = blob.getUint8(2);
    atyp = blob.getUint8(3);

    switch (atyp) {
      case 0x01: // IPv4地址
        dst = IPv4(blob.buffer.asUint8List(4, 4), blob.getUint16(8));
        break;
      case 0x03: // 域名地址
        var len = blob.getUint8(4);
        var hostBytes = blob.buffer.asUint8List(5, len);
        dst = Domain(ascii.decode(hostBytes), blob.getUint16(len + 5));
        break;
      case 0x04:
        break;
    }
  }

  Future<InternetAddress> getAddress() async {
    switch (atyp) {
      case 0x01:
        return (dst as IPv4).address;
      case 0x03:
        List<InternetAddress> addressList =
            await InternetAddress.lookup((dst as Domain).host);
        return addressList.first;
      default:
        return null;
    }
  }
}

class Dst {
  int port;
}

class IPv4 implements Dst, Bnd {
  int port;
  InternetAddress address;

  IPv4(Uint8List addr, this.port) {
    address =
        InternetAddress.fromRawAddress(addr, type: InternetAddressType.IPv4);
  }
}

class IPv6 implements Dst, Bnd {
  int port;
}

class Domain implements Dst, Bnd {
  int port;
  String host;

  Domain(this.host, this.port);
}

class Bnd {
  int port;
}

/// 协商响应
class Socks5Response {
  int ver = 0x05;
  int rep;
  int rsv = 0x00;
  int atyp = 0x01;

  Bnd bnd;

  Socks5Response.from(this.rep, this.bnd);

  Uint8List toByte() {
    var bd = ByteData(10);
    bd.setUint8(0, ver);
    bd.setUint8(1, rep);
    bd.setUint8(2, rsv);
    bd.setUint8(3, atyp);

    Uint8List rawAddr = (bnd as IPv4).address.rawAddress;
    for (var i = 0; i < 4; i++) {
      bd.setUint8(4 + i, rawAddr[i]);
    }
    bd.setUint16(8, bnd.port);

    return bd.buffer.asUint8List();
  }
}