Android Iodine Entwicklerdokumentation

    == Der Client testet die Qualitaet der Uebertragung
    <-- client.c:handshake_qtype_autodetect()
              -> handshake_qtypetest()
              -> send_downenctest()
      hostname[0] = "y"
      hostanme[1] = downenc = 'r'
      hostname[2] = variant = 1 = 'b' (b32)
      hostname[3..5] = rand_seed++
      RX: yrb***.t.yves.tw

    --> 48 bytes aus encoding.h:DOWNCODECHECK
      TX: yrb***.t.yves.tw, 48 bytes data

    == Austausch der Versionsinformationen
    <-- client.c:send_version()
      VERSION=0x00 00 05 02
      hostname[0] = cmd = 'v'
      hostname[1..6] = b32(0,0,5,2,random<<8,random)
      hostname = "vAAAAKAR__"
      RX: vaaaaka****.t.yves.tw

    --> iodined.c:send_version_response()
      der Server bestaetigt mit
      data[0..8] = "VACK" b32(seed>>24, seed>>16, seed>>8, seed, userid)
      TX: vaaaaka***.t.yves.tw, 9 bytes data


    == Senden von Passwort und IP-Konfiguration (Subnetz)
    <-- client.c:send_login()
      cmd = 'l'
      hostname[1..16] = login/password mit seed xored und md5
      hostname[17..18] = seed
      RX: lad24srn4ezmg21qjsfy13msagd0srfq.t.yves.tw

    --> iodined.c:handle_null_request()
      Sendet bei Erfolg die IP Einstellungen wie
      "172.16.0.1-172.16.0.2-1130-16"
      server="172.16.0.1"
      client="172.16.0.2"
      mtu=1130
      netbits=16
      TX: lad24srn4ezmg21qjsfy13msagd0srfq.t.yves.tw
        = 3137322e31362e302e312d3137322e31362e302e322d313133302d3136 (_16)
        = 172.16.0.1-172.16.0.2-1130-16

    == Senden der IP Adresse des Clients
    <-- Request for IP address
      RX: iamin.t.yves.tw

    --> iodined.c:handle_null_request()
        addr = externe IP Adresse des Server (-n Switch)
        reply[0] = 'I';
        reply[1] = (addr >> 24) & 0xFF;
        reply[2] = (addr >> 16) & 0xFF;
        reply[3] = (addr >>  8) & 0xFF;
        reply[4] = (addr >>  0) & 0xFF;
      TX: iamin.t.yves.tw
        = 494e2f737d (_16)

    == Testen auf EDNS Erweiterung
    <-- client.c:handshake_edns0_check()
              -> send_downenctest()
      downenc = 'r' fuer T_NULL 't'
      variant = 1 = 'b' (b32)
      data[0..5]  = "y" downenc variant rand_seed[0..2]
      RX: yrb***.t.yves.tw

    --> iodined.c:handle_null_login() : 937
               -> write_dns( type='R')
      Der Server antwortet mit 48 bytes aus encoding.h:DOWNCODECHECK
      TX: yrb***.t.yves.tw, 48 bytes data


    == Testen der Kodierungen mit verschiedenen Patterns
    <-- client.c:handshake_upenc_autodetect()
      In den folgenden Tests testet der Client ob mit Base128
      kodierte Nachrichten vom DNS Relay korrekt verarbeitet werden.

    --> Der Server schickt die Patterns einfach wieder zurueck.

    == Client legt Kodierung fest, Server bestaetigt
    <-- client.c:handshake_switch_codec()
      hostname[0] = command 's'
      hostname[1] = b32(userid)
      hostname[2] = 'h' (7)
      hostname[3..5] = rand_seed++
      rand_seed++;
      RX: sahmiut.yves.tw

    --> iodined.c:840
      Schreibt den Namen des ausgewaehlten Codecs:
      data="Base128" (kein encoding!)
      TX: sahmiut.yves.tw, 7 bytes of data

    == Anschalten lazy mode (an: Server beantwortet Anfragen nicht sofort)
    <-- client.c:send_lazy_switch()
      hostname[0] = 'o'
      hostname[1] = b32(userid) = 'a'
      hostname[2] = 'l' fuer lazy mode oder 'i'
      hostname[3..5] = rand_seed++
      RX: oalmiv.t.yves.tw

    --> iodined.c:919
      data="Lazy" (kein encoding!)
      TX: oalmiv.t.yves.tw, 4 bytes of data

    ==
    <-- client.c:send_set_downstream_fragsize()
      data[0] = userid;
      data[1] = (fragsize & 0xff00) >> 8;
      data[2] = (fragsize & 0x00ff);
      data[3] = (rand_seed >> 8) & 0xff;
      data[4] = (rand_seed >> 0) & 0xff;
      hostname = 'n' + b32(data)
      RX: naabqbmiw.t.yves.tw

    --> iodined.c:1042
      bestaetigt empfangene Framesize durch Wiederholung

    == Regelmaesige pings fragen den Server nach anstehenden Daten ab
    <-- client.c:send_ping()
      data[0] = userid;
      data[1] = ((inpkt.seqno & 7) << 4) | (inpkt.fragment & 15);
      data[2] = (rand_seed >> 8) & 0xff;
      data[3] = (rand_seed >> 0) & 0xff;
      hostname = 'p' + b32(data)
      RX: paaalcfy.t.yves.tw

    --> iodined.c:1067
      Der Server nutzt die regelmaessigen Pings um Daten an den Client zu liefern.

#include <stdio.h>
#include <string.h>

#include "src/base32.h"
#include "src/encoding.h"

int main(int argc, char *argv[]) {
    struct encoder *b32 = get_base32_encoder();
    char buf[512];
    size_t len = 512;

    if (argc != 3) return 0;
    if (*argv[1] == 'd') {
        int r = b32->decode(buf, &len, argv[2], strlen(argv[2]));
        int i;
        printf("Decoded %d bytes:\n", r);
        for (i = 0; i< r; i++) {
            printf("0x%02hhx (%c) ", buf[i], (buf[i] >= '0' && buf[i] <= 'z') ? buf[i] : ' ');
        }
        printf("\n");
    } else if (*argv[1] == 'e') {
        int r = b32->encode(buf, &len, argv[2], strlen(argv[2]));
        printf("Encoded %d bytes in %ld output bytes: >%s<\n", len, r, buf);
    }
    return 0;
}

# gcc test.c src/base32.c -o test
# ./test e abcdefg
Encoded 7 12 bytes: >mfrggzdfmztq<

andiodine$ $NDK_ROOT/ndk-build clean
Clean: iodine-client [armeabi]
Clean: stdc++ [armeabi]
Clean: iodine-client [x86]
Clean: stdc++ [x86]

andiodine$ $NDK_ROOT/ndk-build
Compile thumb  : iodine-client <= iodine-client.c
.....
SharedLibrary  : libiodine-client.so
Install        : libiodine-client.so => libs/armeabi/libiodine-client.so
Compile x86    : iodine-client <= iodine-client.c
.....
SharedLibrary  : libiodine-client.so
Install        : libiodine-client.so => libs/x86/libiodine-client.so

   android project --path .
   ant debug