adioshun님의 노트

tcpdump_file

Tue, 30 Oct 2007 00:08:23 +0900

    if (RFileName != NULL) {    // 읽어 들일 dump 파일이 있는 지 확인
        int dlt;
        const char *dlt_name;


        pd = pcap_open_offline(RFileName, ebuf);        //open dump file

        /* Open a savefile in the tcpdump/libpcap format to read packets
        *
        *     <function prototype>
        *         pcap_t* pcap_open_offline(const char* fname, char* errbuf)
        */

        if (pd == NULL)
            error("%s", ebuf);

        dlt = pcap_datalink(pd);                        // pcap 디스크립터의 링크레이어 타입을 반환

        dlt_name = pcap_datalink_val_to_name(dlt);        // pcap 디스크립터의 어댑터 이름 반환
        /* Translates a data link type name, which is a DLT_ name with the DLT_ removed,
        * to the corresponding data link type value
        *
        *     <function prototype>
        *         int pcap_datalink_val_to_name(const char* name)
        *         Returns : -1 is returned on failure
        */

        if (dlt_name == NULL) {
            fprintf(stderr, "reading from file %s, link-type %u\n",
                RFileName, dlt);
        } else {
            fprintf(stderr,
                "reading from file %s, link-type %s (%s)\n",
                RFileName, dlt_name,
                pcap_datalink_val_to_description(dlt));
        }
        localnet = 0;
        netmask = 0;
        if (fflag != 0)
            error("-f and -r options are incompatible");
    }// end_if (RFileName != NULL)

pcap_t *pcap_open_offline(char *fname, char *ebuf)

[ 기능 ]

기존에 저장된 파일에서 패킷을 읽기 위해 사용된다.

stdin에서 읽기 위해서는 파일 이름을 "-"으로 한다.

[ 파라미터 ]

char *fname : 오픈할 파일의 이름

char *ebuf : 실패할 경우 에러 메시지가 저장된다 .

[ 리턴 ]

성공 : descriptor

실패 : NULL



5. pcap_dumper_t *pcap_dump_open(pcap_t *p, char *fname)

[ 기능 ]

캡쳐한 내용을 파일에 저장하기 위해서 파일을 오픈한다.

stdout을 지시하려면 파일이름을 "-"를 이용한다.

[ 파라미터 ]

pcap_t *p : pcap_open_offline()이나 pcap_open_live()에서 return되는 descriptor

char *fname : 오픈할 파일의 이름

[ 리턴 ]

성공 : pcap_dumper_t로 패킷 덤프와 관련된 구조체

실패 : NULL

[공부] Tcpdump & pcap분석

Sat, 06 Oct 2007 03:53:46 +0900

Tcpdump

l S: SYN (Synchronize sequence numbers – 연결 요청)

l F: FIN (보낸 쪽에서 연결을 종료 – 정상적인 연결 종료)

l R: RST (비정상적으로 즉시 연결 종료)

l P: PSH (데이터를 즉시 어플리케이션으로 전달)

l Urg: (긴급한 데이터에 우선순위를 높게 줌)

l ‘.’: (SYN, FIN, RESET, PUSH가 아닌 경우로 flag가 설정되지 않았다)

명령어 분석

       tcpdump [ -adeflLnNOpqRStuUvxX ] [ -c count ]
               [ -C file_size ] [ -F file ]
               [ -i interface ] [ -m module ] [ -M secret ]
               [ -r file ] [ -s snaplen ] [ -T type ] [ -w file ]
               [ -W filecount ]
               [ -E spi@ipaddr algo:secret,... ]
               [ -y datalinktype ] [ -Z user ]
               [ expression ]

옵션

-h: 버전 및 기본 사용법을 보여준다.
-a : Network & Broadcast 주소들을 이름들로 바꾼다.
-c Number : 제시된 수의 패킷을 받은 후 종료한다.
-d : compile된 packet-matching code를 사람이 읽을 수 있도록 바꾸어 표준 출력으로 출력하고, 종료한다.
-dd : packet-matching code를 C program의 일부로 출력한다.
-ddd : packet-matching code를 숫자로 출력한다.
-e : 출력되는 각각의 행에 대해서 link-level 헤더를 출력한다.
-f : 외부의 internet address를 가급적 심볼이 아닌 숫자로 출력한다.(Sun의 yp server와의 사용은 가급적 피한다.)
-F file : filter 표현의 입력으로 파일을 받아들인다. 커맨드라인에 주어진 추가의 표현들은 모두무시된다.
-i device : 어느 인터페이스를 경유하는 패킷들을 잡을지 지정한다. 지정되지 않으면인터페이스 리스트를 검색하여 가장 낮은 번호를 가진 인터페이스를 선택
-l : 표준 출력으로 나가는 데이터들을 line buffering한다. 다른 프로그램에서 tcpdump로부터 데이 터를 받고자 할 때 유용하다.
- 보통 'tcpdump -l | tee dat' 나 'tcpdump -l < dat & tail -f dat' 명령으로 연계해서 사용하면 편리하다.
-n : 모든 주소들을 번역하지 않는다(port,host address 등등)
-N : 호스트 이름을 출력할 때, 도메인을 찍지 않는다.
-O : packet-matching code optimizer를 실행하지 않는다. 이 옵션은 optimizer에 있는 버그를 찾을때나 쓰인다.
-p : 인터페이스를 promiscuous mode로 두지 않는다.
-q : 프로토콜에 대한 정보를 덜 출력한다. 따라서 출력되는 라인이 좀 더 짧아진다.
-r file : 패킷들을 '-w'옵션으로 만들어진 파일로 부터 읽어 들인다. 파일에 "-" 가 사용되면 표준입력을 통해서 받아들인다.
-s length: 패킷들로부터 추출하는 샘플을 default값인 68Byte외의 값으로 설정할 때 사용한다.
-T type : 조건식에 의해 선택된 패킷들을 명시된 형식으로 표시한다.
- type에는 다음과 같은 것들이 올 수 있다.
  - rpc(Remote Procedure Call), rtp(Real-Time Applications protocol), rtcp(Real-Time Application control protocal), vat(Visual Audio Tool), wb(distributed White Board)

