Re:답변요 - 소켓!

[Ack#root]

raw소켓은 루트권한으로만 사용할수 있습니다.
이글 참조하세요.
.oO Phrack 49 Oo.

Volume Seven, Issue Forty-Nine

15 of 16


Port Scanning without the SYN flag / Uriel Maimon
(lifesux@cox.org)
translator : 함지만 (realdata@igrus.inha.ac.kr)
IGRUS | KHDP
---------------------------------------------------------


Introduction :
--------------

요즘 들어, 특정한 호스트가 제공하는 서비스들을 알 필요가 증가되고 있다.
포트 스캐닝 분야가 바로 이러한 필요들의 해결책으로 제시되고 있다.
처음, 사탄(SATAN)과 같은 도구에서는 완벽한 three-way-handshake방식으로 각각의
열려진 포트를 접속했었다. 이와 같은 방법의 장점은 스캐닝을 하고 있는 사용자가
일반적으로 ip 패킷을 만들 필요없다는 것인데, 왜냐하면 그는 표준 시스템 호출(
standard system call)을 사용하며, 루트권한(일반적으로 SOCK_RAW, /dev/bpf,
/dev/nit 등은 uid 0의 권한이 필요하다)이 필요없기 때문이다.
반면에 단점으로는 여러가지 방법으로, 대부분 Wietse Venema에 의해 만들어진 TCP
Wrappers를 통해서, 쉽게 탐지할 수 있고 또한 쉽게 막을수 있다는 것이다.

그 다음으로 SYN 스캐닝 또는 완벽한 TCP 연결을 성립시키지 않는 'half open
scanning' 이 있었다. TCP연결을 수행하는 단계를 세단계로 표현하면 다음과
같다 : 접속을 시작하는 쪽(client)에서 TCP 패킷의 SYN 플래그를 켠(on) 상태로
보내면, 이 패킷을 받는 쪽(server)에서는 요청하는 포트가 열려있다면 SYN과
ACK 플래그를 켠(on) 상태로 되돌려 보내지만, 요청하는 포트가 닫혀있다면 RST
플래그를 보내어 연결을 거부한다. 그리고 마지막으로 client에서 ACK 플래그를
켠(on) 한 상태의 TCP 패킷(이러한 패킷들은 그에 일치하는 시퀀스 넘버와 ack
넘버를 지닌다)을 보내고 나면 연결이 이루어진다.
SYN 스캐너는 이와 같은 three-way-handshake 방식에서 처음의 SYN 패킷만을 보
내고, SYN|ACK 또는 RST 의 응답을 기다리는 것이다. 둘 중 하나의 응답을 받을때
그 포트가 열려있는지 닫혀 있는지 알 수 있다는 원리이다. 이러한 방식의 가장
큰 장점은 SATAN detector 나 TCP Wrappers의 로그(log) 기록에 의해 탐지되지
않는다는 점이다.

그러나 이것에도 단점은 있다:

1) 이 방법은 여전히 SYN 접속 시도를 로깅하는 tcplog와 같은 특정 logger에
의해서 탐지 될 수 있고, netstat(1)로도 탐지 당할수 있다.


2) 대부분의 OS에서는 이러한 종류의 스캐닝을 위해 완전한 IP 패킷을 만들어야
한다. (필자(Uriel)는 이것이 어떤 OS에서는 꼭 그럴 필요가 없다는 것에 대해 잘
모르지만, 만약 여러분들이 알고 있다면 필자(Uriel)에게 알려주기 바란다.)
또한, 이 완전한 IP 패킷을 만들때는 SOCK_RAW(getprotbyname('raw'); 대부분의
시스템에서 RAW 소켓)나 /dev/bpf (Berkeley packet filter), /dev/nit (Sun
'Network Interface Tap') 등의 억세스가 요구된다. 이 같은 것들은 종종 루트
또는 권한을 가진 그룹만이 억세스 할 수 있다.


3) 많은 방화벽이 이와 같은 스캔을 필터링 하지만, StealthScan(TM) (all rights
reserved to vicious little red blow ficiouz deliciouz (kosher) chicken surpass
INC PLC LTD) 을 필터링 하지 못할 것이다.

UDP portscanning에 대해서 :
---------------------------

이번 기사에서 필자(Uriel)은 UDP 포트스캐닝이 TCP 보다 덜 복잡하다는 단순한
이유로 언급을 피할 것이다; UDP 포트스캐닝은 스트림 프로토콜 경향의 연결이
아니라 오히려 비연결 데이터그램 프로토콜이다.
UDP 포트가 열려 있는지 닫혀 있는지 스캔하기 위해서는, 간단히 그 포트에 UDP
패킷을 보낸다. 여러분들은 포트가 열려있지 않다면 'Destination Port Unreach-
able' 이라는 ICMP를 받게 될 것이다.


내 생각에는 이와 같은 방법만이 UDP 포트를 스캔할 수 있다고 본다. 하지만
누군가가 다른 방법을 안다면 언제든지 필자(Uriel)에게 메일을 보내주길
바란다.


