= LinkedBlockingDeque()\n\n fun write(data: ByteArray) {\n if (data.size > MAX_PACKET_LEN) throw Error(\"Packet too large\")\n packetQueue.addLast(data)\n }\n\n fun shutdown() {\n this.shutdown = true\n }\n\n override fun run() {\n while (!this.shutdown && clientWriter.channel.isOpen) {\n try {\n val data: ByteArray = this.packetQueue.take()\n try {\n this.clientWriter.write(data)\n } catch (e: IOException) {\n Log.e(TAG, \"Error writing $shutdown data.length bytes to the VPN\")\n e.printStackTrace()\n// this.packetQueue.addFirst(data) // Put the data back, so it's resent\n Thread.sleep(10) // Add an arbitrary tiny pause, in case that helps\n }\n } catch (ignored: InterruptedException) {\n }\n }\n }\n}\n"
},
{
"path": "android/app/src/main/kotlin/com/network/proxy/vpn/socket/CloseableConnection.kt",
"content": "package com.network.proxy.vpn.socket\n\nimport com.network.proxy.vpn.Connection\n\ninterface CloseableConnection {\n /**\n * 关闭连接\n */\n fun closeConnection(connection: Connection)\n}"
},
{
"path": "android/app/src/main/kotlin/com/network/proxy/vpn/socket/Constant.kt",
"content": "package com.network.proxy.vpn.socket\n\nobject Constant {\n const val MAX_RECEIVE_BUFFER_SIZE = 65535\n}"
},
{
"path": "android/app/src/main/kotlin/com/network/proxy/vpn/socket/ProtectSocket.kt",
"content": "package com.network.proxy.vpn.socket\n\nimport java.net.DatagramSocket\nimport java.net.Socket\n\ninterface ProtectSocket {\n\n /**\n * 保护Socket不受VPN连接的影响。保护后，通过该套接字发送的数据将直接进入底层网络，因此其流量不会通过VPN转发。\n */\n fun protect(socket: Socket): Boolean\n\n fun protect(socket: DatagramSocket): Boolean\n\n}"
},
{
"path": "android/app/src/main/kotlin/com/network/proxy/vpn/socket/ProtectSocketHolder.kt",
"content": "package com.network.proxy.vpn.socket\n\nimport java.net.DatagramSocket\nimport java.net.Socket\n\n/**\n * ProtectSocket的持有者，用于在VPNService中获取ProtectSocket的实例\n */\nclass ProtectSocketHolder {\n\n companion object {\n private var protectSocket: ProtectSocket? = null\n\n fun setProtectSocket(protectSocket: ProtectSocket) {\n this.protectSocket = protectSocket\n }\n\n fun getProtectSocket(): ProtectSocket? {\n return protectSocket\n }\n\n fun protect(socket: Socket): Boolean {\n return protectSocket?.protect(socket) ?: false\n }\n\n fun protect(socket: DatagramSocket): Boolean {\n return protectSocket?.protect(socket) ?: false\n }\n }\n\n\n}"
},
{
"path": "android/app/src/main/kotlin/com/network/proxy/vpn/socket/SocketChannelReader.java",
"content": "package com.network.proxy.vpn.socket;\n\nimport androidx.annotation.NonNull;\n\nimport android.util.Log;\n\nimport com.network.proxy.vpn.Connection;\nimport com.network.proxy.vpn.TagKt;\nimport com.network.proxy.vpn.transport.protocol.IP4Header;\nimport com.network.proxy.vpn.transport.protocol.TCPHeader;\nimport com.network.proxy.vpn.transport.protocol.TCPPacketFactory;\nimport com.network.proxy.vpn.transport.protocol.UDPPacketFactory;\n\nimport java.io.IOException;\nimport java.nio.ByteBuffer;\nimport java.nio.channels.ClosedByInterruptException;\nimport java.nio.channels.ClosedChannelException;\nimport java.nio.channels.DatagramChannel;\nimport java.nio.channels.NotYetConnectedException;\nimport java.nio.channels.SelectionKey;\nimport java.nio.channels.SocketChannel;\nimport java.nio.channels.spi.AbstractSelectableChannel;\n\n\n/**\n * Takes a session, and reads all available upstream data back into it.\n * Used by the NIO thread, and run synchronously as part of that non-blocking loop.\n */\nclass SocketChannelReader {\n\n private final String TAG = TagKt.getTAG(this);\n\n private final ClientPacketWriter writer;\n\n public SocketChannelReader(ClientPacketWriter writer) {\n this.writer = writer;\n }\n\n public void read(Connection connection) {\n AbstractSelectableChannel channel = connection.getChannel();\n\n if (channel instanceof SocketChannel) {\n readTCP(connection);\n } else if (channel instanceof DatagramChannel) {\n readUDP(connection);\n } else {\n return;\n }\n\n // Resubscribe to reads, so that we're triggered again if more data arrives later.\n connection.subscribeKey(SelectionKey.OP_READ);\n\n if (connection.isAbortingConnection()) {\n Log.d(TAG, \"removing aborted connection -> \" + connection);\n connection.cancelKey();\n if (channel instanceof SocketChannel) {\n try {\n SocketChannel socketChannel = (SocketChannel) channel;\n if (socketChannel.isConnected()) {\n socketChannel.close();\n }\n } catch (IOException e) {\n Log.e(TAG, e.toString());\n }\n } else {\n try {\n DatagramChannel datagramChannel = (DatagramChannel) channel;\n if (datagramChannel.isConnected()) {\n datagramChannel.close();\n }\n } catch (IOException e) {\n e.printStackTrace();\n }\n }\n connection.closeConnection();\n }\n }\n\n private void readTCP(@NonNull Connection connection) {\n if (connection.isAbortingConnection()) {\n return;\n }\n\n SocketChannel channel = (SocketChannel) connection.getChannel();\n ByteBuffer buffer = ByteBuffer.allocate(Constant.MAX_RECEIVE_BUFFER_SIZE);\n int len;\n\n try {\n do {\n len = channel.read(buffer);\n if (len > 0) { //-1 mean it reach the end of stream\n sendToRequester(buffer, len, connection);\n buffer.clear();\n } else if (len == -1) {\n//\t\t\t\t\tLog.d(TAG,\"End of data from remote server, will send FIN to client\");\n Log.d(TAG, \"send FIN to: \" + connection);\n sendFin(connection);\n connection.setAbortingConnection(true);\n }\n } while (len > 0);\n } catch (NotYetConnectedException e) {\n Log.e(TAG, \"socket not connected\");\n } catch (ClosedByInterruptException e) {\n Log.e(TAG, \"ClosedByInterruptException reading SocketChannel: \" + e.getMessage());\n } catch (ClosedChannelException e) {\n Log.e(TAG, \"ClosedChannelException reading SocketChannel: \" + e.getMessage());\n } catch (IOException e) {\n Log.e(TAG, \"Error reading data from SocketChannel: \" + e.getMessage());\n connection.setAbortingConnection(true);\n }\n }\n\n private void sendToRequester(ByteBuffer buffer, int dataSize, @NonNull Connection connection) {\n // Last piece of data is usually smaller than MAX_RECEIVE_BUFFER_SIZE. We use this as a\n // trigger to set PSH on the resulting TCP packet that goes to the VPN.\n connection.setHasReceivedLastSegment(dataSize < Constant.MAX_RECEIVE_BUFFER_SIZE);\n\n buffer.limit(dataSize);\n buffer.flip();\n // TODO should allocate new byte array?\n byte[] data = new byte[dataSize];\n System.arraycopy(buffer.array(), 0, data, 0, dataSize);\n connection.addReceivedData(data);\n //pushing all data to vpn client\n while (connection.hasReceivedData()) {\n pushDataToClient(connection);\n }\n }\n\n /**\n * create packet data and send it to VPN client\n */\n private void pushDataToClient(@NonNull Connection connection) {\n if (!connection.hasReceivedData()) {\n //no data to send\n Log.d(TAG, \"no data for vpn client\");\n }\n\n IP4Header ipHeader = connection.getLastIpHeader();\n TCPHeader tcpheader = connection.getLastTcpHeader();\n // TODO What does 60 mean?\n int max = connection.getMaxSegmentSize() - 60;\n\n if (max < 1) {\n max = 1024;\n }\n\n byte[] packetBody = connection.getReceivedData(max);\n if (packetBody != null && packetBody.length > 0) {\n long unAck = connection.getSendNext();\n long nextUnAck = connection.getSendNext() + packetBody.length;\n connection.setSendNext((int) nextUnAck);\n //we need this data later on for retransmission\n// connection.setUnackData(packetBody);\n// connection.setResendPacketCounter(0);\n\n byte[] data = TCPPacketFactory.createResponsePacketData(ipHeader,\n tcpheader, packetBody, connection.getHasReceivedLastSegment(),\n connection.getRecSequence(), (int) unAck,\n connection.getTimestampSender(), connection.getTimestampReplyTo());\n\n writer.write(data);\n }\n }\n\n private void sendFin(Connection connection) {\n final IP4Header ipHeader = connection.getLastIpHeader();\n final TCPHeader tcpheader = connection.getLastTcpHeader();\n final byte[] data = TCPPacketFactory.INSTANCE.createFinData(ipHeader, tcpheader,\n connection.getRecSequence(), connection.getSendNext(),\n connection.getTimestampSender(), connection.getTimestampReplyTo());\n\n writer.write(data);\n }\n\n private void readUDP(Connection connection) {\n DatagramChannel channel = (DatagramChannel) connection.getChannel();\n ByteBuffer buffer = ByteBuffer.allocate(Constant.MAX_RECEIVE_BUFFER_SIZE);\n int len;\n\n try {\n do {\n if (connection.isAbortingConnection()) {\n break;\n }\n\n len = channel.read(buffer);\n if (len > 0) {\n buffer.limit(len);\n buffer.flip();\n\n //create UDP packet\n byte[] data = new byte[len];\n System.arraycopy(buffer.array(), 0, data, 0, len);\n byte[] packetData = UDPPacketFactory.createResponsePacket(\n connection.getLastIpHeader(), connection.getLastUdpHeader(), data);\n\n //write to client\n writer.write(packetData);\n\n buffer.clear();\n }\n } while (len > 0);\n } catch (NotYetConnectedException ex) {\n Log.e(TAG, \"failed to read from unconnected UDP socket\");\n } catch (IOException e) {\n Log.e(TAG, \"Failed to read from UDP socket, aborting connection\");\n connection.setAbortingConnection(true);\n }\n }\n}\n"
},
{
"path": "android/app/src/main/kotlin/com/network/proxy/vpn/socket/SocketChannelWriter.java",
"content": "package com.network.proxy.vpn.socket;\n\nimport androidx.annotation.NonNull;\nimport android.util.Log;\n\n\nimport com.network.proxy.vpn.Connection;\nimport com.network.proxy.vpn.TagKt;\nimport com.network.proxy.vpn.transport.protocol.TCPPacketFactory;\n\nimport java.io.IOException;\nimport java.nio.ByteBuffer;\nimport java.nio.channels.DatagramChannel;\nimport java.nio.channels.NotYetConnectedException;\nimport java.nio.channels.SelectionKey;\nimport java.nio.channels.SocketChannel;\nimport java.nio.channels.spi.AbstractSelectableChannel;\n\n\n/**\n * Takes a VPN session, and writes all received data from it to the upstream channel.\n * \n * If any writes fail, it resubscribes to OP_WRITE, and tries again next time\n * that fires (as soon as the channel is ready for more data).\n *
\n * Used by the NIO thread, and run synchronously as part of that non-blocking loop.\n */\npublic class SocketChannelWriter {\n\tprivate final String TAG = TagKt.getTAG(this);\n\n\tprivate final ClientPacketWriter writer;\n\n\tSocketChannelWriter(ClientPacketWriter writer) {\n\t\tthis.writer = writer;\n\t}\n\n\tpublic void write(@NonNull Connection connection) {\n\t\tAbstractSelectableChannel channel = connection.getChannel();\n\t\tif (channel instanceof SocketChannel) {\n\t\t\twriteTCP(connection);\n\t\t} else if(channel instanceof DatagramChannel) {\n\t\t\twriteUDP(connection);\n\t\t} else {\n\t\t\t// We only ever create TCP & UDP channels, so this should never happen\n\t\t\tthrow new IllegalArgumentException(\"Unexpected channel type: \" + channel);\n\t\t}\n\n\t\tif (connection.isAbortingConnection()) {\n\t\t\tLog.d(TAG,\"removing aborted connection -> \" + connection);\n\t\t\tconnection.cancelKey();\n\n\t\t\tif (channel instanceof SocketChannel) {\n\t\t\t\ttry {\n\t\t\t\t\tSocketChannel socketChannel = (SocketChannel) channel;\n\t\t\t\t\tif (socketChannel.isConnected()) {\n\t\t\t\t\t\tsocketChannel.close();\n\t\t\t\t\t}\n\t\t\t\t} catch (IOException e) {\n\t\t\t\t\te.printStackTrace();\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\ttry {\n\t\t\t\t\tDatagramChannel datagramChannel = (DatagramChannel) channel;\n\t\t\t\t\tif (datagramChannel.isConnected()) {\n\t\t\t\t\t\tdatagramChannel.close();\n\t\t\t\t\t}\n\t\t\t\t} catch (IOException e) {\n\t\t\t\t\te.printStackTrace();\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tconnection.closeConnection();\n\t\t}\n\t}\n\n\tprivate void writeUDP(Connection connection) {\n\t\ttry {\n\t\t\twritePendingData(connection);\n//\t\t\tDate dt = new Date();\n//\t\t\tconnection.connectionStartTime = dt.getTime();\n\t\t}catch(NotYetConnectedException ex2){\n\t\t\tconnection.setAbortingConnection(true);\n\t\t\tLog.e(TAG,\"Error writing to unconnected-UDP server, will abort current connection: \"+ex2.getMessage());\n\t\t} catch (IOException e) {\n\t\t\tconnection.setAbortingConnection(true);\n\t\t\te.printStackTrace();\n\t\t\tLog.e(TAG,\"Error writing to UDP server, will abort connection: \"+e.getMessage());\n\t\t}\n\t}\n\t\n\tprivate void writeTCP(Connection connection) {\n\t\ttry {\n\t\t\twritePendingData(connection);\n\t\t} catch (NotYetConnectedException ex) {\n\t\t\tLog.e(TAG,\"failed to write to unconnected socket: \" + ex.getMessage());\n\t\t} catch (IOException e) {\n\t\t\tLog.e(TAG,\"Error writing to server: \" + e);\n\t\t\t\n\t\t\t//close connection with vpn client\n\t\t\tbyte[] rstData = TCPPacketFactory.INSTANCE.createRstData(\n\t\t\t\t\tconnection.getLastIpHeader(), connection.getLastTcpHeader(), 0);\n\n\t\t\twriter.write(rstData);\n\n\t\t\t//remove session\n\t\t\tLog.e(TAG,\"failed to write to remote socket, aborting connection\");\n\t\t\tconnection.setAbortingConnection(true);\n\t\t}\n\t}\n\n\tprivate void writePendingData(Connection connection) throws IOException {\n\t\tif (!connection.hasDataToSend()) return;\n\t\tAbstractSelectableChannel channel = connection.getChannel();\n\n\t\tbyte[] data = connection.getSendingData();\n\t\tByteBuffer buffer = ByteBuffer.allocate(data.length);\n\t\tbuffer.put(data);\n\t\tbuffer.flip();\n\n\t\twhile (buffer.hasRemaining()) {\n\t\t\tint bytesWritten = channel instanceof SocketChannel\n\t\t\t\t? ((SocketChannel) channel).write(buffer)\n\t\t\t\t: ((DatagramChannel) channel).write(buffer);\n\n\t\t\tif (bytesWritten == 0) {\n\t\t\t\tbreak;\n\t\t\t}\n\t\t}\n\n\t\tif (buffer.hasRemaining()) {\n\t\t\t// The channel's own buffer is full, so we have to save this for later.\n\t\t\tLog.i(TAG, buffer.remaining() + \" bytes unwritten for \" + channel);\n\n\t\t\t// Put the remaining data from the buffer back into the session\n\t\t\tconnection.setSendingData(buffer.compact());\n\n\t\t\t// Subscribe to WRITE events, so we know when this is ready to resume.\n\t\t\tconnection.subscribeKey(SelectionKey.OP_WRITE);\n\t\t} else {\n\t\t\t// All done, all good -> wait until the next TCP PSH / UDP packet\n\t\t\tconnection.setDataForSendingReady(false);\n\n\t\t\t// We don't need to know about WRITE events any more, we've written all our data.\n\t\t\t// This is safe from races with new data, due to the session lock in NIO.\n\t\t\tconnection.unsubscribeKey(SelectionKey.OP_WRITE);\n\t\t}\n\t}\n}\n"
},
{
"path": "android/app/src/main/kotlin/com/network/proxy/vpn/socket/SocketNIODataService.java",
"content": "package com.network.proxy.vpn.socket;\n\nimport android.util.Log;\n\n\nimport com.network.proxy.vpn.Connection;\nimport com.network.proxy.vpn.TagKt;\n\nimport java.io.IOException;\nimport java.nio.channels.ClosedChannelException;\nimport java.nio.channels.DatagramChannel;\nimport java.nio.channels.SelectableChannel;\nimport java.nio.channels.SelectionKey;\nimport java.nio.channels.Selector;\nimport java.nio.channels.SocketChannel;\nimport java.nio.channels.spi.AbstractSelectableChannel;\nimport java.util.Iterator;\nimport java.util.concurrent.locks.Lock;\nimport java.util.concurrent.locks.ReentrantLock;\n\n\n/**\n * A service that single-threadedly processes the events around our session connections,\n * entirely via non-blocking NIO.\n *
\n * It uses a Selector that fires on outgoing socket events (connected, readable, writable),\n * handles the resulting operations, and keeps those subscriptions up to date.\n */\npublic class SocketNIODataService implements Runnable {\n\n\tprivate final String TAG = TagKt.getTAG(this);\n\tprivate final ReentrantLock nioSelectionLock = new ReentrantLock();\n\tprivate final ReentrantLock nioHandlingLock = new ReentrantLock();\n\tprivate final Selector selector = Selector.open();\n\n\tprivate final SocketChannelReader reader;\n\tprivate final SocketChannelWriter writer;\n\n\tprivate volatile boolean shutdown = false;\n\n\t\n\tpublic SocketNIODataService(ClientPacketWriter clientPacketWriter) throws IOException {\n\t\treader = new SocketChannelReader(clientPacketWriter);\n\t\twriter = new SocketChannelWriter(clientPacketWriter);\n\t}\n\n\t@Override\n\tpublic void run() {\n\t\tLog.d(TAG,\"SocketNIODataService starting in background...\");\n\t\trunTask();\n\t}\n\n\tpublic void registerSession(Connection connection) throws ClosedChannelException {\n\t\tAbstractSelectableChannel channel = connection.getChannel();\n\n\t\tboolean isConnected = channel instanceof DatagramChannel\n\t\t\t\t? ((DatagramChannel) channel).isConnected()\n\t\t\t\t: ((SocketChannel) channel).isConnected();\n\n//\t\tLog.i(TAG, \"Registering new session: \" + session);\n\n\t\tLock selectorLock = lockSelector(selector);\n\t\ttry {\n\t\t\tSelectionKey selectionKey = channel.register(selector,\n\t\t\t\t\tisConnected\n\t\t\t\t\t\t\t? SelectionKey.OP_READ\n\t\t\t\t\t\t\t: SelectionKey.OP_CONNECT\n\t\t\t);\n\t\t\tconnection.setSelectionKey(selectionKey);\n\t\t\tselectionKey.attach(connection);\n//\t\t\tLog.d(TAG, \"Registered selector successfully\");\n\t\t} finally {\n\t\t\tselectorLock.unlock();\n\t\t}\n\t}\n\n\tprivate Lock lockSelector(Selector selector) {\n\t\tboolean gotSelectionLock = nioSelectionLock.tryLock();\n\t\tif (gotSelectionLock) return nioSelectionLock;\n\n\t\tnioHandlingLock.lock(); // Ensure the NIO thread can't do anything on wakeup\n\t\tselector.wakeup();\n\n\t\tnioSelectionLock.lock(); // Actually get the lock we want\n\t\tnioHandlingLock.unlock(); // Release the handling lock, which we no longer care about\n\n\t\treturn nioSelectionLock;\n\t}\n\n\t/**\n\t * If the selector is currently select()ing, wake it up (e.g. to register changes to\n\t * interestOps). If it's not (and so it probably will select() very soon anyway) do nothing.\n\t * This is designed to be run after changing readyOps, to ensure the new ops get monitored\n\t * immediately (and fire immediately, if already ready). Without this, that blocks.\n\t */\n\tpublic void refreshSelect(Connection connection) {\n\t\tboolean gotLock = nioSelectionLock.tryLock();\n\n\t\tif (!gotLock) {\n\t\t\tconnection.getSelectionKey().selector().wakeup();\n\t\t} else {\n\t\t\tnioSelectionLock.unlock();\n\t\t}\n\t}\n\n\t/**\n\t * Shut down the NIO thread\n\t */\n\tpublic void shutdown(){\n\t\tthis.shutdown = true;\n\t\tselector.wakeup();\n\t}\n\n\tprivate void runTask(){\n\t\tLog.i(TAG, \"NIO selector is running...\");\n\t\t\n\t\twhile(!shutdown){\n\t\t\ttry {\n\t\t\t\tnioSelectionLock.lockInterruptibly();\n\t\t\t\tselector.select();\n\t\t\t} catch (IOException e) {\n\t\t\t\tLog.e(TAG,\"Error in Selector.select(): \" + e.getMessage());\n\t\t\t\ttry {\n\t\t\t\t\tThread.sleep(100);\n\t\t\t\t} catch (InterruptedException ex) {\n\t\t\t\t\tLog.e(TAG, e.toString());\n\t\t\t\t}\n\t\t\t\tcontinue;\n\t\t\t} catch (InterruptedException ex) {\n\t\t\t\tLog.i(TAG, \"Select() interrupted\");\n\t\t\t} finally {\n\t\t\t\tif (nioSelectionLock.isHeldByCurrentThread()) {\n\t\t\t\t\tnioSelectionLock.unlock();\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tif (shutdown) {\n\t\t\t\tbreak;\n\t\t\t}\n\n\t\t\t// A lock here makes it possible to reliably grab the selection lock above\n\t\t\tnioHandlingLock.lock();\n\t\t\ttry {\n\t\t\t\tIterator iterator = selector.selectedKeys().iterator();\n\n\t\t\t\twhile (iterator.hasNext()) {\n\t\t\t\t\tSelectionKey key = iterator.next();\n\t\t\t\t\tConnection connection = ((Connection) key.attachment());\n\t\t\t\t\tsynchronized (connection) { // Sessions are locked during processing (no VPN data races)\n\t\t\t\t\t\ttry {\n\t\t\t\t\t\t\tprocessSelectionKey(key);\n\t\t\t\t\t\t} catch (IOException e) {\n\t\t\t\t\t\t\tsynchronized (key) {\n\t\t\t\t\t\t\t\tkey.cancel();\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\n\t\t\t\t\titerator.remove();\n\t\t\t\t\tif (shutdown) {\n\t\t\t\t\t\tbreak;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t} finally {\n\t\t\t\tnioHandlingLock.unlock();\n\t\t\t}\n\t\t}\n\t\tLog.i(TAG, \"NIO selector shutdown\");\n\t}\n\n\tprivate void processSelectionKey(SelectionKey key) throws IOException {\n\t\tif (!key.isValid()) {\n\t\t\tLog.d(TAG,\"Invalid SelectionKey\");\n\t\t\treturn;\n\t\t}\n\n\t\tSelectableChannel channel = key.channel();\n\n\t\tConnection connection = ((Connection) key.attachment());\n\t\tif (connection == null) {\n\t\t\tLog.w(TAG, \"Key fired with no session attached\");\n\t\t\treturn;\n\t\t}\n\t\t\n\t\tif (channel instanceof SocketChannel && !connection.isConnected() && key.isConnectable()) {\n\t\t\tSocketChannel socketChannel = (SocketChannel) channel;\n\n\t\t\tif (socketChannel.isConnectionPending()) {\n\t\t\t\tboolean connected = socketChannel.finishConnect();\n\t\t\t\tconnection.setConnected(connected);\n\t\t\t} else {\n\t\t\t\tthrow new IllegalStateException(\"TCP channels must either be connected or pending connection\");\n\t\t\t}\n\t\t}\n\n\t\tif (isConnected(channel)) {\n\t\t\tprocessConnectedSelection(key, connection);\n\t\t}\n\t}\n\n\tprivate boolean isConnected(SelectableChannel channel) {\n\t\tif (channel instanceof DatagramChannel) {\n\t\t\treturn ((DatagramChannel) channel).isConnected();\n\t\t} else if (channel instanceof SocketChannel) {\n\t\t\treturn ((SocketChannel) channel).isConnected();\n\t\t} else {\n\t\t\tthrow new IllegalArgumentException(\"isConnected on unexpected channel type: \" + channel);\n\t\t}\n\t}\n\n\tprivate void processConnectedSelection(SelectionKey key, Connection connection) {\n\t\t// Whilst connected, we always want READ and not CONNECT events\n\t\tconnection.unsubscribeKey(SelectionKey.OP_CONNECT);\n\t\tconnection.subscribeKey(SelectionKey.OP_READ);\n\t\tprocessSelectorRead(key, connection);\n\t\tprocessPendingWrite(key, connection);\n\t}\n\n\tprivate void processSelectorRead(SelectionKey selectionKey, Connection connection) {\n\t\tboolean canRead;\n\t\tsynchronized (selectionKey) {\n\t\t\t// There's a race here that requires a lock, as isReadable requires isValid\n\t\t\tcanRead = selectionKey.isValid() && selectionKey.isReadable();\n\t\t}\n\n\t\tif (canRead) reader.read(connection);\n\t}\n\n\tprivate void processPendingWrite(SelectionKey selectionKey, Connection connection) {\n\t\t// Nothing to write? Skip this entirely, and make sure we're not subscribed\n\t\tif (!connection.hasDataToSend() || !connection.isDataForSendingReady()) {\n\t\t\tconnection.unsubscribeKey(SelectionKey.OP_WRITE);\n\t\t\treturn;\n\t\t}\n\n\t\tboolean canWrite;\n\t\tsynchronized (selectionKey) {\n\t\t\t// There's a race here that requires a lock, as isReadable requires isValid\n\t\t\tcanWrite = selectionKey.isValid() && selectionKey.isWritable();\n\t\t}\n\n\t\tif (canWrite) {\n\t\t\tconnection.unsubscribeKey(SelectionKey.OP_WRITE);\n\t\t\twriter.write(connection); // This will resubscribe to OP_WRITE if it can't complete\n\t\t}\n\t}\n}\n"
},
{
"path": "android/app/src/main/kotlin/com/network/proxy/vpn/transport/Packet.kt",
"content": "package com.network.proxy.vpn.transport\n\nimport com.network.proxy.vpn.transport.protocol.IP4Header\nimport com.network.proxy.vpn.transport.protocol.TransportHeader\n\nclass Packet(var ipHeader: IP4Header, var transportHeader: TransportHeader, var buffer: ByteArray) {\n}"
},
{
"path": "android/app/src/main/kotlin/com/network/proxy/vpn/transport/icmp/ICMPPacket.java",
"content": "package com.network.proxy.vpn.transport.icmp;\n\n\nimport androidx.annotation.NonNull;\n\npublic class ICMPPacket {\n // Two ICMP packets we can handle: simple ping & pong\n public static final byte ECHO_REQUEST_TYPE = 8;\n public static final byte ECHO_SUCCESS_TYPE = 0;\n\n // One very common packet we ignore: connection rejection. Unclear why this happens,\n // random incoming connections that the phone tries to reply to? Nothing we can do though,\n // as we can't forward ICMP onwards, and we can't usefully respond or react.\n public static final byte DESTINATION_UNREACHABLE_TYPE = 3;\n\n public final byte type;\n final byte code; // 0 for request, 0 for success, 0 - 15 for error subtypes\n\n final int checksum;\n final int identifier;\n final int sequenceNumber;\n\n final byte[] data;\n\n ICMPPacket(\n int type,\n int code,\n int checksum,\n int identifier,\n int sequenceNumber,\n byte[] data\n ) {\n this.type = (byte) type;\n this.code = (byte) code;\n this.checksum = checksum;\n this.identifier = identifier;\n this.sequenceNumber = sequenceNumber;\n this.data = data;\n }\n\n @NonNull\n public String toString() {\n return \"ICMP packet type \" + type + \"/\" + code + \" id:\" + identifier +\n \" seq:\" + sequenceNumber + \" and \" + data.length + \" bytes of data\";\n }\n}\n"
},
{
"path": "android/app/src/main/kotlin/com/network/proxy/vpn/transport/icmp/ICMPPacketFactory.java",
"content": "package com.network.proxy.vpn.transport.icmp;\n\n\nimport androidx.annotation.NonNull;\n\nimport com.network.proxy.vpn.transport.protocol.IP4Header;\nimport com.network.proxy.vpn.util.PacketUtil;\n\nimport java.io.ByteArrayOutputStream;\nimport java.nio.ByteBuffer;\n\n\npublic class ICMPPacketFactory {\n\n public static ICMPPacket parseICMPPacket(@NonNull ByteBuffer stream) {\n final byte type = stream.get();\n final byte code = stream.get();\n final int checksum = stream.getShort();\n\n final int identifier = stream.getShort();\n final int sequenceNumber = stream.getShort();\n\n final byte[] data = new byte[stream.remaining()];\n stream.get(data);\n\n return new ICMPPacket(type, code, checksum, identifier, sequenceNumber, data);\n }\n\n public static ICMPPacket buildSuccessPacket(ICMPPacket requestPacket) {\n return new ICMPPacket(\n 0,\n 0,\n 0,\n requestPacket.identifier,\n requestPacket.sequenceNumber,\n requestPacket.data\n );\n }\n\n public static byte[] packetToBuffer(IP4Header ipHeader, ICMPPacket packet) {\n byte[] ipData = ipHeader.toBytes();\n\n ByteArrayOutputStream icmpDataBuffer = new ByteArrayOutputStream();\n icmpDataBuffer.write(packet.type);\n icmpDataBuffer.write(packet.code);\n\n icmpDataBuffer.write(asShortBytes(0 /* checksum placeholder */), 0, 2);\n\n if (packet.type == ICMPPacket.ECHO_REQUEST_TYPE || packet.type == ICMPPacket.ECHO_SUCCESS_TYPE) {\n icmpDataBuffer.write(asShortBytes(packet.identifier), 0, 2);\n icmpDataBuffer.write(asShortBytes(packet.sequenceNumber), 0, 2);\n\n byte[] extraData = packet.data;\n icmpDataBuffer.write(extraData, 0, extraData.length);\n } else {\n throw new IllegalArgumentException(\"Can't serialize unrecognized ICMP packet type\");\n }\n\n byte[] icmpPacketData = icmpDataBuffer.toByteArray();\n byte[] checksum = PacketUtil.INSTANCE.calculateChecksum(icmpPacketData, 0, icmpPacketData.length);\n\n ByteBuffer resultBuffer = ByteBuffer.allocate(ipData.length + icmpPacketData.length);\n resultBuffer.put(ipData);\n resultBuffer.put(icmpPacketData);\n\n // Replace the checksum placeholder\n resultBuffer.position(ipData.length + 2);\n resultBuffer.put(checksum);\n resultBuffer.position(0);\n\n byte[] result = new byte[resultBuffer.remaining()];\n resultBuffer.get(result);\n return result;\n }\n\n private static byte[] asShortBytes(int value) {\n return ByteBuffer.allocate(2).putShort((short) value).array();\n }\n\n}\n"
},
{
"path": "android/app/src/main/kotlin/com/network/proxy/vpn/transport/protocol/IP4Header.kt",
"content": "package com.network.proxy.vpn.transport.protocol\n\nimport android.util.Log\nimport java.nio.ByteBuffer\nimport java.nio.ByteOrder\n\n/**\n * IPv4报头的数据结构。\n */\ndata class IP4Header(\n var ipVersion: Byte = 0, //对于IPv4，其值为4（因此命名为IPv4）。 4bit\n private var internetHeaderLength: Byte = 0, //头部长度 4bit\n private var diffTypeOfService: Byte, //差分服务代码点 =>6位\n private var ecn: Byte = 0, //显式拥塞通知（ECN）\n var totalLength: Int = 0, //此IP数据包的总长度 16bit\n var identification: Int = 0, //主要用于唯一标识单个IP数据报的片段组。 16bit\n private var mayFragment: Boolean, // 1bit 用于指示数据报是否可以分段。\n private var lastFragment: Boolean, // 1bit 用于指示数据报是否是片段中的最后一个。\n var fragmentOffset: Short = 0, //13bit，指定特定片段相对于原始未分段的IP数据报的开始的偏移量。\n private var timeToLive: Byte = 0, //用于防止数据报持续存在。8bit\n var protocol: Byte = 0, //定义IP数据报的数据部分中使用的协议。 8bit\n var headerChecksum: Int = 0, //用于对头部进行错误检查的16位字段。 16bit\n var sourceIP: Int = 0, //发送者的IPv4地址。 32bit\n var destinationIP: Int = 0 //接收者的IPv4地址。 32bit\n) {\n //用于控制或识别片段的3比特字段。\n //bit 0: 保留；必须为零\n //bit 1: Don't Fragment (DF)\n //bit 2: More Fragments (MF)\n private var flag: Byte = initFlag()\n\n private fun initFlag(): Byte {\n var initFlag = 0\n if (mayFragment) {\n initFlag = 0x40\n }\n\n if (lastFragment) {\n initFlag = (initFlag or 0x20)\n }\n return initFlag.toByte()\n }\n\n fun setMayFragment(mayFragment: Boolean) {\n this.mayFragment = mayFragment\n flag = if (mayFragment) {\n (flag.toInt() or 0x40).toByte()\n } else {\n (flag.toInt() and 0xBF).toByte()\n }\n }\n\n fun getIPHeaderLength(): Int {\n return internetHeaderLength * 4\n }\n\n fun copy(): IP4Header {\n return IP4Header(\n ipVersion, internetHeaderLength, diffTypeOfService, ecn, totalLength, identification,\n mayFragment, lastFragment, fragmentOffset, timeToLive, protocol, headerChecksum,\n sourceIP, destinationIP\n )\n }\n\n fun toBytes(): ByteArray {\n val buffer = ByteBuffer.allocate(getIPHeaderLength())\n buffer.order(ByteOrder.BIG_ENDIAN)\n val versionAndHeaderLength = (ipVersion.toInt() shl 4) + internetHeaderLength\n buffer.put(versionAndHeaderLength.toByte())\n\n val typeOfService: Byte = (diffTypeOfService.toInt() shl 2 and (ecn\n .toInt() and 0xFF)).toByte()\n buffer.put(typeOfService)\n\n buffer.putShort(totalLength.toShort())\n buffer.putShort(identification.toShort())\n\n //组合标志和部分片段偏移\n buffer.put((fragmentOffset.toInt() shr 8 and 0x1F or flag.toInt()).toByte())\n buffer.put(fragmentOffset.toByte())\n\n buffer.put(timeToLive)\n buffer.put(protocol)\n buffer.putShort(headerChecksum.toShort())\n buffer.putInt(sourceIP)\n buffer.putInt(destinationIP)\n return buffer.array()\n }\n}\n\nobject IPPacketFactory {\n private const val IP4_HEADER_SIZE = 20\n private const val IP4_VERSION = 0x04\n\n /**\n * 从给定的ByteBuffer流创建IPv4标头\n */\n fun createIP4Header(buffer: ByteBuffer): IP4Header? {\n if (buffer.remaining() < IP4_HEADER_SIZE) {\n throw IllegalArgumentException(\"IP header byte array must have at least $IP4_HEADER_SIZE bytes\")\n }\n\n val versionAndHeaderLength: Byte = buffer.get()\n val ipVersion = (versionAndHeaderLength.toInt() shr 4).toByte()\n if (ipVersion.toInt() != IP4_VERSION) {\n Log.e(\"IPPacketFactory\", \"Invalid IP version $ipVersion\")\n return null\n }\n\n val internetHeaderLength = (versionAndHeaderLength.toInt() and 0x0F).toByte()\n\n val typeOfService = buffer.get().toInt()\n val diffTypeOfService: Byte = (typeOfService shr 2).toByte();\n val ecn: Byte = (typeOfService and 0x03).toByte()\n\n val totalLength: Int = buffer.getShort().toInt()\n val identification: Int = buffer.getShort().toInt()\n\n val flagsAndFragmentOffset: Short = buffer.getShort()\n val mayFragment = flagsAndFragmentOffset.toInt() and 0x4000 != 0\n val lastFragment = flagsAndFragmentOffset.toInt() and 0x2000 != 0\n val fragmentOffset = (flagsAndFragmentOffset.toInt() and 0x1FFF).toShort()\n\n val timeToLive: Byte = buffer.get()\n val protocol: Byte = buffer.get()\n val checksum: Int = buffer.getShort().toInt()\n val sourceIp: Int = buffer.getInt()\n val desIp: Int = buffer.getInt()\n\n if (internetHeaderLength > 5) {\n // drop the IP option\n for (i in 0 until (internetHeaderLength - 5)) {\n buffer.getInt()\n }\n }\n\n return IP4Header(\n ipVersion, internetHeaderLength, diffTypeOfService, ecn, totalLength, identification,\n mayFragment, lastFragment, fragmentOffset, timeToLive, protocol, checksum,\n sourceIp, desIp\n )\n }\n}"
},
{
"path": "android/app/src/main/kotlin/com/network/proxy/vpn/transport/protocol/TCPHeader.kt",
"content": "package com.network.proxy.vpn.transport.protocol\n\nimport java.nio.ByteBuffer\nimport java.nio.ByteOrder\n\n/**\n * TCP报头的数据结构。\n */\nclass TCPHeader(\n private var sourcePort: Int = 0, //源端口号 16bit\n private var destinationPort: Int = 0, //目的端口号 16bit\n var sequenceNumber: Long = 0, //序列号 32bit\n var ackNumber: Long = 0, //确认号 32bit\n var dataOffset: Int = 0, //数据偏移4bit\n var isNS: Boolean = false, //ECN-nonce concealment protection (experimental: see RFC 3540)\n var flags: Int = 0, //标志位 9bit\n var windowSize: Int = 0, //窗口大小 16bit\n var checksum: Int = 0, //校验和 16bit\n private var urgentPointer: Int = 0, //紧急指针 16bit\n var options: ByteArray? = null //选项\n) : TransportHeader {\n\n //options\n var maxSegmentSize: Short = 0\n private var windowScale: Byte = 0\n private var isSelectiveAckPermitted = false\n var timeStampSender = 0\n var timeStampReplyTo = 0\n\n companion object {\n private const val END_OF_OPTIONS_LIST: Byte = 0\n private const val NO_OPERATION: Byte = 1\n private const val MAX_SEGMENT_SIZE: Byte = 2\n private const val WINDOW_SCALE: Byte = 3\n private const val SELECTIVE_ACK_PERMITTED: Byte = 4\n private const val TIME_STAMP: Byte = 8\n }\n\n fun isSYN(): Boolean {\n return flags and 0x02 != 0\n }\n\n fun isFIN(): Boolean {\n return flags and 0x01 != 0\n }\n\n fun isRST(): Boolean {\n return flags and 0x04 != 0\n }\n\n fun isPSH(): Boolean {\n return flags and 0x08 != 0\n }\n\n fun isACK(): Boolean {\n return flags and 0x10 != 0\n }\n\n fun isURG(): Boolean {\n return flags and 0x20 != 0\n }\n\n fun isECE(): Boolean {\n return flags and 0x40 != 0\n }\n\n fun isCWR(): Boolean {\n return flags and 0x80 != 0\n }\n\n fun setIsRST(isRST: Boolean) {\n flags = if (isRST) {\n (flags or 0x04)\n } else {\n (flags and 0xFB)\n }\n }\n\n fun setIsSYN(isSYN: Boolean) {\n flags = if (isSYN) {\n (flags or 0x02)\n } else {\n (flags and 0xFD)\n }\n }\n\n fun setIsFIN(isFIN: Boolean) {\n flags = if (isFIN) {\n (flags or 0x01)\n } else {\n (flags and 0xFE)\n }\n }\n\n fun setIsPSH(isPSH: Boolean) {\n flags = if (isPSH) {\n (flags or 0x08)\n } else {\n (flags and 0xF7)\n }\n }\n\n fun setIsACK(isACK: Boolean) {\n flags = if (isACK) {\n (flags or 0x10)\n } else {\n (flags and 0xEF)\n }\n }\n\n fun getTCPHeaderLength(): Int {\n return dataOffset * 4\n }\n\n fun toBytes(): ByteArray {\n val tcpHeaderLength = getTCPHeaderLength()\n val tcpHeader = ByteArray(tcpHeaderLength)\n val byteBuffer = ByteBuffer.wrap(tcpHeader)\n byteBuffer.order(ByteOrder.BIG_ENDIAN)\n\n byteBuffer.putShort(sourcePort.toShort())\n byteBuffer.putShort(destinationPort.toShort())\n\n byteBuffer.putInt(sequenceNumber.toInt())\n byteBuffer.putInt(ackNumber.toInt())\n\n //is ns and data offset\n byteBuffer.put(((dataOffset shl 4) and 0xF0 or (if (isNS) 0x1 else 0x0)).toByte())\n byteBuffer.put(flags.toByte())\n byteBuffer.putShort(windowSize.toShort())\n byteBuffer.putShort(checksum.toShort())\n byteBuffer.putShort(urgentPointer.toShort())\n// encodeTcpOptions()?.let {\n// byteBuffer.put(it)\n// }\n\n return tcpHeader\n }\n\n fun copy(): TCPHeader {\n return TCPHeader(\n sourcePort, destinationPort, sequenceNumber, ackNumber,\n dataOffset, isNS, flags, windowSize, checksum, urgentPointer,\n options\n )\n }\n\n private fun handleTcpOptions() {\n if (options == null) {\n return\n }\n\n var index = 0\n val packet = ByteBuffer.wrap(options!!)\n val optionsSize = options!!.size\n\n while (index < optionsSize) {\n val optionKind = packet.get()\n index++\n if (optionKind == END_OF_OPTIONS_LIST || optionKind == NO_OPERATION) {\n continue\n }\n val size = packet.get()\n index++\n when (optionKind) {\n MAX_SEGMENT_SIZE -> {\n maxSegmentSize = packet.getShort()\n index += 2\n }\n\n WINDOW_SCALE -> {\n windowScale = packet.get()\n index++\n }\n\n SELECTIVE_ACK_PERMITTED -> isSelectiveAckPermitted = true\n TIME_STAMP -> {\n timeStampSender = packet.getInt()\n timeStampReplyTo = packet.getInt()\n index += 8\n }\n\n else -> {\n skipRemainingOptions(packet, size.toInt())\n index = index + size - 2\n }\n }\n }\n }\n\n private fun skipRemainingOptions(packet: ByteBuffer, size: Int) {\n for (i in 2 until size) {\n packet.get()\n }\n }\n\n override fun getSourcePort(): Int {\n return sourcePort\n }\n\n override fun getDestinationPort(): Int {\n return destinationPort\n }\n\n fun setSourcePort(sourcePort: Int) {\n this.sourcePort = sourcePort\n }\n\n fun setDestinationPort(destinationPort: Int) {\n this.destinationPort = destinationPort\n }\n}"
},
{
"path": "android/app/src/main/kotlin/com/network/proxy/vpn/transport/protocol/TCPPacketFactory.kt",
"content": "package com.network.proxy.vpn.transport.protocol\n\nimport com.network.proxy.vpn.transport.Packet\nimport com.network.proxy.vpn.util.PacketUtil\nimport java.nio.ByteBuffer\nimport java.util.concurrent.ThreadLocalRandom\n\nobject TCPPacketFactory {\n\n private const val TCP_HEADER_LENGTH = 20\n\n /**\n * 从tcp报文创建tcpHeader\n */\n @JvmStatic\n fun createTCPHeader(byteBuffer: ByteBuffer): TCPHeader {\n if (byteBuffer.remaining() < TCP_HEADER_LENGTH) {\n throw IllegalArgumentException(\"Invalid TCP Header Length\")\n }\n\n val sourcePort: Int = byteBuffer.getShort().toInt() and 0xFFFF\n val destinationPort: Int = byteBuffer.getShort().toInt() and 0xFFFF\n val sequenceNumber: Long = byteBuffer.getInt().toLong()\n val ackNumber: Long = byteBuffer.getInt().toLong()\n\n val dataOffsetAndReserved = byteBuffer.get()\n val dataOffset = (dataOffsetAndReserved.toInt() and 0xF0) shr 4\n val isNs: Boolean = dataOffsetAndReserved.toInt() and 0x1 > 0x0\n\n val flags = byteBuffer.get().toInt()\n\n val window = byteBuffer.short.toInt()\n val checksum = byteBuffer.short.toInt()\n val urgentPointer = byteBuffer.short.toInt()\n\n var optionsAndPadding: ByteArray? = null\n val optionsSize = dataOffset - 5\n if (optionsSize > 0) {\n optionsAndPadding = ByteArray(optionsSize * 4)\n byteBuffer.get(optionsAndPadding, 0, optionsSize * 4)\n }\n return TCPHeader(\n sourcePort, destinationPort, sequenceNumber, ackNumber,\n dataOffset, isNs, flags, window, checksum, urgentPointer, optionsAndPadding\n )\n }\n\n /**\n * 创建带有RST标志的数据包，以便在需要重置时发送到客户端。\n */\n fun createRstData(ipHeader: IP4Header, tcpHeader: TCPHeader, dataLength: Int): ByteArray {\n val ip = ipHeader.copy()\n val tcp = tcpHeader.copy()\n\n var ackNumber: Long = 0\n var seqNumber: Long = 0\n\n if (tcp.ackNumber > 0) {\n seqNumber = tcp.ackNumber\n } else {\n ackNumber = tcp.sequenceNumber + dataLength\n }\n\n tcp.ackNumber = ackNumber\n tcp.sequenceNumber = seqNumber\n\n //将IP从源翻转到目标\n flipIp(ip, tcp)\n\n ip.identification = 0\n\n tcp.flags = 0\n tcp.isNS = false\n tcp.setIsRST(true)\n\n tcp.dataOffset = 5\n tcp.options = null\n tcp.windowSize = 0\n\n //重新计算IP长度\n val totalLength = ip.getIPHeaderLength() + tcp.getTCPHeaderLength()\n\n ip.totalLength = totalLength\n\n return createPacketData(ip, tcp, null)\n }\n\n /**\n * 创建数据包数据以发送回客户端\n */\n @JvmStatic\n fun createResponsePacketData(\n ipHeader: IP4Header, tcpHeader: TCPHeader, packetData: ByteArray?, isPsh: Boolean,\n ackNumber: Long, seqNumber: Long, timeSender: Int, timeReplyTo: Int\n ): ByteArray {\n val ip = ipHeader.copy()\n val tcp = tcpHeader.copy()\n\n flipIp(ip, tcp)\n tcp.ackNumber = ackNumber\n tcp.sequenceNumber = seqNumber\n ip.identification = PacketUtil.getPacketId()\n\n //总是发送ACK\n\n //ACK is always sent\n tcp.setIsACK(true)\n tcp.setIsSYN(false)\n tcp.setIsPSH(isPsh)\n tcp.setIsFIN(false)\n tcp.timeStampSender = timeSender\n tcp.timeStampReplyTo = timeReplyTo\n tcp.dataOffset = 5\n tcp.options = null\n\n var totalLength = ip.getIPHeaderLength() + tcp.getTCPHeaderLength()\n if (packetData != null) {\n totalLength += packetData.size\n }\n ip.totalLength = totalLength\n\n return createPacketData(ip, tcp, packetData)\n }\n\n\n /**\n * 向客户端确认服务器已收到请求。\n */\n @JvmStatic\n fun createResponseAckData(\n ipHeader: IP4Header, tcpHeader: TCPHeader, ackToClient: Long\n ): ByteArray {\n val ip = ipHeader.copy()\n val tcp = tcpHeader.copy()\n\n flipIp(ip, tcp)\n val seqNumber = tcp.ackNumber\n tcp.ackNumber = ackToClient\n tcp.sequenceNumber = seqNumber\n\n ip.identification = PacketUtil.getPacketId()\n\n //ACK\n tcp.setIsACK(true)\n tcp.setIsSYN(false)\n tcp.setIsPSH(false)\n tcp.setIsFIN(false)\n tcp.dataOffset = 5\n tcp.options = null\n\n ip.totalLength = ip.getIPHeaderLength() + tcp.getTCPHeaderLength()\n return createPacketData(ip, tcp, null)\n }\n\n //将IP从源翻转到目标\n private fun flipIp(ip: IP4Header, tcp: TCPHeader) {\n val sourceIp = ip.destinationIP\n val destIp = ip.sourceIP\n val sourcePort = tcp.getDestinationPort()\n val destPort = tcp.getSourcePort()\n\n ip.destinationIP = destIp\n ip.sourceIP = sourceIp\n tcp.setDestinationPort(destPort)\n tcp.setSourcePort(sourcePort)\n }\n\n /**\n * 通过写回客户端流创建SYN-ACK数据包数据\n */\n fun createSynAckPacketData(ipHeader: IP4Header, tcpHeader: TCPHeader): Packet {\n val ip = ipHeader.copy()\n val tcp = tcpHeader.copy()\n\n flipIp(ip, tcp)\n\n //ack = received sequence + 1\n val ackNumber = tcpHeader.sequenceNumber + 1\n tcp.ackNumber = ackNumber\n\n //服务器生成的初始序列号\n val seqNumber = ThreadLocalRandom.current().nextLong(0, 100000)\n tcp.sequenceNumber = seqNumber\n\n //SYN-ACK\n tcp.setIsACK(true)\n tcp.setIsSYN(true)\n\n tcp.timeStampReplyTo = tcp.timeStampSender\n tcp.timeStampSender = PacketUtil.currentTime\n\n tcp.dataOffset = 5\n tcp.options = null\n ip.totalLength = ip.getIPHeaderLength() + tcp.getTCPHeaderLength()\n\n return Packet(ip, tcp, createPacketData(ip, tcp, null))\n }\n\n /**\n * 创建发送到客户端的FIN-ACK\n */\n fun createFinAckData(\n ipHeader: IP4Header, tcpHeader: TCPHeader, ackToClient: Long,\n seqToClient: Long, isFin: Boolean, isAck: Boolean\n ): ByteArray {\n val ip = ipHeader.copy()\n val tcp = tcpHeader.copy()\n\n flipIp(ip, tcp)\n\n tcp.ackNumber = ackToClient\n tcp.sequenceNumber = seqToClient\n ip.identification = PacketUtil.getPacketId()\n\n //ACK\n tcp.setIsACK(isAck)\n tcp.setIsSYN(false)\n tcp.setIsPSH(false)\n tcp.setIsFIN(isFin)\n\n tcp.dataOffset = 5\n tcp.options = null\n\n ip.totalLength = ip.getIPHeaderLength() + tcp.getTCPHeaderLength()\n return createPacketData(ip, tcp, null)\n }\n\n fun createFinData(\n ip: IP4Header, tcp: TCPHeader, ackNumber: Long, seqNumber: Long,\n timeSender: Int, timeReplyTo: Int\n ): ByteArray {\n //将IP从源翻转到目标\n flipIp(ip, tcp)\n\n tcp.ackNumber = ackNumber\n tcp.sequenceNumber = seqNumber\n\n ip.identification = PacketUtil.getPacketId()\n\n tcp.timeStampReplyTo = timeReplyTo\n tcp.timeStampSender = timeSender\n\n tcp.flags = 0\n tcp.isNS = false\n tcp.setIsACK(true)\n tcp.setIsFIN(true)\n\n tcp.dataOffset = 5\n tcp.options = null\n //窗口大小应为零\n tcp.windowSize = 0\n\n ip.totalLength = ip.getIPHeaderLength() + tcp.getTCPHeaderLength()\n return createPacketData(ip, tcp, null)\n }\n\n /**\n * 从tcpHeader创建tcp报文\n */\n private fun createPacketData(ipHeader: IP4Header, tcpHeader: TCPHeader, data: ByteArray?):\n ByteArray {\n val dataLength = data?.size ?: 0\n\n val buffer =\n ByteBuffer.allocate(ipHeader.getIPHeaderLength() + tcpHeader.getTCPHeaderLength() + dataLength)\n val ipBuffer = ipHeader.toBytes()\n val tcpBuffer = tcpHeader.toBytes()\n\n buffer.put(ipBuffer)\n buffer.put(tcpBuffer)\n\n data?.let { buffer.put(it) }\n\n val zero = byteArrayOf(0, 0)\n //计算前先将校验和清零\n buffer.position(10)\n buffer.put(zero)\n\n val ipChecksum = PacketUtil.calculateChecksum(buffer.array(), 0, ipBuffer.size)\n buffer.position(10)\n buffer.put(ipChecksum)\n\n val tcpStart = ipBuffer.size\n buffer.position(tcpStart + 16)\n buffer.put(zero)\n\n val tcpChecksum = PacketUtil.calculateTCPHeaderChecksum(\n buffer.array(), tcpStart, tcpBuffer.size + dataLength,\n ipHeader.destinationIP, ipHeader.sourceIP\n )\n\n //将新的校验和写回阵列\n buffer.position(tcpStart + 16)\n buffer.put(tcpChecksum)\n return buffer.array()\n }\n\n}\n"
},
{
"path": "android/app/src/main/kotlin/com/network/proxy/vpn/transport/protocol/TransportHeader.kt",
"content": "package com.network.proxy.vpn.transport.protocol\n\ninterface TransportHeader {\n fun getSourcePort(): Int\n fun getDestinationPort(): Int\n}"
},
{
"path": "android/app/src/main/kotlin/com/network/proxy/vpn/transport/protocol/UDPHeader.kt",
"content": "package com.network.proxy.vpn.transport.protocol\n\n\nimport com.network.proxy.vpn.util.PacketUtil\nimport java.nio.ByteBuffer\n\n\n/**\n * UDP报头的数据结构。\n */\ndata class UDPHeader(\n var sourcePort: Int = 0, //源端口号 16bit\n var destinationPort: Int = 0, //目的端口号 16bit\n var length: Int = 0, //UDP数据报长度 16bit\n var checksum: Int = 0 //校验和 16bit\n)\n\n\nobject UDPPacketFactory {\n @JvmStatic\n fun createUDPHeader(stream: ByteBuffer): UDPHeader {\n require(stream.remaining() >= 8) { \"Minimum UDP header is 8 bytes.\" }\n val srcPort = stream.getShort().toInt() and 0xffff\n val destPort = stream.getShort().toInt() and 0xffff\n val length = stream.getShort().toInt() and 0xffff\n val checksum = stream.getShort().toInt()\n return UDPHeader(srcPort, destPort, length, checksum)\n }\n\n /**\n * 创建用于响应vpn客户端的数据包\n */\n @JvmStatic\n fun createResponsePacket(ip: IP4Header, udp: UDPHeader, packetData: ByteArray?): ByteArray {\n val buffer: ByteArray\n var udpLen = 8\n if (packetData != null) {\n udpLen += packetData.size\n }\n val srcPort = udp.destinationPort\n val destPort = udp.sourcePort\n val ipHeader = ip.copy()\n val srcIp = ip.destinationIP\n val destIp = ip.sourceIP\n ipHeader.setMayFragment(false)\n ipHeader.sourceIP = srcIp\n ipHeader.destinationIP = destIp\n ipHeader.identification = PacketUtil.getPacketId()\n\n //ip的长度是整个数据包的长度 => IP header length + UDP header length (8) + UDP body length\n val totalLength = ipHeader.getIPHeaderLength() + udpLen\n ipHeader.totalLength = totalLength\n buffer = ByteArray(totalLength)\n val ipData = ipHeader.toBytes()\n\n // clear IP checksum\n ipData[11] = 0\n ipData[10] = 0\n\n //calculate checksum for IP header\n val ipChecksum = PacketUtil.calculateChecksum(ipData, 0, ipData.size)\n //write result of checksum back to buffer\n System.arraycopy(ipChecksum, 0, ipData, 10, 2)\n System.arraycopy(ipData, 0, buffer, 0, ipData.size)\n\n //copy UDP header to buffer\n var start = ipData.size\n val intContainer = ByteArray(4)\n PacketUtil.writeIntToBytes(srcPort, intContainer, 0)\n\n //extract the last two bytes of int value\n System.arraycopy(intContainer, 2, buffer, start, 2)\n start += 2\n\n PacketUtil.writeIntToBytes(destPort, intContainer, 0)\n System.arraycopy(intContainer, 2, buffer, start, 2)\n start += 2\n PacketUtil.writeIntToBytes(udpLen, intContainer, 0)\n System.arraycopy(intContainer, 2, buffer, start, 2)\n start += 2\n\n val checksum: Short = 0\n PacketUtil.writeIntToBytes(checksum.toInt(), intContainer, 0)\n System.arraycopy(intContainer, 2, buffer, start, 2)\n start += 2\n\n //now copy udp data\n if (packetData != null) System.arraycopy(packetData, 0, buffer, start, packetData.size)\n return buffer\n }\n}\n\n"
},
{
"path": "android/app/src/main/kotlin/com/network/proxy/vpn/util/PacketUtil.kt",
"content": "package com.network.proxy.vpn.util\n\nimport android.util.Log\nimport com.network.proxy.vpn.formatTag\nimport com.network.proxy.vpn.transport.protocol.IP4Header\nimport com.network.proxy.vpn.transport.protocol.TCPHeader\nimport java.nio.ByteBuffer\nimport java.nio.ByteOrder\n\n/**\n * Helper class to perform various useful task\n */\nobject PacketUtil {\n @get:Synchronized\n private var packetId = 0\n fun getPacketId() = packetId++\n\n val currentTime: Int\n get() = (System.currentTimeMillis() / 1000).toInt()\n\n /**\n * convert int to byte array\n * [...](https://docs.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html)\n *\n * @param value int value 32 bits\n * @param buffer array of byte to write to\n * @param offset position to write to\n */\n fun writeIntToBytes(value: Int, buffer: ByteArray, offset: Int) {\n if (buffer.size - offset < 4) {\n return\n }\n buffer[offset] = (value ushr 24 and 0x000000FF).toByte()\n buffer[offset + 1] = (value shr 16 and 0x000000FF).toByte()\n buffer[offset + 2] = (value shr 8 and 0x000000FF).toByte()\n buffer[offset + 3] = (value and 0x000000FF).toByte()\n }\n\n /**\n * convert array of max 4 bytes to int\n *\n * @param buffer byte array\n * @param start Starting point to be read in byte array\n * @param length Length to be read\n * @return value of int\n */\n fun getNetworkInt(buffer: ByteArray, start: Int, length: Int): Int {\n var value = 0\n var end = start + Math.min(length, 4)\n if (end > buffer.size) end = buffer.size\n for (i in start until end) {\n value = value or (buffer[i].toInt() and 0xFF)\n if (i < end - 1) value = value shl 8\n }\n return value\n }\n\n /**\n * validate TCP header checksum\n *\n * @param source Source Port\n * @param destination Destination Port\n * @param data Payload\n * @param tcpLength TCP Header length\n * @return boolean\n */\n fun isValidTCPChecksum(\n source: Int, destination: Int,\n data: ByteArray, tcpLength: Short, tcpOffset: Int\n ): Boolean {\n var buffersize = tcpLength + 12\n var isodd = false\n if (buffersize % 2 != 0) {\n buffersize++\n isodd = true\n }\n val buffer = ByteBuffer.allocate(buffersize)\n buffer.putInt(source)\n buffer.putInt(destination)\n buffer.put(0.toByte()) //reserved => 0\n buffer.put(6.toByte()) //TCP protocol => 6\n buffer.putShort(tcpLength)\n buffer.put(data, tcpOffset, tcpLength.toInt())\n if (isodd) {\n buffer.put(0.toByte())\n }\n return isValidIPChecksum(buffer.array(), buffersize)\n }\n\n /**\n * validate IP Header checksum\n *\n * @param data byte stream\n * @return boolean\n */\n private fun isValidIPChecksum(data: ByteArray, length: Int): Boolean {\n var start = 0\n var sum = 0\n while (start < length) {\n sum += getNetworkInt(data, start, 2)\n start = start + 2\n }\n\n //carry over one's complement\n while (sum shr 16 > 0) sum = (sum and 0xffff) + (sum shr 16)\n\n //flip the bit to get one' complement\n sum = sum.inv()\n val buffer = ByteBuffer.allocate(4)\n buffer.putInt(sum)\n return buffer.getShort(2).toInt() == 0\n }\n\n fun calculateChecksum(data: ByteArray, offset: Int, length: Int): ByteArray {\n var start = offset\n var sum = 0\n while (start < length) {\n sum += getNetworkInt(data, start, 2)\n start = start + 2\n }\n //carry over one's complement\n while (sum shr 16 > 0) {\n sum = (sum and 0xffff) + (sum shr 16)\n }\n //flip the bit to get one' complement\n sum = sum.inv()\n\n //extract the last two byte of int\n val checksum = ByteArray(2)\n checksum[0] = (sum shr 8).toByte()\n checksum[1] = sum.toByte()\n return checksum\n }\n\n fun calculateTCPHeaderChecksum(\n data: ByteArray,\n offset: Int,\n tcplength: Int,\n destip: Int,\n sourceip: Int\n ): ByteArray {\n var buffersize = tcplength + 12\n var odd = false\n if (buffersize % 2 != 0) {\n buffersize++\n odd = true\n }\n val buffer = ByteBuffer.allocate(buffersize)\n buffer.order(ByteOrder.BIG_ENDIAN)\n\n //create virtual header\n buffer.putInt(sourceip)\n buffer.putInt(destip)\n buffer.put(0.toByte()) //reserved => 0\n buffer.put(6.toByte()) //tcp protocol => 6\n buffer.putShort(tcplength.toShort())\n\n //add actual header + data\n buffer.put(data, offset, tcplength)\n\n //padding last byte to zero\n if (odd) {\n buffer.put(0.toByte())\n }\n val tcparray = buffer.array()\n return calculateChecksum(tcparray, 0, buffersize)\n }\n\n fun intToIPAddress(addressInt: Int): String {\n return (addressInt ushr 24 and 0x000000FF).toString() + \".\" +\n (addressInt ushr 16 and 0x000000FF) + \".\" +\n (addressInt ushr 8 and 0x000000FF) + \".\" +\n (addressInt and 0x000000FF)\n }\n\n fun getOutput(\n ipHeader: IP4Header, tcpheader: TCPHeader,\n packetData: ByteArray\n ): String {\n val tcpLength = (packetData.size -\n ipHeader.getIPHeaderLength()).toShort()\n val isValidChecksum = isValidTCPChecksum(\n ipHeader.sourceIP, ipHeader.destinationIP,\n packetData, tcpLength, ipHeader.getIPHeaderLength()\n )\n val isValidIPChecksum = isValidIPChecksum(\n packetData,\n ipHeader.getIPHeaderLength()\n )\n val packetBodyLength = (packetData.size - ipHeader.getIPHeaderLength()\n - tcpheader.getTCPHeaderLength())\n val str = StringBuilder(\"\\r\\nIP Version: \")\n .append(ipHeader.ipVersion.toInt())\n .append(\"\\r\\nProtocol: \").append(ipHeader.protocol.toInt())\n .append(\"\\r\\nID# \").append(ipHeader.identification)\n .append(\"\\r\\nTotal Length: \").append(ipHeader.totalLength)\n .append(\"\\r\\nData Length: \").append(packetBodyLength)\n .append(\"\\r\\nDest: \").append(intToIPAddress(ipHeader.destinationIP))\n .append(\":\").append(tcpheader.getDestinationPort())\n .append(\"\\r\\nSrc: \").append(intToIPAddress(ipHeader.sourceIP))\n .append(\":\").append(tcpheader.getSourcePort())\n .append(\"\\r\\nACK: \").append(tcpheader.ackNumber)\n .append(\"\\r\\nSeq: \").append(tcpheader.sequenceNumber)\n .append(\"\\r\\nIP Header length: \").append(ipHeader.getIPHeaderLength())\n .append(\"\\r\\nTCP Header length: \").append(tcpheader.getTCPHeaderLength())\n .append(\"\\r\\nACK: \").append(tcpheader.isACK())\n .append(\"\\r\\nSYN: \").append(tcpheader.isSYN())\n .append(\"\\r\\nCWR: \").append(tcpheader.isCWR())\n .append(\"\\r\\nECE: \").append(tcpheader.isECE())\n .append(\"\\r\\nFIN: \").append(tcpheader.isFIN())\n .append(\"\\r\\nNS: \").append(tcpheader.isNS)\n .append(\"\\r\\nPSH: \").append(tcpheader.isPSH())\n .append(\"\\r\\nRST: \").append(tcpheader.isRST())\n .append(\"\\r\\nURG: \").append(tcpheader.isURG())\n .append(\"\\r\\nIP checksum: \").append(ipHeader.headerChecksum)\n .append(\"\\r\\nIs Valid IP Checksum: \").append(isValidIPChecksum)\n .append(\"\\r\\nTCP Checksum: \").append(tcpheader.checksum)\n .append(\"\\r\\nIs Valid TCP checksum: \").append(isValidChecksum)\n .append(\"\\r\\nFragment Offset: \").append(ipHeader.fragmentOffset.toInt())\n .append(\"\\r\\nWindow: \").append(tcpheader.windowSize)\n .append(\"\\r\\nData Offset: \").append(tcpheader.dataOffset)\n return str.toString()\n }\n\n /**\n * detect packet corruption flag in tcp options sent from client ACK\n *\n * @param tcpHeader TCPHeader\n * @return boolean\n */\n fun isPacketCorrupted(tcpHeader: TCPHeader): Boolean {\n val options = tcpHeader.options\n if (options != null) {\n var i = 0\n while (i < options.size) {\n val kind = options[i]\n if (kind.toInt() == 0 || kind.toInt() == 1) {\n } else if (kind.toInt() == 2) {\n i += 3\n } else if (kind.toInt() == 3 || kind.toInt() == 14) {\n i += 2\n } else if (kind.toInt() == 4) {\n i++\n } else if (kind.toInt() == 5 || kind.toInt() == 15) {\n i = i + options[++i] - 2\n } else if (kind.toInt() == 8) {\n i += 9\n } else if (kind.toInt() == 23) {\n return true\n } else {\n Log.e(\n formatTag(PacketUtil::class.java.name),\n \"unknown option: $kind\"\n )\n }\n i++\n }\n }\n return false\n }\n}\n\n"
},
{
"path": "android/app/src/main/kotlin/com/network/proxy/vpn/util/ProcessInfoManager.kt",
"content": "package com.network.proxy.vpn.util\n\nimport android.content.Context\nimport android.net.ConnectivityManager\nimport android.os.Build\nimport android.os.Process\nimport android.system.OsConstants\nimport android.util.Log\nimport androidx.annotation.RequiresApi\nimport com.network.proxy.ProxyVpnService\nimport com.network.proxy.plugin.ProcessInfo\nimport com.network.proxy.vpn.Connection\nimport kotlinx.coroutines.CoroutineScope\nimport java.io.File\nimport java.net.InetSocketAddress\nimport java.nio.channels.SocketChannel\nimport java.util.concurrent.TimeUnit\nimport kotlinx.coroutines.Dispatchers\nimport kotlinx.coroutines.launch\nimport kotlinx.coroutines.withContext\n\n/**\n * 进程信息管理器，用于获取进程信息\n * @author wanghongen\n */\nclass ProcessInfoManager private constructor() {\n companion object {\n @Suppress(\"all\")\n val instance = ProcessInfoManager()\n }\n\n class NetworkInfo(val uid: Int, val remoteHost: String, val remotePort: Int)\n\n private val localPortCache =\n SimpleCache(10_000, 60, TimeUnit.SECONDS)\n\n\n private val appInfoCache = SimpleCache(10_000, 300, TimeUnit.SECONDS)\n\n\n var activity: Context? = null\n\n @RequiresApi(Build.VERSION_CODES.N)\n fun setConnectionOwnerUid(connection: Connection) {\n CoroutineScope(Dispatchers.IO).launch {\n\n val sourceAddress =\n InetSocketAddress(PacketUtil.intToIPAddress(connection.sourceIp), connection.sourcePort)\n val destinationAddress = InetSocketAddress(\n PacketUtil.intToIPAddress(connection.destinationIp), connection.destinationPort\n )\n\n val uid = getProcessInfoUid(sourceAddress, destinationAddress)\n val channel = connection.channel\n if (uid != null && uid != Process.INVALID_UID && channel is SocketChannel && channel.isOpen) {\n try {\n val localAddress = channel.localAddress as InetSocketAddress\n val networkInfo =\n NetworkInfo(uid, destinationAddress.hostString, destinationAddress.port)\n localPortCache.put(localAddress.port, networkInfo)\n } catch (e: java.nio.channels.ClosedChannelException) {\n Log.w(\"ProcessInfoManager\", \"setConnectionOwnerUid\", e)\n }\n }\n }\n }\n\n fun removeConnection(connection: Connection) {\n if (Build.VERSION.SDK_INT < Build.VERSION_CODES.Q) {\n return\n }\n\n val channel = connection.channel\n if (channel is SocketChannel && channel.isOpen) {\n try {\n val localAddress = channel.localAddress as InetSocketAddress\n localPortCache.remove(localAddress.port)\n } catch (e: java.nio.channels.ClosedChannelException) {\n Log.w(\"ProcessInfoManager\", \"removeConnection\", e)\n }\n }\n }\n\n @RequiresApi(Build.VERSION_CODES.N)\n private fun getProcessInfoUid(\n localAddress: InetSocketAddress, remoteAddress: InetSocketAddress\n ): Int? {\n// Log.d(TAG, \"getProcessInfo: $localAddress $remoteAddress\")\n\n if (activity == null) {\n return null\n }\n\n try {\n val connectivityManager: ConnectivityManager =\n activity!!.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager\n\n val uid = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {\n connectivityManager.getConnectionOwnerUid(\n OsConstants.IPPROTO_TCP, localAddress, remoteAddress\n )\n } else {\n val method = ConnectivityManager::class.java.getMethod(\n \"getConnectionOwnerUid\",\n Int::class.javaPrimitiveType,\n InetSocketAddress::class.java,\n InetSocketAddress::class.java\n )\n method.invoke(\n connectivityManager, OsConstants.IPPROTO_TCP, localAddress, remoteAddress\n ) as Int\n }\n\n if (uid != Process.INVALID_UID) {\n return uid\n }\n } catch (e: Exception) {\n Log.w(\"ProcessInfoManager\", \"Exception in getProcessInfoUid\", e)\n return null\n }\n\n Log.w(\n \"ProcessInfoManager\",\n \"Failed to get UID for local address $localAddress and remote address $remoteAddress\"\n )\n return null\n }\n\n suspend fun getProcessInfoByPort(host: String?, localPort: Int): ProcessInfo? {\n val networkInfo = localPortCache.get(localPort)\n if (networkInfo != null) {\n val processInfo = getProcessInfo(networkInfo.uid)\n if (processInfo != null) {\n val result = processInfo.copy()\n result[\"remoteHost\"] = networkInfo.remoteHost\n result[\"remotePort\"] = networkInfo.remotePort\n return result\n }\n return null\n }\n\n if (host == null || localPort <= 0 || ProxyVpnService.host == null || ProxyVpnService.port <= 0) {\n Log.w(\"ProcessInfoManager\", \"Invalid host or local port: $host:$localPort or ProxyVpnService not initialized\")\n return null\n }\n\n if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {\n return withContext(Dispatchers.IO) {\n val localAddress = InetSocketAddress(host, localPort)\n val remoteAddress = InetSocketAddress(ProxyVpnService.host, ProxyVpnService.port)\n\n val uid = getProcessInfoUid(localAddress, remoteAddress)\n\n if (uid == null || uid == Process.INVALID_UID) {\n return@withContext null\n }\n\n\n val processInfo = getProcessInfo(uid)\n if (processInfo != null) {\n localPortCache.put(\n localPort, NetworkInfo(uid, remoteAddress.hostString, remoteAddress.port)\n )\n\n val result = processInfo.copy()\n result[\"remoteHost\"] = remoteAddress.hostString\n result[\"remotePort\"] = remoteAddress.port\n return@withContext result\n } else {\n Log.w(\"ProcessInfoManager\", \"No process info found for UID: $uid\")\n null\n }\n }\n } else {\n Log.w(\"ProcessInfoManager\", \"Access to /proc/net/tcp is restricted on non-rooted devices.\")\n }\n return null\n }\n\n fun getRemoteAddressByPort(localPort: Int): Map? {\n val networkInfo = localPortCache.get(localPort)\n if (networkInfo != null) {\n return mapOf(\n \"remoteHost\" to networkInfo.remoteHost,\n \"remotePort\" to networkInfo.remotePort\n )\n }\n return null\n }\n\n private fun getProcessInfo(uid: Int): ProcessInfo? {\n var appInfo = appInfoCache.get(uid)\n if (appInfo != null) return appInfo\n\n val packageManager = activity?.packageManager ?: return null\n val pkgNames: Array? = try {\n packageManager.getPackagesForUid(uid)\n } catch (e: Exception) {\n Log.w(\"ProcessInfoManager\", \"getPackagesForUid SecurityException: $uid\", e)\n null\n }\n if (pkgNames == null) return null\n\n for (pkgName in pkgNames) {\n try {\n val applicationInfo = packageManager.getApplicationInfo(pkgName, 0)\n appInfo = ProcessInfo.create(packageManager, applicationInfo)\n appInfoCache.put(uid, appInfo)\n return appInfo\n } catch (e: Exception) {\n // Ignore packages that can't be found\n }\n }\n return null\n }\n\n}\n"
},
{
"path": "android/app/src/main/kotlin/com/network/proxy/vpn/util/SimpleCache.kt",
"content": "package com.network.proxy.vpn.util\n\nimport java.util.concurrent.ConcurrentHashMap\nimport java.util.concurrent.Executors\nimport java.util.concurrent.TimeUnit\n\nclass SimpleCache(\n private val maxSize: Int,\n private val expireAfterAccess: Long,\n private val timeUnit: TimeUnit\n) {\n private val cache = ConcurrentHashMap>()\n\n companion object {\n private val EXECUTOR = Executors.newSingleThreadScheduledExecutor()\n }\n\n\n init {\n EXECUTOR.scheduleWithFixedDelay(\n { cleanUp() },\n expireAfterAccess,\n expireAfterAccess,\n timeUnit\n )\n }\n\n fun put(key: K, value: V) {\n if (cache.size >= maxSize) {\n cache.keys.iterator().next()?.let { cache.remove(it) }\n }\n cache[key] = CacheEntry(value, System.nanoTime())\n }\n\n fun get(key: K): V? {\n val entry = cache[key] ?: return null\n if (System.nanoTime() - entry.lastAccessTime > timeUnit.toNanos(expireAfterAccess)) {\n cache.remove(key)\n return null\n }\n\n entry.lastAccessTime = System.nanoTime()\n return entry.value\n }\n\n fun remove(key: K) {\n cache.remove(key)\n }\n\n fun clear() {\n cache.clear()\n }\n\n private fun cleanUp() {\n val now = System.nanoTime()\n val expirationTime = timeUnit.toNanos(expireAfterAccess)\n\n val iterator = cache.entries.iterator()\n while (iterator.hasNext()) {\n val entry = iterator.next()\n if (now - entry.value.lastAccessTime > expirationTime) {\n iterator.remove()\n }\n }\n }\n\n private data class CacheEntry(val value: V, var lastAccessTime: Long)\n}"
},
{
"path": "android/app/src/main/kotlin/com/network/proxy/vpn/util/TLS.kt",
"content": "package com.network.proxy.vpn.util\n\nimport java.nio.ByteBuffer\nimport kotlin.math.min\n\n\nobject TLS {\n\n /**\n * 判断是否是TLS Client Hello\n */\n fun isTLSClientHello(packetData: ByteBuffer): Boolean {\n if (packetData.remaining() < 43) return false\n val position = packetData.position()\n val data = packetData.array()\n if (data[position].toInt() != 0x16 /* handshake */) return false\n if (data[1 + position].toInt() != 0x03) return false\n return if (data[5 + position].toInt() != 0x01) false else data[9 + position].toInt() == 0x03 && data[10 + position] >= 0x00 && data[1 + position] <= 0x03\n }\n\n /**\n * 从TLS Client Hello 解析域名\n */\n fun getDomain(buffer: ByteBuffer): String? {\n var offset = buffer.position()\n val limit = buffer.limit()\n //TLS Client Hello\n if (buffer[offset].toInt() != 0x16) return null\n //Skip 43 byte header\n offset += 43\n if (limit < (offset + 1)) return null\n\n //read session id\n val sessionIDLength = buffer[offset++]\n offset += sessionIDLength\n\n //read cipher suites\n if (offset + 2 > limit) return null\n val cipherSuitesLength = buffer.getShort(offset)\n offset += 2\n offset += cipherSuitesLength\n\n //read Compression method.\n if (offset + 1 > limit) return null\n val compressionMethodLength = buffer[offset++].toInt() and 0xFF\n offset += compressionMethodLength\n if (offset > limit) return null\n\n //read Extensions\n if (offset + 2 > limit) return null\n\n val extensionsLength = buffer.getShort(offset)\n offset += 2\n if (offset + extensionsLength > limit) return null\n\n var end: Int = offset + extensionsLength\n end = min(end, limit)\n while (offset + 4 <= end) {\n val extensionType = buffer.getShort(offset)\n val extensionLength = buffer.getShort(offset + 2)\n offset += 4\n //server_name\n if (extensionType.toInt() == 0) {\n if (offset + 5 > limit) return null\n val serverNameListLength = buffer.getShort(offset)\n offset += 2\n if (offset > limit) return null\n if (offset + serverNameListLength > limit) return null\n\n val serverNameType = buffer[offset++]\n val serverNameLength = buffer.getShort(offset)\n offset += 2\n if (offset > limit || serverNameType.toInt() != 0) return null\n if (offset + serverNameLength > limit) return null\n val serverNameBytes = ByteArray(serverNameLength.toInt())\n buffer.get(serverNameBytes)\n return String(serverNameBytes)\n } else {\n offset += extensionLength\n }\n }\n return null\n }\n\n}"
},
{
"path": "android/app/src/main/res/drawable/launch_background.xml",
"content": "\n\n\n