-S : TCP sequence번호를 상대적인 번호가 아닌 절대적인 번호로 출력한다.
-t : 출력되는 각각의 라인에 시간을 출력하지 않는다.
-tt : 출력되는 각각의 라인에 형식이 없는 시간들을 출력한다.
-v : 좀 더 많은 정보들을 출력한다.
-vv : '-v'보다 좀 더 많은 정보들을 출력한다.
-vvv : 16진수값 형태로 정보를 보여준다. 보통 -X옵션과 사용되어
-w : 캡춰한 패킷들을 분석해서 출력하는 대신에 그대로 파일에 저장한다.
-x : 각각의 패킷을 헥사코드로 출력한다.
-X : 헥사코드와 ascii형태 모두 출력해준다. 보통 -x 옵션과 같이 사용된다.

조건식(expression)

옵션의 제일 마지막인 조건식은 어떤 패킷들을 출력할 지를 선택하는 데 쓰인다. 조건식이 주어지지 않는다면 모든 패킷들이 대상이 된다. 조건식들은 하나 또는 여러 개의 primitive들로 구성되어 있고 primitive들은 다시 하나 또는 여러 개의 qualifier들 다음에 오는 하나의 값으로 이루어진다.

qualifier

type : 주어진 값의 종류가 무엇인지를 나타낸다.
- 가능한 type들은 'host', 'net', 'port'가 있다.type이 없는 값들은 type을 host라 가정한다.
dir : id로 부터의 어떤 특정한 전송 방향을 나타낸다.
- 가능한 방향은 'src', 'dst', 'src or dst', 'src and dst'이다. 만약 방향이 정해지지 않았다면, src or dst라 가정한다. "For `null' link layers (i.e. point to point protocols such as slip) the inb ound and out bound qualifiers can be used to specify a desired direction."
proto : 매칭을 특정 프로토콜에 한해서 수행한다. 가능한 프로토콜들은 ether, fddi, ip, arp, rarp, decnet, lat, sca, moprc, mopdl, tcp, udp이다. 만약 프로토콜이 명시되지 않았다면, 해당하는 값의 type에 관련된 모든 프로토콜들이 그 대상이 된다
위의 패턴을 따르지 않는 primitive : gateway, broadcast, less, greater, 산술식이 있으며 참고로 더 정교한 조건식을 사용하려면 'and(&&)','or(||)','not(!)'을 사용할 수 있다.

사용가능한 primitive들

dst host HOST => packet의 IP destination 항목이 HOST일때 참이 된다.
src host HOST => packet의 IP source 항목이 HOST일때 참이 된다.
host HOST => IP source, IP destination 항목 중 어느 하나라도 HOST이면 참이다.
ether dst ehost => ethernet destination 주소가 ehost일 때 참이다.
ether src ehost => ethernet source 주소가 ehost일 때 참이다.
ether host ehost => ethernet source, destination 항목들 중 어느 하나라도 ehost이면 참이다.
gateway host => 패킷이 host를 게이트웨이로 사용하면 참이다.
- 이 말의 의미는 ethernet sour ce나 destination 항목은 host이지만, IP source와 destination은 host가 아닐 때를 말한다.
dst net NET => 패킷의 IP destination 주소가 NET의 network number를 가지고 있을 때 참이다.
src net NET => 패킷의 IP source 주소가 NET의 network number를 가지고 있을 때 참이다.
net NET => 패킷의 IP source 주소 혹은 destination 주소가 NET의 network number를 가 지고 있을 때 참이다.
net netmask mask => IP 어드레스가 지정된 netmask를 통해서 net과 매칭되면 참이다.
net net/len => IP 어드레스가 netmask와 len 비트만큼 매치되면 참이다.
dst port PORT => 패킷이 ip/tcp, ip/udp 프로토콜의 패킷이고 destination port의 값이 PORT일 때 참이다.
src port PORT => 패킷의 source port의 값으로 PORT를 가지면 참이다.
port PORT => 패킷의 source, destination port 중에 하나라도 PORT이면 참이다.
less length => 패킷이 length보다 짧거나 같으면 참이다.(len <= length)
greater length => 패킷이 length보다 짧거나 같으면 참이다.(len >= length)
ip proto protocol => 패킷이 지정된 종류의 프로토콜의 ip패킷이면 참이다.
- Protocol은 icmp, igrp, udp, nd, tcp 중의 하나 혹은 몇 개가 될 수 있다. 주의할 점은 tcp, udp, icmp들은 '\'로 escape되어야 한다.
ehter broadcast => 패킷이 ethernet broadcast 패킷이라면 참이다. ehter는 생략 가능하다.
ip broadcast => 패킷이 IP broadcast 패킷이라면 참이다.
ether multicast => 패킷이 IP multicast 패킷이라면 참이다.
ether proto protocol => 패킷 이 ether type의 protocol이라면 참이다.
- protocol은 ip, arp, rarp 중에 하나 혹은 몇개가 될 수 있다. ip proto protocol에서와 마찬가지로 ip, arp, rarp는 escape 되어야 한다.
decnet src host => 만약 DECNET의 source address가 host이면 참이다.
이 어드레스는 '10.123'이 나 DECNET의 host name일 수 있다. DECNET host name은 DECNET에서 돌아가도록 설정된 Ultrix 시스템에서만 사용 가능하다.
decnet dst host => DECNET destination address가 host이면 참이다.
decnet host HOST => DECNET source, destination address중의 하나라도 HOST이면 참이다.
ip, arp, rarp, decnet => ether proto [ip|arp|rarp|decnet]의 약어
lat, moprc, mopdl => ether proto [lat|moprc|mopdl]의 약어
tcp, udp, icmp => ip proto [tcp|udp|icmp]의 약어
expr relop expr
- EXPR
- proto [expr:size]의 형식을 띤다. proto, expr, size에 올 수 있는 것들은 다음과 같다.
  - proto : ether, fddi, ip, arp, rarp, tcp, udp, icmp
  - expr : indicate Byte offset of packet of proto
  - size : optional. indicate the size of bytes in field of interest
  - default is one, and can be two or four