The StealthScan:
----------------

스텔스 스캔은 BSD 코드의 bug network 코드에 의존한다. 대부분의 OS가 보편적
으로 사용하는 네트워크 코드가 BSD 네트워크 코드이거나 이것에서 파생된 것이
다. (여기서 시스코 라우터들은 명백히 제외된다....이후 필자의 농담....
Gosh! GOOD networking code ?!?@$! <GASP> HERESY! Alan Cox will have a heart
attack when he hears of this!)


이 기술의 단점:

1) IP 패킷을 만들어야만 한다. 필자는 이같은 문제에 대해 몇몇 불안정한 시스템
호출이 삽입되는 일 없다면 해결책이 없다고 본다. 요즘은 SLIP/PPP 서비스가 너무도
흔해졌기 때문에 한 서버에서 슈퍼 유저의 억세스 권한을 얻는 것이 더이상 문제되지
않으므로 이같은 필요가 없다.

2) 이 방법은 네트워크 코드의 버그에 의존한다. 이것이 가까운 장래에는 아마도
고쳐질 수 있을 것이다. ( 이하 필자의 농담 ..Shhhhhh. Don't tell Alan Cox.
He hates good efficient networking code.) 예를 들어, OPEN BSD 에서는 벌써
이 버그를 고쳤다.

3) 스캔의 결과가 알려지지 않고, 다른 아키텍쳐나 OS에서는 스캔의 결과가 비슷하
지 않을 수도 있다. 이와 같은 경우는 믿을만하지 않다.
(역자의 주 : 역자(realdata)가 알아본 결과 micro$oft 운영체제 사용서버들은 전혀
반응하지 않는다고 한다.)

다른 방법들에 비해 뛰어난 장점:

1) 로그(log)기록을 하기가 어렵다는 것이다. 설사 이방법이 알려져 로깅방법이
고안된다 하더라도 이 버그의 보완없이는 여전히 문제가 남아있다.

2) 몇몇 방화벽들을 교묘하게 피할 수 있다.

3) netstat(1)에 나타나지 않는다.

4) Standard TCP three-way-handshake 의 어떤 부분으로도 구성되지 않았다.

5) 여러 방법들이 이와 같은 원리로 구현되고 있다.

기본적인 알고리즘은 이러하다 :

ACK, FIN 플래그를 켠(on) 상태의 TCP 패킷을 사용한다. 왜냐하면 이와 같은
패킷은 열려지지 않은 포트로 보내었을때 언제나 RST로 응답하기 때문이다.
이제 부터는 'RST'나 'FIN','ACK' 패킷에 대해서 알아보자.


method #1:

FIN 패킷을 보낸다. 이 패킷이 도달하는 호스트는 그 포트가 닫혀있는 포트라면 RST
로 응답할 것이고, 열려있다면 RST로 응답하지 않을 것이다. 사실 이 방법이 수많은
호스트에서 효과가 있다는 것은 대부분의 OS 커널안의 네트워크 코드 상태가 문제점
이 많음을 시사해 주는 것이다.


method #2

ACK 패킷을 보낸다. 만일 응답하는 패킷의 ttl(time-to-live)의 값이 돌려 받은
RST 패킷의 것보다 낮거나, 윈도우 사이즈가 0보다 크면 그 포트는 아마 열려진
것이다.

(ttl에 대해서: 이 버그는 거의 알만한 것이다. IP의 주요한 기능은 라우팅이다.
인터페이스가 변경될때 마다(역자의 주: 여기서의 인터페이스는 라우터를 말한다),
패킷의 ttl 값은 1씩 빼진다. 포트가 열려있는 경우라면, ttl 은 패킷을 받거나
조사할때 그 값이 감소된다. 그러나 포트가 닫혀 있을 때, SYN 플래그가 아닌
다른 플래그 즉, RST가 보내지면 ttl은 1만큼 더 낮아진다. 이것이 그 경우가 아닐지도
모르겠다. 필자(Uriel)는 BSD 네트워크에서 이 이론을 체크해보지는 않았다. )


- 소스는 따로 번역하지 않았습니다. 아마도 원문으로 보시는게 이해하는데 더욱
쉬울것이라는 판단아래서 ....

