java - test - Firewall de Android con VpnService

netguard pro apk 2019

Question

Estoy tratando de implementar un firewall simple para Android con VpnService para el proyecto BS. Elijo VpnService porque funcionará en dispositivos no rooteados. Registrará las conexiones y le permitirá filtrar la conexión. (Basado en IP)

Hay una aplicación que hace esto para que sea posible.

Google Play App Store

Investigué un poco y descubrí que VpnService crea una interfaz Tun. Nada mas. (Sin implementación de VPN solo un túnel) Le permite dar una dirección a esta interfaz y agregar rutas. Devuelve un descriptor de archivo. Puede leer paquetes salientes y escribir paquetes entrantes.

Creé una clase derivada de VpnService y comencé el servicio. Puedo configurar tun0 con la clase VpnService.Builder. Cuando miro mobiwol''s conexión mobiwol''s con adb shell netcfg crea una interfaz tun0 con la dirección 10.2.3.4/32. Enruta todos los paquetes a esta red privada y los envía a internet. Estoy intentando lo mismo. Creado una interfaz con 10.0.0.2/32 dirección. Se agregó una ruta con la función addRoute. 0.0.0.0/0 para que pueda capturar todos los paquetes de toda la red hasta donde yo entiendo. (Soy bastante nuevo en este tema y sigo aprendiendo. Encontré piezas en Internet, así que no estoy muy seguro. Corrígeme si me equivoco).

Creé 2 hilos en servicio. Uno lee desde el descriptor de archivo y lo escribe en 127.0.0.1 con un socket protegido. (No estoy seguro de si debería leer / escribir en 127.0.0.1. Tal vez este es el problema).

Analicé los paquetes que leí del descriptor de archivo. Por ejemplo:

01000101    byte:69     //ipv4 20byte header
00000000    byte:0      //TOS
00000000    byte:0      //Total Length
00111100    byte:60     //Total Length
11111100    byte:-4     //ID
11011011    byte:-37    //ID
01000000    byte:64     //fragment
00000000    byte:0      //"
01000000    byte:64     //TTL
00000110    byte:6      //Protocol 6 -> TCP
01011110    byte:94     //Header checksum
11001111    byte:-49    //Header checksum
00001010    byte:10     //10.0.0.2
00000000    byte:0
00000000    byte:0
00000010    byte:2
10101101    byte:-83    //173.194.39.78 //google
00111110    byte:-62
00100111    byte:39
********    byte:78

10110100    byte:-76    // IP option
01100101    byte:101
00000001    byte:1
10111011    byte:-69
                //20byte IP haeder
01101101    byte:109
.       .       //40byte data (i couldnt parse TCP header, 
                    I think its not needed when I route this in IP layer)
.       .
.       .
00000110    byte:6

No encontré ningún otro encabezado IP en el resto de los datos. Creo que debería haber una encapsulación entre la red 10.0.0.2 a la red local (192.168.2.1) e Internet. No estoy seguro.

Mi verdadero problema es que me quedé atrapado en el hilo de los paquetes entrantes. No puedo leer nada Ninguna respuesta. Como puede ver en la captura de pantalla, no hay datos entrantes:

screenshot

Intento leer desde la misma conexión que uso para escribir en 127.0.0.1 con un socket protegido.

Android <-> Tun Interface (tun0) <-> conexión a Internet

Todos los paquetes <-> 10.0.0.2 <-> 127.0.0.1? <-> 192.168.2.1 <-> Internet?

No pude encontrar nada útil sobre VpnService. (El ejemplo de ToyVPN es inútil) Leo documentos sobre Tun / Tap de Linux, pero se trata de hacer túneles entre el host y el control remoto. Quiero el host y el control remoto en el mismo dispositivo. No como túneles.

¿Cómo puedo hacer esto?

Editar: Código solicitado. Está en una etapa muy temprana. Como mencioné antes, es una clase derivada de VpnService. 2 hilos (lectura y escritura) creados en hilo de servicio.

package com.git.firewall;

public class GITVpnService extends VpnService implements Handler.Callback, Runnable {
    private static final String TAG = "GITVpnService";

    private String mServerAddress = "127.0.0.1";
    private int mServerPort = 55555;
    private PendingIntent mConfigureIntent;

    private Handler mHandler;
    private Thread mThread;