- RELOP
  - !=, =, <=, >=, etc.

이 조건식을 사용하기 위해서는 먼저 해당하는 Protocol(proto)의 헤더에 관련된 것들을 자세히 알아야만 한다. proto에는 대상이 될 프로토콜을 지정한다. expr에는 프로토콜 헤더의 처음부터의 Byte Offset을 지정하는 식이 들어가게 된다. Size는 Option이며 지정이 안 되어 있을 경우에는 자동으로 1byte를 지칭한다. 따라서 이 조건식을 사용하게 되면 헤더에 포함된 정보를 Bitmask를 사용하여 직 접 원하는 패킷인지를 가려낼 수 있기 때문에, 보다 정밀한 사용이 가능하게 된다.

TCPDUMP 사용 예제

security라는 호스트로부터 날아오고, 날아가는 패킷들을 출력 # tcpdump host security
security와 mazinga, getarobo 사이에 날아다니고 있는 패킷들을 출력 # tcpdump host security and \( mazinga or getarobo \)
security에서 elgaim을 제외한 모든 호스트로 날아다니는 IP 패킷들을 출력 # tcpdump ip host security and not elgaim
gateway amurorei를 거치는 ftp에 관련된 패킷들을 출력 # tcpdump 'gateway amurorei and ( port ftp or ftp-data )'
local호스트가 아닌 호스트와 로컬호스트가 맺는 TCP 커넥션의 시작과 마지막 패 킷들을 출력한다(SYN, FIN 패킷). # tcpdump 'tcp[13] & 3 != 0 and not src and dst net non-local'
gateway amurorei를 지나는 576Byte보다 큰 패킷들을 출력한다 # tcpdump 'gateway amurorei and ip[2:2] > 576'
Ethernet boradcast 혹은 multicast를 통해서 보내진 것이 아닌, IP broadcast 혹 은 multicast 패킷들을 출력한다. # tcpdump 'ehter[0] & 1 = 0 and ip[16] >= 224'
Echo request/reply가 아닌 ICMP 패킷들을 모두 출력한다. # tcpdump 'icmp[0] != 8 and icmp[0] != 0'

mytcpdump 예제

출처 : http://www.awarenetwork.org/home/iqlord/exploits/collection/knu.c [mytcpdump]

Pcap 라이브러리

pacp_open_live() : 네트워크 디바이스 열기

pcap_t *pcap_open_live(char *device, int snaplen, int promisc, int to_ms, char *ebuf)

device : 디바이스 이름 (eth0, hme0)
snplen : 한번에 캡쳐할 크기 지정
promisc : 캡쳐할 대상
- 0 : 목적지가 자신, 브로드 캐스트, 자신포함한 멀티 캐스트
- 1 : 모든 패킷
to_ms : 버퍼링 시간, 패킷 도착후 OS가 처리 대기 시간
- 0 : 충분히 패킷 도착 할떄 까지 대기
ebuf : 에러 발생시 원인 저장

성공시 pcap_t 타입의 디바이스 디스크립터, 실패시 null

pcap_lookupdev() : 패킷 캡쳐 할수 있는 디바이스 찾기

char *pcap_lookupdev (char *ebuf);

ebuf : 에러 발생시 원인 저장

성공시 디바이스 이름 반환

pcap_loop() : 패킷 캡쳐 함수 (pcap_dispatch와 비슷)

int pcap_loop(pcap_t *p, int maxcnt, pcap_handler callback, u_char *args);

*p : pcap 디스크립터
maxcnt : 캡쳐할 최대 수
callback : 패킷 읽어 드린후 처리 하기 위해 내부적으로 호출하는 콜백 함수
args : callback 함수의 인자

callback 함수의 사용 문법

void (*pcap_handler)(u_char *args, const struct pcap_pkthdr *, const u_char *packet);

args : pcap_loop()에서 넘겨 받은 인자
pcap_pkthdr : 캡쳐한 패킷의 길이나 시간 관련 정보

struct pcap_pkthdr {
         struct timeval ts;      /* time stamp */
         bpf_u_int32 caplen;     /* length of portion present */
         bpf_u_int32 len;        /* length this packet (off wire) */
};

packet : 캡쳐된 데이터의 첫 부분을 가르키는 포인터

참고 : 옵션 처리 함수 getopt

The getopt and getopt_long functions automate some of the chore involved in parsing typical unix command line options.

한글 설명 : http://man.kldp.org/wiki/ManPage/getopt.3

[mytcpdump]

Mon, 01 Oct 2007 18:43:28 +0900

/* konewka network utility.

* mytcpdump engine. home use only.

* tested against Linux 2.4.

*/

#include <stdio.h>

#include <sys/socket.h>

#include <sys/types.h>

#include <netinet/ip.h>

#include <netinet/tcp.h>

#include <netinet/in.h>

#include <netinet/ip.h>

#include <sys/ioctl.h>

#include <linux/if.h>

#include <string.h>

#include <time.h>

#include <stdlib.h>

#include <arpa/inet.h>

#include <unistd.h>

#include <netdb.h>

#include <signal.h>



#define VER "0.3"

#define BUF_SIZE 4096



#define IPHDRSIZE (sizeof(struct iphdr))

#define TCPHDRSIZE (sizeof(struct tcphdr))



void usage(u_char *prog);

void packetdump(u_char* pkt, u_int plen);

char *nat_detect(ulong src, ushort ttl);

char *ip2host(ulong ip);

int promisc(u_char *ifname, ushort set);

int printhdr(u_char* packet);

void printdate(void);

void die();



struct nat {

    ulong ip[100];

    ushort ttl[100];

};



struct in_addr ia;

struct nat masq;

u_char *dev = "lo";

u_int sd = 0,

    count = 0,

    pdump = 0, 

    resolve = 0,

    cpos = 0,

    syn_mode = 0;