Uriel
/*
* scantcp.c
*
* version 1.32
*
* Scans for listening TCP ports by sending packets to them and waiting for
* replies. Relys upon the TCP specs and some TCP implementation bugs found
* when viewing tcpdump logs.
*
* As always, portions recycled (eventually, with some stops) from n00k.c
* (Wow, that little piece of code I wrote long ago still serves as the base
* interface for newer tools)
*
* Technique:
* 1. Active scanning: not supported - why bother.
*
* 2. Half-open scanning:
* a. send SYN
* b. if reply is SYN|ACK send RST, port is listening
* c. if reply is RST, port is not listening
*
* 3. Stealth scanning: (works on nearly all systems tested)
* a. sends FIN
* b. if RST is returned, not listening.
* c. otherwise, port is probably listening.
*
* (This bug in many TCP implementations is not limited to FIN only; in fact
* many other flag combinations will have similar effects. FIN alone was
* selected because always returns a plain RST when not listening, and the
* code here was fit to handle RSTs already so it took me like 2 minutes
* to add this scanning method)
*
* 4. Stealth scanning: (may not work on all systems)
* a. sends ACK
* b. waits for RST
* c. if TTL is low or window is not 0, port is probably listening.
*
* (stealth scanning was created after I watched some tcpdump logs with
* these symptoms. The low-TTL implementation bug is currently believed
* to appear on Linux only, the non-zero window on ACK seems to exists on
* all BSDs.)
*
* CHANGES:
* --------
* 0. (v1.0)
* - First code, worked but was put aside since I didn't have time nor
* need to continue developing it.
* 1. (v1.1)
* - BASE CODE MOSTLY REWRITTEN (the old code wasn't that maintainable)
* - Added code to actually enforce the usecond-delay without usleep()
* (replies might be lost if usleep()ing)
* 2. (v1.2)
* - Added another stealth scanning method (FIN).
* Tested and passed on:
* AIX 3
* AIX 4
* IRIX 5.3
* SunOS 4.1.3
* System V 4.0
* Linux
* FreeBSD
* Solaris
*
* Tested and failed on:
* Cisco router with services on ( IOS 11.0)
*
* 3. (v1.21)
* - Code commented since I intend on abandoning this for a while.
*
* 4. (v1.3)
* - Resending for ports that weren't replied for.
* (took some modifications in the internal structures. this also
* makes it possible to use non-linear port ranges
* (say 1-1024 and 6000))
*
* 5. (v1.31)
* - Flood detection - will slow up the sending rate if not replies are
* recieved for STCP_THRESHOLD consecutive sends. Saves alot of resends
* on easily-flooded networks.
*
* 6. (v1.32)
* - Multiple port ranges support.
* The format is: <start-end>|<num>[,<start-end>|<num>,...]
*
* Examples: 20-26,113
* 20-100,113-150,6000,6660-6669
*
* PLANNED: (when I have time for this)
* ------------------------------------
* (v2.x) - Multiple flag combination selections, smart algorithm to point
* out uncommon replies and cross-check them with another flag
*
*/

#define RESOLVE_QUIET

#include <stdio.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <netinet/ip_tcp.h>
#include <sys/time.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <signal.h>
#include <errno.h>

#include "resolve.c"
#include "tcppkt03.c"

#define STCP_VERSION "1.32"
#define STCP_PORT 1234 /* Our local port. */
#define STCP_SENDS 3
#define STCP_THRESHOLD 8
#define STCP_SLOWFACTOR 10

/* GENERAL ROUTINES ------------------------------------------- */

void banner(void)
{
printf("\nscantcp\n");
printf("version %s\n",STCP_VERSION);
}

void usage(const char *progname)
{
printf("\nusage: \n");
printf("%s <method> <source> <dest> <ports> <udelay> <delay> [sf]\n\n",progname);
printf("\t<method> : 0: half-open scanning (type 0, SYN)\n");
printf("\t 1: stealth scanning (type 1, FIN)\n");
printf("\t 2: stealth scanning (type 2, ACK)\n");
printf("\t<source> : source address (this host)\n");
printf("\t<dest> : target to scan\n");
printf("\t<ports> : ports/and or ranges to scan - eg: 21-30,113,6000\n");
printf("\t<udelay> : microseconds to wait between TCP sends\n");
printf("\t<delay> : seconds to wait for TCP replies\n");
printf("\t[sf] : slow-factor in case sends are dectected to be too fast\n\n");
}

/* OPTION PARSING etc ---------------------------------------- */

unsigned char *dest_name;
unsigned char *spoof_name;
struct sockaddr_in destaddr;

unsigned long dest_addr;
unsigned long spoof_addr;
unsigned long usecdelay;
unsigned waitdelay;

int slowfactor = STCP_SLOWFACTOR;

struct portrec /* the port-data structure */
{
unsigned n;
int state;
unsigned char ttl;
unsigned short int window;
unsigned long int seq;
char sends;

} *ports;

char *portstr;

unsigned char scanflags;

int done;

int rawsock; /* socket descriptors */
int tcpsock;

int lastidx = 0; /* last sent index */
int maxports; /* total number of ports */

