Simpler DNS Client

[Johnny00]

Hallo liebes Forum,

ich bin am verzweifeln.. ich suche und suche tagelang und ich bekomm einfach nichts hin!
ich würde gerne einen einfachen dns client schreiben, der mit zu einem host die dazugehörige IP
adresse ermittelt (A record), jedoch ohne java funktionen wie getHostByName() etc.
Ich will das ganze manuell machen, sprich mit nameservern kommunizieren.

Meine Idee war es zwei Klassen zu erstellen.
Eine hauptklasse und einen resolver der mit den nameservern kommunizieren kann.

Laut dem RFC 1035 kann ich die Daten per TCP/ UDP verschicken.
Das heißt also ich kann mit Sockets und Datagrammen arbeiten soweit ich mich nicht irre.
Ich hab herausgefunden, dass in der Anfrage der A record den Wert "1" hat und die CLASS ist standardmäßig: IN.

Meine Fragen sind nun:
- Wie erstelle ich diese "Oktett Pakete" ?
- Wie bringe ich meine Query unter?
- Wie sieht überhaupt meine query aus wenn ich einfach nur den A record eines hosts (z.b. google.de)
haben will?
- Wie bekomme ich so eine Paket Struktur hin?:

    +---------------------+
    |        Header             |
    +---------------------+
    |       Question            | the question for the name server
    +---------------------+
    |        Answer             | RRs answering the question
    +---------------------+
    |      Authority            | RRs pointing toward an authority
    +---------------------+
    |      Additional            | RRs holding additional information
    +---------------------+

- Wie kann ich weitere Optionen, wie "recursive" übergeben?
- Wie empfange ich die Daten und wie kann ich diese auswerten?? (wegen der oktett struktur)

Ich hab zahlreiche Programme gefunden unter anderem auch dnsjava und ich habe auch probiert den quellcode zu analysieren.. jedoch finde ich mich da nicht zurecht, da da programm zu komplex für mich ist.

Ich bin am verzweifeln da ich nicht weiß wo ich anfangen soll.
Das hintergrundwissen über DNS Server ist mehr oder weniger vorhanden, jedoch
bekomme ich die impelementation in java einfach nicht hin weil ich darüber nichts gefunden habe.

Das forum hab ich auch schon durchsucht nach "dns client", hab leider auch nichts gefunden.

Ich bin dankbar für jede hilfe... sodass ich mal anfangen kann an dem programm zu arbeiten



[EDIT]

Ich hab mehrmals probiert mit einem nameserver zu kommunizieren...
aber sowas wie:

            socket = new Socket ("217.237.148.70", 53);
            in = socket.getInputStream();
            out = socket.getOutputStream();
            
            String query = "google.de IN A";
            out.write ( query.getBytes() );
         
            for (int g; (g = in.read()) != -1;) {
                System.out.write (g);
            }

klappt leider nicht.. mein programm bekommt gar keine ausgabe...

[/EDIT]


Mit freundlichem Gruß
Johnny

 

[Johnny00]

*push*

hat denn gar keiner eine idee ? ???:L

 

[Noctarius]

Ich glaube irgendwie nicht, dass "google.de IN A" alles ist, was der DNS Server als Request erwartet. Auch die Request Packages haben meiner Erinnerung nach Headerdaten.

 

[Johnny00]

Das ist ja genau mein Problem.
Ich weiß nicht wie ich das Paket "bauen" und verschicken kann ..

 

[Noctarius]

Bytes zusammenbauen und abschicken

 

[Johnny00]

Ja, wie genau kann ich die Bytes zusammenfassen?

Ich habe hier eine kleine Anleitung gefunden:

DNS MESSAGE FORMAT

Header
Question
Answer
Authority
Additional

DNS HEADER FORMAT

OCTET 1,2 	ID 
OCTET 3,4	QR(1 bit) + OPCODE(4 bit)+ AA(1 bit) + TC(1 bit) + RD(1 bit)+ RA(1 bit) + 
		Z(3 bit) + RCODE(4 bit)