int main(int argc, char *argv[]) {

    u_int opt, i;

    u_char packet[BUF_SIZE], prompt[] = "konewka network utility";



    signal(SIGINT, die);

    signal(SIGTERM, die);

    signal(SIGKILL, die);

    signal(SIGQUIT, die);

    signal(SIGSEGV, die);

    signal(SIGHUP, SIG_IGN);

    

    fprintf(stdout, "%s ver. %s -- http://www.olek.org/\n", prompt, VER);

    for (i=0;i<(strlen(prompt)+30+strlen(VER));i++) putchar('-');

    putchar('\n');

 

    while ((opt = getopt(argc, argv, "i:rhSX")) != EOF) {

    switch (opt) {

 case 'r':

     resolve = 1;

      break;

        case 'i':

     dev = optarg;

     break;

        case 'X':

     pdump = 1;

        break;

        case 'S':

     syn_mode = 1;

     break;

        case 'h':

     usage(argv[0]);

           break;

        default:

      usage(argv[0]);

           break;

        }

    }



    if (getuid()) {

       fprintf(stdout, "knu: need euid=0, got %d\n", geteuid());

 return -1; }



    if ((sd = socket(PF_INET, SOCK_RAW, IPPROTO_TCP)) < 0) {

   fprintf(stderr, "knu: can't create raw socket.\n");

       return -1; }

    

    if (promisc(dev, 1) < 0) {

     fprintf(stderr, "knu: can't set promicuous mode.\n");

     return -1; }



    fprintf(stdout, "knu: %s entered promiscuous mode.\n", dev);



    while (1) {

       memset(packet, '\0', sizeof(packet));

     recvfrom(sd, packet, sizeof(packet), 0, NULL, 0);

 printhdr(packet);

    }

return 0; 

}



void usage(u_char *prog) {

    fprintf(stdout, "usage: %s [ -rhpSX ] [ -i device ]\n", prog);

    fprintf(stdout, "  -r\tresolve host names (not recommended)\n");

    fprintf(stdout, "  -X\tfull packet dump\n");

    fprintf(stdout, "  -S\tgo into SYN mode\n");

    fprintf(stdout, "  -h\tthis message\n");

    exit(0); 

}



void packetdump(u_char* pkt, u_int plen) {

    u_int i;

    u_char buff[17];

    u_char *ptr = buff;

    

    for (i=0;i<plen;i++) {

   u_char ppkt = *pkt++;

     if (!(i%16))

          printf(" (0x%02x) ", i); /* calosc */

 printf("%02x ", ppkt); /* hex */



    *ptr++ = isprint(ppkt) ? ppkt : '.';

      if (!((i+1)%16)) {

            *ptr = 0;

         printf(" %s\n", (ptr=buff));

  }

    }

    

    if (plen%16) {

    *ptr = 0;

 while(plen++%16)

      printf("   ");

        printf(" %s\n", buff);

    }

    putchar('\n');

}



char *ip2host(ulong ip) {

    static struct hostent *hp;

    static char blah[1024];

 

    ia.s_addr = ip;

    hp = gethostbyaddr((char *)&ia, sizeof(struct in_addr), AF_INET);

    if (!hp) strcpy(blah, inet_ntoa(ia));

    else strcpy(blah, hp->h_name);

 

    return (blah);

}



int promisc(u_char *ifname, ushort set) {

    struct ifreq ifr;



    memset(&ifr, 0, sizeof(ifr));

    strcpy(ifr.ifr_name, ifname);

    if (ioctl(sd, SIOCGIFFLAGS, &ifr) < 0)

  return -1;

    

    if (set) {

  ifr.ifr_flags |= IFF_PROMISC;

     if (ioctl(sd, SIOCSIFFLAGS, &ifr) < 0)

         return -1;

    }

    else {

 ifr.ifr_flags &= ~IFF_PROMISC;

        if (ioctl(sd, SIOCSIFFLAGS, &ifr) < 0)

         return -1;

    }



    return 0;

}



void die() {

    fprintf(stdout, "(%d packets read)\n", count);

    if (promisc(dev, 0) < 0)

    fprintf(stderr, "knu: error, can't left promisc mode.\n");

    else

  fprintf(stderr, "knu: %s left promiscuous mode.\n", dev);

    close(sd);

    exit(0);

}



char *nat_detect(ulong src, ushort ttl) {

    u_int i, tmp;

    

    for (i=0;i<=cpos;i++) {

  if (masq.ip[i] == src) {

      tmp = masq.ttl[i] - ttl;

          if (tmp < 0)

               tmp = ttl - masq.ttl[i];

      if (tmp > 0 && tmp <= 3)

                return " (NAT)";

      else if (!tmp)

                return "";

            else if (tmp >= 4)

         return "";

        }

    }

    

    if ((cpos++) == 100)

      cpos = 0;



    masq.ttl[cpos] = ttl;

    masq.ip[cpos] = src;

    return "";

}