void timeout(int signum) /* timeout handler */
{ /* this is actually the data */
int someopen = 0; /* analyzer function. werd. */
unsigned lastsent;
int checklowttl = 0;

struct portrec *p;

printf("* SCANNING IS OVER\n\n");
fflush(stdout);

done = 1;


for (lastsent = 0;lastsent<maxports;lastsent++)
{
p = ports+lastsent;
if (p->state == -1)
if (p->ttl > 64)
{
checklowttl = 1;
break;
}
}

/* the above loop checks whether there's need to report low-ttl packets */

for (lastsent = 0;lastsent<maxports;lastsent++)
{
p = ports+lastsent;

destaddr.sin_port = htons(p->n);

tcpip_send(rawsock,&destaddr,
spoof_addr,destaddr.sin_addr.s_addr,
STCP_PORT,ntohs(destaddr.sin_port),
TH_RST,
p->seq++, 0,
512,
NULL,
0);
} /* just RST -everything- sent */
/* this inclued packets a reply */
/* (even RST) was recieved for */




for (lastsent = 0;lastsent<maxports;lastsent++)
{ /* here is the data analyzer */
p = ports+lastsent;
switch (scanflags)
{
case TH_SYN:
switch(p->state)
{
case -1: break;
case 1 : printf("# port %d is listening.\n",p->n);
someopen++;
break;
case 2 : printf("# port %d maybe listening (unknown response).\n",
p->n);
someopen++;
break;
default: printf("# port %d needs to be rescanned.\n",p->n);
}
break;
case TH_ACK:
switch (p->state)
{
case -1:
if (((p->ttl < 65) && checklowttl) || (p->window >0))
{
printf("# port %d maybe listening",p->n);
if (p->ttl < 65) printf(" (low ttl)");
if (p->window >0) printf(" (big window)");
printf(".\n");
someopen++;
}
break;
case 1:
case 2:
printf("# port %d has an unexpected response.\n",
p->n);
break;
default:
printf("# port %d needs to be rescanned.\n",p->n);
}
break;
case TH_FIN:
switch (p->state)
{
case -1:
break;
case 0 :
printf("# port %d maybe open.\n",p->n);
someopen++;
break;
default:
printf("# port %d has an unexpected response.\n",p->n);
}
}
}

printf("-----------------------------------------------\n");
printf("# total ports open or maybe open: %d\n\n",someopen);
free(ports);

exit(0); /* heh. */

}


int resolve_one(const char *name, unsigned long *addr, const char *desc)
{
struct sockaddr_in tempaddr;
if (resolve(name, &tempaddr,0) == -1) {
printf("error: can't resolve the %s.\n",desc);
return -1;
}

*addr = tempaddr.sin_addr.s_addr;
return 0;
}

void give_info(void)
{
printf("# response address : %s (%s)\n",spoof_name,inet_ntoa(spoof_addr));
printf("# target address : %s (%s)\n",dest_name,inet_ntoa(dest_addr));
printf("# ports : %s\n",portstr);
printf("# (total number of ports) : %d\n",maxports);
printf("# delay between sends : %lu microseconds\n",usecdelay);
printf("# delay : %u seconds\n",waitdelay);
printf("# flood dectection threshold : %d unanswered sends\n",STCP_THRESHOLD);
printf("# slow factor : %d\n",slowfactor);
printf("# max sends per port : %d\n\n",STCP_SENDS);
}


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

if (strrchr(argv[0],'/') != NULL)
argv[0] = strrchr(argv[0],'/') + 1;

if (argc < 7) {
printf("%s: not enough arguments\n",argv[0]);
return -1;
}

switch (atoi(argv[1]))
{
case 0 : scanflags = TH_SYN;
break;
case 1 : scanflags = TH_FIN;
break;
case 2 : scanflags = TH_ACK;
break;
default : printf("%s: unknown scanning method\n",argv[0]);
return -1;
}

spoof_name = argv[2];
dest_name = argv[3];

portstr = argv[4];

usecdelay = atol(argv[5]);
waitdelay = atoi(argv[6]);

if (argc > 7) slowfactor = atoi(argv[7]);

if ((usecdelay == 0) && (slowfactor > 0))
{
printf("%s: adjusting microsecond-delay to 1usec.\n");
usecdelay++;
}
return 0;
}

/* MAIN ------------------------------------------------------ */