    private ParcelFileDescriptor mInterface;

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        // The handler is only used to show messages.
        if (mHandler == null) {
            mHandler = new Handler(this);
        }

        // Stop the previous session by interrupting the thread.
        if (mThread != null) {
            mThread.interrupt();
        }
        // Start a new session by creating a new thread.
        mThread = new Thread(this, "VpnThread");
        mThread.start();
        return START_STICKY;
    }

    @Override
    public void onDestroy() {
        if (mThread != null) {
            mThread.interrupt();
        }
    }

    @Override
    public boolean handleMessage(Message message) {
        if (message != null) {
            Toast.makeText(this, (String)message.obj, Toast.LENGTH_SHORT).show();
        }
        return true;
    }

    @Override
    public synchronized void run() {
        try {
            Log.i(TAG, "Starting");
            InetSocketAddress server = new InetSocketAddress(
                    mServerAddress, mServerPort);

            run(server);

              } catch (Exception e) {
            Log.e(TAG, "Got " + e.toString());
            try {
                mInterface.close();
            } catch (Exception e2) {
                // ignore
            }
            Message msgObj = mHandler.obtainMessage();
            msgObj.obj = "Disconnected";
            mHandler.sendMessage(msgObj);

        } finally {

        }
    }

    DatagramChannel mTunnel = null;


    private boolean run(InetSocketAddress server) throws Exception {
        boolean connected = false;

        android.os.Debug.waitForDebugger();

        // Create a DatagramChannel as the VPN tunnel.
        mTunnel = DatagramChannel.open();

        // Protect the tunnel before connecting to avoid loopback.
        if (!protect(mTunnel.socket())) {
            throw new IllegalStateException("Cannot protect the tunnel");
        }

        // Connect to the server.
        mTunnel.connect(server);

        // For simplicity, we use the same thread for both reading and
        // writing. Here we put the tunnel into non-blocking mode.
        mTunnel.configureBlocking(false);

        // Authenticate and configure the virtual network interface.
        handshake();

        // Now we are connected. Set the flag and show the message.
        connected = true;
        Message msgObj = mHandler.obtainMessage();
        msgObj.obj = "Connected";
        mHandler.sendMessage(msgObj);

        new Thread ()
        {
            public void run ()
                {
                    // Packets to be sent are queued in this input stream.
                    FileInputStream in = new FileInputStream(mInterface.getFileDescriptor());
                    // Allocate the buffer for a single packet.
                    ByteBuffer packet = ByteBuffer.allocate(32767);
                    int length;
                    try
                    {
                        while (true)
                        {
                            while ((length = in.read(packet.array())) > 0) {
                                    // Write the outgoing packet to the tunnel.
                                    packet.limit(length);
                                    debugPacket(packet);    // Packet size, Protocol, source, destination
                                    mTunnel.write(packet);
                                    packet.clear();

                                }
                            }
                    }
                    catch (IOException e)
                    {
                            e.printStackTrace();
                    }

            }
        }.start();

        new Thread ()
        {

            public void run ()
            {
                    DatagramChannel tunnel = mTunnel;
                    // Allocate the buffer for a single packet.
                    ByteBuffer packet = ByteBuffer.allocate(8096);
                    // Packets received need to be written to this output stream.
                    FileOutputStream out = new FileOutputStream(mInterface.getFileDescriptor());

                    while (true)
                    {
                        try
                        {
                            // Read the incoming packet from the tunnel.
                            int length;
                            while ((length = tunnel.read(packet)) > 0)
                            {
                                    // Write the incoming packet to the output stream.
                                out.write(packet.array(), 0, length);

                                packet.clear();

                            }
                        }
                        catch (IOException ioe)
                        {
                                ioe.printStackTrace();
                        }
                    }
            }
        }.start();

        return connected;
    }

    private void handshake() throws Exception {

        if (mInterface == null)
        {
            Builder builder = new Builder();

            builder.setMtu(1500);
            builder.addAddress("10.0.0.2",32);
            builder.addRoute("0.0.0.0", 0);
            //builder.addRoute("192.168.2.0",24);
            //builder.addDnsServer("8.8.8.8");

            // Close the old interface since the parameters have been changed.
            try {
                mInterface.close();
            } catch (Exception e) {
                // ignore
            }


            // Create a new interface using the builder and save the parameters.
            mInterface = builder.setSession("GIT VPN")
                    .setConfigureIntent(mConfigureIntent)
                    .establish();
        }
    }

    private void debugPacket(ByteBuffer packet)
    {
        /*
        for(int i = 0; i < length; ++i)
        {
            byte buffer = packet.get();

            Log.d(TAG, "byte:"+buffer);
        }*/



        int buffer = packet.get();
        int version;
        int headerlength;
        version = buffer >> 4;
        headerlength = buffer & 0x0F;
        headerlength *= 4;
        Log.d(TAG, "IP Version:"+version);
        Log.d(TAG, "Header Length:"+headerlength);

        String status = "";
        status += "Header Length:"+headerlength;

        buffer = packet.get();      //DSCP + EN
        buffer = packet.getChar();  //Total Length

        Log.d(TAG, "Total Length:"+buffer);

        buffer = packet.getChar();  //Identification
        buffer = packet.getChar();  //Flags + Fragment Offset
        buffer = packet.get();      //Time to Live
        buffer = packet.get();      //Protocol

        Log.d(TAG, "Protocol:"+buffer);

        status += "  Protocol:"+buffer;

        buffer = packet.getChar();  //Header checksum

        String sourceIP  = "";
        buffer = packet.get();  //Source IP 1st Octet
        sourceIP += buffer;
        sourceIP += ".";

        buffer = packet.get();  //Source IP 2nd Octet
        sourceIP += buffer;
        sourceIP += ".";

        buffer = packet.get();  //Source IP 3rd Octet
        sourceIP += buffer;
        sourceIP += ".";

        buffer = packet.get();  //Source IP 4th Octet
        sourceIP += buffer;

        Log.d(TAG, "Source IP:"+sourceIP);

        status += "   Source IP:"+sourceIP;

        String destIP  = "";
        buffer = packet.get();  //Destination IP 1st Octet
        destIP += buffer;
        destIP += ".";

        buffer = packet.get();  //Destination IP 2nd Octet
        destIP += buffer;
        destIP += ".";

        buffer = packet.get();  //Destination IP 3rd Octet
        destIP += buffer;
        destIP += ".";

        buffer = packet.get();  //Destination IP 4th Octet
        destIP += buffer;

        Log.d(TAG, "Destination IP:"+destIP);

        status += "   Destination IP:"+destIP;
        /*
        msgObj = mHandler.obtainMessage();
        msgObj.obj = status;
        mHandler.sendMessage(msgObj);
        */

        //Log.d(TAG, "version:"+packet.getInt());
        //Log.d(TAG, "version:"+packet.getInt());
        //Log.d(TAG, "version:"+packet.getInt());

    }

}