int printhdr(u_char* packet) {

    struct iphdr *ip;

    struct tcphdr *tcp;

    u_int hops;

    

    ip = (struct iphdr *)packet;

    tcp = (struct tcphdr *)(packet + IPHDRSIZE);

    

    if (syn_mode && !tcp->syn)

     return 0;

    

    printdate();

    

    ia.s_addr = ip->saddr;

    fprintf(stdout, " %s:%d -> ", (resolve == 1) ? 

    ip2host(ip->saddr) : inet_ntoa(ia), ntohs(tcp->source));

    

    ia.s_addr = ip->daddr;

    fprintf(stdout, "%s:%d", (resolve == 1) ?

    ip2host(ip->daddr) : inet_ntoa(ia), ntohs(tcp->dest));

    

    if (ip->ttl <= 32)

      hops = 32 - ip->ttl;

    else if (ip->ttl > 32 && ip->ttl <= 64)

      hops = 64 - ip->ttl;

    else if (ip->ttl > 64 && ip->ttl <= 128)

     hops = 128 - ip->ttl;

    else if (ip->ttl > 128 && ip->ttl <= 255)

   hops = 255 - ip->ttl;

        

    /* NAT */

    if (ip->saddr != ip->daddr || !tcp->window)

   printf("%s", nat_detect(htonl(ip->saddr), hops));

    

    /* XMAS, NULL scanning detect */

    if (tcp->urg && tcp->psh && tcp->fin)

  fprintf(stdout, " (XMAS scan)\n");

    else if (!tcp->ack && !tcp->urg && !tcp->psh && !tcp->fin && !tcp->syn && !tcp->rst)

        fprintf(stdout, " (NULL scan)\n");

    else

  putchar('\n');

    

    /* tcp flags */

    fprintf(stdout, "\t%c%c%c%c%c%c",

    (tcp->urg == 1) ? 'U' : '.',

    (tcp->fin == 1) ? 'F' : '.', 

    (tcp->ack == 1) ? 'A' : '.', 

    (tcp->psh == 1) ? 'P' : '.', 

    (tcp->rst == 1) ? 'R' : '.', 

    (tcp->syn == 1) ? 'S' : '.');

    

    /* ttl, win, id .. */

    fprintf(stdout, " (ttl %d, id %d, win %d, len %d)", ip->ttl, ntohs(ip->id), 

    ntohs(tcp->window), ntohs(ip->tot_len));

    

    /* fragment bit */

    if (htons(ip->frag_off) == IP_DF)

  fprintf(stdout, " (DF)");

    

    /* show the distance betwen dst and src host */

    fprintf(stdout, " distance: %d hops", hops);



    putchar('\n');

        

    /* packet dump ? */

    if (pdump)

   packetdump(packet, htons(ip->tot_len));

    

    ++count;

}



void printdate(void) {

    u_char *buff;

    time_t now = time(NULL);

    

    buff = ctime((const time_t *)&now);

    buff[strlen(buff)-1] = '\0';

    fprintf(stdout, "<%s>", buff);

}

[세미나] KIDS

Fri, 17 Aug 2007 03:18:25 +0900

개요^#

리눅스 네트워크 아키텍쳐나 리눅스 커널의 동적으로 확장 가능한 기능들을 살펴 보겠다 .

동적 확장 가능한 기능에 대한 일반적 접근
KIDS를 사용하여 어떻게 확장 가능 기능들을 관리 하는지 언급
KIDS 구성 요소들이 embedded되었는지 언급
캐릭터 기반 장비들을 사용하용하여 KIDS 시스템을 설정

1. Managing Dynamically extendable function^#

리눅스 네트워크 아키텍쳐는 매순간 변화 & 발전 중이다.
대부분 경우 이런 확장은 동적(Runtime)으로도 발생한다.
ex) 네트워크 레이어, 전송 레이어, 패킷 필터
이런 확장을 관리 하기 위해서 우리에게 필요한것은 적용된 기능들을 감시할 적절한 인터페이스와 구조체이다.
아래의 함수들은 새 기능들을 커널에 등록할때 동작중인 기능들을 제거 할때 사용된다.

register_functionality() : 새 기능을 추가
unregister functionlity() : 기존 기능 빼기

위 함수 실행시 초기화 과정및 clean up단계 필요

ex) 해당 기능을 다른 곳에서 사용중인지 확인(Reference count == 0)후 unregistering

등록 작업 순서

추가할 새로운 기능의 관리 구조체를 리스트, 해쉬테이블 또는 다른 관리 구조체에 저장하기
이런 관리 구조체 저장에 필요로 하는 메모리 공간 예약 하거나 필요한 다른 자원을 호출한다.
Reference Counter값을 증가 시킨다.
Proc 디렉토리에 엔트리를 생성한다
상태 메시지를 출력하기 위하여 printk()를 사용한다

새 기능 추가시 많은 설정 정보가 필요하다..이들을 모두를 파라미터로 넘기기에는 무리가 있으므로 [관리 구조체]를 생성후 사용한다.
- 이러한 관리 구조체를 이용한 정보 넘기기 방식을 사용하면 등록후에 해당 기능과 파라미터에 접근할수 있다.
- 관리 구조체 : 레지스터링시 필요한 파라미터 저장 (ex: net_device, packet_type)
  - 저장후 포인터를 registeration 함수에게 전달
  - 관리 구조체의 요소들은 작업에 따라 크게 2개로 구분
    - 설정 데이터 : 기능 추가 전에 정해 지고 난후 관리 구조체로 전달
    - Runtime variables : 기능 추가 전에는 정해지지 않음 , 기능 사용중에 요청함

2. Structure of the KIDS construction system^#

이장에서는 KIDS프레임 워크가 어떻게 리눅스에 구현되는지 살펴 보겠다.

KIDS 는 Karlsruhe Implementation architecture of Differentiated Services의 약어이다.

구성 요소들은 Object-Oriented Concept의 특성을 가진다
QoS 메커니즘을 네트워크 상에서 디자인, 평가, 사용을 목적으로 계발
KIDS는 QoS 메커니즘의 구조및 상호 연동성을 설명한 축약 모델이다.
또한 여러 QoS 정책(Behavior)을 독립적으로 정의 할수도 있게 한다.
여러 플랫폼에 적용 가능 (Unix, OMNET++ 시뮬레이션 툴)

위의 특징들로 인하여 이미 개발된 많은 QoS 기술들과의 차이점을 지닌다.

2.1 Elementary QoS Components

KIDS는 개별적인 QoS메커니즘에 구현 가능한 프레임 워크 생성시 유연성, 확장성, 모듈화 가능하도록 디자인 되었다.
- 이는 QoS 메커니즘에 적용되는 컨포먼트들의 사용에 달려 있다.
컨포넌트들의 손쉬운 조합과 ensuring all potential degrees of freedom 이 KIDS의 KIDS 디자인의 가장 중요한 요소이다.
KIDS는 일종의 레고 장남감과 비슷하다.
- 이때 장난감 블록은 서로 다른 인터페이스를 가진 컨포넌트라고 볼수 있다.
- 같은 인터페이스를 가진 컨포넌트들은 서로 연결되어 QoS메터니즘을 생성 할수 있다.