int build_ports(char *str) /* build the initial port-database */
{
int i;
int n;
struct portrec *p;
int sport;

char *s;


s = str;
maxports = 0;
n = 0;

while (*s != '\0')
{
switch (*s)
{
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
n *= 10;
n += (*s - '0');
break;
case '-':
if (n == 0) return -1;
sport = n;
n = 0;
break;
case ',':
if (n == 0) return -1;
if (sport != 0)
{
if (sport >= n) return -1;
maxports += n-sport;
sport = 0;
} else
maxports++;
n = 0;
break;
}
s++;
}
if (n == 0) return -1;
if (sport != 0)
{
if (sport >= n) return -1;
maxports += n-sport;
sport = 0;
}
else
maxports++;

maxports+=2;

if ((ports = (struct portrec *)malloc((maxports)*sizeof(struct portrec))) == NULL)
{
fprintf(stderr,"\nerror: not enough memory for port database\n\n");
exit(1);
}

s = str;
maxports = 0;
n = 0;

while (*s != '\0')
{
switch (*s)
{
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
n *= 10;
n += (*s - '0');
break;
case '-':
if (n == 0) return -1;
sport = n;
n = 0;
break;
case ',':
if (n == 0) return -1;
if (sport != 0)
{
if (sport >= n) return -1;
while (sport <= n)
{
for (i=0;i<maxports;i++)
if ((ports+i)->n == sport) break;

if (i < maxports-1 )
printf("notice: duplicate port - %d\n",sport);
else
{
(ports+maxports)->n = sport;
maxports++;
}
sport++;
}
sport = 0;
} else
{
for (i=0;i<maxports;i++)
if ((ports+i)->n == n) break;

if (i < maxports-1 )
printf("notice: duplicate port - %d\n",n);
else
{
(ports+maxports)->n = n;
maxports++;
}
}
n = 0;
break;
}
s++;
}


if (n == 0) return -1;
if (sport != 0)
{
if (sport >= n) return -1;
while (sport <= n)
{
for (i=0;i<maxports;i++)
if ((ports+i)->n == sport) break;

if (i < maxports-1 )
printf("notice: duplicate port - %d\n",sport);
else
{
(ports+maxports)->n = sport;
maxports++;
}
sport++;
}
sport = 0;
} else
{
for (i=0;i<maxports;i++)
if ((ports+i)->n == n) break;

if (i < maxports-1 )
printf("notice: duplicate port - %d\n",n);
else
{
(ports+maxports)->n = n;
maxports++;
}
}

printf("\n");

for (i=0;i<maxports;i++)
{
p = ports+i;
p->state = 0;
p->sends = 0;
}

return 0;

}

struct portrec *portbynum(int num)
{
int i = 0;

while ( ((ports+i)->n != num) && (i<maxports) ) i++;

if ( i == maxports ) return NULL;

return (ports+i);
}

struct portrec *nextport(char save)
{
struct portrec *p = ports;
int doneports = 0;

int oldlastidx = lastidx;

while (doneports != maxports)
{
p = ports+lastidx;

if ((p->state != 0) || (p->sends == STCP_SENDS))
{
doneports++;
lastidx++;
lastidx %= maxports;
}
else
break;
}

if (save)
lastidx = oldlastidx;
else
lastidx = (lastidx + 1) % maxports;

if (doneports == maxports) return NULL;

return p;
}




inline unsigned long usecdiff(struct timeval‎ *a, struct timeval‎ *b)
{
unsigned long s;

s = b->tv_sec - a->tv_sec;
s *= 1000000;
s += b->tv_usec - a->tv_usec;

return s; /* return the stupid microsecond diff */
}

void main(int argc, char *argv[])
{
int lastsent = 0;

char buf[3000];

struct iphdr *ip = (struct iphdr *)(buf);
struct tcphdr *tcp = (struct tcphdr *)(buf+sizeof(struct iphdr));

struct sockaddr_in from;
int fromlen;

struct portrec *readport;

fd_set rset, wset;

struct timeval‎ waitsend, now, del;

unsigned long udiff;

int sendthreshold = 0;


banner();

if (parse_args(argc,argv))
{
usage(argv[0]);
return;
}

if (resolve_one(dest_name,
&dest_addr,
"destination host")) exit(1);

destaddr.sin_addr.s_addr = dest_addr;
destaddr.sin_family = AF_INET;

if (resolve_one(spoof_name,
&spoof_addr,
"source host")) exit(1);

if ( build_ports(portstr) == -1)
{
printf("\n%s: bad port string\n",argv[0]);
usage(argv[0]);
return;
}

give_info();

if ((tcpsock = socket(AF_INET, SOCK_RAW, IPPROTO_TCP)) == -1)
{
printf("\nerror: couldn't get TCP raw socket\n\n");
exit(1);
}
if ((rawsock = socket(AF_INET, SOCK_RAW, IPPROTO_RAW)) == -1)
{
printf("\nerror: couldn't get raw socket\n\n");
exit(1);
}

/* well, let's get to it. */

done = 0;

printf("* BEGINNING SCAN\n");
fflush(stdout);

gettimeofday(&waitsend,NULL);

while (!done)
{

if (nextport(1) == NULL)
{
alarm(0); /* no more sends, now we just */
signal(SIGALRM,timeout); /* to wait <waitdelay> seconds */
alarm(waitdelay); /* before resetting and giving */
} /* results. */

FD_ZERO(&rset);

FD_SET(tcpsock,&rset);

gettimeofday(&now,NULL);

udiff = usecdiff(&waitsend,&now);

/* here comes the multiple choice select().
* well, there are 3 states:
* 1. already sent all the packets.
* 2. didn't send all the packets, but it's not time for another send
* 3. didn't send all the packets and it is time for another send.
*/

if (nextport(1) != NULL)
if (udiff > usecdelay)
{
FD_ZERO(&wset);
FD_SET(rawsock,&wset);
select(FD_SETSIZE,&rset,&wset,NULL,NULL);
} else
{
del.tv_sec = 0;
del.tv_usec = usecdelay;
select(FD_SETSIZE,&rset,NULL,NULL,&del);
}
else
select(FD_SETSIZE,&rset,NULL,NULL,NULL);

if (FD_ISSET(tcpsock,&rset)) /* process the reply */
{
fromlen = sizeof(from);

recvfrom(tcpsock,&buf,3000,0,
(struct sockaddr *)&from,&fromlen);

if (from.sin_addr.s_addr == destaddr.sin_addr.s_addr)
if (ntohs(tcp->th_dport) == STCP_PORT)
{
printf("* got reply");

readport = portbynum(ntohs(tcp->th_sport));

if (readport == NULL)
printf(" -- bad port");
else
{
sendthreshold = 0;
if (!readport->state)
{
readport->ttl = ip->ttl;
readport->window = tcp->th_win;

if (tcp->th_flags & TH_RST)
{
readport->state = -1;
printf(" (RST)");
if (readport->ttl < 65) printf(" (short ttl)");
if (readport->window > 0) printf(" (big window)");
}
else
if (tcp->th_flags & (TH_ACK | TH_SYN))
{
readport->state = 1;
printf(" (SYN+ACK)");
tcpip_send(rawsock,&destaddr,
spoof_addr,destaddr.sin_addr.s_addr,
STCP_PORT,readport->n,
TH_RST,
readport->seq++, 0,
512,
NULL,
0);
}
else
{
readport->state = 2;
printf(" (UNEXPECTED)");
tcpip_send(rawsock,&destaddr,
spoof_addr,destaddr.sin_addr.s_addr,
STCP_PORT,readport->n,
TH_RST,
readport->seq++, 0,
512,
NULL,
0);
}
}
else
printf(" (duplicate)");
}
printf("\n");
fflush(stdout);
}
}

if (nextport(1) != NULL)
if (FD_ISSET(rawsock,&wset)) /* process the sends */
{
readport = nextport(0);

destaddr.sin_port = htons(readport->n);

printf("* sending to port %d ",ntohs(destaddr.sin_port));

readport->seq = lrand48();
readport->sends++;

tcpip_send(rawsock,&destaddr,
spoof_addr,destaddr.sin_addr.s_addr,
STCP_PORT,ntohs(destaddr.sin_port),
scanflags,
readport->seq++, lrand48(),
512,
NULL,
0);

gettimeofday(&waitsend,NULL);

FD_ZERO(&wset);

printf("\n");

if ((++sendthreshold > STCP_THRESHOLD) && (slowfactor))
{
printf("\n\n -- THRESHOLD CROSSED - SLOWING UP SENDS\n\n");
usecdelay *= slowfactor;
sendthreshold = 0;
}
}
}
}