OCTET 5,6	QDCOUNT 
OCTET 7,8	ANCOUNT	
OCTET 9,10	NSCOUNT	
OCTET 11,12	ARCOUNT

QUESTION FORMAT

OCTET 1,2,…n 	QNAME 
OCTET n+1,n+2	QTYPE
OCTET n+3,n+4	QCLASS 

ANSWER, AUTHORITY, ADDITIONAL FORMAT

OCTET 1,2,..n 		NAME 
OCTET n+1,n+2		TYPE
OCTET n+3,n+4		CLASS 
OCTET n+5,n+6,n+7,n+8	TTL 
OCTET n+9,n+10		RDLENGTH
OCTET n+11,n+12,…..	RDATA

...Nehmen wir zuerst den header:

OCTET 1,2 ID
OCTET 3,4 QR(1 bit) + OPCODE(4 bit)+ AA(1 bit) + TC(1 bit) + RD(1 bit)+ RA(1 bit) +
Z(3 bit) + RCODE(4 bit)
OCTET 5,6 QDCOUNT
OCTET 7,8 ANCOUNT
OCTET 9,10 NSCOUNT
OCTET 11,12 ARCOUNT


Ich muss ja irgendwie die bytes erstellen. für den header hab ich in dem fall von 1-12 (0-11)
also:

byte[] b = new byte[12];

zuerst kommt die ID, die ist in byte[0] und byte[1]:
nehmen wir mal an ID: 3

b[0] = 00000000;
b[1] = 00000011;

dann kommt octett 3,4 jeweils 8 bit

b[2] = 00000000;
b[3] = 00000000;

dann kommt qdcount:

b[4] = 00000000; // länge der question anfrage, in dem fall die länge der domain
b[5] = 00000000;

dann kommt ancount:

b[6] = 00000000; // länge der antwort, wenn wir das paket schicken ist sie dann standard 0?
b[7] = 00000000;

dann kommt nscount:

b[8] = 00000000;
b[9] = 00000000;

und dann kommt arcount:

b[10] = 00000000;
b[11] = 00000000;

und das wäre dann mein header?
das gleicht müsste ich dann nochmal machen mit:

Question
Answer
Authority
Additional

und dann schicken? .. ich probier ja schon alles damit ichs verstehe.. aber irgendwie klappts nicht

 

[Noctarius]

ByteBuffer z.B.

 

[Johnny00]

und wie kann ich dann meine bits in den bytebuffer schreiben, die ich brauche?
so wie ich das geschrieben habe denk ich nicht dass das geht... also dass ich die einzelnen bits nacheinander reihen kann..

und außerdem.. muss ich noch die domain übergeben z.b. Google von der ich den A record haben will,
kommt das auch als byte ins array?

(Man da merk ich richtig wie viel Know-How mir fehlt :/)

EDIT:
In einem anderen Forum habe ich folgendes gefunden:

ByteBuffer bbuf = ByteBuffer.wrap( string.getBytes() );

kann ich in dem fall:

String id = "12";
ByteBuffer bbuf = ByteBuffer.wrap( id.getBytes() );

(nur für die ID erstmal)

machen und es wird korrekt zugeordnet?

 

[Noctarius]

Das Zauberwort heißt hier Bitwise und Bit Shift Operations Bitwise and Bit Shift Operators (The Java™ Tutorials > Learning the Java Language > Language Basics) oder Java Blog Buch : 02.05.02 “Fortgeschrittene” Operatoren

kann ich in dem fall:

String id = "12";
ByteBuffer bbuf = ByteBuffer.wrap( id.getBytes() );

(nur für die ID erstmal)

machen und es wird korrekt zugeordnet?

Nein kannst du nicht, weil das den String in Bytes kodiert, nicht was da als Zahl drin steht.

 

[Johnny00]