두 종류의 컨포넌트들 (인터페이스기준 )

Packet interface (네모): 컴포넌트는 패킷 아웃풋 X(인터페이스)를 받은 메시지를 다른 컨포넌트에게 전달시 사용된다. 편의상 KIDS 컨포넌트는 하나의 인풋만을 가지고 있다.

message interface (동글): 컴포넌트는 메시지 아웃풋 X(인터페이스)를 나중의 패킷을 요청시 메시지를 다른 컨포넌트에게 전달시 사용하다.

위 중 종류의 인터페이스 타입을 이용하여서 5개의 컨포넌트 클래스를 나눌수 있다. (QoS 메커니즘은 이런 클래스의 조합으로 이루어 진다)

Operative components(BHVR) : 패킷 상에서 동작 한다. 패킷 수신후 정해진 알고리즘을 패킷에 적용시킨다.
- Examples: Token Bucket, Shaper, Marker, Dropper, Classifier, Random Early Detection (RED)

Queue Components(QUEUE) : 컴포넌트가 패킷을 큐에 넣거나 뺄때 사용되는 데이터 구조체
- Examples: FIFO Queue, Earliest-Deadline-First-Queue

Enqueuing Components (ENQ_BHVR) : 주어진 방법에 따라 패킷을 큐에 넣는다.
- Examples: Head-Enqueue, Tail-Enqueue, EDF-Enqueue.

Dequeuing components (DEQ_BHVR) : 주어진 방법에 따라 패킷을 큐에서 빼낸다. 이때 dequeue 요청은 메시지 input을 통해 수신후, 요청이 적절하다면 패킷은 패킷 output을 통해 이동하나.
- Examples: Head-Dequeue, Tail-Dequeue

Strategic components (DEQ_DISC) : 큐와 유연하게 연동될수 있는 정책(Strategic)을 구현하다.
- Examples: Priority Queuing, Weighted Fair Queuing, Round Robin.

<Figure 22-2. Five different KIDS component classes.>

2.2 Hooks

3. Using the KIDS example to extend the linux network architecture