/*
* tcp_pkt.c
*
* routines for creating TCP packets, and sending them into sockets.
*
* (version 0.3)
*
*
* BUGFIX: - it seems like the TCP pseudo header checksum was
* acting up in serveral cases.
* ADDED : - HEXDUMP macro.
* - packet dump handling
*/

/* remove inlines for smaller size but lower speed */

#include <netinet/in.h>
#include <string.h>
#include <sys/types.h>
#include <netinet/ip.h>
#include <netinet/tcp.h>

#define IPHDRSIZE sizeof(struct iphdr)
#define TCPHDRSIZE sizeof(struct tcphdr)
#define PSEUDOHDRSIZE sizeof(struct pseudohdr)

/* ********** RIPPED CODE START ******************************** */

/*
* in_cksum --
* Checksum routine for Internet Protocol family headers (C Version)
*/
unsigned short in_cksum(addr, len)
u_short *addr;
int len;
{
register int nleft = len;
register u_short *w = addr;
register int sum = 0;
u_short answer = 0;

/*
* Our algorithm is simple, using a 32 bit accumulator (sum), we add
* sequential 16 bit words to it, and at the end, fold back all the
* carry bits from the top 16 bits into the lower 16 bits.
*/
while (nleft > 1) {
sum += *w++;
nleft -= 2;
}

/* mop up an odd byte, if necessary */
if (nleft == 1) {
*(u_char *)(&answer) = *(u_char *)w ;
sum += answer;
}

/* add back carry outs from top 16 bits to low 16 bits */
sum = (sum >> 16) + (sum & 0xffff); /* add hi 16 to low 16 */
sum += (sum >> 16); /* add carry */
answer = ~sum; /* truncate to 16 bits */
return(answer);
}

/* ********** RIPPED CODE END ******************************** */

/*
* HEXDUMP()
*
* not too much to explain
*/
inline void HEXDUMP(unsigned len, unsigned char *data)
{
unsigned i;
for (i=0;i<len;i++) printf("%02X%c",*(data+i),((i+1)%16) ? ' ' : '\n');
}

/*
* tcpip_send()
*
* sends a totally customized datagram with TCP/IP headers.
*/