Okay, also mein Problem war es ein Paket zu erstellen, welches ich dann verschicken kann.
Du hast mir gesagt ich soll einen ByteBuffer benutzen damit ich die einzelnen bits zusammen fassen kann. Ferner hast du mir gesagt, dass ich mich BitShift Operationen auseinander setzen soll.

Bis hier her habe ich es verstanden, aber ich habe immernoch nicht verstanden wie ich eine einfache anfrage an den nameserver verschicken kann, sodass er diese versteht, dieser letzte schritt fehlt mir einfach weil ich nicht so denke, wie du denkst.
Ich weiß nicht wie ich die Operatoren nutzen kann um mein Paket zu erstellen.

Kannst du mir bitte einach nur mal zeigen wie du es genau meinst?
Einfach nur einen Testheader erstellen, damit ich sehen kann wie ich den ByteBuffder benutze und wie ich das genau mit den Operatoren anstelle?

Wäre richtig super wenn du mir das einmal zeigen könntest anhand des headers.
Die anderen sektionen (wie Question, Answer..) die kann ich dann einfach nach dem gleichen prinzip machen.

Bin dir bis jetzt schon sehr dankbar dass du dir überhaupt nimmst!

 

[Noctarius]

- Bytes mit Shiftoperator zusammenbauen
- Bytes in den ByteBuffer schieben
- ByteBuffer in den Outputstream des Socket schreiben

 

[Johnny00]

Okay, dann will ich mal loslegen

Zunächst einmal brauchen wir den ByteBuffer:

ByteBuffer buf = ByteBuffer.allocate (1024); // Testwert

Dann erstellen wir den Header:

int id = 0xA // für ID = 10;
int se = 0x100 // = 0000000100000000 // Für QR=0  OPCODE=0  AA = 0  TC=0 RD = 1 RA=0 Z =0  RCCODE=0
int qdcount = 0x1;
int ancount = 0x0;
int nscount = 0x0;
int arcount = 0x0;

Somit hab ich den header:

DNS Header
ID=10 QR=0 OPCODE=0 AA = 0 TC=0 RD = 1 RA=0 Z =0 RCCODE=0 QDCOUNT=1
ANCOUNT=0 NSCOUNT=0 ARCOUNT=0

Und nun füg ich das ganze in den buffer ein:

buf.putInt (id);
buf.putInt (se);
buf.putInt (qdcount);
buf.putInt (ancount);
buf.putInt (nscount);
buf.putInt (arcount);

Der header ist also schonmal im buffer... nun kommt die QUESTION- Sektion
Diese besteht aus:

OCTET 1,2,…n QNAME
OCTET n+1,n+2 QTYPE
OCTET n+3,n+4 QCLASS

also:

byte[] qname = new String ("www.google.de").getBytes();
int qtype = 0x1;
int qclass = 0x1;

und dann im buffer einfügen:

buf.put (qname, 0, qname.length);
buf.putInt (qtype);
buf.putInt (qclass);

Und nun schicke ich den buf (Buffer) über den Socket an den Nameserver.

Ist das denn so endlich richtig??

 

[Noctarius]

Kommt drauf an ob du Ints brauchst oder Bits.

Ein Byte sind 8Bit. Wenn du also im Header nur 4 Bit für einen Wert brauchst musst du das Byte mit den fehlenden Bit auffüllen, die danach im Header sind.

Beispiel:
4 Bit Id [c]0010[/c]
2 Bit Command [c]11[/c]
1 Bit Flag1 [c]0[/c]
1 Bit Flag2 [c]1[/c]

Dann hast du ein Byte wo 4 Werte drin gespeichert werden.

Ein Byte ist also [c]0000 0000[/c] wir brauchen aber ein Byte das so aussieht [c]0010 1101[/c], weil wir ja die Werte einbringen müssen.

byte header = 0x02; // Startwert 0x02 (Bitwert 0010)
header = header << 2 && 0x03; // 2 Bit nach links schieben und mit 0x03 (Bitwert 11) verknüpfen 
header = header << 1 && 0x00; // 1 Bit nach links schieben und mit 0x00 (Bitwert 0) verknüpfen
header = header << 1 && 0x01; // 1 Bit nach links schieben und mit 0x01 (Bitwert 1) verknüpfen