이전장에서는 KIDS 프레임워크의 구성에 대하여 설명 하였다.
이번장에서는 KIDS를 리눅스 커널에 구현함으로써 어떻게 기능 확장이 가능한지를 예시 삼아 설명 하도록 하겠다. (특히, 컴포넌트의 디자인및 관리
- 컨포넌트를 어떻게 디자인 하는가?
- 컨포넌트를 왜 디자인 하는가?
- 컨포넌트를 Runtime시점에 어떻게 커널에게 연결(Introduce) 시키는가?
- Hook를 서로다른 커널 인터페이스에게 구현하는가?
  - 이 말은 커널을 바꾸지 않고도 KIDS를 추가 할수 있다는 것이다.

3.1 Conponents and Their instances^#

KIDS의 Conponent concept상 두 분류로 구성되어 있다.
- Components
  - 특별 목적(Behavoir)를 하는 QoS메커니즘
  - Linux KIDS의 bhvr_type 구조체의 관리를 받음 (이 구조체 안에는 컴포넌트의 모든 속성이 들어 있음)
- Component instances
  - 컴포넌트의 인스턴스가 필요시 생성
  - 이때문에 bhvr 타입의 구조체를 생성하여야 한다. (이 구조체 안에는component instance의 모든 속성이 들어 있음)
  - Instance는 component의 행동 양식(Behavior)를 저장, 따라서 컴포넌트의 bhvr_type구조체를 참조 하고있다.

struct bhvr_type
{
   char              name[STRLEN];   //컴포넌트 이름 (ex: Token_Bucket)
   unsigned int      bhvr_class_id; //컴포넌트의 클래스(ex: BHVR_ID, ENQ_BHVR_ID, DEQ_BHVR_ID, DEQ_DISC_ID, and QUEUE_ID)
   unsigned long     private_data_size; //각 컴포넌트 인스턴스의 bhvr 구조체에서 사용되는 private data 구조체의 크기 지정
   unsigned int      instances; //컴포넌트에서 생성된 인스턴스 관리 (ex : 0일 경우 컴포넌트가 커널에서 삭제 되었음을 의미)
   struct bhvr_type *next; // bhvr_type_list의 해당하는 bhvr_type 구조체로의 링크
   int               (*func) (struct bhvr *, struct sk_buff *); //컴포넌트의 인스턴스에게 패킷 전달시 실행 되는 함수
   struct sk_buff*   (*deq_func) (struct bhvr *); // dequeuing & strategic 컴포넌트
// 구현된 메시지 인터페이스와 연관성 지님, 컴포넌트의 인스턴스가 패킷을 요청시 호출된다.
// 컴포넌트는 두개의 함수중 하나를 구현한다.(fucn = 패킷 인터페이스 인풋 소유, deq_func= 메시지 인터페이스소유)
   int               (*constructor) (struct bhvr *bhvr, char * data, int flag); //bhvr인스턴스가 초기화 되거나 설정이 변경시 호출
   int               (*destructor) (struct bhvr *bhvr); //bhvr 인스턴스 삭제시 호출
   struct bhvr*      (*get_bhvr) (struct bhvr *bhvr, char * port); //컴포넌트 인스턴스의 bhvr 구조체의 주소를 알아 오기위해 KIDS가 호출
   int               (*append_bhvr) (struct bhvr *new_bhvr, struct bhvr *old_bhvr, char *port);
// 아웃풋으로써 현재 컨포넌트 인스턴스(=old_bhvr)을 새 컨포넌트 인스턴스로 연결(=new_bhvr)
int (*proc) (struct bhvr *bhvr, char *ptr, int layer); //bhvr 컨포넌트 인스턴스의 정보 생성
//대부분 proc 파일의 output이다
int (*get_config) (struct bhvr *bhvr, char *ptr); // KIDS 설정신텍스에 맞추어서 bhvr 컨포넌트 인스턴스의 설정 정보를 ptr버퍼공간에 쓸때 호출
};

struct bhvr
{
char name[STRLEN]; //현 인스턴스의 이름 (ex : tb0, marker1)
unsigned int use_counter; // 현 bhvr 구조체의 레퍼런스 횟수
struct bhvr *next_bhvr; // bhvr_list에 있는 bhvr 데이터 구조체의 링크, 컴포넌트 탐색시 사용됨
struct bhvr_type *bhvr_type; // bhvr_ype 구조체에 정의 되어 있는 컴포넌트 인스턴스의 특정 작업(behavior)의 주소
char bhvr_data[0]; // private 정보를 위해 공간 확보용 (Place holder)
};

Using the token - Bucjet component as an example for a private data structure^#

bhvr_data 구조체의 private 정보(bhvr_data)를 저장하고 있는건 중요하다.
특정 컨포넌트 인스턴스의 상태나 설정에 관련된 정보는 bhvr 구조체의 Private data 구조체 안에서 인스턴스 그 자체로써 관리 된다.

다음은 Token_Bucket 컨포넌트의 private data 구조체를 가르킨다.

struct tb_data
{
   unsigned int     rate, bucket_size;
   unsigned long    token, packets_arvd, packets_in, packets_out;
   CPU_STAMP        last_arvl, cycles_per_byte;
   struct bhvr      *enough_token_bhvr;
   struct bhvr      *not_enough_token_bhvr;
   int              (*enough_token_func) (struct bhvr *, struct sk_buff *);
   int              (*not_enough_token_func) (struct bhvr *, struct sk_buff *);
};

위의 Private data 구조체의 각 변수 들은 세개의 그룹으로 나누어 질수 있다.

파라미터 & 변수 : 컨포넌트의 변수들은 컨포넌트에 구현된 알고리즘에 따라 각각 독립적이다. 이것때문에 변수들은 컨포넌트의 Private data 구조체로 관리 되어야 한다.
Func()함수나 deq_func()함수의 포인터 정보(function pointer)
bhvr_strucuture의 주소(reference)

Private information은 각 컨포넌트 output에 대하여 (2),(3)의 요소들을 관리 한다. 그이유는 아웃풋의 갯수 또한 각 컨포넌트마다 다르고, bhvr_type 구조체에 넣어서 관리 할수 없기 때문이다.

3.2 Registering and Managing Components^#

bhvr_type_list : resistered componenrs 관리

[등록 작업] : QoS메커니즘을 적용시키기 위해 Linux KIDS를 사용하

선행 작업 : 커널에게 어떤 component가 현재 사용 가능한지 알려 주어야 함
- 이를 위해 Linux KIDS는 bhvr_type_list를 유지 하야 등록된 모든 컨포넌트를 관리
- bhvr_type_list는 vhbr_type 데이터 구조체에 각각 연결 되어 있다.
등록 함수 호출 : register_bhvr_type함수를 이용하여서 bhvr_type구조체에 정의되어 있는 컴포넌트들을 등록
- 이 말은 bhvr_type구조체가 bhvr_type_list에 들어 가게 되면, 그때부터 해당 컴포턴트를 커널을 인식할수 있고, 사용자는 해당 컴포넌트의 인스턴스를 생성할수 있다.

[해지 작업]

해지 함수 호출 : unregister_bhv_type함수를 이용하여서 컴포넌트를 리스트에서 등록해지
- 물론 등록 해지 전에는 해당 컴포넌트와 관련된 인스턴스 들이 남아 있으면 안된다.

Linux KIDS는 동적으로 기능들을 등록 및 해지 하기 위하여 두개의 요소들을 추가적으로 가지고 있다.
- Hooks
  - hook 구조체에 위하여 정의 되어 있다.
  - 등록 : register_hook()
  - 해지 : unregister_hook()
  - 만약 프로토콜 인스턴스가 hook지원을 원한다면 적절한 hook 구조체 생성후 hook를 등록하게 된다. 추가적으로 컨포넌트들은 해당 hook에 추가되게 된다.
  - 이후 컨포넌트들은 이 hook를 참조 할수 있다.
- queue categories
  - kids_queue_type 구조체에 의하여 관리 되어 진다.
  - 등록 : register_queue_type()
  - 해지 : unregister_queue_type()
  - queue variant의 인스턴스들은 kids_queue구조체에 정의 되어 있다.
  - 큐 관리는 컨포넌트 카테고리와 거의 흡사하다. 하지만 컴포넌트와 큐는 다른것이므로 서로 독립적으로 관리 되어야 한다.

3.3 Managing Component Instances^#

본장에서는 컨포넌트의 인스턴스 들을 어떻게 생성, 삭제, 링킹등의 관리를 하는지 살펴 보겠다.

[개요]

가능한 쉽게 QoS메커니즘을 관리 하기 위하여 별도의 신택스가 개발 되었다.
캐릭터 기반 장비(dev/kids)은 설정 명령어들 Linux KIDS에게 전달 할수 있다.
- 이떄 사용되는 함수 : create_bhvr(), remove_vhbr(), change_bhvr()

create_bhvr(type,name, data, id)

컴포넌트(name)의 인스턴스 생성시 사용
- 해당 컴포넌트는 bhvr_type_list(등록된 컴포넌트 리스트)에 이미 존재 하여야 함

새 컴포턴드 인스턴스를 위한 메모리 공간이 예약됨 (메모리 공간 = bhvr 구조체_모든 컴포넌트와 동일+private data 구조체_각 컴포넌트마다 다름 )
bhvr 구조체 초기화
컴포넌트의 constructor 호출 (private date공간을 컴포넌트의 설정 파라미터로 채우기), 설정 파라미터들은 CREATE명령어를 통해 추출된후 데이터 캐릭터 스트링으로 전달된다. 한번 생성된 후에는 컴포턴트들은 다른 컨포넌트들과 연결되지 않는다.
bhvr_list에 등록된다.

remove_bhvr(name, force)

name에 정의된 컴포넌트 인스터스를 삭제 하고 bhvr_list에서 제거 한다.
force는 인스턴스의 user_counter가 무시 되어야 한다는 점을 알릴때 사용된다.
데이터 구조체가 release될때 컴포넌트의 destructor이 호출되어 자원을 release한다.

change_bhvr(name, data)

runtime시의 컴포넌트 인스턴스의 private data를 바꾸는데 사용된다.
INIT_BHVR플래그가 설정지 않는다
Constructor는 파라미터에서 지정한 것들만 바꾼다, 그렇지 않을경우에는 모든 인스턴스 들이 초기화 된다.

3.4 Implementating Hooks^#

Hooks는 기존의 프로토콜 인스턴스의 확장기능으로써 사용자가 쉽게 KIDS 프레임 워크의 규칙에 기반한 QoS컨포넌트들을 embed할수 있도록 한다.
중요한 요소중 하나는 hook를 통해 확장하고자 하는 위치 설정이다.(프로토콜 인스턴스의 프로세스 안에서)
- 그 이유는 사용자는 항상 특정 양의 패킷들과 특정 위치를 지정하기 떄문이다.
  - ex) IP_FORWARD hook지점에서의 모든 패킷 포워딩 , IP_LOCAL_DELIVER hook지점에서의 IP인스턴스의 모든 패킷은 내부(locally)로 전달