inline int tcpip_send(int socket,
struct sockaddr_in *address,
unsigned long s_addr,
unsigned long t_addr,
unsigned s_port,
unsigned t_port,
unsigned char tcpflags,
unsigned long seq,
unsigned long ack,
unsigned win,
char *datagram,
unsigned datasize)
{

struct pseudohdr {
unsigned long saddr;
unsigned long daddr;
char useless;
unsigned char protocol;
unsigned int tcplength;
};

unsigned char packet[2048];
struct iphdr *ip = (struct iphdr *)packet;
struct tcphdr *tcp = (struct tcphdr *)(packet+IPHDRSIZE);
struct pseudohdr *pseudo = (struct pseudohdr *)(packet+IPHDRSIZE-PSEUDOHDRSIZE);
unsigned char *data = (unsigned char *)(packet+IPHDRSIZE+TCPHDRSIZE);

/*
* The above casts will save us a lot of memcpy's later.
* The pseudo-header makes this way become easier than a union.
*/

memcpy(data,datagram,datasize);
memset(packet,0,TCPHDRSIZE+IPHDRSIZE);

/* The data is in place, all headers are zeroed. */

pseudo->saddr = s_addr;
pseudo->daddr = t_addr;
pseudo->protocol = IPPROTO_TCP;
pseudo->tcplength = htons(TCPHDRSIZE+datasize);

/* The TCP pseudo-header was created. */

tcp->th_sport = htons(s_port);
tcp->th_dport = htons(t_port);
tcp->th_off = 5; /* 20 bytes, (no options) */
tcp->th_flags = tcpflags;
tcp->th_seq = htonl(seq);
tcp->th_ack = htonl(ack);
tcp->th_win = htons(win); /* we don't need any bigger, I guess. */

/* The necessary TCP header fields are set. */

tcp->th_sum = in_cksum(pseudo,PSEUDOHDRSIZE+TCPHDRSIZE+datasize);

memset(packet,0,IPHDRSIZE);
/* The pseudo-header is wiped to clear the IP header fields */

ip->saddr = s_addr;
ip->daddr = t_addr;
ip->version = 4;
ip->ihl = 5;
ip->ttl = 255;
ip->id = random()%1996;
ip->protocol = IPPROTO_TCP; /* should be 6 */
ip->tot_len = htons(IPHDRSIZE + TCPHDRSIZE + datasize);
ip->check = in_cksum((char *)packet,IPHDRSIZE);

/* The IP header is intact. The packet is ready. */

#ifdef TCP_PKT_DEBUG
printf("Packet ready. Dump: \n");
#ifdef TCP_PKT_DEBUG_DATA
HEXDUMP(IPHDRSIZE+TCPHDRSIZE+datasize,packet);
#else
HEXDUMP(IPHDRSIZE+TCPHDRSIZE,packet);
#endif
printf("\n");
#endif

return sendto(socket, packet, IPHDRSIZE+TCPHDRSIZE+datasize, 0, (struct sockaddr *)address, sizeof(struct sockaddr));

/* And off into the raw socket it goes. */
}




/*
* resolve.c
*
* resolves an internet text address into (struct sockaddr_in).
*
* CHANGES: 1. added the RESOLVE_QUIET preprocessor conditions. Jan 1996
* 2. added resolve_rns() to always provide both name/ip. March 1996
*/

#include <sys/types.h>
#include <string.h>
#include <netdb.h>
#include <stdio.h>
#include <netinet/in.h>

int resolve( const char *name, struct sockaddr_in *addr, int port )
{
struct hostent *host;

/* clear everything in case I forget something */
bzero(addr,sizeof(struct sockaddr_in));

if (( host = gethostbyname(name) ) == NULL ) {
#ifndef RESOLVE_QUIET
fprintf(stderr,"unable to resolve host \"%s\" -- ",name);
perror("");
#endif
return -1;
}

addr->sin_family = host->h_addrtype;
memcpy((caddr_t)&addr->sin_addr,host->h_addr,host->h_length);
addr->sin_port = htons(port);

return 0;
}

int resolve_rns( char *name , unsigned long addr )
{
struct hostent *host;
unsigned long address;

address = addr;
host = gethostbyaddr((char *)&address,4,AF_INET);

if (!host) {
#ifndef RESOLVE_QUIET
fprintf(stderr,"unable to resolve host \"%s\" -- ",inet_ntoa(addr));
perror("");
#endif

return -1;
}


strcpy(name,host->h_name);

return 0;
}


unsigned long addr_to_ulong(struct sockaddr_in *addr)
{
return addr->sin_addr.s_addr;
}

-----<EOF>----------------------------------------------------------
+ 번역후기...

Phrack 49 - 15 TCP port Stealth Scanning 은 매우 흥미로웠습니다.
번역을 하면서도 많은 호기심들을 갖게한 기사였습니다.
어쨌든 매끄럽지 못한 번역이지만 끝까지 읽어주신 분들께 감사드리며
시간적 여유가 있다면 소스까지도 분석해 보고 싶습니다.

흥미로운 글을 프랙에 올린 이 기사의 저자 Uriel Maimon에게 감사하고
이글이 많은 도움이 되길 바랍니다.

그리고 틀린 부분이나 보충할 부분은 언제든지 저에게 메일 주십시오.

(realdata@igrus.inha.ac.kr)

Inha Group of Research for Unix Security | KHDP