Answer 1

Tal vez es mejor buscar proyectos de código abierto como OpenVpn . Funciona en el nivel API 14+ (Ice Cream Sandwhich) sin acceso de root.

Answer 2

Hace unos meses , se hizo una pregunta similar , y aunque las respuestas no son muy reveladoras, los comentarios en la respuesta aceptada dan una idea de lo que puede estar yendo mal.

Debe tener en cuenta qué capa del modelo OSI reside su lógica:

• Las transmisiones entrantes y salientes de VpnService se encuentran en la capa de red; está recibiendo (y debería estar transmitiendo) paquetes de IP sin formato, como describe en su pregunta.

  En la secuencia de bytes de muestra, puede ver que la secuencia de bytes entrantes es un datagrama IPv4, ya que los primeros cuatro bits son 0100 (4). Consulte esta especificación de estructura de paquetes para obtener detalles sobre IPv4.

• Al reenviar las solicitudes, se encuentra en la capa de la aplicación; Debería estar transmitiendo los contenidos de la carga útil UDP o TCP (es decir, solo sus datos, no los encabezados) usando respectivamente un DatagramSocket o un Socket.

  Tenga en cuenta que esto omite la capa de transporte ya que esas implementaciones se encargan de construir el encabezado UDP (en el caso de DatagramSocket) y el encabezado TCP y las opciones (en el caso de Socket).

Su aplicación esencialmente necesitará poder interpretar y construir encabezados y opciones IPv4 e IPv6, y como carga útil IP, los encabezados UDP y las cabeceras y opciones de TCP.