func (handler *VMessOutboundHandler) startCommunicate(request *vmessio.VMessRequest, dest v2net.Address, ray core.OutboundRay) error { conn, err := net.DialTCP("tcp", nil, &net.TCPAddr{dest.IP, int(dest.Port), ""}) log.Debug("VMessOutbound dialing tcp: %s", dest.String()) if err != nil { log.Error("Failed to open tcp (%s): %v", dest.String(), err) return err } defer conn.Close() input := ray.OutboundInput() output := ray.OutboundOutput() requestWriter := vmessio.NewVMessRequestWriter() err = requestWriter.Write(conn, request) if err != nil { log.Error("Failed to write VMess request: %v", err) close(output) return err } requestKey := request.RequestKey[:] requestIV := request.RequestIV[:] responseKey := md5.Sum(requestKey) responseIV := md5.Sum(requestIV) response := vmessio.VMessResponse{} nBytes, err := conn.Read(response[:]) if err != nil { close(output) log.Error("Failed to read VMess response (%d bytes): %v", nBytes, err) return err } log.Debug("Got response %v", response) // TODO: check response encryptRequestWriter, err := v2io.NewAesEncryptWriter(requestKey, requestIV, conn) if err != nil { close(output) log.Error("Failed to create encrypt writer: %v", err) return err } decryptResponseReader, err := v2io.NewAesDecryptReader(responseKey[:], responseIV[:], conn) if err != nil { close(output) log.Error("Failed to create decrypt reader: %v", err) return err } readFinish := make(chan bool) writeFinish := make(chan bool) go handler.dumpInput(encryptRequestWriter, input, readFinish) go handler.dumpOutput(decryptResponseReader, output, writeFinish) <-readFinish conn.CloseWrite() log.Debug("VMessOut closing write") <-writeFinish return nil }
func startCommunicate(request *vmessio.VMessRequest, dest v2net.Address, ray core.OutboundRay) error { input := ray.OutboundInput() output := ray.OutboundOutput() conn, err := net.DialTCP("tcp", nil, &net.TCPAddr{dest.IP, int(dest.Port), ""}) log.Debug("VMessOutbound dialing tcp: %s", dest.String()) if err != nil { log.Error("Failed to open tcp (%s): %v", dest.String(), err) close(output) return err } log.Debug("VMessOut: Tunneling request for %s", request.Address.String()) defer conn.Close() requestFinish := make(chan bool) responseFinish := make(chan bool) go handleRequest(conn, request, input, requestFinish) go handleResponse(conn, request, output, responseFinish) <-requestFinish conn.CloseWrite() <-responseFinish return nil }
func (handler *VMessInboundHandler) HandleConnection(connection net.Conn) error { defer connection.Close() reader := vmessio.NewVMessRequestReader(handler.clients) request, err := reader.Read(connection) if err != nil { log.Debug("Failed to parse VMess request: %v", err) return err } log.Debug("Received request for %s", request.Address.String()) ray := handler.vPoint.NewInboundConnectionAccepted(request.Address) input := ray.InboundInput() output := ray.InboundOutput() readFinish := make(chan bool) writeFinish := make(chan bool) go handleInput(request, connection, input, readFinish) responseKey := md5.Sum(request.RequestKey[:]) responseIV := md5.Sum(request.RequestIV[:]) response := vmessio.NewVMessResponse(request) responseWriter, err := v2io.NewAesEncryptWriter(responseKey[:], responseIV[:], connection) if err != nil { return log.Error("Failed to create encrypt writer: %v", err) } //responseWriter.Write(response[:]) // Optimize for small response packet buffer := make([]byte, 0, 1024) buffer = append(buffer, response[:]...) data, open := <-output if open { buffer = append(buffer, data...) } responseWriter.Write(buffer) if open { go handleOutput(request, responseWriter, output, writeFinish) } else { close(writeFinish) } <-writeFinish if tcpConn, ok := connection.(*net.TCPConn); ok { log.Debug("VMessIn closing write") tcpConn.CloseWrite() } <-readFinish return nil }
func (vconn *FreedomConnection) DumpInput(conn net.Conn, input <-chan []byte, finish chan<- bool) { for { data, open := <-input if !open { finish <- true log.Debug("Freedom finishing input.") break } nBytes, err := conn.Write(data) log.Debug("Freedom wrote %d bytes with error %v", nBytes, err) } }
func (server *SocksServer) dumpOutput(conn net.Conn, output <-chan []byte, finish chan<- bool) { for { buffer, open := <-output if !open { finish <- true log.Debug("Socks finishing output") break } nBytes, err := conn.Write(buffer) log.Debug("Writing %d bytes with error %v", nBytes, err) } }
func (handler *VMessOutboundHandler) dumpInput(writer io.Writer, input <-chan []byte, finish chan<- bool) { for { buffer, open := <-input if !open { finish <- true log.Debug("VMessOutbound finishing input.") break } nBytes, err := writer.Write(buffer) log.Debug("VMessOutbound: Wrote %d bytes with error %v", nBytes, err) } }
func (handler *VMessInboundHandler) HandleConnection(connection net.Conn) error { defer connection.Close() reader := vmessio.NewVMessRequestReader(handler.clients) request, err := reader.Read(connection) if err != nil { log.Debug("Failed to parse VMess request: %v", err) return err } log.Debug("Received request for %s", request.Address.String()) response := vmessio.NewVMessResponse(request) nBytes, err := connection.Write(response[:]) if err != nil { return log.Error("Failed to write VMess response (%d bytes): %v", nBytes, err) } requestKey := request.RequestKey[:] requestIV := request.RequestIV[:] responseKey := md5.Sum(requestKey) responseIV := md5.Sum(requestIV) requestReader, err := v2io.NewAesDecryptReader(requestKey, requestIV, connection) if err != nil { return log.Error("Failed to create decrypt reader: %v", err) } responseWriter, err := v2io.NewAesEncryptWriter(responseKey[:], responseIV[:], connection) if err != nil { return log.Error("Failed to create encrypt writer: %v", err) } ray := handler.vPoint.NewInboundConnectionAccepted(request.Address) input := ray.InboundInput() output := ray.InboundOutput() readFinish := make(chan bool) writeFinish := make(chan bool) go handler.dumpInput(requestReader, input, readFinish) go handler.dumpOutput(responseWriter, output, writeFinish) <-writeFinish if tcpConn, ok := connection.(*net.TCPConn); ok { log.Debug("VMessIn closing write") tcpConn.CloseWrite() } <-readFinish return nil }
func (vconn *FreedomConnection) DumpOutput(conn net.Conn, output chan<- []byte, finish chan<- bool) { for { buffer := make([]byte, 512) nBytes, err := conn.Read(buffer) log.Debug("Freedom reading %d bytes with error %v", nBytes, err) if err == io.EOF { close(output) finish <- true log.Debug("Freedom finishing output.") break } output <- buffer[:nBytes] } }
func (handler *VMessOutboundHandler) dumpOutput(reader io.Reader, output chan<- []byte, finish chan<- bool) { for { buffer := make([]byte, BufferSize) nBytes, err := reader.Read(buffer) log.Debug("VMessOutbound: Reading %d bytes, with error %v", nBytes, err) if err == io.EOF { close(output) finish <- true log.Debug("VMessOutbound finishing output.") break } output <- buffer[:nBytes] } }
func (server *SocksServer) dumpInput(conn net.Conn, input chan<- []byte, finish chan<- bool) { for { buffer := make([]byte, 512) nBytes, err := conn.Read(buffer) log.Debug("Reading %d bytes, with error %v", nBytes, err) if err == io.EOF { close(input) finish <- true log.Debug("Socks finishing input.") break } input <- buffer[:nBytes] } }
func (vconn *FreedomConnection) CloseConn(conn net.Conn, readFinish <-chan bool, writeFinish <-chan bool) { <-writeFinish if tcpConn, ok := conn.(*net.TCPConn); ok { log.Debug("Closing freedom write.") tcpConn.CloseWrite() } <-readFinish conn.Close() }
func (handler *VMessInboundHandler) HandleConnection(connection net.Conn) error { defer connection.Close() reader := vmessio.NewVMessRequestReader(handler.clients) request, err := reader.Read(connection) if err != nil { return err } log.Debug("Received request for %s", request.Address.String()) response := vmessio.NewVMessResponse(request) nBytes, err := connection.Write(response[:]) log.Debug("Writing VMess response %v", response) if err != nil { return log.Error("Failed to write VMess response (%d bytes): %v", nBytes, err) } requestKey := request.RequestKey[:] requestIV := request.RequestIV[:] responseKey := md5.Sum(requestKey) responseIV := md5.Sum(requestIV) requestReader, err := v2io.NewAesDecryptReader(requestKey, requestIV, connection) if err != nil { return log.Error("Failed to create decrypt reader: %v", err) } responseWriter, err := v2io.NewAesEncryptWriter(responseKey[:], responseIV[:], connection) if err != nil { return log.Error("Failed to create encrypt writer: %v", err) } ray := handler.vPoint.NewInboundConnectionAccepted(request.Address) input := ray.InboundInput() output := ray.InboundOutput() finish := make(chan bool, 2) go handler.dumpInput(requestReader, input, finish) go handler.dumpOutput(responseWriter, output, finish) handler.waitForFinish(finish) return nil }
// Read reads blocks from underlying reader, the length of blocks must be // a multiply of BlockSize() func (reader CryptionReader) Read(blocks []byte) (int, error) { nBytes, err := reader.reader.Read(blocks) log.Debug("CryptionReader: Read %d bytes", nBytes) if nBytes > 0 { reader.stream.XORKeyStream(blocks[:nBytes], blocks[:nBytes]) } if err != nil { log.Error("Error reading blocks: %v", err) } return nBytes, err }
func (server *SocksServer) dumpOutput(conn net.Conn, output <-chan []byte, finish chan<- bool) { for { buffer, open := <-output if !open { finish <- true break } nBytes, _ := conn.Write(buffer) log.Debug("Writing %d bytes", nBytes) } }
func (server *SocksServer) Listen(port uint16) error { listener, err := net.Listen("tcp", ":"+strconv.Itoa(int(port))) if err != nil { log.Error("Error on listening port %d: %v", port, err) return err } log.Debug("Working on tcp:%d", port) server.accepting = true go server.AcceptConnections(listener) return nil }
func (vconn *FreedomConnection) Start(ray core.OutboundRay) error { input := ray.OutboundInput() output := ray.OutboundOutput() conn, err := net.Dial("tcp", vconn.dest.String()) if err != nil { return log.Error("Failed to open tcp: %s", vconn.dest.String()) } log.Debug("Sending outbound tcp: %s", vconn.dest.String()) finish := make(chan bool, 2) go vconn.DumpInput(conn, input, finish) go vconn.DumpOutput(conn, output, finish) go vconn.CloseConn(conn, finish) return nil }
func handleResponse(conn *net.TCPConn, request *vmessio.VMessRequest, output chan<- []byte, finish chan<- bool) error { defer close(finish) responseKey := md5.Sum(request.RequestKey[:]) responseIV := md5.Sum(request.RequestIV[:]) response := vmessio.VMessResponse{} nBytes, err := conn.Read(response[:]) if err != nil { log.Error("Failed to read VMess response (%d bytes): %v", nBytes, err) return err } log.Debug("Got response %v", response) // TODO: check response decryptResponseReader, err := v2io.NewAesDecryptReader(responseKey[:], responseIV[:], conn) if err != nil { log.Error("Failed to create decrypt reader: %v", err) return err } v2net.ReaderToChan(output, decryptResponseReader) return nil }
func (r *VMessRequestReader) Read(reader io.Reader) (*VMessRequest, error) { buffer := make([]byte, 256) nBytes, err := reader.Read(buffer[:core.IDBytesLen]) if err != nil { return nil, err } log.Debug("Read user hash: %v", buffer[:nBytes]) userId, timeSec, valid := r.vUserSet.GetUser(buffer[:nBytes]) if !valid { return nil, ErrorInvalidUser } aesCipher, err := aes.NewCipher(userId.CmdKey()) if err != nil { return nil, err } aesStream := cipher.NewCFBDecrypter(aesCipher, v2hash.Int64Hash(timeSec)) decryptor := v2io.NewCryptionReader(aesStream, reader) if err != nil { return nil, err } nBytes, err = decryptor.Read(buffer[0:1]) if err != nil { return nil, err } randomLength := buffer[0] if randomLength <= 0 || randomLength > 32 { return nil, fmt.Errorf("Unexpected random length %d", randomLength) } _, err = decryptor.Read(buffer[:randomLength]) if err != nil { return nil, err } nBytes, err = decryptor.Read(buffer[0:1]) if err != nil { return nil, err } request := &VMessRequest{ UserId: *userId, Version: buffer[0], } if request.Version != Version { log.Error("Unknown VMess version %d", request.Version) return nil, ErrorInvalidVerion } // TODO: check number of bytes returned _, err = decryptor.Read(request.RequestIV[:]) if err != nil { return nil, err } _, err = decryptor.Read(request.RequestKey[:]) if err != nil { return nil, err } _, err = decryptor.Read(request.ResponseHeader[:]) if err != nil { return nil, err } _, err = decryptor.Read(buffer[0:1]) if err != nil { return nil, err } request.Command = buffer[0] _, err = decryptor.Read(buffer[0:2]) if err != nil { return nil, err } port := binary.BigEndian.Uint16(buffer[0:2]) _, err = decryptor.Read(buffer[0:1]) if err != nil { return nil, err } switch buffer[0] { case addrTypeIPv4: _, err = decryptor.Read(buffer[1:5]) if err != nil { return nil, err } request.Address = v2net.IPAddress(buffer[1:5], port) case addrTypeIPv6: _, err = decryptor.Read(buffer[1:17]) if err != nil { return nil, err } request.Address = v2net.IPAddress(buffer[1:17], port) case addrTypeDomain: _, err = decryptor.Read(buffer[1:2]) if err != nil { return nil, err } domainLength := buffer[1] _, err = decryptor.Read(buffer[2 : 2+domainLength]) if err != nil { return nil, err } request.Address = v2net.DomainAddress(string(buffer[2:2+domainLength]), port) } _, err = decryptor.Read(buffer[0:1]) if err != nil { return nil, err } randomLength = buffer[0] _, err = decryptor.Read(buffer[:randomLength]) if err != nil { return nil, err } return request, nil }
func (w *VMessRequestWriter) Write(writer io.Writer, request *VMessRequest) error { buffer := make([]byte, 0, 300) counter := w.randomRangeInt64(time.Now().UTC().Unix(), 30) idHash := w.idHash.Hash(request.UserId.Bytes, counter) log.Debug("Writing userhash: %v", idHash) buffer = append(buffer, idHash...) encryptionBegin := len(buffer) randomLength := mrand.Intn(32) + 1 randomContent := make([]byte, randomLength) _, err := rand.Read(randomContent) if err != nil { return err } buffer = append(buffer, byte(randomLength)) buffer = append(buffer, randomContent...) buffer = append(buffer, request.Version) buffer = append(buffer, request.RequestIV[:]...) buffer = append(buffer, request.RequestKey[:]...) buffer = append(buffer, request.ResponseHeader[:]...) buffer = append(buffer, request.Command) portBytes := make([]byte, 2) binary.BigEndian.PutUint16(portBytes, request.Address.Port) buffer = append(buffer, portBytes...) switch { case request.Address.IsIPv4(): buffer = append(buffer, addrTypeIPv4) buffer = append(buffer, request.Address.IP...) case request.Address.IsIPv6(): buffer = append(buffer, addrTypeIPv6) buffer = append(buffer, request.Address.IP...) case request.Address.IsDomain(): buffer = append(buffer, addrTypeDomain) buffer = append(buffer, byte(len(request.Address.Domain))) buffer = append(buffer, []byte(request.Address.Domain)...) } paddingLength := mrand.Intn(32) + 1 paddingBuffer := make([]byte, paddingLength) _, err = rand.Read(paddingBuffer) if err != nil { return err } buffer = append(buffer, byte(paddingLength)) buffer = append(buffer, paddingBuffer...) encryptionEnd := len(buffer) aesCipher, err := aes.NewCipher(request.UserId.CmdKey()) if err != nil { return err } aesStream := cipher.NewCFBEncrypter(aesCipher, v2hash.Int64Hash(counter)) cWriter := v2io.NewCryptionWriter(aesStream, writer) _, err = writer.Write(buffer[0:encryptionBegin]) if err != nil { return err } _, err = cWriter.Write(buffer[encryptionBegin:encryptionEnd]) if err != nil { return err } return nil }
func (vconn *FreedomConnection) DumpOutput(conn net.Conn, output chan<- []byte, finish chan<- bool) { v2net.ReaderToChan(output, conn) close(output) log.Debug("Freedom closing output") finish <- true }
func (handler *VMessInboundHandler) dumpOutput(writer io.Writer, output <-chan []byte, finish chan<- bool) { v2net.ChanToWriter(writer, output) log.Debug("VMessOut closing output") finish <- true }
func (handler *VMessInboundHandler) dumpInput(reader io.Reader, input chan<- []byte, finish chan<- bool) { v2net.ReaderToChan(input, reader) close(input) log.Debug("VMessIn closing input") finish <- true }
// Write writes the give blocks to underlying writer. The length of the blocks // must be a multiply of BlockSize() func (writer CryptionWriter) Write(blocks []byte) (int, error) { log.Debug("CryptionWriter writing %d bytes", len(blocks)) writer.stream.XORKeyStream(blocks, blocks) return writer.writer.Write(blocks) }
func (server *SocksServer) dumpOutput(writer io.Writer, output <-chan []byte, finish chan<- bool) { v2net.ChanToWriter(writer, output) log.Debug("Socks output closed") finish <- true }
func (server *SocksServer) dumpInput(reader io.Reader, input chan<- []byte, finish chan<- bool) { v2net.ReaderToChan(input, reader) close(input) log.Debug("Socks input closed") finish <- true }
func (server *SocksServer) HandleConnection(connection net.Conn) error { defer connection.Close() auth, err := socksio.ReadAuthentication(connection) if err != nil { log.Error("Error on reading authentication: %v", err) return err } expectedAuthMethod := socksio.AuthNotRequired if server.config.AuthMethod == JsonAuthMethodUserPass { expectedAuthMethod = socksio.AuthUserPass } if !auth.HasAuthMethod(expectedAuthMethod) { authResponse := socksio.NewAuthenticationResponse(socksio.AuthNoMatchingMethod) socksio.WriteAuthentication(connection, authResponse) log.Info("Client doesn't support allowed any auth methods.") return ErrorAuthenticationFailed } log.Debug("Auth accepted, responding auth.") authResponse := socksio.NewAuthenticationResponse(socksio.AuthNotRequired) socksio.WriteAuthentication(connection, authResponse) request, err := socksio.ReadRequest(connection) if err != nil { log.Error("Error on reading socks request: %v", err) return err } response := socksio.NewSocks5Response() if request.Command == socksio.CmdBind || request.Command == socksio.CmdUdpAssociate { response := socksio.NewSocks5Response() response.Error = socksio.ErrorCommandNotSupported socksio.WriteResponse(connection, response) log.Info("Unsupported socks command %d", request.Command) return ErrorCommandNotSupported } response.Error = socksio.ErrorSuccess response.Port = request.Port response.AddrType = request.AddrType switch response.AddrType { case socksio.AddrTypeIPv4: copy(response.IPv4[:], request.IPv4[:]) case socksio.AddrTypeIPv6: copy(response.IPv6[:], request.IPv6[:]) case socksio.AddrTypeDomain: response.Domain = request.Domain } log.Debug("Socks response port = %d", response.Port) socksio.WriteResponse(connection, response) ray := server.vPoint.NewInboundConnectionAccepted(request.Destination()) input := ray.InboundInput() output := ray.InboundOutput() finish := make(chan bool, 2) go server.dumpInput(connection, input, finish) go server.dumpOutput(connection, output, finish) server.waitForFinish(finish) return nil }
func (handler *VMessOutboundHandler) dumpOutput(reader io.Reader, output chan<- []byte, finish chan<- bool) { v2net.ReaderToChan(output, reader) close(output) log.Debug("VMessOut closing output") finish <- true }
func (request *VMessRequest) ToBytes(idHash v2hash.CounterHash, randomRangeInt64 v2math.RandomInt64InRange) ([]byte, error) { buffer := make([]byte, 0, 300) counter := randomRangeInt64(time.Now().UTC().Unix(), 30) hash := idHash.Hash(request.UserId.Bytes, counter) log.Debug("Writing userhash: %v", hash) buffer = append(buffer, hash...) encryptionBegin := len(buffer) randomLength := mrand.Intn(32) + 1 randomContent := make([]byte, randomLength) _, err := rand.Read(randomContent) if err != nil { return nil, err } buffer = append(buffer, byte(randomLength)) buffer = append(buffer, randomContent...) buffer = append(buffer, request.Version) buffer = append(buffer, request.RequestIV[:]...) buffer = append(buffer, request.RequestKey[:]...) buffer = append(buffer, request.ResponseHeader[:]...) buffer = append(buffer, request.Command) portBytes := make([]byte, 2) binary.BigEndian.PutUint16(portBytes, request.Address.Port) buffer = append(buffer, portBytes...) switch { case request.Address.IsIPv4(): buffer = append(buffer, addrTypeIPv4) buffer = append(buffer, request.Address.IP...) case request.Address.IsIPv6(): buffer = append(buffer, addrTypeIPv6) buffer = append(buffer, request.Address.IP...) case request.Address.IsDomain(): buffer = append(buffer, addrTypeDomain) buffer = append(buffer, byte(len(request.Address.Domain))) buffer = append(buffer, []byte(request.Address.Domain)...) } paddingLength := mrand.Intn(32) + 1 paddingBuffer := make([]byte, paddingLength) _, err = rand.Read(paddingBuffer) if err != nil { return nil, err } buffer = append(buffer, byte(paddingLength)) buffer = append(buffer, paddingBuffer...) encryptionEnd := len(buffer) aesCipher, err := aes.NewCipher(request.UserId.CmdKey()) if err != nil { return nil, err } aesStream := cipher.NewCFBEncrypter(aesCipher, v2hash.Int64Hash(counter)) aesStream.XORKeyStream(buffer[encryptionBegin:encryptionEnd], buffer[encryptionBegin:encryptionEnd]) return buffer, nil }
func (handler *VMessOutboundHandler) waitForFinish(finish <-chan bool) { <-finish <-finish log.Debug("Finishing waiting for VMessOutbound ending.") }
func (vconn *FreedomConnection) DumpInput(conn net.Conn, input <-chan []byte, finish chan<- bool) { v2net.ChanToWriter(conn, input) log.Debug("Freedom closing input") finish <- true }