그리고 제가 삽질한거===========
[root@localhost TFT1]# gcc scantcp.c -o scantcp
In file included from tcppkt03.c:21,
from scantcp.c:111:
/usr/include/netinet/tcp.h:145:17: warning: "TCP_MSS" redefined
/usr/include/netinet/ip_tcp.h:68:1: warning: this is the location of the prev
s definition
In file included from tcppkt03.c:22,
from scantcp.c:112:
/usr/include/netinet/tcp.h:74: redefinition of `struct tcphdr'
In file included from scantcp.c:112:
tcppkt03.c: In function `tcpip_send':
tcppkt03.c:129: structure has no member named `th_sport'
tcppkt03.c:130: structure has no member named `th_dport'
tcppkt03.c:131: structure has no member named `th_off'
tcppkt03.c:132: structure has no member named `th_flags'
tcppkt03.c:133: structure has no member named `th_seq'
tcppkt03.c:134: structure has no member named `th_ack'
tcppkt03.c:135: structure has no member named `th_win'
tcppkt03.c:139: structure has no member named `th_sum'
scantcp.c: In function `main':
scantcp.c:715: structure has no member named `th_dport'
scantcp.c:719: structure has no member named `th_sport'
scantcp.c:729: structure has no member named `th_win'
scantcp.c:731: structure has no member named `th_flags'
scantcp.c:739: structure has no member named `th_flags'
scantcp.c:597: warning: return type of `main' is not `int'
[root@localhost TFT1]#
Display all 1935 possibilities? (y or n)
[root@localhost TFT1]# gcc scantcp.c -o scantcp
scantcp.c: In function `main':
scantcp.c:597: warning: return type of `main' is not `int'
[root@localhost TFT1]# who
------------------------------------------------------------------
수정 =>
/* remove inlines for smaller size but lower speed */

#include <netinet/in.h>
#include <string.h>
#include <sys/types.h>
#include <netinet/ip.h>
/* #include <netinet/tcp.h>*/ <=헤더파일 주석처러

#define IPHDRSIZE sizeof(struct iphdr)
#define TCPHDRSIZE sizeof(struct tcphdr)
#define PSEUDOHDRSIZE sizeof(struct pseudohdr)

/* ********** RIPPED CODE START ******************************** */
----------------------------------------------------------------
[root@localhost TFT1]# gcc scantcp.c -o scantcp
scantcp.c: In function `main':
scantcp.c:597: warning: return type of `main' is not `int'
[root@localhost TFT1]# who
===실행결과=============================================================
[root@localhost _phrack]# ./scantcp 0 211.123.123.123 203.253.27.177 1-30 10 1

scantcp
version 1.32

# response address : 211.123.123.123 (211.123.123.123)
# target address : 203.253.27.177 (203.253.27.177)
# ports : 1-30
# (total number of ports) : 30
# delay between sends : 10 microseconds
# delay : 1 seconds
# flood dectection threshold : 8 unanswered sends
# slow factor : 10
# max sends per port : 3

* BEGINNING SCAN
* sending to port 1
* sending to port 2
* sending to port 3
* sending to port 4
* sending to port 5
* sending to port 6
* sending to port 7
* sending to port 8
* sending to port 9


-- THRESHOLD CROSSED - SLOWING UP SENDS

* sending to port 10
* sending to port 11
* sending to port 12
* sending to port 13
* sending to port 14
* sending to port 15
* sending to port 16
* sending to port 17
* sending to port 18


-- THRESHOLD CROSSED - SLOWING UP SENDS

* sending to port 19
* sending to port 20
* sending to port 21
* sending to port 22
* sending to port 23
* sending to port 24
* sending to port 25
* sending to port 26
* sending to port 27


-- THRESHOLD CROSSED - SLOWING UP SENDS

* sending to port 28
* sending to port 29
* sending to port 30
* sending to port 1
* sending to port 2
* sending to port 3
* sending to port 4
* sending to port 5
* sending to port 6
.
.
.
----------옵션을 어떻게 하는걸까.ㅡㅡ
[Anesra@localhost TFT1]$ ./scantcp 0 211.123.123.123 203.253.27.177 1-30 10 1

scantcp
version 1.32

# response address : 211.123.123.123 (211.123.123.123)
# target address : 203.253.27.177 (203.253.27.177)
# ports : 1-30
# (total number of ports) : 30
# delay between sends : 10 microseconds
# delay : 1 seconds
# flood dectection threshold : 8 unanswered sends
# slow factor : 10
# max sends per port : 3


error: couldn't get TCP raw socket

[Anesra@localhost TFT1]$
역시 일반권한으론 TCP raw socket을 못쓰는 구나.
------------------------------------------------------------------




--------------------- [원본 메세지] ---------------------
raw socket 에대해서 자세하게 설명하구 있는 사이트나 문서알구
계시분은 좀 알려주세여 핵랩10깨기 힘드네여..
raw socket 예젤라두 있음 좋구여..
모두들 즐핵하시기를