Wie sieht also unser Byte in den Schritten aus?

0000 0000: Leeres Byte
0000 0010: Startwert
0000 1000: 2 Bit nach links verschoben
0000 1011: mit 0x03 verknüpft
0001 0110: 1 Bit nach links verschoben
0001 0110: mit 0x00 verknüpft
0010 1100: 1 Bit nach links verschoben
0010 1101: mit 0x01 verknüpft

Dieses fertig aufbereitete Byte kannst du dann in den ByteBuffer schieben.

 

[Johnny00]

Ach alles klar jetzt versteh ich wie das Byte aufzubereiten ist!
Endlich

Der Header besteht also aus 12 Bytes:

OCTET 1,2 ID = 2 Byte
OCTET 3,4 QR(1 bit) + OPCODE(4 bit)+ AA(1 bit) + TC(1 bit) + RD(1 bit)+ RA(1 bit) +
Z(3 bit) + RCODE(4 bit) = 2 Byte
OCTET 5,6 QDCOUNT = 2 Byte
OCTET 7,8 ANCOUNT = 2 Byte
OCTET 9,10 NSCOUNT = 2 Byte
OCTET 11,12 ARCOUNT = 2 Byte

= 12 Byte Header

Wenn ich nun die ID aufbereite dann hab ich ja zwei bytes:

0000 0000 0000 0000
---------- ----------
Byte 1 Byte 2

Wenn ich die ID nun bearbeite dann steht dann sowas da:
0000 0000 0000 0010 ... als Beispiel. diese 2 Bytes beinhalten die ID
und diese 2 Bytes schreib ich dann einfach in den ByteBuffer.
(wenn ich die beiden als hex zusamenfasse bekomm ich ja 0x02)

SO müsste ich das doch richtig verstanden haben.

Und dann noch eine kleine Frage bevor ich weitermache mit meinem Programm:
wie pack ich meinen string in den bytebuffer?
in meinem beispiel hatte ich ja den host "google.de" angesprochen, und du meintest mit getBytes() kann ich das nicht machen.

kann ich das so lösen:

String qname = "google.de";
byte[] bytes = qname.getBytes();
buf.put(bytes);

?

 

[Noctarius]

Kannst du schon, du musst nur an die Datenrepresentation zwischen ASCII und UTF-8 (was Java intern nutzt) denken und passend umwandeln.

 

[Johnny00]

Soo ich habs erstmal mit meiner ersten Methode probiert:

import java.net.*;
import java.io.*;
import java.nio.*;
import java.nio.channels.DatagramChannel;

public class Test
{
    public Test()
    {
    try {
        DatagramChannel channel = DatagramChannel.open();
        SocketAddress address = new InetSocketAddress(0);
        DatagramSocket socket = channel.socket();
        socket.bind(address);
        
        SocketAddress server = new InetSocketAddress("217.5.100.185", 53);
        channel.connect (server);
        
        ByteBuffer buf = ByteBuffer.allocate (1024);
            int id = 0xA; // für ID = 10;
            int se = 0x100; // = 0000000100000000 // Für QR=0  OPCODE=0  AA = 0  TC=0 RD = 1 RA=0 Z =0  RCCODE=0
            int qdcount = 0x1;
            int ancount = 0x0;
            int nscount = 0x0;
            int arcount = 0x0;
            
            buf.putInt (id);
            buf.putInt (se);
            buf.putInt (qdcount);
            buf.putInt (ancount);
            buf.putInt (nscount);
            buf.putInt (arcount);
            
            byte[] qname = new String ("google.de").getBytes();
            int qtype = 0x1;
            int qclass = 0x1;
            
            buf.put (qname, 0, qname.length);
            buf.putInt (qtype);
            buf.putInt (qclass);
            
            buf.flip();
            channel.write (buf);
            buf.clear();

            channel.read(buf);
            buf.flip();            
    } catch (Exception e) {
            System.out.println (e);
    }
    System.out.println ("OK");
    }
}