다른 인터페이스마다의 설정의 이점으로 리눅스네트워크 아키텍쳐는 프로토콜 인스턴스를 기능에 따라 확장할수 있도록 방법을 기본적으로 제공한다.
이러한 인터페이스들은 KIDS에서도 사용된다. 따라서 별도의 소스코드 수정 없이도 리눅스에 그대로 사용가능하다.
IP인스턴스를 위한 hook는 넷필터 인터페이스에 기반을 두고 있다.
Data-link 계층 hook는 트래픽 컨트롤 인터페이스에 기반을 두고 있다.

추가적인 hooks는 runtime일때라도 쉽게 통합될수있다.
1. hook를 통합하기 위해서는 hook데이터 구조체에서 요구하는 관련 정보들을 저장
2. register_hook()를 이용하여서 등록 한다.
확장하고자 하는 프로토콜 인스턴스 들은 함수 호출을 통하여 쉽게 확장 가능한다

3.5 How a Component works^#

커널에 일단 KIDS 프레임워크의 모든 컴포넌트들을 등록
컨포넌트 체인을 생성후, 컨포넌트가 hook를 참조하게 함
컨포넌트들을 동작 시켜야 하는지에 대한 설명이 필요 <- 이장의 주제

token_bucket_func()

int token_bucket_func(struct bhvr *tb_bhvr, struct sk_buff *skb)
{
   struct tb_data *data = (struct tb_data *) &(tb_bhvr->bhvr_data);
   CPU_STAMP       now;

   data->packets_arvd++;
   TAKE_TIME(now);
   /* calcs the tokens, that are produced since the last packet arrival */
   (unsigned long) data->token += (((unsigned long) (now - data->last_arvl)) /
                                        (unsigned long) data->cycles_per_byte);
   /* check, if the bucket is overflood */
   if (data->token > data->bucket_size)
      data->token = data->bucket_size;
   data->last_arvl = now;
   /* check, if there are enough tokens to send the packet */
   if (data->token < skb->len)
   {   /* not enough tokens -> out of profile */
       data->packets_out++;
       /* forward the packet to the next behavior (out-of-profile) */
       if ((data->not_enough_token_bhvr) && (data->not_enough_token_func))
          return data->not_enough_token_func(data->not_enough_token_bhvr, skb);
   }
   else
   {   /* enough tokens -> in profile */
       data->token -= skb->len;
       data->packets_in++;
       /* forward the packet to the next behavior (in-profile) */
       if ((data->enough_token_bhvr ) && (data->enough_token_func))
          return data->enough_token_func(data->enough_token_bhvr, skb);
   }
   return KIDS_ACCEPT; /* Do not discard packet, when no behavior is attached */
}

Token_Bucket 컨포넌트는 Operative 컨포넌트 클래스에 속한다.
- 즉, 하나의 패킷 인풋과 n개의 패킷 아웃풋을 가지고 있어야 한다.
  - ex) 2개의 아웃풋 : confirm & non_confirm

Token_Bucket 컨포넌트의 인스턴스가 패킷을 수신하게 되면 이와 연관된 func()핸들링 절차가 호출된다.
- 얻게 되는 파라미터들로는 socket buffer, skb, 컨포넌트 인스턴스의 데이터를 가르키는 포인터 정보들이 있다.

[ 순서 ]

처음에, 인스턴스의 private data의 포인터는 type cast를 가르키는 이 포인터 안에서만 가르키도록 되어 있다.
함수가 완전히 reentrant되고 나면, 자신의 private data나 local 변수안에서만 작동하게 된다.
이어서 token bucket 알고리즘에 따라 일련의 계산 작업이 수행된다.
그리고 통계 변수의 정보들이 업데이트 된다.
1. 이러한 계산의 결과 값은 아웃풋을 결론짓게 되고 이 값을 통해 socket buffer의 포워딩시 이용된다.
만약 해당 아웃풋에 연관되는 인스턴스가 없을경우 함수는 KIDS_ACCEPT 결과값을 반환한다.
1. 이 뜻은 패킷이 hook에게로 포워딩되어야 한다
counterpart부분은 KIDS_DROP이다.
1. 이 부분은 hook에게 socket buffer을 드랍시키라고 한다.
하지만 컴포넌트 인스턴스가 지정된 output(data-> ..._bhvr != NULL)을 따르게 된다면
1. 인스턴스의 핸들링 절차(data->..._funv())가 호출된다.
2. 그리고 나서 이어지는 인스턴스의 데이터에 대한 포인터가 이 핸들러의 루틴으로 전달 된다.
이어지는 텀포넌트 인스터스의 반환값은 token-bucket 컨포넌트의 반환값으로 바로 사용되게 된다.