 Network에 대해 같이 알아가요~ by archan |
| 카테고리 |
| 이전블로그 |
| 이글루링크 |
| 최근 등록된 덧글 |
|
자기소개서는 특정한 기업의 입사를 위해 작성하는 일정한 의도를 가진 글이다. 따라서 구직자는 ‘셀링 포인트(selling point)’를 강조해야 한다. 회사에서 자신을 채용해야 하는 이유를 한마디로 설명해줘야 한다. 때문에 목표의식이 뚜렷해야 한다. 하고 싶은 일이 무엇인지 정하기 않고 단순히 ‘취업’ 그 자체가 목적인 경우, 아무리 성실히 자기소개서를 작성했다고 하더라도 ‘알맹이’없는 글이 되고 만다.
그러나 자기소개서에는 왕도가 없다. 100점 정답이라 할 수 있는 자기소개서는 없다는 것이다. 인사담당자의 주관에 따라 그 점수가 달라질 수 있기 때문이다. 다만 인사담당자의 눈길을 끌수 있어야 하며, 동감을 얻어낼 수 있어야 한다. 그러기 위해서는 ‘열심히 하겠다’는 판에 박힌 이야기는 안된다. 참신하며 구체적인 문장으로 표현해 줘야 한다. HR포털 인크루트(www.incruit.com 대표 이광석)의 도움을 받아 잘못 쓴 자기 소개서(샘플 A)와 잘쓴 자기소개서(샘플 B)를 함께 보며 비교해보겠다. <잘못되 예>의 자기소개서의 경우 내용 자체가 너무 평범하고 보편적인 내용이다. 지원하는 회사, 직종에 맞춰 자기소개서를 작성하지 않았고 본인의 독특한 경험사항을 바탕으로 구체적으로 기술하려는 노력의 흔적도 보이지 않는다. * 헤드라인을 달아라 자기소개서는 나를 팔기 위해 ‘나’라는 상품을 홍보하는 것이다. 따라서 인사담당자들의 관심을 끌기 위해서는 자신의 특성을 한눈에 파악할 수 있어야 한다. 자신만의 남다른 경험, 경력이 있어도 아무 특징 없이 단순 나열식으로 기술만 한다면 인사담당자는 지원자의 특성을 파악하지 못하고 보통의 지원자라고 속단한다. 따라서 기사 전체 내용을 파악할 수 있는 신문 기사 헤드라인처럼 자신의 능력과 경력, 자질 등을 인사담당자가 한눈에 파악할 수 있도록 간략한 문장이나 재치 있는 단어를 사용, 자기소개서 중간 중간에 헤드라인을 달아라. * 상상력이 아닌 손발로 찾아다니며 쓰라 최근 기업은 입사 즉시 업무에 투입할 수 있는 인재를 원한다. 따라서 인사담당자의 눈에 띄려면 기업에서 채용하려고 하는 해당 업무에 내가 최적의 인재임을 강조해야 한다. 아무리 많은 경력과 자격증을 갖고 있어도 지원하는 회사의 업무와 관련이 없다면 무용지물이다. 자신이 지원하는 업무와 관련 있는 자격증과 경력을 부각시켜라. 그러기 위해서는 회사에서 충원하고자 사람이 담당하는 일이 무엇인지 보다 구체적으로 파악해야 한다. 회사 홈페이지를 참조하거나 인맥을 동원해 해당 업무가 요구하는 스킬이 무엇인지 어떤 일들을 하게 되는지 조사해야 한다. 또는 회사 홈페이지 게시판을 통해 문의하거나 인사담당자가에게 직접 전화로 물어봄으로써 해당직에 대한 자신의 열의를 보여라. 그렇게 하면 파악한 업무 내용에 대해 구체적으로 자신이 ‘왜 해당 업무에 가장 적합한 사람인지’, ‘자신의 어떤 점이 장점으로 작용하는지’, ‘지원하는 동기와 앞으로 회사에 어떻게 기여할 수 있는지’ 등을 논리적으로 설명, 자신의 조건을 효과적으로 부각시킬 수 있다. # by archan | 2007/01/10 14:42 | 상식코너 | 트랙백 | 덧글(0)
Roll Your Own Firewall with Netfilter
By Victor Castro Created 2003-10-13 01:00 How to create a micro-firewall with kernel modules and packet filtering. Every self-respecting Linux guru should be familiar with firewalls and how to install and configure them. With this in mind, Linux gurus also should be curious about how firewalls function and how to build a firewall of his or her own. Explaining exactly these two things is the goal of this article. Here, we attempt to write a firewall in less than 60 lines of C code. As impossible as this may sound, it actually is quite simple to do using the power of Linux kernel modules and Netfilter. Netfilter is a packet filtering subsystem in the Linux kernel stack and has been there since kernel 2.4.x. Netfilter's core consists of five hook functions declared in linux/netfilter_ipv4.h. Although these functions are for IPv4, they aren't much different from those used in the IPv6 counterpart. The hooks are used to analyze packets in various locations on the network stack. This situation is depicted below: [INPUT]--->[1]--->[ROUTE]--->[3]--->[4]--->[OUTPUT] | ^ | | | [ROUTE] v | [2] [5] | ^ | | v | [INPUT*] [OUTPUT*] [1] NF_IP_PRE_ROUTING [2] NF_IP_LOCAL_IN [3] NF_IP_FORWARD [4] NF_IP_POST_ROUTING [5] NF_IP_LOCAL_OUT [*] Network Stack NF_IP_PRE_ROUTING is called right after the packet has been received. This is the hook we are most interested in for our micro-firewall. NF_IP_LOCAL_IN is used for packets that are destined for the network stack and thus has not been forwarded. NF_IP_FORWARD is for packets not addressed to us but that should be forwarded. NF_IP_POST_ROUTING is for packets that have been routed and are ready to leave, and NF_IP_LOCAL_OUT is for packets sent out from our own network stack. Each function has a chance to mangle or do what it wishes with the packets, but it eventually has to return a Netfilter code. Here are the codes that can be returned and what they mean: NF_ACCEPT: accept the packet (continue network stack trip) NF_DROP: drop the packet (don't continue trip) NF_REPEAT: repeat the hook function NF_STOLEN: hook steals the packet (don't continue trip) NF_QUEUE: queue the packet to userspace After we write our hook function, we have to register its options with the nf_hook_ops struct located in linux/netfilter.h. struct nf_hook_ops { struct list_head list; nf_hookfn *hook; int pf; int hooknum; int priority; }; The first thing we see in the struct is the list_head struct, which is used to keep a linked list of hooks, but it's not necessary for our firewall. The nf_hookfn* struct member is the name of the hook function that we define. The pf integer member is used to identify the protocol family; it's PF_INET for IPv4. The next field is the hooknum int, and this is for the hook we want to use. The last field is the priority int. The priorities are specified in linux/netfilter_ipv4.h, but for our situation we want NF_IP_PRI_FIRST. That's enough theory. No one has learned anything from theory alone, so let's learn by crawling into the trenches and writing our first module. Our module should block all traffic in and out of the network stack and should use the NF_IP_PRE_ROUTING and NF_IP_POST_ROUTING hooks. We start by defining our hook function and registering the nf_hook_ops structs in init_module(). Finally, we unregister the hooks in cleanup(). #define __KERNEL__ #define MODULE #include <linux/kernel.h> #include <linux/module.h> #include <linux/netfilter.h> #include <linux/netfilter_ipv4.h> static struct nf_hook_ops netfilter_ops_in; /* NF_IP_PRE_ROUTING */ static struct nf_hook_ops netfilter_ops_out; /* NF_IP_POST_ROUTING */ /* Function prototype in <linux/netfilter> */ unsigned int main_hook(unsigned int hooknum, struct sk_buff **skb, const struct net_device *in, const struct net_device *out, int (*okfn)(struct sk_buff*)) { return NF_DROP; /* Drop ALL Packets */ } int init_module() { netfilter_ops_in.hook = main_hook; netfilter_ops_in.pf = PF_INET; netfilter_ops_in.hooknum = NF_IP_PRE_ROUTING; netfilter_ops_in.priority = NF_IP_PRI_FIRST; netfilter_ops_out.hook = main_hook; netfilter_ops_out.pf = PF_INET; netfilter_ops_out.hooknum = NF_IP_POST_ROUTING; netfilter_ops_out.priority = NF_IP_PRI_FIRST; nf_register_hook(&netfilter_ops_in); /* register NF_IP_PRE_ROUTING hook */ nf_register_hook(&netfilter_ops_out); /* register NF_IP_POST_ROUTING hook */ return 0; } void cleanup() { nf_unregister_hook(&netfilter_ops_in); /*unregister NF_IP_PRE_ROUTING hook*/ nf_unregister_hook(&netfilter_ops_out); /*unregister NF_IP_POST_ROUTING hook*/ } Let's walk through the code. We start with the regular #define and #include statements and declare our two nf_hook_ops structs, one for what comes in and one for what goes out. We then see our hook function, which passes a few important parameters. The first, hooknum, is a hooktype we already have covered. The second is a pointer to a pointer to a socket kernel buffer. The next two are netdevice pointers; we'll use these later to block and filter interfaces. The last parameter is a pointer to a function that takes in an sk_buff. With that in place, all we do in the hook function is drop all packets by returning NF_DROP. Inside init_module(), we fill in the nf_hook_ops structs and then formally register the hooks with nf_register_hook(). In cleanup(), all we do is unregister the two hooks with nf_unregister_hook(). To get the module working, compile and load it with the following commands, assuming the source file is called drop.c: $>cc -c drop.c $>insmod drop.o Once the module is up and running, open Ethereal or an equivalent program and watch the packets not come in. To unload the module, issue the command $>rmmod drop. Now we move on to our main project, called micro-firewall. The firewall is going to filter packets based on IP address, interface and TCP/UDP protocol and/or port. The firewall is a kernel module and is less than 60 lines of code in length. Let's look at the code first then review it: #define __KERNEL__ #define MODULE #include <linux/ip.h> #include <linux/kernel.h> #include <linux/module.h> #include <linux/netdevice.h> #include <linux/netfilter.h> #include <linux/netfilter_ipv4.h> #include <linux/skbuff.h> #include <linux/udp.h> static struct nf_hook_ops netfilter_ops; static unsigned char *ip_address = "\xC0\xA8\x00\x01"; static char *interface = "lo"; unsigned char *port = "\x00\x17"; struct sk_buff *sock_buff; struct udphdr *udp_header; unsigned int main_hook(unsigned int hooknum, struct sk_buff **skb, const struct net_device *in, const struct net_device *out, int (*okfn)(struct sk_buff*)) { if(strcmp(in->name,interface) == 0){ return NF_DROP; } sock_buff = *skb; if(!sock_buff){ return NF_ACCEPT; } if(!(sock_buff->nh.iph)){ return NF_ACCEPT; } if(sock_buff->nh.iph->saddr == *(unsigned int*)ip_address){ return NF_DROP; } if(sock_buff->nh.iph->protocol != 17){ return NF_ACCEPT; } udp_header = (struct udphdr *)(sock_buff->data + (sock_buff->nh.iph->ihl *4)); if((udp_header->dest) == *(unsigned short*)port){ return NF_DROP; } return NF_ACCEPT; } int init_module() { netfilter_ops.hook = main_hook; netfilter_ops.pf = PF_INET; netfilter_ops.hooknum = NF_IP_PRE_ROUTING; netfilter_ops.priority = NF_IP_PRI_FIRST; nf_register_hook(&netfilter_ops); return 0; } void cleanup_module() { nf_unregister_hook(&netfilter_ops); } We start with the #define and #include statements. Next, we declare an nf_hook_ops and an IP address (192.168.0.1) in network byte order. We also declare a char* called "lo" for the loopback interface, which we want to block. We also declare a char* for port 23, the telnet port. The last globals are a pointer to a socket kernel buffer and a pointer to a UDP header. The hook function is where we do the real work. In our first statement, we compare the name of the device the packet came from to our char* interface. If the device is the loopback device, we return NF_DROP. In other words, we drop the packet. That's all that is involved with filtering by interface. We easily could have filtered packets from the Ethernet device by replacing <coe>lo with eth0 in the char* interface declaration. Next, we filter by IP address and use the sk_buff to check for an IP address. We first check to see if we have a valid sk_buff, then we validate the IP packet, and finally we compare IP addresses. Our last filtering technique is by protocol and/or port. Here we decide to filter by UDP port. First we check to see if we have a valid UDP packet. If we do, we copy the packet's UDP struct to our own. Finally, we compare the packet's UDP port with port 23 (telnet). If all else fails, the hook function returns NF_ACCEPT and the packet goes on its merry way through the network stack. Compile and load the firewall with the following commands: $>cc -c firewall.c $>insmod firewall.o Once again, fire up Ethereal and see if the rules in the firewall holds. The packet filtering we did is straight-forward, and the possibilities are endless if you use your imagination. Unload the module with $>rmmod firewall, and things go back to normal. We've taken a magical trip through the world of Netfilter, and what we got is our micro-firewall. Many possibilities for Netfilter exist, not only with firewalls but for many other useful network tools. Victor Castro can be reached via his Web site [1]. # by archan | 2006/12/14 13:51 | Linux Packet Filter | 트랙백 | 덧글(0)
22.1.1 프로그램 인수 구문 관례들. POSIX 에서 커맨드 라인 인수들을 위해서 다음과 같은 관례들을 권장하고 있다. getopt(22.1.2 둁 하이픈(hyphen (`_') ) 구획문자(delimiter)로 시작하는 인수들은 옵션이 있다. 둁 한 개의 토큰에서 한 개의 하이픈 구획문자 뒤에 따르는 것은, 만일 그 옵션들이 인수들을 취하 둁 옵션 이름들은 단일한 알파벳 문자들이다( isalnum에 관하여; 4.1절[Classification of Characters] 둁 어떤 옵션들을 인수를 필요로 한다. 예를들어, ld 명령의 `-o' 옵션은 출력 파일 이름으로 하나의 둁 옵션과 옵션이 필요로 하는 인수들은 토큰으로 분리되어 나타날 수도 있고, 그렇지 않을 수도 있 둁 옵션들은 전형적으로 다른 비-옵션 인수들에 선행된다. GNU C 라이브러리에 있는 getopt의 구현은 당신의 프로그램을 사용하는 사용자가 심지어 옵션과 둁 인수 `--'는 모든 옵션들을 종결시킨다; 다음에 따르는 인수들은 그들이 하이픈으로 시작할지라 둁 한 개의 하이픈 문자가 들어가있는 토큰은 보통 비-옵션 인수로써 취급된다. 관례상, 그것은 기 둁 옵션들은 어떤 순서대로 공급되어지고, 또는 여러번 중복해서 나타나기도 할 것이다. 해석은 특 GNU 는 그들의 관례에 따라서 긴 옵션을 더한다. 긴 옵션들은 `--'뒤에 따르는 이름으로 구성되 22.1.2 프로그램 옵션들을 구문분석하기. 이번에는 getopt 함수를 어떻게 호출하는지에 대해서 자세히 설명한다. 이 기능을 사용하기 위해서, 변수 : int opterr 만일 이 변수의 값이 0이 아니면, getopt는 만일 알지못하는 옵션 문자가 들어오거나 인수를 필요로 변수 : int optopt getopt가 알려지지 않은 옵션 문자와 만나거나 필요한 인수가 빠져있는 옵션일 때, getopt는 그 옵션 변수 : int optind 이 변수는 앞으로 분석할 배열 argv의 다음 요소에 대한 인덱스로 getopt에 의해 설정된다. 일단 변수 : chat *optarg 이 변수는 인수들을 받아들이는 옵션들을 위해서, 옵션 인수들의 값을 가리키는 포인터로써 getopt 함수 : int getopt(int argc, char **argv, const char *options) getopt 함수는 argv와 argc 인수들에의해 지정된 인수 목록으로부터 다음 옵션 인수를 얻는다. 보 만일 옵션 인수 문자열이 하이픈(`-')으로 시작한다면, 이것은 특별하게 취급된다. 그들은 옵션 문 외부변수 optind를 비교해야만 한다. 만일 어떤 옵션이 인수를 가진다면, getopt 는 변수들 optarg안에 그것을 저장함으로써 인수를 리턴 만일 알려지지 않은 옵션문자를 사용하거나, 옵션 인수가 빠져있다면 getopt는 `?'를 리턴하고 현재 22.1.3 getopt를 사용해서 인수를 구문분석하는 예제. 다음은 getopt가 전형적으로 어떻게 사용되는지를 보여주는 예제이다. 핵심은 다음과 같다: 둁 보통, getopt는 루프안에서 호출된다. getopt가 더 이상 나타난 옵션이 없음을 알리기 위해서 -1 둁 switch 구문은 getopt로부터의 리턴값에 따른 각각의 처리에 사용된다. 각각의 경우는 프로그램에 둁 두 번째 루프는 남아있는 비-옵션 인수들을 처리하는데 사용된다. #include <unistd.h> #include <stdio.h> int main (int argc, char **argv) { int aflag = 0; int bflag = 0; char *cvalue = NULL; int index; int c; opterr = 0; while ((c = getopt (argc, argv, "abc:")) != -1) switch (c) { case 'a': aflag = 1; break; case 'b': bflag = 1; break; case 'c': cvalue = optarg; break; case '?': if (isprint (optopt)) fprintf(stderr, "Unknown option `-%c'.\n", optopt); else fprintf (stderr, "Unknown option character `\\x%x'.\n", optopt); return 1; default: abort (); } printf("aflag = %d, bflag = %d, cvalue = %s\n", aflag, bflag, cvalue); for (index = optind; index < argc; index++) printf ("Non-option argument %s\n", argv[index]); return 0; } 다음은 위의 프로그램을 여러 가지 인수들의 조합을 사용했을 때 어떤 결과를 나타내는지에 대한 % testopt aflag = 0, bflag = 0, cvalue = (null) % testopt -a -b aflag = 1, bflag = 1, cvalue = (null) % testopt -ab aflag = 1, bflag = 1, cvalue = (null) % testopt -c foo aflag = 0, bflag = 0, cvalue = foo % testopt -cfoo aflag = 0, bflag = 0, cvalue = foo % testopt arg1 aflag = 0, bflag = 0, cvalue = (null) Non-option argument arg1 % testopt -a arg1 aflag = 1, bflag = 0, cvalue = (null) Non-option argument arg1 % testopt -c foo arg1 aflag = 0, bflag = 0, cvalue = foo Non-option argument arg1 % testopt -a -- -b aflag = 1, bflag = 0, cvalue = (null) Non-option argument -b % testopt -a - aflag = 1, bflag = 0, cvalue = (null) Non-option argument - 22.1.4 긴 옵션들을 구문분석하기. 단일한-문자 옵션들로만 되어있는 GNU-스타일의 긴 옵션들을 받아들이기 위해서는 getopt 대신에 데이터 타입 : struct option 이 구조체는 getopt_long을 위한 단일한 긴 옵션 이름을 설명한다. 긴 옵션을 구성하는 옵션의 하나 const char *name 이 필드는 옵션의 이름으로 문자열이다. int has_arg 이 필드는 옵션이 인수를 취하는지 또는 취하지 않는지의 여부를 알린다. 그것은 정수이고 그곳에 int *flag int val 이 필드들은 그 옵션이 발생할 때 옵션에 대하여 어떻게 보고를 하거나 동작할것인지를 제어한다. 함수 : int getopt__long (int argc, char **argv, const char *shortopts, struct 벡터 argv ( 길이는 argc이다.)로부터 옵션들을 해독한다. 인수 shortopts는 getopt가 해독할 수 있 getopt_long가 긴 옵션을 만났을 때, 그것은 그 옵션을 정의하는 flag 와 val 필드에 기초한 동작들 만일 flag가 널 포인터라면, getopt_long 은 발견한 옵션을 지적하도록 val의 내용을 리턴한다. 당신 만일 flag가 널 포인터가 아니라면, 단지 프로그램안에서 flag가 설정된 이 옵션을 의미한다. flag는 어떤 긴 옵션에서, getopt_long는 배열 longopts안의 옵션 정의에 대한 인덱스를, *indexptr에 저장하 어떤 긴 옵션이 인수를 가질 때, getopt_long는 리턴하기 전에 변수 optarg안에 인수값을 저장한다. 22.1.5 긴 옵션들의 구분분석에 대한 예제. #include <stdio.h> /* 플래그는 `--verbose' 에 의해 설정한다. */ static int verbose_flag; int main (argc, argv) int argc; char **argv; { int c; while (1) { static struct option long_options[] = { /* 그들 옵션들은 플래그를 설정한다.*/ {"verbose", 0, &verbose_flag, 1}, {"brief", 0, &verbose_flag, 0}, /* 그들 옵션들은 플래그를 설정하지 않는다. 우리는 그들의 인덱스에 의해 그들을 구분한다. */ {"add", 1, 0, 0}, {"append", 0, 0, 0}, {"delete", 1, 0, 0}, {"create", 0, 0, 0}, {"file", 1, 0, 0}, {0, 0, 0, 0} }; /* getopt_long는 이곳에 옵션 인덱스를 저장한다. */ int option_index = 0; c = getopt_long (argc, argv, "abc:d:", long_options, &option_index); /* 옵션들의 끝을 검출한다. */ if (c == -1) break; switch (c) { case 0: /* 만일 이 옵션이 플래그를 설정하면, 지금 아무런 일도 하지 말아라. */ if (long_options[option_index].flag != 0) break; printf("option %s", long_options[option_index].name); if (optarg) printf(" with arg %s", optarg); printf("\n"); break; case 'a': puts("option -a\n"); break; case 'b': puts("option -b\n"); break; case 'c': printf("option -c with value `%s'\n", optarg); break; case 'd': printf("option -d with value `%s'\n", optarg); break; case '?': /* getopt_long는 이미 에러 메시지를 프린트했다. */ break; default: abort (); } } /* 그들이 맞추쳤던 것으로 `--verbose'와 `--brief'를 보고하는 대신에, 우리는 그들로부터 나온 결 if (verbose_flag) puts ("verbose flag is set"); /* 남아있는 코맨드 라인 인수들을( 옵션이 없는) 출력하라. */ if (optind < argc) { printf ("non-option ARGV-elements: "); while (optind < argc) printf ("%s ", argv[optind++]); putchar ('\n'); } exit (0); } # by archan | 2006/12/14 02:32 | C언어 잡동사니 | 트랙백 | 덧글(0)
|