Wenn ich nun buf.getInt() mache liefert mir das Programm:

32769
0
0

Weißt du vll. was da falshc sein könnte?
Nun probier ich das auch mit deiner methode und dem bit shifting.

 

[Noctarius]

Ints sind immer noch Ints und keine Bytes, bzw 4 Bytes... Ergo ist und bleibt dein Header 1. zu lang, 2. falsch.

 

[Johnny00]

Okay, nun hab ich es so:

import java.net.*;
import java.io.*;
import java.nio.*;
import java.nio.channels.DatagramChannel;

public class Test2
{
    public Test2()
    {
    try {
        DatagramChannel channel = DatagramChannel.open();
        SocketAddress address = new InetSocketAddress(0);
        DatagramSocket socket = channel.socket();
        socket.bind(address);
        
        SocketAddress server = new InetSocketAddress("217.5.100.185", 53);
        channel.connect (server);
        
        ByteBuffer buf = ByteBuffer.allocate (1024);

        // Header //
        
        // 1. ID besteht aus 2 Bytes
        
        byte id1 = 0x0;
        byte id2 = 0x1;
        
        buf.put (id1);
        buf.put (id2);
        // ID = 1;
        
        // 2. Parameter aus 2 Bytes
        
        // 1. Byte - QR(1 bit) + OPCODE(4 bit)+ AA(1 bit) + TC(1 bit) + RD(1 bit)
        byte par0 = 0x0;    // QR = 0
        par0 = (byte) (par0 << 4 & 0x0); // Opcode = 0
        par0 = (byte) (par0 << 1 & 0x0); // AA = 0
        par0 = (byte) (par0 << 1 & 0x0); // TC = 0
        par0 = (byte) (par0 << 1 & 0x1); // RD = 1
        // 2. Byte -  RA(1 bit) + Z(3 bit) + RCODE(4 bit)
        byte par1 = 0x0; // RR = Z = RCODE 0 0
        
        buf.put (par0);
        buf.put (par1);
        // HEADER fertig !
        
        // Nun kommt QUESTION
        //OCTET 1,2,…n  QNAME 
        //OCTET n+1,n+2   QTYPE
        //OCTET n+3,n+4   QCLASS 
        
        byte[] qname = new String ("google.de").getBytes();
        byte qtype = 0x1;
        byte qclass = 0x1;
        
        buf.put (qname, 0, qname.length);
        buf.put (qtype);
        buf.put (qclass);

        // Question Section ENDE
        buf.flip();
        channel.write (buf);
        buf.clear();
        
        channel.read(buf);
        buf.flip();
    } catch (Exception e) {
            System.out.println (e);
    }

        
    System.out.println ("OK");
    }
}

.. bis hierhin bin ich nun gekommen, leider hab ich immer noch kein vernünftiges ergebnis.
wo harpert es?

 

[Noctarius]

Kannst du schon, du musst nur an die Datenrepresentation zwischen ASCII und UTF-8 (was Java intern nutzt) denken und passend umwandeln.

Siehe oben (eventuell), hab noch nie versucht das DNS Protokoll zu bauen

Und wieso flippst du den Buffer?

 

[Johnny00]

Ich hab das anhand einer Anleitung gemacht:

Socket based on new IO and DatagramChannel : DatagramChannelNetworkJava Tutorial

Die flippen den buffer bevor die ihn an den channel schicken.

Und was meinst du genau mit der kodierung?

Also:

   public byte[] convertCharArrayToByteArray(char[] ca) {
     byte[] ba = new byte[ca.length * 2];
     java.nio.ByteBuffer.wrap(ba).asCharBuffer().put(ca);
     return ba;
   } 

  char [] myCharArray = new String("google.de").toCharArray ();
  buf.put (convertCharArrayToByteArray(myCharArray));

 

[Noctarius]

Naja Kodierung bedeutet: ASCII != UTF-8