---[ Phrack Magazine Volume 7, Issue 51 September 01, 1997, article 11 of 17 -------------------------[ The Art of Port Scanning --------[ Fyodor 번역: 광주 해커스랩 [Techniques] 정계옥(hook7346@kornet.net) [Feature] 홍상국(scrude@orgio.net) [Abstract][Introduction][The Code]류성철(oprix@hanmail.net) [요약] Abstract 이 문서는 어느 서버의 어느 포트(프로토콜의 추상화와 비슷한 개념)가 열렸는지 를 확인하는 기술을 말한다. 포트는 정보 교류를 위한 기초가 된다. 이 존재를 아는 건 서버와 정보를 교환하는데 유리하다. 따라서 이런 네트워크 환경을 검색하려는 사람들에겐 특히 해커에겐 아주 유용한 기술이다. 여러 매체에서 떠드는 데 비해서 인터넷은 TCP 80포트로만 이루어진게 아니다. WWW로만 모은 정보를 사용하는 사람이 있다면 그사람은 보통실력의 AOL 사용자와 같은 수준일 뿐이다. 또 이 문서는 내가 속한 프로그램을 만드는 프로젝트의 문서를 소개하는 의미도 있다. 그 프로그램은 거대 네트워크를 검사할때나 다른 스캐너를 쓸때 맞닥뜨리는 문제를 해결한 포트 스캐너이다. 이름은 nmap이라고 하고 아래의 기술을 쓸 수 있다. - vanilla TCP connect() scanning, - TCP SYN (half open) scanning, - TCP FIN (stealth) scanning, - TCP ftp proxy (bounce attack) scanning - SYN/FIN scanning using IP fragments (bypasses packet filters), - UDP recvfrom() scanning, - UDP raw ICMP port unreachable scanning, - ICMP scanning (ping-sweep), and - reverse-ident scanning. 아래의 소스 코드는 자유스럽게 배포해도 좋다. [소개] Introduction 역자 왈: 왜 이부분에 이글이 들어갔는지 모르겠다. 저자 넋두리인듯 싶다. 귀찮아서 번역은 피했다. Scanning, as a method for discovering exploitable communication channels, has been around for ages. The idea is to probe as many listeners as possible, and keep track of the ones that are receptive or useful to your particular need. Much of the field of advertising is based on this paradigm, and the "to current resident" brute force style of bulk mail is an almost perfect parallel to what we will discuss. Just stick a message in every mailbox and wait for the responses to trickle back. Scanning entered the h/p world along with the phone systems. Here we have this tremendous global telecommunications network, all reachable through codes on our telephone. Millions of numbers are reachable locally, yet we may only be interested in 0.5% of these numbers, perhaps those that answer with a carrier. The logical solution to finding those numbers that interest us is to try them all. Thus the field of "wardialing" arose. Excellent programs like Toneloc were developed to facilitate the probing of entire exchanges and more. The basic idea is simple. If you dial a number and your modem gives you a CONNECT, you record it. Otherwise the computer hangs up and tirelessly dials the next one. While wardialing is still useful, we are now finding that many of the computers we wish to communicate with are connected through networks such as the Internet rather than analog phone dialups. Scanning these machines involves the same brute force technique. We send a blizzard of packets for various protocols, and we deduce which services are listening from the responses we receive (or don't receive). [기술적인 내용들] Techniques 지금까지, 목표서버(공격하고자 하는 서버)가 사용하며 열고있는 프로토콜과 포트들을 검사 하기 위한 수많은 기술들이 발전해 왔다. 그 기술들은 각기 장점과 단점을 가지고 있다. 이제부터 가장 일반적인 것들을 나열해 보겠다. - TCP connect() 스캐닝 : 이것은 TCP 스캐닝중에서 가장 기본적인 모형이다. O/S(운영체 제)가 제공하는 connect() 시스템 콜은 서버의 각기 잘 알려진 포트로 접속하기 위해서 사용된다. 만약, 그러한 포트가 열려져 있다면, connect() 시스템 콜은 정상적으로 동작된다. 그러나, 포트가 닫혀 있으면, 그 포트는 도달할 수 없는 것으로 판명된다. 이 TCP connect() 스캐닝의 하나의 강점은 이 시스템 콜을 누구나 사용할 수 있다는 것이 다. 유닉스시스템을 사용하는 모든 사용자는 이 시스템 콜을 이용할 수 있다. 또 하나의 이 점은 속도다. 각각의 목표 포트에 독립적인 connect() 콜을 일렬방식으로 만든다면, 느린 접속에 꽤 많은 시간이 걸릴 것이지만, 우리는 병렬방식으로 많은 Socket( connect()콜의 접속상태 )을 이용하여 스캔을 빠르게 수행할 수 있다. non-blocking I/O를 이용하면, 짧은 time-out period(.제한시간)를 설정하고, 한꺼번에 모든 Socket들의 상태를 볼 수 있다. 이것은 NMAP이 지원하는 가장 빠른 스캐닝방법이며, -t 옵션을 쓰면 사용할 수 있다. 이 방식의 크나큰 약점은 쉽게 발각되고 필터링된다는 것이다. 목표서버는 connect() 콜의 접속을 받은 서비스를 통해서 많은 양의 접속 및 에러메시지가 로그에 기록되면 바로 접속을 끊을 것이다. - TCP SYN 스캐닝 : 이 기술은 통상 "half-open"(반만 열려진)스캐닝으로 불려진다. 왜냐 하면 완벽한 TCP 연결을 하지 않기 때문이다. 여러분은 실제로 접속을 하려는 것처럼 SYN 패킷을 보내고, 응답을 기다린다. SYN|ACK 응답은 포트가 열려져 있음을 가리킨다. RST 응답은 포트가 닫혀져 있음을 가리킨다. 만약, SYN|ACK 응답이 오면, 여러분은 즉시 RST 응답을 보내어 connect() 접속을 끊는다. (실제로는 kernel이 우리를 위해서 이 작업을 대 신해 준다.) 이 스캐닝 기술의 이점은 일부 사이트들만이 이런 접속상황을 로그파일에 기록한다는 것이 다. ( 역자주: 이 문서가 쓰여질 때는 그랬는지 모르지만, 이 글을 해석하는 지금은 안 그 럴 것이다.) 불행히도, 일반적인 SYN 패킷을 만들기 위해서는 root 관리자의 권한을 가져야 한다. SYN 스캐닝을 하려면 NMAP에서 -s 옵션을 사용하면 된다. - TCP FIN 스캐닝 : 이제는 SYN 스캐닝조차 더 이상 비밀스러운 것이 아니다. 어떤 firewall 들과 packet filter들은 열려져 있지 않은 포트들에 접근하는 SYN 패킷들을 감시한 다. 그리고, synlogger와 Courtney 같은 프로그램 또한, 이런 SYN 스캔을 감지할 수 있다. 반면에, FIN 패킷은 그러한 방해를 뚫을 수 있다. 이 스캐닝 기술은 Phrack 49의 15번 문 서로써 Uriel Maimon에 의해서 자세히 설명되어 있다. 닫혀진 포트들은 FIN 패킷에 RST로 응답하는 경향이 있다. 열려진 포트들은 FIN 패킷을 무 시한다. 이것은 TCP 운용에서의 하나의 bug이며, 100% 신뢰할 수 없다. ( 어떤 시스템들, 특히 Micro$oft 운영체제 사용서버들, 은 전혀 반응을 보이지 않는다.) 이 기술은 대부분의 다른 시스템에서는 아주 잘 동작한다. FIN 스캐닝은 NMAP에서 -U 옵션으로 사용된다. - Fragmentation 스캐닝 : 이것은 본질적으로 전혀 새로운 기술이 아닌 다른 기술들의 변 형된 형태이다. 여러분은 단순히 탐지패킷을 보내는 것이 아니라 패킷을 몇 개의 작은 IP fragment로 나눈다. 여러분은 여러분이 하고자 하는 작업을 packet filter들이나 다른 것들 이 감지하지 못하도록 TCP 헤더를 몇 개의 패킷으로 분리시킨다. 주의하기 바란다!! 어떤 프로그램들을 이러한 아주 작은 패킷을 다루는데 문제가 발생한다. 내(Fyodor)가 애용하는 스니퍼(sniffer)는 24byte 패킷이 온 후에 첫 번째로 오는 36byte fragment를 인식하지 못한다. 이 방법이 모든 IP fragment들을 큐(Queue : 직렬형의 버퍼)에 저장하는 packet filter나 firewall을 통과하지 못하더라도, 수많은 네트워크들은 이러한 fragment들에 대한 정보를 조 사할 만한 여유가 없다. 이 특징은 스캐너라고 불리우는 프로그램들 사이에서는 약간은 생소한 것이다. (이러한 기 능을 하는 스캐너를 나(Fyodor)는 아직 보지 못했다.) 이 기능을 추천해 준 daemon9에게 감사한다. "-f"옵션을 사용하면, 지정된 SYN 또는 FIN 스캔에게 아주 작은 fragment로 분할된 패킷 을 보내도록 할 수 있다. - TCP 역 ident 스캐닝 : 1996년 버그트랙(bugtraq)에서 Dave Goldsmith가 발표했던 것과 같이 ident 프로토콜(RFC1413)은 설사 어떤 프로세스(프로그램)가 접속을 초기화하지 않았 더라도, TCP방식으로 접속된 그 프로세서의 실행권자 username을 공개시켜 버린다. 예를 들어서, 여러분은 http포트로 접속하고, identd를 이용하여 서버가 root 권한으로 실행되고 있는지를 알 수 있다. 이 스캐닝은 오직 상대서버와의 완전한 TCP 접속상태에서만 가능하 다.("-t" 옵션을 반드시 써야한다는 것을 의미한다.) NMAP의 "-i"옵션을 모든 열려진 포트의 소유권자를 밝혀내는데 쓰인다. - FTP bounce attack : ftp 프로토콜(RFC959)의 흥미로운 특징은 Proxy ftp 접속(대리 ftp 접속)을 지원한다는 것이다. 쉽게 말하면, 우리는 evil.com 이라는 서버에서 target.com의 FTP Server-PI(프로토콜 해석기)로 접속할 수 있다. 그러면 우리는 Server-PI가 Server-DTP(자료전송 프로세서)를 초기화시키고, 인터넷과 연결된 어떤 곳으로든 파일을 보낼 수 있도록 할 수 있다. 비록 RFC에서 하나의 서버로부터 다른 서버로 파일을 전송하는 것이 허용된다고 명백하게 명시하였지만, User-DTP도 아마 가능할 것이다. 1985년에 RFC가 처음 제정되었을 때, 이것은 매우 잘 동작하였지만, 지금 우리는 사람들이 ftp서버를 강탈하고, 데이터를 인터넷의 임의지점으로 유출시키는 것을 허용치 않는다. 1995년에 *Hobbit*는 FTP 프로토콜의 이 약점이 "도달할 수 없는 이메일이나 news를 가상 적으로 전송하거나, 여러 사이트의 서버들을 자꾸 건들거나, 디스크를 채우거나, 방화벽을 뛰어넘도록 시도하거나, 통상 동시에 추적하기 난처하고 어렵게 만드는데 사용될 수 있다" 라고 기술했다. 우리가 이것을 이용하게 된 이유는 놀랍게도 proxy ftp 서버의 TCP 포트들을 스캔하기 위 해서이다. 이런 식으로, 여러분은 방화벽뒤의 ftp서버에 접속할 수 있게 된다. 그리고는, 방 화벽으로 가려져 있는 듯한 (139포트가 아주 좋은 예이다.) 포트들을 스캔한다. 만약, ftp서버가 어느 한 디렉토리(예를 들어, /incoming 디렉토리)에 읽기 또는 쓰기 권한 을 허용하고 있다면, 여러분은 미리 찾아놓은 열려진 포트들로 임의의 데이터를 전송할 수 있다. 포트 스캐닝에 있어서, 우리의 기술은 수동적인 "user-DTP"가 특정포트로 응답대기중이다. 라고 정의하기 위해서 PORT 명령어를 사용한다. 그리고, 우리는 현재 디렉토리를 LIST 해 보려고 시도한다. 그러면, 결과는 server-DTP 채널을 통하여 보내진다. 만약 우리의 목표서 버가 특정포트에 응답대기중이라면, 전송은 정상적으로 수행될 것이다. (150 또는 226 응답 을 생성하면서...) 그렇지 않으면, 우리는 "425 데이터접속을 생성할 수 없습니다. 접속거부" 라는 메시지를 받을 것이다. 그리고 난 후, 우리는 또 다른 PORT 명령을 내려서 다음 포트 를 시험해 본다. 이 방식의 좋은 점은 아주 확실하다는 것이다. (추적하기 어렵고, 방화벽을 통과할 가능성 이 있다.) 단점은 속도가 느리고, 어떤 FTP 서버들은 proxy기능을 사용할 수 없도록 만들어 놓았고, 이미 방어책을 만들어 놓았다. 이 방식이 유용한가를 밝히기 위해서 이 방식이 동작하고 하 지 않는 사이트들의 최초화면 제목(Banner)을 몇가지 나열해 보았다. *Bounce attacks worked:* 220 xxxxxxx.com FTP server (Version wu-2.4(3) Wed Dec 14 ...) ready. 220 xxx.xxx.xxx.edu FTP server ready. 220 xx.Telcom.xxxx.EDU FTP server (Version wu-2.4(3) Tue Jun 11 ...) ready. 220 lem FTP server (SunOS 4.1) ready. 220 xxx.xxx.es FTP server (Version wu-2.4(11) Sat Apr 27 ...) ready. 220 elios FTP server (SunOS 4.1) ready *Bounce attack failed:* 220 wcarchive.cdrom.com FTP server (Version DG-2.0.39 Sun May 4 ...) ready. 220 xxx.xx.xxxxx.EDU Version wu-2.4.2-academ[BETA-12](1) Fri Feb 7 220 ftp Microsoft FTP Service (Version 3.0). 220 xxx FTP server (Version wu-2.4.2-academ[BETA-11](1) Tue Sep 3 ...) ready. 220 xxx.unc.edu FTP server (Version wu-2.4.2-academ[BETA-13](6) ...) ready. 'x'로 표시된 것은 허점이 있는 서버들을 보호하기 위함이지만, 단순히 한 줄에 맞추기 위해 서 문자수를 줄인 것으로 보면 된다. 여러 개의 '.'도 같은 목적으로 쓰였다. bounce attack은 -b 옵션으로 NMAP에서 사용된다. proxy_server는 일반적 인 URL 형식으로 표시될 수 있다. username:passwd@server:port의 형식. 또한, 서버에 따 라 약간씩 다르지만 어떤 형식이든 가능하다. - UDP ICMP 포트 도달불능 스캐닝 : 이 스캐닝방법은 TCP 대신 UDP를 사용한다는 점에 서 앞에 나열된 방법들과 구별된다. UDP 프로토콜이 간단한데 반하여, 오히려 UDP를 이용 한 스캐닝은 무척 어렵다. 왜냐하면, 열려진 포트들은 우리의 탐지에 정상적인 응답을 하지 않고, 닫혀진 포트들은 에러패킷을 응답하도록 요구받지 않기 때문이다. 운 좋게도, 대부분 의 서버들은 여러분이 닫혀진 UDP포트로 패킷을 보내면 ICMP_PORT_UNREACH에러를 반 드시 보낸다. 그러므로, 포트가 열려져 있지 않는지를 알 수 있게되고, 역으로 생각하면 어 떤 포트들이 열려져 있는지를 판단할 수 있다. UDP패킷들과 ICMP 에러들은 도착한다는 보 장이 없다. 그래서, 이 부류의 UDP스캐너들은 반드시 손실될 것 같은 패킷들의 재전송을 수행해야 한다. ( 그렇지 않는다면, 여러분은 엄청난 양의 잘못된 결과를 얻게 될 것이다.) 또한, 이 스캐닝 기술은 RFC1812의 section 4.3.2.8을 충실히 따르고, ICMP 에러메시지의 비율을 제한하는 서버들의 보정작업을 하기 때문에 느리다. 실제로 리눅스 커널( net/ipv4/icmp.h 파일안에 있는... )은 4초당 80개로 목적지 도달불능 메시지 발생을 제한한다. 게다가, 시간을 넘겼을 경우에는 1/4초간의 휴지기간(쉬는 시간)을 가진다. 언젠가, 나는 이것을 감지하기 위해서 보다 나은 알고리즘을 NMAP에 추가할 것이다. 또한, 여러분은 도달불능 포트를 읽기 위해 필요한 raw ICMP 소켓을 생성하기 위해서는 root 가 되어야 한다. "-u"옵션은 root 권한 사용자들에게 이 스캐닝을 지원하기 위해 쓰인다. 어떤 사람들은 UDP 스캐닝은 불완전하고 쓸모없는 것으로 치부한다. 나는 그들에게 최근의 솔라리스 rpcbind 보안헛점을 상기시키고 싶다. Rpcbind는 32770번을 넘어간 포트 어딘가에 알려지지 않은 UDP 포트를 숨기고 있다. 111 번 포트는 firewall로 가려져 있기 때문에 문제가 되지 않겠지만, 30000번보다 높은 번호의 포트를 열고 있다는 것을 여러분이 어떻게 알 것인가? -- UDP 스캐너가 있다면 여러분도 알 수 있다. -UDP recvfrom() 과 write() 스캐닝 : root 권한의 user가 아니면 포트도달불능 에러를 직 접 읽을 수가 없는데 반하여, 리눅스를 그 에러들이 접수되었을 때 간접적으로 사용자에게 알려줄 만큼 훌륭하다. 예를 들면, 닫혀진 포트로 두 번째 write() 콜은 일반적으로 실패할 것이다. netcat과 Pluvius의 pscan.c 와 같은 많은 스캐너들은 그렇게 한다. 나는 또하나, non-blocking UDP소켓에 recvfrom()콜을 하게되면 ICMP 에러를 받지 못했다면 일반적으로 EAGAIN("Try Again:재시도", 에러번호 13번)을 응답한다. 그렇지 않고, ICMP 에러를 받았다면 ECONNREFUSED( "접속거부", 에러번호 111번)로 응답한다. 이 기술은 루트권한이 아닌 사용자들에게 -u 옵션을 사용했을 때, 열려진 포트들을 판단하 기 위해 쓰여진다. 루트권한 사용자들로 -l 옵션을 쓰면 강제로 이 방식을 사용할 수 있지 만, 바보같은 짓이다. - ICMP echo 스캐닝 : 이것은 실제로 포트스캐닝이 아니다. ICMP가 포트의 특징을 가지고 있지 않기 때문이다. 그러나, 이것은 네트워크내에서 어떤 서버들이 실제 가동중인지를 ping 테스트를 통해서 판단하는데 때때로 유용하다. -P 옵션이 이를 위해서 쓰인다. 또한, 여러분은 매우 큰 네트워크를 검색할 때 PING_TIMEOUT #define을 조정하기를 원할지도 모른다. NMAP는 이 작업을 보다 쉽게 하기 위해서 host/bitmask 표현을 지원한다. 예를 들 어, "nmap -P cert.org/24 152.148.0.0/16"은 CERT네트워크의 C클래스와 B클래스의 주소 중에서 152.148.*.*로 나타내어지는 모든 주소를 검색할 것이다. 한 개의 조직안의 6bit 서브넷을 검색하기 위한 "Host/26"의 표현도 유용하다. [특징] Features nmap 을 만들기 전에 인터넷과 사설 네트워크(인트라넷이란 말은 쓰고 싶지 않다.)에서 다른 스캐너를 찾는데 많은 시간을 썼다. 나는 지금 이용 가능한 최고의 스캐너들, Julian Assange의including strobe, Hobbit의 netcat, Uriel Maimon의 stcp, Pluvius의 pscan, Dave Goldsmith위 ident-scan와 wietse Venema 의 SATAN tcp/udp 등 꽤 많은 수의 스캐너들을 사용해 보았다. 그것들은 모두 우수한 스캐너들이다. 사실, 나는 결국 다른 것들의 최고의 기능들을 지원하 기 위해 그것들의 내부구조까지 연구했다. 마침내, /usr/local/sbin 디렉토리에 있는 많은 수의 다른 스캐너들을 함께 사용하는 것보다 오히려 완전히 새로운 스캐너를 만드는 게 낫겠다고 생각했다. 내가 모든 코드를 쓰는 동안, nmap는 그 이전의 스캐너로부터 많은 좋은 아이디어들을 얻어왔다. 거기에 Fragmentation Scanning같은 새로운 기술과 다른 스캐너에 있었다면 좋았을 걸하는 기능들을 덧붙여 갔다. 여기에 nmap의 유용한 특징 중 몇개를 적어보았다. -동적 지연 시간 계산 : 어떤 스캐너들은 패킷들을 발송하는데 드는 지연시간을 사용자가 넣어 줘야 한다. 이런 정보까지 넣어주어야 하나? 확실하게 호스트들에 Ping을 할 수 있다. 그렇지만, 호스트가 많은 수의 요청을 받았을 경우엔 ping값이 제멋대로 변한다. 썩 좋은 건 아니다. nmap은 적절한 지연시간을 계산하려 애쓴다. 다시 전달되어 오는 패킷을 조사하는 것도 그중 하나이다. 그 결과 스캔 과정동안 지연시간을 수정할 수 있다. 루트 권한을 가진 사용자가, 초기 지연 시간을 아는 중요 방법은 내부의 “핑” 함수 호출 시간을 재는 것이다. 루트 권한이 없는 사용자들은 , 목표 호스트의 닫힌 포트에 connect() 함수를 써서 재본다. 이방법으로 그럭저럭 쓸만한 값을 얻을 수 있다. 덧 붙여서 말하면 혹시라도 지연시간을 자신이 정하고 싶다면 -w 옵션을 사용하면 되지만, 그리 추천하고 싶지 않다. -재전송 retransmission: 어떤 스캐너들은 단지 모든 검사 패킷들을 보내고，응답을 모은다. 그러나 되돌아오는 패킷이 손실될 경우엔 잘못된 결과를 얻게 된다. 특히 패킷이 손실되냐 안 되냐는 점은 수동적인 스캔 방법인 UDP 스캔과 FIN 스캔에서 중요하다. 그 스캔이 찾는 값이 어느 포트가 보낸 패킷에 응답을 안 하는가 하는 정보이기 때문이다. 대부분의 경우, 응답하지 않는 포트들을 위해 확인차 nmap는 설정한 값만큼 패킷을 다시 보내본다. -병렬 포트 스캐닝 : 어떤 스캐너들은 전체 65535개의 포트를 검사하는데 한번에 하나씩 차례로 스캔을 한다. 매우 빠른 로컬 네트워크 상에서라면 잘 작동된다. 인터넷과 같은 커다란 네트워크에서는 이런 속도론 할 수가 없다. nmap는 모든 TCP와 UDP 모드들에서 Non-Bolocking I/O(역자 주:딱히 번역할 말이 생각이 나지 않는다. 멈춤없이 한다고 생각하자. 자세한 건 accept함수와 관련이 있다.)와 병렬 스캔을 사용한다. 동시에 병렬로 작동하는 스캔의 수는 -M(최대 소켓 옵션)으로 설정할 수 있다. 매우 빠른 네트워크에서 이 값을 18 혹은 그 이상으로 늘린다면 실행속도 저하가 나오지만, 느린 네트워크에서는 만족할 만한 실행속도 향상이 있다. 유연한 포트 지정 Flexible port specification : 나는 항상 모든 65535의 포트들을 스캔하고 싶지는 않다. 또한 1 부터 N 값까지 스캔할 수 있는 스캐너도 마음에 들지 않는다. -p 옵션으로 스캔을 위해 포트들과 범위들을 마음대로 지정할 수 있다. 예를 들면,‘-p 21-25,80,113,60000-’ 이렇게 적은 뜻은 (끝에 따라오는 하이픈은 65535란 값이 생략되어 있고 앞서 나오는 하이픈은 1에서 부터 시작하는 걸 의미한다) 21부터-25 포트 그리고 80 또한 113번 포트와 60000부터 65535 까지 포트를 검사하라는 말이다. /etc/services에서 설정된 포트들만을 검사하는 -F(빠른) 옵션을 사용할 수 있다. 유연한 목표 지정 Flexible target specification : 나는 한개의 호스트이상을 자주 스캔하고 싶은데, 일일히 커다란 네트워크 상의 각각의 호스트 주소를 일일이 적고 싶지 않다. nmap은 nmap의 옵션(또는 옵션 인수)이 아닌 모든 것은 타겟 호스트로 간주한다. 앞에서도 말했지만, 호스트 이름이나 IP 주소에 /mask를 선택적으로 덧붙이면 같은 값을 같은 모든 호스트들을 검사할 수 있다. 다운 된 호스트 검사 detection of down hosts : 어떤 스캐너들은 대규모 네트워크도 검사 할 수 있다. 그러나 다운된 호스트의 65535개의 포트를 검사한 다는 건 시간 낭비가 아닐까? nmap은 기본적으로 다운된 호스트인지 아닌지 사전에 ping을 각각의 호스트에 보내서 시간 낭비를 막는다. 이상한 포트에 값을 보내서 다운된 호스트를 아는데나 잘못해서 네트워크 주소나 브로드 캐스트 주소를 보냈을 때도 유용하다.(역자 주:무슨 소리인지 잘 모르겠다.) 원문은 It is also capable of bailing on hosts that seem down based on strange port scanning errors. It is also meant to be tolerant of people who accidentally scan network addresses, broadcast addresses , etc. 당신의 IP 주소 검사 detection of your IP address: 몇 가지 이유로 많은 수의 스캐너가 입력값 중 하나로 당신의 IP 주소를 요구한다. ifconfig하기도 싫고 스캔 할 때마다 내 자신의 주소를 아는걸 원치 않는다. 물론 입력값으로 주는 방법이 주소가 바뀔 때마다 다시 컴파일해서 사용하는 것보다 훨씬 낫긴 하지만. nmap의 경우는 처음에 ping을 사용하는 동안 주소를 알아내고, echo 값으로 돌아오는 패킷의 받는 주소를 사용한다. 그 값이 router를 통과하는 값이 기 대문이다. 만약 이렇게 안 된다면(호스트에 Ping을 할 수가 없다면) nmapd는 각각의 인터페이스를 조사하고 그 값을 사용한다. -S 옵션으로 그값을 그냥 지정해 줄 수 있다. 그러나 다른 사람이 SYN과 FIN 스캔을 하는 것처럼 보이기를 바란다면 이 옵션을 사용하지 마라. 다른 옵션들 Some other, more minor options: -v (verbose): 대화식으로 사용하고 싶을때 쓴면 좋다. 다른 유용한 메시지도 나오고 정렬된 결과값이 나오기 전에 어떤 포트가 열렸는지 먼저 알 수 있다.(역자 주: 성질 급한 사람 용이군~) -r (randomize): 목표 호스트의 포트를 임으로 검사한다.(역자 주: 요즘 나오는 좋은 침입자 감지 시스템은 한 호스트에서 포트 검사가 차례로 오면 로그를 남기든지 막아버린다.) -q (quash argv): argv[0] 값을 변화시켜서 to FAKE_ARGV ("pine" 이 기본값)로 보이게 한다. 그리고 다른 옵션들은 제거 시켜 버린다. w와 ps명령을 칠때 위험하지 않은 일을 하는 것처럼 보인다. -h 옵션을 요약해서 보여준다. Also look for http://www.dhp.com/~fyodor/nmap/,그리고 그것은 내가 나중 버전들과 더 많은 정보를 둘 예정의 웹 사이트이다. (역자 주: 언제부터 인 지는 모르지만 http://www.insecure.org/nmap으로 바뀌었다.) [코드] The code 역자 주: 혹시라도 코드에 이해가 힘들까봐 원문과 함께 편집했습니다. This should compile fine on any Linux box with 'gcc -O6 -o nmap nmap.c -lm'. It is distrubuted under the terms of the GNU GENERAL PUBLIC LICENSE. If you have problems or comments, feel free to mail me (fyodor@dhp.com). 이 프로그램은 'gcc -O6 -o nmap nmap.c -lm'이라고 하면 리눅스에서는 잘 컴파일 된다. 이 프로그램은 GNU GPL 라이브러리 하에서 배포된다. 혹시 문제가 생기거나 질문이 있다면 fyodor@dhp.com으로 연락주기 바란다. <++> nmap/Makefile # A trivial makefile for Network Mapper # 아주 간단한 nmap을 위한 makefile nmap: nmap.c nmap.h gcc -Wall -O6 -o nmap nmap.c -lm <--> <++> nmap/nmap.h #ifndef NMAP_H #define NMAP_H /************************INCLUDES**********************************/ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include /**/ #include /**/ #include #include #include #include #include #include /************************DEFINES************************************/ /* #define to zero if you don't want to ignore hosts of the form xxx.xxx.xxx.{0,255} (usually network and broadcast addresses) */ /* 네트워크 자신과 브로드 캐스트 주소를 무시하지 않으려면 값을 0으로 하세요. */ #define IGNORE_ZERO_AND_255_HOSTS 1 #define DEBUGGING 0 /* Default number of ports in paralell. Doesn't always involve actual sockets. Can also adjust with the -M command line option. */ /* 동시에 열수 있는 소켓의 갯수입니다. 실제적으로 항상 열수 있는 소켓 수는 아닙니다. -M 옵션으로 바꿀 있습니다. */ #define MAX_SOCKETS 36 /* If reads of a UDP port keep returning EAGAIN (errno 13), do we want to count the port as valid? */ /* UDP 포트에서 EAGAIN이라는 에러 값을 얻어낸다면, 그 포트는 열려 있는 걸로 간주할까요? */ #define RISKY_UDP_SCAN 0 /* This ideally should be a port that isn't in use for any protocol on our machine or on the target */ /* 어떤 서버나 이 포트는 사용되지 않는다고 예상할 수 있는 포트 */ #define MAGIC_PORT 49724 /* How many udp sends without a ICMP port unreachable error does it take before we consider the port open? */ /* 몇 개의 도달 할 수 없다는 ICMP를 에러를 받아야 그 포트가 닫혀있다고 생각할까요? */ #define UDP_MAX_PORT_RETRIES 4 /*How many seconds before we give up on a host being alive? */ /*서버가 살아있는지 판단하기위해 기다리는 시간은? */ #define PING_TIMEOUT 2 #define FAKE_ARGV "pine" /* What ps and w should show if you use -q */ /* nmap이 ps나 w에서는 어떤 프로그램으로 보이길 원하는가요? */ /* How do we want to log into ftp sites for */ /* ftp 사이트에 들어갔을때 log에 어떻게 남길까요? */ #define FTPUSER "anonymous" #define FTPPASS "-wwwuser@" #define FTP_RETRIES 2 /* How many times should we relogin if we lose control connection? */ /* 연결이 끊길 경우 몇 번 재 접속 할까요? */ #define UC(b) (((int)b)&0xff) #define MORE_FRAGMENTS 8192 /*NOT a user serviceable parameter */ /* 사용자와 관련 없는 인수 */ #define fatal(x) { fprintf(stderr, "%s\n", x); exit(-1); } #define error(x) fprintf(stderr, "%s\n", x); /***********************STRUCTURES**********************************/ typedef struct port { unsigned short portno; unsigned char proto; char *owner; struct port *next; } port; struct ftpinfo { char user[64]; char pass[256]; /* methinks you're paranoid if you need this much space */ /* 더 많은 값이 필요하다면 편집증이 심하시군요. */ char server_name[MAXHOSTNAMELEN + 1]; struct in_addr server; unsigned short port; int sd; /* socket descriptor */ /* 소켓 변별자 */ }; typedef port *portlist; /***********************PROTOTYPES**********************************/ /* print usage information */ /* 사용자 정보 출력 */ void printusage(char *name); /* our scanning functions */ portlist tcp_scan(struct in_addr target, unsigned short *portarray, portlist *ports); portlist syn_scan(struct in_addr target, unsigned short *portarray, struct in_addr *source, int fragment, portlist *ports); portlist fin_scan(struct in_addr target, unsigned short *portarray, struct in_addr *source, int fragment, portlist *ports); portlist udp_scan(struct in_addr target, unsigned short *portarray, portlist *ports); portlist lamer_udp_scan(struct in_addr target, unsigned short *portarray, portlist *ports); portlist bounce_scan(struct in_addr target, unsigned short *portarray, struct ftpinfo *ftp, portlist *ports); /* Scan helper functions */ /* 스캔을 돕는 함수 */ unsigned long calculate_sleep(struct in_addr target); int check_ident_port(struct in_addr target); int getidentinfoz(struct in_addr target, int localport, int remoteport, char *owner); int parse_bounce(struct ftpinfo *ftp, char *url); int ftp_anon_connect(struct ftpinfo *ftp); /* port manipulators */ /* 포트를 조정함수 */ unsigned short *getpts(char *expr); /* someone stole the name getports()! */ unsigned short *getfastports(int tcpscan, int udpscan); int addport(portlist *ports, unsigned short portno, unsigned short protocol, char *owner); int deleteport(portlist *ports, unsigned short portno, unsigned short protocol); void printandfreeports(portlist ports); int shortfry(unsigned short *ports); /* socket manipulation functions */ /* 소켓 조정 함수 */ void init_socket(int sd); int unblock_socket(int sd); int block_socket(int sd); int recvtime(int sd, char *buf, int len, int seconds); /* RAW packet building/dissasembling stuff */ /* Raw 패킷을 만들고 분석하는 함수 */ int send_tcp_raw( int sd, struct in_addr *source, struct in_addr *victim, unsigned short sport, unsigned short dport, unsigned long seq, unsigned long ack, unsigned char flags, unsigned short window, char *data, unsigned short datalen); int isup(struct in_addr target); unsigned short in_cksum(unsigned short *ptr,int nbytes); int send_small_fragz(int sd, struct in_addr *source, struct in_addr *victim, int sport, int dport, int flags); int readtcppacket(char *packet, int readdata); int listen_icmp(int icmpsock, unsigned short outports[], unsigned short numtries[], int *num_out, struct in_addr target, portlist *ports); /* general helper functions */ /* 일반적으로 쓰이는 편리한 함수 */ void hdump(unsigned char *packet, int len); void *safe_malloc(int size); #endif /* NMAP_H */ <--> <++> nmap/nmap.c #include "nmap.h" /* global options */ /* 전체 옵션 */ short debugging = DEBUGGING; short verbose = 0; int number_of_ports = 0; /* How many ports do we scan per machine? */ /* 서버당 몇개의 포트를 스캔 할 겁니까? */ int max_parallel_sockets = MAX_SOCKETS; extern char *optarg; extern int optind; short isr00t = 0; short identscan = 0; char current_name[MAXHOSTNAMELEN + 1]; unsigned long global_delay = 0; unsigned long global_rtt = 0; struct in_addr ouraddr = { 0 }; int main(int argc, char *argv[]) { int i, j, arg, argvlen; short fastscan=0, tcpscan=0, udpscan=0, synscan=0, randomize=0; short fragscan = 0, finscan = 0, quashargv = 0, pingscan = 0, lamerscan = 0; short bouncescan = 0; short *ports = NULL, mask; struct ftpinfo ftp = { FTPUSER, FTPPASS, "", { 0 }, 21, 0}; portlist openports = NULL; struct hostent *target = 0; unsigned long int lastip, currentip, longtmp; char *target_net, *p; struct in_addr current_in, *source=NULL; int hostup = 0; char *fakeargv[argc + 1]; /* argv faking silliness */ /* argv 를 바꾸기 위한 부분 */ for(i=0; i < argc; i++) { fakeargv[i] = safe_malloc(strlen(argv[i]) + 1); strncpy(fakeargv[i], argv[i], strlen(argv[i]) + 1); } fakeargv[argc] = NULL; if (argc < 2 ) printusage(argv[0]); /* OK, lets parse these args! */ /* 인자들을 검색합니다. */ while((arg = getopt(argc,fakeargv,"b:dFfhilM:Pp:qrS:stUuw:v")) != EOF) { switch(arg) { case 'b': bouncescan++; if (parse_bounce(&ftp, optarg) < 0 ) { fprintf(stderr, "Your argument to -b is fucked up. Use the normal url style: user:pass@server:port or just use server and use default anon login\n Use -h for help\n"); } break; case 'd': debugging++; break; case 'F': fastscan++; break; case 'f': fragscan++; break; case 'h': case '?': printusage(argv[0]); case 'i': identscan++; break; case 'l': lamerscan++; udpscan++; break; case 'M': max_parallel_sockets = atoi(optarg); break; case 'P': pingscan++; break; case 'p': if (ports) fatal("Only 1 -p option allowed, seperate multiple ranges with commas."); ports = getpts(optarg); break; case 'r': randomize++; break; case 's': synscan++; break; case 'S': if (source) fatal("You can only use the source option once!\n"); source = safe_malloc(sizeof(struct in_addr)); if (!inet_aton(optarg, source)) fatal("You must give the source address in dotted deciman, currently.\n"); break; case 't': tcpscan++; break; case 'U': finscan++; break; case 'u': udpscan++; break; case 'q': quashargv++; break; case 'w': global_delay = atoi(optarg); break; case 'v': verbose++; } } /* Take care of user wierdness */ /* 혹시라도 사용자의 실수가 있을까봐 */ isr00t = !(geteuid()|geteuid()); if (tcpscan && synscan) fatal("The -t and -s options can't be used together.\ If you are trying to do TCP SYN scanning, just use -s.\ For normal connect() style scanning, use -t"); if ((synscan || finscan || fragscan || pingscan) && !isr00t) fatal("Options specified require r00t privileges. You don't have them!"); if (!tcpscan && !udpscan && !synscan && !finscan && !bouncescan && !pingscan) { tcpscan++; if (verbose) error("No scantype specified, assuming vanilla tcp connect()\ scan. Use -P if you really don't want to portscan."); if (fastscan && ports) fatal("You can use -F (fastscan) OR -p for explicit port specification.\ Not both!\n"); } /* If he wants to bounce of an ftp site, that site better damn well be reachable! */ /* ftp 사이트를 bounce 공격을 하려면 그 사이트가 작동해야 겠지요! */ if (bouncescan) { if (!inet_aton(ftp.server_name, &ftp.server)) { if ((target = gethostbyname(ftp.server_name))) memcpy(&ftp.server, target->h_addr_list[0], 4); else { fprintf(stderr, "Failed to resolve ftp bounce proxy hostname/IP: %s\n", ftp.server_name); exit(1); } } else if (verbose) printf("Resolved ftp bounce attack proxy to %s (%s).\n", target->h_name, inet_ntoa(ftp.server)); } printf("\nStarting nmap V 1.21 by Fyodor (fyodor@dhp.com, www.dhp.com/~fyodor/nmap/\n"); if (!verbose) error("Hint: The -v option notifies you of open ports as they are found.\n"); if (fastscan) ports = getfastports(synscan|tcpscan|fragscan|finscan|bouncescan, udpscan|lamerscan); if (!ports) ports = getpts("1-1024"); /* more fakeargv junk, BTW malloc'ing extra space in argv[0] doesn't work */ /* fakeargv를 이용해서 argv의 내용을 바꿉니다. 근데 argv[0]과 같은 크기여야 겠지요. */ if (quashargv) { argvlen = strlen(argv[0]); if (argvlen < strlen(FAKE_ARGV)) fatal("If you want me to fake your argv, you need to call the program with a longer name. Try the full pathname, or rename it fyodorssuperdedouperportscanner"); strncpy(argv[0], FAKE_ARGV, strlen(FAKE_ARGV)); for(i = strlen(FAKE_ARGV); i < argvlen; i++) argv[0][i] = '\0'; for(i=1; i < argc; i++) { argvlen = strlen(argv[i]); for(j=0; j <= argvlen; j++) argv[i][j] = '\0'; } } srand(time(NULL)); while(optind < argc) { /* Time to parse the allowed mask */ /* mask를 검색 */ target = NULL; target_net = strtok(strdup(fakeargv[optind]), "/"); mask = (p = strtok(NULL,""))? atoi(p) : 32; if (debugging) printf("Target network is %s, scanmask is %d\n", target_net, mask); if (!inet_aton(target_net, ¤t_in)) { if ((target = gethostbyname(target_net))) memcpy(¤tip, target->h_addr_list[0], 4); else { fprintf(stderr, "Failed to resolve given hostname/IP: %s\n", target_net); } } else currentip = current_in.s_addr; longtmp = ntohl(currentip); currentip = longtmp & (unsigned long) (0 - pow(2,32 - mask)); lastip = longtmp | (unsigned long) (pow(2,32 - mask) - 1); while (currentip <= lastip) { openports = NULL; longtmp = htonl(currentip); target = gethostbyaddr((char *) &longtmp, 4, AF_INET); current_in.s_addr = longtmp; if (target) strncpy(current_name, target->h_name, MAXHOSTNAMELEN); else current_name[0] = '\0'; current_name[MAXHOSTNAMELEN + 1] = '\0'; if (randomize) shortfry(ports); #ifdef IGNORE_ZERO_AND_255_HOSTS if (IGNORE_ZERO_AND_255_HOSTS && (!(currentip % 256) || currentip % 256 == 255)) { printf("Skipping host %s because IGNORE_ZERO_AND_255_HOSTS is set in the source.\n", inet_ntoa(current_in)); hostup = 0; } else{ #endif if (isr00t) { if (!(hostup = isup(current_in))) { if (!pingscan) printf("Host %s (%s) appears to be down, skipping scan.\n", current_name, inet_ntoa(current_in)); else printf("Host %s (%s) appears to be down\n", current_name, inet_ntoa(current_in)); } else if (debugging || pingscan) printf("Host %s (%s) appears to be up ... good.\n", current_name, inet_ntoa(current_in)); } else hostup = 1; /* We don't really check because the lamer isn't root.*/ } /* Time for some actual scanning! */ /* 실제적인 스캔을 하는 부분 */ if (hostup) { if (tcpscan) tcp_scan(current_in, ports, &openports); if (synscan) syn_scan(current_in, ports, source, fragscan, &openports); if (finscan) fin_scan(current_in, ports, source, fragscan, &openports); if (bouncescan) { if (ftp.sd <= 0) ftp_anon_connect(&ftp); if (ftp.sd > 0) bounce_scan(current_in, ports, &ftp, &openports); } if (udpscan) { if (!isr00t || lamerscan) lamer_udp_scan(current_in, ports, &openports); else udp_scan(current_in, ports, &openports); } if (!openports && !pingscan) printf("No ports open for host %s (%s)\n", current_name, inet_ntoa(current_in)); if (openports) { printf("Open ports on %s (%s):\n", current_name, inet_ntoa(current_in)); printandfreeports(openports); } } currentip++; } optind++; } return 0; } __inline__ int unblock_socket(int sd) { int options; /*Unblock our socket to prevent recvfrom from blocking forever on certain target ports. */ options = O_NONBLOCK | fcntl(sd, F_GETFL); fcntl(sd, F_SETFL, options); return 1; } __inline__ int block_socket(int sd) { int options; options = (~O_NONBLOCK) & fcntl(sd, F_GETFL); fcntl(sd, F_SETFL, options); return 1; } /* Currently only sets SO_LINGER, I haven't seen any evidence that this helps. I'll do more testing before dumping it. */ /* SO_LINGER라고 설정해 놓았지만 실제로 이게 잘 작동하도록 돕는지 확인해 보지 못했다. */ __inline__ void init_socket(int sd) { struct linger l; l.l_onoff = 1; l.l_linger = 0; if (setsockopt(sd, SOL_SOCKET, SO_LINGER, &l, sizeof(struct linger))) { fprintf(stderr, "Problem setting socket SO_LINGER, errno: %d\n", errno); perror("setsockopt"); } } /* Convert a string like "-100,200-1024,3000-4000,60000-" into an array of port numbers*/ /* 넘어온 포트에 관한 인자값을 포트와 관련된 배열로 바꾼다. */ unsigned short *getpts(char *origexpr) { int exlen = strlen(origexpr); char *p,*q; unsigned short *tmp, *ports; int i=0, j=0,start,end; char *expr = strdup(origexpr); ports = safe_malloc(65536 * sizeof(short)); i++; i--; for(;j < exlen; j++) if (expr[j] != ' ') expr[i++] = expr[j]; expr[i] = '\0'; exlen = i + 1; i=0; while((p = strchr(expr,','))) { *p = '\0'; if (*expr == '-') {start = 1; end = atoi(expr+ 1);} else { start = end = atoi(expr); if ((q = strchr(expr,'-')) && *(q+1) ) end = atoi(q + 1); else if (q && !*(q+1)) end = 65535; } if (debugging) printf("The first port is %d, and the last one is %d\n", start, end); if (start < 1 || start > end) fatal("Your port specifications are illegal!"); for(j=start; j <= end; j++) ports[i++] = j; expr = p + 1; } if (*expr == '-') { start = 1; end = atoi(expr+ 1); } else { start = end = atoi(expr); if ((q = strchr(expr,'-')) && *(q+1) ) end = atoi(q+1); else if (q && !*(q+1)) end = 65535; } if (debugging) printf("The first port is %d, and the last one is %d\n", start, end); if (start < 1 || start > end) fatal("Your port specifications are illegal!"); for(j=start; j <= end; j++) ports[i++] = j; number_of_ports = i; ports[i++] = 0; tmp = realloc(ports, i * sizeof(short)); free(expr); return tmp; } unsigned short *getfastports(int tcpscan, int udpscan) { int portindex = 0, res, lastport = 0; unsigned int portno = 0; unsigned short *ports; char proto[10]; char line[81]; FILE *fp; ports = safe_malloc(65535 * sizeof(unsigned short)); proto[0] = '\0'; if (!(fp = fopen("/etc/services", "r"))) { printf("We can't open /etc/services for reading! Fix your system or don't use -f\n"); perror("fopen"); exit(1); } while(fgets(line, 80, fp)) { res = sscanf(line, "%*s %u/%s", &portno, proto); if (res == 2 && portno != 0 && portno != lastport) { lastport = portno; if (tcpscan && proto[0] == 't') ports[portindex++] = portno; else if (udpscan && proto[0] == 'u') ports[portindex++] = portno; } } number_of_ports = portindex; ports[portindex++] = 0; return realloc(ports, portindex * sizeof(unsigned short)); } void printusage(char *name) { printf("%s [options] [hostname[/mask] . . .] options (none are required, most can be combined): -t tcp connect() port scan -s tcp SYN stealth port scan (must be root) -u UDP port scan, will use MUCH better version if you are root -U Uriel Maimon (P49-15) style FIN stealth scan. -l Do the lamer UDP scan even if root. Less accurate. -P ping \"scan\". Find which hosts on specified network(s) are up. -b ftp \"bounce attack\" port scan -f use tiny fragmented packets for SYN or FIN scan. -i Get identd (rfc 1413) info on listening TCP processes. -p ports: ex: \'-p 23\' will only try port 23 of the host(s) \'-p 20-30,63000-\' scans 20-30 and 63000-65535 default: 1-1024 -F fast scan. Only scans ports in /etc/services, a la strobe(1). -r randomize target port scanning order. -h help, print this junk. Also see http://www.dhp.com/~fyodor/nmap/ -S If you want to specify the source address of SYN or FYN scan. -v Verbose. Its use is recommended. Use twice for greater effect. -w delay. n microsecond delay. Not recommended unless needed. -M maximum number of parallel sockets. Larger isn't always better. -q quash argv to something benign, currently set to \"%s\". Hostnames specified as internet hostname or IP address. Optional '/mask' specifies subnet. cert.org/24 or 192.88.209.5/24 scan CERT's Class C.\n", name, FAKE_ARGV); exit(1); } portlist tcp_scan(struct in_addr target, unsigned short *portarray, portlist *ports) { int starttime, current_out = 0, res , deadindex = 0, i=0, j=0, k=0, max=0; struct sockaddr_in sock, stranger, mysock; int sockaddr_in_len = sizeof(struct sockaddr_in); int sockets[max_parallel_sockets], deadstack[max_parallel_sockets]; unsigned short portno[max_parallel_sockets]; char owner[513], buf[65536]; int tryident = identscan, current_socket /*actually it is a socket INDEX*/; fd_set fds_read, fds_write; struct timeval nowait = {0,0}, longwait = {7,0}; signal(SIGPIPE, SIG_IGN); /* ignore SIGPIPE so our 'write 0 bytes' test doesn't crash our program!*/ /* 프로그램이 SIGPIPE 같은 신호를 받고 다운 되지 않도록 신호를 무시하도록 설정 */ owner[0] = '\0'; starttime = time(NULL); bzero((char *)&sock,sizeof(struct sockaddr_in)); sock.sin_addr.s_addr = target.s_addr; if (verbose || debugging) printf("Initiating TCP connect() scan against %s (%s)\n", current_name, inet_ntoa(sock.sin_addr)); sock.sin_family=AF_INET; FD_ZERO(&fds_read); FD_ZERO(&fds_write); if (tryident) tryident = check_ident_port(target); /* Initially, all of our sockets are "dead" */ /* 기본적으로 소캣이 죽어있다고 기본값을 설정한다. */ for(i = 0 ; i < max_parallel_sockets; i++) { deadstack[deadindex++] = i; portno[i] = 0; } deadindex--; /* deadindex always points to the most recently added dead socket index */ /* deadindex는 항상 최근에 socket index에 추가된 곳을 가르킨다. */ while(portarray[j]) { longwait.tv_sec = 7; longwait.tv_usec = nowait.tv_sec = nowait.tv_usec = 0; for(i=current_out; i < max_parallel_sockets && portarray[j]; i++, j++) { current_socket = deadstack[deadindex--]; if ((sockets[current_socket] = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) == -1) {perror("Socket troubles"); exit(1);} if (sockets[current_socket] > max) max = sockets[current_socket]; current_out++; unblock_socket(sockets[current_socket]); init_socket(sockets[current_socket]); portno[current_socket] = portarray[j]; sock.sin_port = htons(portarray[j]); if ((res = connect(sockets[current_socket],(struct sockaddr *)&sock,sizeof(struct sockaddr)))!=-1) printf("WTF???? I think we got a successful connection in non-blocking!!@#$\n"); else { switch(errno) { case EINPROGRESS: /* The one I always see */ /* 자주 볼 수 있는 부분 */ case EAGAIN: block_socket(sockets[current_socket]); FD_SET(sockets[current_socket], &fds_write); FD_SET(sockets[current_socket], &fds_read); break; default: printf("Strange error from connect: (%d)", errno); perror(""); /*falling through intentionally*/ /* 고의적으로 실패 */ case ECONNREFUSED: if (max == sockets[current_socket]) max--; deadstack[++deadindex] = current_socket; current_out--; portno[current_socket] = 0; close(sockets[current_socket]); break; } } } if (!portarray[j]) sleep(1); /*wait a second for any last packets*/ /* 늦게 올수 있는 패킷을 위해 기다린다. */ while((res = select(max + 1, &fds_read, &fds_write, NULL, (current_out < max_parallel_sockets)? &nowait : &longwait)) > 0) { for(k=0; k < max_parallel_sockets; k++) if (portno[k]) { if (FD_ISSET(sockets[k], &fds_write) && FD_ISSET(sockets[k], &fds_read)) { /*printf("Socket at port %hi is selectable for r & w.", portno[k]);*/ res = recvfrom(sockets[k], buf, 65536, 0, (struct sockaddr *) & stranger, &sockaddr_in_len); if (res >= 0) { if (debugging || verbose) printf("Adding TCP port %hi due to successful read.\n", portno[k]); if (tryident) { if ( getsockname(sockets[k], (struct sockaddr *) &mysock, &sockaddr_in_len ) ) { perror("getsockname"); exit(1); } tryident = getidentinfoz(target, ntohs(mysock.sin_port), portno[k], owner); } addport(ports, portno[k], IPPROTO_TCP, owner); } if (max == sockets[k]) max--; FD_CLR(sockets[k], &fds_read); FD_CLR(sockets[k], &fds_write); deadstack[++deadindex] = k; current_out--; portno[k] = 0; close(sockets[k]); } else if(FD_ISSET(sockets[k], &fds_write)) { /*printf("Socket at port %hi is selectable for w only.VERIFYING\n", portno[k]);*/ res = send(sockets[k], buf, 0, 0); if (res < 0 ) { signal(SIGPIPE, SIG_IGN); if (debugging > 1) printf("Bad port %hi caught by 0-byte write!\n", portno[k]); } else { if (debugging || verbose) printf("Adding TCP port %hi due to successful 0-byte write!\n", portno[k]); if (tryident) { if ( getsockname(sockets[k], (struct sockaddr *) &mysock , &sockaddr_in_len ) ) { perror("getsockname"); exit(1); } tryident = getidentinfoz(target, ntohs(mysock.sin_port), portno[k], owner); } addport(ports, portno[k], IPPROTO_TCP, owner); } if (max == sockets[k]) max--; FD_CLR(sockets[k], &fds_write); deadstack[++deadindex] = k; current_out--; portno[k] = 0; close(sockets[k]); } else if ( FD_ISSET(sockets[k], &fds_read) ) { printf("Socket at port %hi is selectable for r only. This is very wierd.\n", portno[k]); if (max == sockets[k]) max--; FD_CLR(sockets[k], &fds_read); deadstack[++deadindex] = k; current_out--; portno[k] = 0; close(sockets[k]); } else { /*printf("Socket at port %hi not selecting, readding.\n",portno[k]);*/ FD_SET(sockets[k], &fds_write); FD_SET(sockets[k], &fds_read); } } } } if (debugging || verbose) printf("Scanned %d ports in %ld seconds with %d parallel sockets.\n", number_of_ports, time(NULL) - starttime, max_parallel_sockets); return *ports; } /* gawd, my next project will be in c++ so I don't have to deal with this crap ... simple linked list implementation */ /* 내 다음 프로젝트는 이 단순 연결리스트를 다루는 c++인데 꼭 다룰 필요가 있을까? */ int addport(portlist *ports, unsigned short portno, unsigned short protocol, char *owner) { struct port *current, *tmp; int len; if (*ports) { current = *ports; /* 첫번째 경우 list앞에 집어 넣기 */ /* case 1: we add to the front of the list */ if (portno <= current->portno) { if (current->portno == portno && current->proto == protocol) { if (debugging || verbose) printf("Duplicate port (%hi/%s)\n", portno , (protocol == IPPROTO_TCP)? "tcp": "udp"); return -1; } tmp = current; *ports = safe_malloc(sizeof(struct port)); (*ports)->next = tmp; current = *ports; current->portno = portno; current->proto = protocol; if (owner && *owner) { len = strlen(owner); current->owner = malloc(sizeof(char) * (len + 1)); strncpy(current->owner, owner, len + 1); } else current->owner = NULL; } else { /* case 2: we add somewhere in the middle or end of the list */ /* 두번째 경우 list의 중간과 끝에 값을 집어넣을 수 있다. */ while( current->next && current->next->portno < portno) current = current->next; if (current->next && current->next->portno == portno && current->next->proto == protocol) { if (debugging || verbose) printf("Duplicate port (%hi/%s)\n", portno , (protocol == IPPROTO_TCP)? "tcp": "udp"); return -1; } tmp = current->next; current->next = safe_malloc(sizeof(struct port)); current->next->next = tmp; tmp = current->next; tmp->portno = portno; tmp->proto = protocol; if (owner && *owner) { len = strlen(owner); tmp->owner = malloc(sizeof(char) * (len + 1)); strncpy(tmp->owner, owner, len + 1); } else tmp->owner = NULL; } } else { /* Case 3, list is null */ /* 세번째 경우 list가 비어 있을 때 */ *ports = safe_malloc(sizeof(struct port)); tmp = *ports; tmp->portno = portno; tmp->proto = protocol; if (owner && *owner) { len = strlen(owner); tmp->owner = safe_malloc(sizeof(char) * (len + 1)); strncpy(tmp->owner, owner, len + 1); } else tmp->owner = NULL; tmp->next = NULL; } return 0; /*success */ /* 성공 */ } int deleteport(portlist *ports, unsigned short portno, unsigned short protocol) { portlist current, tmp; if (!*ports) { if (debugging > 1) error("Tried to delete from empty port list!"); return -1; } /* Case 1, deletion from front of list*/ /* 첫번째 경우 리스트 앞에서 삭제 */ if ((*ports)->portno == portno && (*ports)->proto == protocol) { tmp = (*ports)->next; if ((*ports)->owner) free((*ports)->owner); free(*ports); *ports = tmp; } else { current = *ports; for(;current->next && (current->next->portno != portno || current->next->proto != protocol); current = current->next); if (!current->next) return -1; tmp = current->next; current->next = tmp->next; if (tmp->owner) free(tmp->owner); free(tmp); } return 0; /* success */ /* 성공 */ } void *safe_malloc(int size) { void *mymem; if (size < 0) fatal("Tried to malloc negative amount of memmory!!!"); if ((mymem = malloc(size)) == NULL) fatal("Malloc Failed! Probably out of space."); return mymem; } void printandfreeports(portlist ports) { char protocol[4]; struct servent *service; port *current = ports, *tmp; printf("Port Number Protocol Service"); printf("%s", (identscan)?" Owner\n":"\n"); while(current != NULL) { strcpy(protocol,(current->proto == IPPROTO_TCP)? "tcp": "udp"); service = getservbyport(htons(current->portno), protocol); printf("%-13d%-11s%-16s%s\n", current->portno, protocol, (service)? service->s_name: "unknown", (current->owner)? current->owner : ""); tmp = current; current = current->next; if (tmp->owner) free(tmp->owner); free(tmp); } printf("\n"); } /* This is the version of udp_scan that uses raw ICMP sockets and requires root priviliges.*/ /* 이버전의 udp_scan은 raw ICMP 소켓을 이용하므로 root 권한이 필요합니다. */ portlist udp_scan(struct in_addr target, unsigned short *portarray, portlist *ports) { int icmpsock, udpsock, tmp, done=0, retries, bytes = 0, res, num_out = 0; int i=0,j=0, k=0, icmperrlimittime, max_tries = UDP_MAX_PORT_RETRIES; unsigned short outports[max_parallel_sockets], numtries[max_parallel_sockets]; struct sockaddr_in her; char senddata[] = "blah\n"; unsigned long starttime, sleeptime; struct timeval shortwait = {1, 0 }; fd_set fds_read, fds_write; bzero(outports, max_parallel_sockets * sizeof(unsigned short)); bzero(numtries, max_parallel_sockets * sizeof(unsigned short)); /* Some systems (like linux) follow the advice of rfc1812 and limit * the rate at which they will respons with icmp error messages * (like port unreachable). icmperrlimittime is to compensate for that. */ /* 어떤 시스템의 경우는 RFC 1812의 권고를 따라서 특정비율로 icmp메시지(예로 도달할 수 없다는 메시지)를 보내게 되면 약간씩 시간지연 시켜 답해준다. */ icmperrlimittime = 60000; sleeptime = (global_delay)? global_delay : (global_rtt)? (1.2 * global_rtt) + 30000 : 1e5; if (global_delay) icmperrlimittime = global_delay; starttime = time(NULL); FD_ZERO(&fds_read); FD_ZERO(&fds_write); if (verbose || debugging) printf("Initiating UDP (raw ICMP version) scan against %s (%s) using wait delay of %li usecs.\n", current_name, inet_ntoa(target), sleeptime); if ((icmpsock = socket(AF_INET, SOCK_RAW, IPPROTO_ICMP)) < 0) perror("Opening ICMP RAW socket"); if ((udpsock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP)) < 0) perror("Opening datagram socket"); unblock_socket(icmpsock); her.sin_addr = target; her.sin_family = AF_INET; while(!done) { tmp = num_out; for(i=0; (i < max_parallel_sockets && portarray[j]) || i < tmp; i++) { close(udpsock); if ((udpsock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP)) < 0) perror("Opening datagram socket"); if ((i > tmp && portarray[j]) || numtries[i] > 1) { if (i > tmp) her.sin_port = htons(portarray[j++]); else her.sin_port = htons(outports[i]); FD_SET(udpsock, &fds_write); FD_SET(icmpsock, &fds_read); shortwait.tv_sec = 1; shortwait.tv_usec = 0; usleep(icmperrlimittime); res = select(udpsock + 1, NULL, &fds_write, NULL, &shortwait); if (FD_ISSET(udpsock, &fds_write)) bytes = sendto(udpsock, senddata, sizeof(senddata), 0, (struct sockaddr *) &her, sizeof(struct sockaddr_in)); else { printf("udpsock not set for writing port %d!", ntohs(her.sin_port)); return *ports; } if (bytes <= 0) { if (errno == ECONNREFUSED) { retries = 10; do { /* This is from when I was using the same socket and would * (rather often) get strange connection refused errors, it * shouldn't happen now that I create a new udp socket for each * port. At some point I will probably go back to 1 socket again. */ /* 이것은 같은 소켓을 이용할때 에러를 거부하는 이상한 연결을 얻을 때 사용한다. 각각의 포트에 새로운 udp소켓을 사용하진 않는다. 어떤 시점에서 다시 처음 소켓으로 돌아간다. */ printf("sendto said connection refused on port %d but trying again anyway.\n", ntohs(her.sin_port)); usleep(icmperrlimittime); bytes = sendto(udpsock, senddata, sizeof(senddata), 0, (struct sockaddr *) &her, sizeof(struct sockaddr_in)); printf("This time it returned %d\n", bytes); } while(bytes <= 0 && retries-- > 0); } if (bytes <= 0) { printf("sendto returned %d.", bytes); fflush(stdout); perror("sendto"); } } if (bytes > 0 && i > tmp) { num_out++; outports[i] = portarray[j-1]; } } } usleep(sleeptime); tmp = listen_icmp(icmpsock, outports, numtries, &num_out, target, ports); if (debugging) printf("listen_icmp caught %d bad ports.\n", tmp); done = !portarray[j]; for (i=0,k=0; i < max_parallel_sockets; i++) if (outports[i]) { if (++numtries[i] > max_tries - 1) { if (debugging || verbose) printf("Adding port %d for 0 unreachable port generations\n", outports[i]); addport(ports, outports[i], IPPROTO_UDP, NULL); num_out--; outports[i] = numtries[i] = 0; } else { done = 0; outports[k] = outports[i]; numtries[k] = numtries[i]; if (k != i) outports[i] = numtries[i] = 0; k++; } } if (num_out == max_parallel_sockets) { printf("Numout is max sockets, that is a problem!\n"); sleep(1); /* Give some time for responses to trickle back, and possibly to reset the hosts ICMP error limit */ /* 일정시간 보낼 수 잇는 ICMP 에러를 보내는 한계를 넘고 각기 따로 오는 답을 받을 시간을 얻으려 시간을 더 준다. */ } } if (debugging || verbose) printf("The UDP raw ICMP scanned %d ports in %ld seconds with %d parallel sockets.\n", number_of_ports, time(NULL) - starttime, max_parallel_sockets); close(icmpsock); close(udpsock); return *ports; } int listen_icmp(int icmpsock, unsigned short outports[], unsigned short numtries[], int *num_out, struct in_addr target, portlist *ports) { char response[1024]; struct sockaddr_in stranger; int sockaddr_in_size = sizeof(struct sockaddr_in); struct in_addr bs; struct iphdr *ip = (struct iphdr *) response; struct icmphdr *icmp = (struct icmphdr *) (response + sizeof(struct iphdr)); struct iphdr *ip2; unsigned short *data; int badport, numcaught=0, bytes, i, tmptry=0, found=0; while ((bytes = recvfrom(icmpsock, response, 1024, 0, (struct sockaddr *) &stranger, &sockaddr_in_size)) > 0) { numcaught++; bs.s_addr = ip->saddr; if (ip->saddr == target.s_addr && ip->protocol == IPPROTO_ICMP && icmp->type == 3 && icmp->code == 3) { ip2 = (struct iphdr *) (response + 4 * ip->ihl + sizeof(struct icmphdr)); data = (unsigned short *) ((char *)ip2 + 4 * ip2->ihl); badport = ntohs(data[1]); /*delete it from our outports array */ found = 0; for(i=0; i < max_parallel_sockets; i++) if (outports[i] == badport) { found = 1; tmptry = numtries[i]; outports[i] = numtries[i] = 0; (*num_out)--; break; } if (debugging && found && tmptry > 0) printf("Badport: %d on try number %d\n", badport, tmptry); if (!found) { if (debugging) printf("Badport %d came in late, deleting from portlist.\n", badport); if (deleteport(ports, badport, IPPROTO_UDP) < 0) if (debugging) printf("Port deletion failed.\n"); } } else { printf("Funked up packet!\n"); } } return numcaught; } /* This fucntion is nonsens. I wrote it all, really optimized etc. Then found out that many hosts limit the rate at which they send icmp errors :( I will probably totally rewrite it to be much simpler at some point. For now I won't worry about it since it isn't a very important functions (UDP is lame, plus there is already a much better function for people who are r00t */ /* 이 함수는 좀 이상하다. 최적화 시켰다. 그후에 많은 호스트가 icmp에러를 보내는 비율을 제한하는걸 알았다. 난 어느 점에서 간단하게 다시 썼다. 지금은 이게 중요한 함수라고 생각이 안 되어 별로 신경이 안 쓰인다. UDP 자체가 부족한 부분이 있어서 root권한을 가진 사람이 더 유리하다. */ portlist lamer_udp_scan(struct in_addr target, unsigned short *portarray, portlist *ports) { int sockaddr_in_size = sizeof(struct sockaddr_in),i=0,j=0,k=0, bytes; int sockets[max_parallel_sockets], trynum[max_parallel_sockets]; unsigned short portno[max_parallel_sockets]; int last_open = 0; char response[1024]; struct sockaddr_in her, stranger; char data[] = "\nhelp\nquit\n"; unsigned long sleeptime; unsigned int starttime; /* Initialize our target sockaddr_in */ /* 목표를 향한 소켓 설정 */ bzero((char *) &her, sizeof(struct sockaddr_in)); her.sin_family = AF_INET; her.sin_addr = target; if (global_delay) sleeptime = global_delay; else sleeptime = calculate_sleep(target) + 60000; /*large to be on the safe side */ /* 안전하도록 되도록 크게 잡는다. */ if (verbose || debugging) printf("Initiating UDP scan against %s (%s), sleeptime: %li\n", current_name, inet_ntoa(target), sleeptime); starttime = time(NULL); for(i = 0 ; i < max_parallel_sockets; i++) trynum[i] = portno[i] = 0; while(portarray[j]) { for(i=0; i < max_parallel_sockets && portarray[j]; i++, j++) { if (i >= last_open) { if ((sockets[i] = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP)) == -1) {perror("datagram socket troubles"); exit(1);} block_socket(sockets[i]); portno[i] = portarray[j]; } her.sin_port = htons(portarray[j]); bytes = sendto(sockets[i], data, sizeof(data), 0, (struct sockaddr *) &her, sizeof(struct sockaddr_in)); usleep(5000); if (debugging > 1) printf("Sent %d bytes on socket %d to port %hi, try number %d.\n", bytes, sockets[i], portno[i], trynum[i]); if (bytes < 0 ) { printf("Sendto returned %d the FIRST TIME!@#$!, errno %d\n", bytes, errno); perror(""); trynum[i] = portno[i] = 0; close(sockets[i]); } } last_open = i; /* Might need to change this to 1e6 if you are having problems*/ /* 문제가 있다면 100000 라고 써보라. */ usleep(sleeptime + 5e5); for(i=0; i < last_open ; i++) { if (portno[i]) { unblock_socket(sockets[i]); if ((bytes = recvfrom(sockets[i], response, 1024, 0, (struct sockaddr *) &stranger, &sockaddr_in_size)) == -1) { if (debugging > 1) printf("2nd recvfrom on port %d returned %d with errno %d.\n", portno[i], bytes, errno); if (errno == EAGAIN /*11*/) { if (trynum[i] < 2) trynum[i]++; else { if (RISKY_UDP_SCAN) { printf("Adding port %d after 3 EAGAIN errors.\n", portno[i]); addport(ports, portno[i], IPPROTO_UDP, NULL); } else if (debugging) printf("Skipping possible false positive, port %d\n", portno[i]); trynum[i] = portno[i] = 0; close(sockets[i]); } } else if (errno == ECONNREFUSED /*111*/) { if (debugging > 1) printf("Closing socket for port %d, ECONNREFUSED received.\n", portno[i]); trynum[i] = portno[i] = 0; close(sockets[i]); } else { printf("Curious recvfrom error (%d) on port %hi: ", errno, portno[i]); perror(""); trynum[i] = portno[i] = 0; close(sockets[i]); } } else /*bytes is positive*/ /* 값이 양수이면 */{ if (debugging || verbose) printf("Adding UDP port %d due to positive read!\n", portno[i]); addport(ports,portno[i], IPPROTO_UDP, NULL); trynum[i] = portno[i] = 0; close(sockets[i]); } } } /* Update last_open, we need to create new sockets.*/ /* last_open까지 사용되어 새로운 소켓이 더 필요하다. */ for(i=0, k=0; i < last_open; i++) if (portno[i]) { close(sockets[i]); sockets[k] = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP); /* unblock_socket(sockets[k]);*/ portno[k] = portno[i]; trynum[k] = trynum[i]; k++; } last_open = k; for(i=k; i < max_parallel_sockets; i++) trynum[i] = sockets[i] = portno[i] = 0; } if (debugging) printf("UDP scanned %d ports in %ld seconds with %d parallel sockets\n", number_of_ports, time(NULL) - starttime, max_parallel_sockets); return *ports; } /* This attempts to calculate the round trip time (rtt) to a host by timing a connect() to a port which isn't listening. A better approach is to time a ping (since it is more likely to get through firewalls. This is now implemented in isup() for users who are root. */ /* connect()함수를 이용해서 닫힌 포트에 갔다가 돌아오는 시간을 계산한다. 더 좋은 방법은 ping을 쓰면 된다. 이 ping은 방화벽까지 갈 수 있고 root권한을 가진 사용자가 isup()이라는 함수를 사용해서 쓸 수 있다. */ unsigned long calculate_sleep(struct in_addr target) { struct timeval begin, end; int sd; struct sockaddr_in sock; int res; if ((sd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) == -1) {perror("Socket troubles"); exit(1);} sock.sin_family = AF_INET; sock.sin_addr.s_addr = target.s_addr; sock.sin_port = htons(MAGIC_PORT); gettimeofday(&begin, NULL); if ((res = connect(sd, (struct sockaddr *) &sock, sizeof(struct sockaddr_in))) != -1) printf("You might want to change MAGIC_PORT in the include file, it seems to be listening on the target host!\n"); close(sd); gettimeofday(&end, NULL); if (end.tv_sec - begin.tv_sec > 5 ) /*uh-oh!*/ return 0; return (end.tv_sec - begin.tv_sec) * 1000000 + (end.tv_usec - begin.tv_usec); } /* Checks whether the identd port (113) is open on the target machine. No sense wasting time trying it for each good port if it is down! */ /* 목표에 identd 포트가 작동된다면 검사한다. 만약 다운 되었을 경우엔 시간낭비일 뿐이다. */ int check_ident_port(struct in_addr target) { int sd; struct sockaddr_in sock; int res; if ((sd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) == -1) {perror("Socket troubles"); exit(1);} sock.sin_family = AF_INET; sock.sin_addr.s_addr = target.s_addr; sock.sin_port = htons(113); /*should use getservbyname(3), yeah, yeah */ res = connect(sd, (struct sockaddr *) &sock, sizeof(struct sockaddr_in)); close(sd); if (res < 0 ) { if (debugging || verbose) printf("identd port not active\n"); return 0; } if (debugging || verbose) printf("identd port is active\n"); return 1; } int getidentinfoz(struct in_addr target, int localport, int remoteport, char *owner) { int sd; struct sockaddr_in sock; int res; char request[15]; char response[1024]; char *p,*q; char *os; owner[0] = '\0'; if ((sd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) == -1) {perror("Socket troubles"); exit(1);} sock.sin_family = AF_INET; sock.sin_addr.s_addr = target.s_addr; sock.sin_port = htons(113); usleep(50000); /* If we aren't careful, we really MIGHT take out inetd, some are very fragile */ /* 조심스럽지 못하면 inetd를 쓰지 말아야 한다. 어떤 것은 쉽게 다운 된다. */ res = connect(sd, (struct sockaddr *) &sock, sizeof(struct sockaddr_in)); if (res < 0 ) { if (debugging || verbose) printf("identd port not active now for some reason ... hope we didn't break it!\n"); close(sd); return 0; } sprintf(request,"%hi,%hi\r\n", remoteport, localport); if (debugging > 1) printf("Connected to identd, sending request: %s", request); if (write(sd, request, strlen(request) + 1) == -1) { perror("identd write"); close(sd); return 0; } else if ((res = read(sd, response, 1024)) == -1) { perror("reading from identd"); close(sd); return 0; } else { close(sd); if (debugging > 1) printf("Read %d bytes from identd: %s\n", res, response); if ((p = strchr(response, ':'))) { p++; if ((q = strtok(p, " :"))) { if (!strcasecmp( q, "error")) { if (debugging || verbose) printf("ERROR returned from identd\n"); return 0; } if ((os = strtok(NULL, " :"))) { if ((p = strtok(NULL, " :"))) { if ((q = strchr(p, '\r'))) *q = '\0'; if ((q = strchr(p, '\n'))) *q = '\0'; strncpy(owner, p, 512); owner[512] = '\0'; } } } } } return 1; } /* A relatively fast (or at least short ;) ping function. Doesn't require a seperate checksum function */ /* 상대적으로 빠른 ping 함수를 이용해서 각각의 checksum 함수를 필요로 하지 않는다. */ int isup(struct in_addr target) { int res, retries = 3; struct sockaddr_in sock; /*type(8bit)=8, code(8)=0 (echo REQUEST), checksum(16)=34190, id(16)=31337 */ #ifdef __LITTLE_ENDIAN_BITFIELD unsigned char ping[64] = { 0x8, 0x0, 0x8e, 0x85, 0x69, 0x7A }; #else unsigned char ping[64] = { 0x8, 0x0, 0x85, 0x8e, 0x7A, 0x69 }; #endif int sd; struct timeval tv; struct timeval start, end; fd_set fd_read; struct { struct iphdr ip; unsigned char type; unsigned char code; unsigned short checksum; unsigned short identifier; char crap[16536]; } response; sd = socket(AF_INET, SOCK_RAW, IPPROTO_ICMP); bzero((char *)&sock,sizeof(struct sockaddr_in)); sock.sin_family=AF_INET; sock.sin_addr = target; if (debugging > 1) printf(" Sending 3 64 byte raw pings to host.\n"); gettimeofday(&start, NULL); while(--retries) { if ((res = sendto(sd,(char *) ping,64,0,(struct sockaddr *)&sock, sizeof(struct sockaddr))) != 64) { fprintf(stderr, "sendto in isup returned %d! skipping host.\n", res); return 0; } FD_ZERO(&fd_read); FD_SET(sd, &fd_read); tv.tv_sec = 0; tv.tv_usec = 1e6 * (PING_TIMEOUT / 3.0); while(1) { if ((res = select(sd + 1, &fd_read, NULL, NULL, &tv)) != 1) break; else { read(sd,&response,sizeof(response)); if (response.ip.saddr == target.s_addr && !response.type && !response.code && response.identifier == 31337) { gettimeofday(&end, NULL); global_rtt = (end.tv_sec - start.tv_sec) * 1e6 + end.tv_usec - start.tv_usec; ouraddr.s_addr = response.ip.daddr; close(sd); return 1; } } } } close(sd); return 0; } portlist syn_scan(struct in_addr target, unsigned short *portarray, struct in_addr *source, int fragment, portlist *ports) { int i=0, j=0, received, bytes, starttime; struct sockaddr_in from; int fromsize = sizeof(struct sockaddr_in); int sockets[max_parallel_sockets]; struct timeval tv; char packet[65535]; struct iphdr *ip = (struct iphdr *) packet; struct tcphdr *tcp = (struct tcphdr *) (packet + sizeof(struct iphdr)); fd_set fd_read, fd_write; int res; struct hostent *myhostent; char myname[MAXHOSTNAMELEN + 1]; int source_malloc = 0; FD_ZERO(&fd_read); FD_ZERO(&fd_write); tv.tv_sec = 7; tv.tv_usec = 0; if ((received = socket(AF_INET, SOCK_RAW, IPPROTO_TCP)) < 0 ) perror("socket trobles in syn_scan"); unblock_socket(received); FD_SET(received, &fd_read); /* First we take what is given to us as source. If that isn't valid, we take what should have swiped from the echo reply in our ping function. If THAT doesn't work either, we try to determine our address with gethostname and gethostbyname. Whew! */ /* 먼저 인자가 무언가 확인하고, 잘못되었으면 ping 함수의 echo reply를 해본다. 작동되지 않는다면 gethostname과 gethostbyname을 써서 주소를 알아낸다. */ if (!source) { if (ouraddr.s_addr) { source = &ouraddr; } else { source = safe_malloc(sizeof(struct in_addr)); source_malloc = 1; if (gethostname(myname, MAXHOSTNAMELEN) || !(myhostent = gethostbyname(myname))) fatal("Your system is fucked up.\n"); memcpy(source, myhostent->h_addr_list[0], sizeof(struct in_addr)); } if (debugging) printf("We skillfully deduced that your address is %s\n", inet_ntoa(*source)); } starttime = time(NULL); do { for(i=0; i < max_parallel_sockets && portarray[j]; i++) { if ((sockets[i] = socket(AF_INET, SOCK_RAW, IPPROTO_RAW)) < 0 ) perror("socket trobles in syn_scan"); else { if (fragment) send_small_fragz(sockets[i], source, &target, MAGIC_PORT, portarray[j++], TH_SYN); else send_tcp_raw(sockets[i], source , &target, MAGIC_PORT, portarray[j++],0,0,TH_SYN,0,0,0); usleep(10000); } } if ((res = select(received + 1, &fd_read, NULL, NULL, &tv)) < 0) perror("select problems in syn_scan"); else if (res > 0) { while ((bytes = recvfrom(received, packet, 65535, 0, (struct sockaddr *)&from, &fromsize)) > 0 ) { if (ip->saddr == target.s_addr) { if (tcp->th_flags & TH_RST) { if (debugging > 1) printf("Nothing open on port %d\n", ntohs(tcp->th_sport)); } else /*if (tcp->th_flags & TH_SYN && tcp->th_flags & TH_ACK)*/ { if (debugging || verbose) { printf("Possible catch on port %d! Here it is:\n", ntohs(tcp->th_sport)); readtcppacket(packet,1); } addport(ports, ntohs(tcp->th_sport), IPPROTO_TCP, NULL); } } } } for(i=0; i < max_parallel_sockets && portarray[j]; i++) close(sockets[i]); } while (portarray[j]); if (debugging || verbose) printf("The TCP SYN scan took %ld seconds to scan %d ports.\n", time(NULL) - starttime, number_of_ports); if (source_malloc) free(source); /* Gotta save those 4 bytes! ;) */ close(received); return *ports; } int send_tcp_raw( int sd, struct in_addr *source, struct in_addr *victim, unsigned short sport, unsigned short dport, unsigned long seq, unsigned long ack, unsigned char flags, unsigned short window, char *data, unsigned short datalen) { struct pseudo_header { /*for computing TCP checksum, see TCP/IP Illustrated p. 145 */ /* TCP checksum 계산 */ unsigned long s_addr; unsigned long d_addr; char zer0; unsigned char protocol; unsigned short length; }; char packet[sizeof(struct iphdr) + sizeof(struct tcphdr) + datalen]; /*With these placement we get data and some field alignment so we aren't wasting too much in computing the checksum */ /* 우리가 얻을 수 있는 정보와 필드 정렬은 checksum에서 계산하는데 너무 시간을 소비하지 않는다. */ struct iphdr *ip = (struct iphdr *) packet; struct tcphdr *tcp = (struct tcphdr *) (packet + sizeof(struct iphdr)); struct pseudo_header *pseudo = (struct pseudo_header *) (packet + sizeof(struct iphdr) - sizeof(struct pseudo_header)); int res; struct sockaddr_in sock; char myname[MAXHOSTNAMELEN + 1]; struct hostent *myhostent; int source_malloced = 0; /* check that required fields are there and not too silly */ /* 필요한 부분만 검사하는 건 괜찮다. */ if ( !victim || !sport || !dport || sd < 0) { fprintf(stderr, "send_tcp_raw: One or more of your parameters suck!\n"); return -1; } /* if they didn't give a source address, fill in our first address */ /* 우리 주소가 없다면 그 부분을 채운다. */ if (!source) { source_malloced = 1; source = safe_malloc(sizeof(struct in_addr)); if (gethostname(myname, MAXHOSTNAMELEN) || !(myhostent = gethostbyname(myname))) fatal("Your system is fucked up.\n"); memcpy(source, myhostent->h_addr_list[0], sizeof(struct in_addr)); if (debugging > 1) printf("We skillfully deduced that your address is %s\n", inet_ntoa(*source)); } /*do we even have to fill out this damn thing? This is a raw packet, after all */ /* 이걸 해야해? raw 패킷이다. */ sock.sin_family = AF_INET; sock.sin_port = htons(dport); sock.sin_addr.s_addr = victim->s_addr; bzero(packet, sizeof(struct iphdr) + sizeof(struct tcphdr)); pseudo->s_addr = source->s_addr; pseudo->d_addr = victim->s_addr; pseudo->protocol = IPPROTO_TCP; pseudo->length = htons(sizeof(struct tcphdr) + datalen); tcp->th_sport = htons(sport); tcp->th_dport = htons(dport); if (seq) tcp->th_seq = htonl(seq); else tcp->th_seq = rand() + rand(); if (flags & TH_ACK && ack) tcp->th_ack = htonl(seq); else if (flags & TH_ACK) tcp->th_ack = rand() + rand(); tcp->th_off = 5 /*words*/; tcp->th_flags = flags; if (window) tcp->th_win = window; else tcp->th_win = htons(2048); /* Who cares */ /* 뭐가 문제야? */ tcp->th_sum = in_cksum((unsigned short *)pseudo, sizeof(struct tcphdr) + sizeof(struct pseudo_header) + datalen); /* Now for the ip header */ /* IP 헤더 */ bzero(packet, sizeof(struct iphdr)); ip->version = 4; ip->ihl = 5; ip->tot_len = htons(sizeof(struct iphdr) + sizeof(struct tcphdr) + datalen); ip->id = rand(); ip->ttl = 255; ip->protocol = IPPROTO_TCP; ip->saddr = source->s_addr; ip->daddr = victim->s_addr; ip->check = in_cksum((unsigned short *)ip, sizeof(struct iphdr)); if (debugging > 1) { printf("Raw TCP packet creation completed! Here it is:\n"); readtcppacket(packet,ntohs(ip->tot_len)); } if (debugging > 1) printf("\nTrying sendto(%d , packet, %d, 0 , %s , %d)\n", sd, ntohs(ip->tot_len), inet_ntoa(*victim), sizeof(struct sockaddr_in)); if ((res = sendto(sd, packet, ntohs(ip->tot_len), 0, (struct sockaddr *)&sock, sizeof(struct sockaddr_in))) == -1) { perror("sendto in send_tcp_raw"); if (source_malloced) free(source); return -1; } if (debugging > 1) printf("successfully sent %d bytes of raw_tcp!\n", res); if (source_malloced) free(source); return res; } /* A simple program I wrote to help in debugging, shows the important fields of a TCP packet*/ /* 간단한 프로그램 디버깅도움도 되고 TCP 패킷의 중요한 필드를 보여준다. */ int readtcppacket(char *packet, int readdata) { struct iphdr *ip = (struct iphdr *) packet; struct tcphdr *tcp = (struct tcphdr *) (packet + sizeof(struct iphdr)); char *data = packet + sizeof(struct iphdr) + sizeof(struct tcphdr); int tot_len; struct in_addr bullshit, bullshit2; char sourcehost[16]; int i; if (!packet) { fprintf(stderr, "readtcppacket: packet is NULL!\n"); return -1; } bullshit.s_addr = ip->saddr; bullshit2.s_addr = ip->daddr; tot_len = ntohs(ip->tot_len); strncpy(sourcehost, inet_ntoa(bullshit), 16); i = 4 * (ntohs(ip->ihl) + ntohs(tcp->th_off)); if (ip->protocol == IPPROTO_TCP) if (ip->frag_off) printf("Packet is fragmented, offset field: %u", ip->frag_off); else { printf("TCP packet: %s:%d -> %s:%d (total: %d bytes)\n", sourcehost, ntohs(tcp->th_sport), inet_ntoa(bullshit2), ntohs(tcp->th_dport), tot_len); printf("Flags: "); if (!tcp->th_flags) printf("(none)"); if (tcp->th_flags & TH_RST) printf("RST "); if (tcp->th_flags & TH_SYN) printf("SYN "); if (tcp->th_flags & TH_ACK) printf("ACK "); if (tcp->th_flags & TH_PUSH) printf("PSH "); if (tcp->th_flags & TH_FIN) printf("FIN "); if (tcp->th_flags & TH_URG) printf("URG "); printf("\n"); printf("ttl: %hi ", ip->ttl); if (tcp->th_flags & (TH_SYN | TH_ACK)) printf("Seq: %lu\tAck: %lu\n", tcp->th_seq, tcp->th_ack); else if (tcp->th_flags & TH_SYN) printf("Seq: %lu\n", ntohl(tcp->th_seq)); else if (tcp->th_flags & TH_ACK) printf("Ack: %lu\n", ntohl(tcp->th_ack)); } if (readdata && i < tot_len) { printf("Data portion:\n"); while(i < tot_len) printf("%2X%c", data[i], (++i%16)? ' ' : '\n'); printf("\n"); } return 0; } /* We don't exactly need real crypto here (thank god!)\n"*/ /* 실제적인 crypto 함수가 필요치 않았다. */ int shortfry(unsigned short *ports) { int num; unsigned short tmp; int i; for(i=0; i < number_of_ports; i++) { num = rand() % (number_of_ports); tmp = ports[i]; ports[i] = ports[num]; ports[num] = tmp; } return 1; } /* Much of this is swiped from my send_tcp_raw function above, which doesn't support fragmentation */ /* 앞의 send_tcp_raw 함수엔 fragmentation 부분이 없다. */ int send_small_fragz(int sd, struct in_addr *source, struct in_addr *victim, int sport, int dport, int flags) { struct pseudo_header { /*for computing TCP checksum, see TCP/IP Illustrated p. 145 */ /* TCP checksum 계산 */ unsigned long s_addr; unsigned long d_addr; char zer0; unsigned char protocol; unsigned short length; }; /*In this placement we get data and some field alignment so we aren't wasting too much to compute the TCP checksum.*/ /* TCP checksum을 계산하는데 그리 시간이 걸리지 않는다. */ char packet[sizeof(struct iphdr) + sizeof(struct tcphdr) + 100]; struct iphdr *ip = (struct iphdr *) packet; struct tcphdr *tcp = (struct tcphdr *) (packet + sizeof(struct iphdr)); struct pseudo_header *pseudo = (struct pseudo_header *) (packet + sizeof(struct iphdr) - sizeof(struct pseudo_header)); char *frag2 = packet + sizeof(struct iphdr) + 16; struct iphdr *ip2 = (struct iphdr *) (frag2 - sizeof(struct iphdr)); int res; struct sockaddr_in sock; int id; /*Why do we have to fill out this damn thing? This is a raw packet, after all */ /* 이런 힘든 일을 꼭 해야될까? raw 패킷 만들기 */ sock.sin_family = AF_INET; sock.sin_port = htons(dport); sock.sin_addr.s_addr = victim->s_addr; bzero(packet, sizeof(struct iphdr) + sizeof(struct tcphdr)); pseudo->s_addr = source->s_addr; pseudo->d_addr = victim->s_addr; pseudo->protocol = IPPROTO_TCP; pseudo->length = htons(sizeof(struct tcphdr)); tcp->th_sport = htons(sport); tcp->th_dport = htons(dport); tcp->th_seq = rand() + rand(); tcp->th_off = 5 /*words*/; tcp->th_flags = flags; tcp->th_win = htons(2048); /* Who cares */ tcp->th_sum = in_cksum((unsigned short *)pseudo, sizeof(struct tcphdr) + sizeof(struct pseudo_header)); /* Now for the ip header of frag1 */ /* frag1d를 위한 ip 헤더 */ bzero(packet, sizeof(struct iphdr)); ip->version = 4; ip->ihl = 5; /*RFC 791 allows 8 octet frags, but I get "operation not permitted" (EPERM) when I try that. */ /*RFC 791 8개의 부분까지 허용한다. 그러나 내가 이걸 했을때 잘 작동 되지 않았다. */ ip->tot_len = htons(sizeof(struct iphdr) + 16); id = ip->id = rand(); ip->frag_off = htons(MORE_FRAGMENTS); ip->ttl = 255; ip->protocol = IPPROTO_TCP; ip->saddr = source->s_addr; ip->daddr = victim->s_addr; ip->check = in_cksum((unsigned short *)ip, sizeof(struct iphdr)); if (debugging > 1) { printf("Raw TCP packet fragment #1 creation completed! Here it is:\n"); hdump(packet,20); } if (debugging > 1) printf("\nTrying sendto(%d , packet, %d, 0 , %s , %d)\n", sd, ntohs(ip->tot_len), inet_ntoa(*victim), sizeof(struct sockaddr_in)); if ((res = sendto(sd, packet, ntohs(ip->tot_len), 0, (struct sockaddr *)&sock, sizeof(struct sockaddr_in))) == -1) { perror("sendto in send_syn_fragz"); return -1; } if (debugging > 1) printf("successfully sent %d bytes of raw_tcp!\n", res); /* Create the second fragment */ /* 두번째 조각 만들기 */ bzero(ip2, sizeof(struct iphdr)); ip2->version = 4; ip2->ihl = 5; ip2->tot_len = htons(sizeof(struct iphdr) + 4); /* the rest of our TCP packet */ /* 나머지 TCP 패킷 */ ip2->id = id; ip2->frag_off = htons(2); ip2->ttl = 255; ip2->protocol = IPPROTO_TCP; ip2->saddr = source->s_addr; ip2->daddr = victim->s_addr; ip2->check = in_cksum((unsigned short *)ip2, sizeof(struct iphdr)); if (debugging > 1) { printf("Raw TCP packet fragment creation completed! Here it is:\n"); hdump(packet,20); } if (debugging > 1) printf("\nTrying sendto(%d , ip2, %d, 0 , %s , %d)\n", sd, ntohs(ip2->tot_len), inet_ntoa(*victim), sizeof(struct sockaddr_in)); if ((res = sendto(sd, ip2, ntohs(ip2->tot_len), 0, (struct sockaddr *)&sock, sizeof(struct sockaddr_in))) == -1) { perror("sendto in send_tcp_raw"); return -1; } return 1; } /* Hex dump */ /* 헥사 덤프 */ void hdump(unsigned char *packet, int len) { unsigned int i=0, j=0; printf("Here it is:\n"); for(i=0; i < len; i++){ j = (unsigned) (packet[i]); printf("%-2X ", j); if (!((i+1)%16)) printf("\n"); else if (!((i+1)%4)) printf(" "); } printf("\n"); } portlist fin_scan(struct in_addr target, unsigned short *portarray, struct in_addr *source, int fragment, portlist *ports) { int rawsd, tcpsd; int done = 0, badport, starttime, someleft, i, j=0, retries=2; int source_malloc = 0; int waiting_period = retries, sockaddr_in_size = sizeof(struct sockaddr_in); int bytes, dupesinarow = 0; unsigned long timeout; struct hostent *myhostent; char response[65535], myname[513]; struct iphdr *ip = (struct iphdr *) response; struct tcphdr *tcp; unsigned short portno[max_parallel_sockets], trynum[max_parallel_sockets]; struct sockaddr_in stranger; timeout = (global_delay)? global_delay : (global_rtt)? (1.2 * global_rtt) + 10000 : 1e5; bzero(&stranger, sockaddr_in_size); bzero(portno, max_parallel_sockets * sizeof(unsigned short)); bzero(trynum, max_parallel_sockets * sizeof(unsigned short)); starttime = time(NULL); if (debugging || verbose) printf("Initiating FIN stealth scan against %s (%s), sleep delay: %ld useconds\n", current_name, inet_ntoa(target), timeout); if (!source) { if (ouraddr.s_addr) { source = &ouraddr; } else { source = safe_malloc(sizeof(struct in_addr)); source_malloc = 1; if (gethostname(myname, MAXHOSTNAMELEN) || !(myhostent = gethostbyname(myname))) fatal("Your system is fucked up.\n"); memcpy(source, myhostent->h_addr_list[0], sizeof(struct in_addr)); } if (debugging || verbose) printf("We skillfully deduced that your address is %s\n", inet_ntoa(*source)); } if ((rawsd = socket(AF_INET, SOCK_RAW, IPPROTO_RAW)) < 0 ) perror("socket trobles in fin_scan"); if ((tcpsd = socket(AF_INET, SOCK_RAW, IPPROTO_TCP)) < 0 ) perror("socket trobles in fin_scan"); unblock_socket(tcpsd); while(!done) { for(i=0; i < max_parallel_sockets; i++) { if (!portno[i] && portarray[j]) { portno[i] = portarray[j++]; } if (portno[i]) { if (fragment) send_small_fragz(rawsd, source, &target, MAGIC_PORT, portno[i], TH_FIN); else send_tcp_raw(rawsd, source , &target, MAGIC_PORT, portno[i], 0, 0, TH_FIN, 0, 0, 0); usleep(10000); /* *WE* normally do not need this, but the target lamer often does */ } } usleep(timeout); dupesinarow = 0; while ((bytes = recvfrom(tcpsd, response, 65535, 0, (struct sockaddr *) &stranger, &sockaddr_in_size)) > 0) if (ip->saddr == target.s_addr) { tcp = (struct tcphdr *) (response + 4 * ip->ihl); if (tcp->th_flags & TH_RST) { badport = ntohs(tcp->th_sport); if (debugging > 1) printf("Nothing open on port %d\n", badport); /* delete the port from active scanning */ for(i=0; i < max_parallel_sockets; i++) if (portno[i] == badport) { if (debugging && trynum[i] > 0) printf("Bad port %d caught on fin scan, try number %d\n", badport, trynum[i] + 1); trynum[i] = 0; portno[i] = 0; break; } if (i == max_parallel_sockets) { if (debugging) printf("Late packet or dupe, deleting port %d.\n", badport); dupesinarow++; if (ports) deleteport(ports, badport, IPPROTO_TCP); } } else if (debugging > 1) { printf("Strange packet from target%d! Here it is:\n", ntohs(tcp->th_sport)); if (bytes >= 40) readtcppacket(response,1); else hdump(response,bytes); } } /* adjust waiting time if neccessary */ /* 필요하면 기다리는 시간을 조정한다. */ if (dupesinarow > 6) { if (debugging || verbose) printf("Slowing down send frequency due to multiple late packets.\n"); if (timeout < 10 * ((global_delay)? global_delay: global_rtt + 20000)) timeout *= 1.5; else { printf("Too many late packets despite send frequency decreases, skipping scan.\n"); if (source_malloc) free(source); return *ports; } } /* Ok, collect good ports (those that we haven't received responses too after all our retries */ /* 모든 시도후에도 어떤 응답도 받을 수 없는 포트를 모은다. */ someleft = 0; for(i=0; i < max_parallel_sockets; i++) if (portno[i]) { if (++trynum[i] >= retries) { if (verbose || debugging) printf("Good port %d detected by fin_scan!\n", portno[i]); addport(ports, portno[i], IPPROTO_TCP, NULL); send_tcp_raw( rawsd, source, &target, MAGIC_PORT, portno[i], 0, 0, TH_FIN, 0, 0, 0); portno[i] = trynum[i] = 0; } else someleft = 1; } if (!portarray[j] && (!someleft || --waiting_period <= 0)) done++; } if (debugging || verbose) printf("The TCP stealth FIN scan took %ld seconds to scan %d ports.\n", time(NULL) - starttime, number_of_ports); if (source_malloc) free(source); close(tcpsd); close(rawsd); return *ports; } int ftp_anon_connect(struct ftpinfo *ftp) { int sd; struct sockaddr_in sock; int res; char recvbuf[2048]; char command[512]; if (verbose || debugging) printf("Attempting connection to ftp://%s:%s@%s:%i\n", ftp->user, ftp->pass, ftp->server_name, ftp->port); if ((sd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0) { perror("Couldn't create ftp_anon_connect socket"); return 0; } sock.sin_family = AF_INET; sock.sin_addr.s_addr = ftp->server.s_addr; sock.sin_port = htons(ftp->port); res = connect(sd, (struct sockaddr *) &sock, sizeof(struct sockaddr_in)); if (res < 0 ) { printf("Your ftp bounce proxy server won't talk to us!\n"); exit(1); } if (verbose || debugging) printf("Connected:"); while ((res = recvtime(sd, recvbuf, 2048,7)) > 0) if (debugging || verbose) { recvbuf[res] = '\0'; printf("%s", recvbuf); } if (res < 0) { perror("recv problem from ftp bounce server"); exit(1); } snprintf(command, 511, "USER %s\r\n", ftp->user); send(sd, command, strlen(command), 0); res = recvtime(sd, recvbuf, 2048,12); if (res <= 0) { perror("recv problem from ftp bounce server"); exit(1); } recvbuf[res] = '\0'; if (debugging) printf("sent username, received: %s", recvbuf); if (recvbuf[0] == '5') { printf("Your ftp bounce server doesn't like the username \"%s\"\n", ftp->user); exit(1); } snprintf(command, 511, "PASS %s\r\n", ftp->pass); send(sd, command, strlen(command), 0); res = recvtime(sd, recvbuf, 2048,12); if (res < 0) { perror("recv problem from ftp bounce server\n"); exit(1); } if (!res) printf("Timeout from bounce server ..."); else { recvbuf[res] = '\0'; if (debugging) printf("sent password, received: %s", recvbuf); if (recvbuf[0] == '5') { fprintf(stderr, "Your ftp bounce server refused login combo (%s/%s)\n", ftp->user, ftp->pass); exit(1); } } while ((res = recvtime(sd, recvbuf, 2048,2)) > 0) if (debugging) { recvbuf[res] = '\0'; printf("%s", recvbuf); } if (res < 0) { perror("recv problem from ftp bounce server"); exit(1); } if (verbose) printf("Login credentials accepted by ftp server!\n"); ftp->sd = sd; return sd; } int recvtime(int sd, char *buf, int len, int seconds) { int res; struct timeval timeout = {seconds, 0}; fd_set readfd; FD_ZERO(&readfd); FD_SET(sd, &readfd); res = select(sd + 1, &readfd, NULL, NULL, &timeout); if (res > 0 ) { res = recv(sd, buf, len, 0); if (res >= 0) return res; perror("recv in recvtime"); return 0; } else if (!res) return 0; perror("select() in recvtime"); return -1; } portlist bounce_scan(struct in_addr target, unsigned short *portarray, struct ftpinfo *ftp, portlist *ports) { int starttime, res , sd = ftp->sd, i=0; char *t = (char *)⌖ int retriesleft = FTP_RETRIES; char recvbuf[2048]; char targetstr[20]; char command[512]; snprintf(targetstr, 20, "%d,%d,%d,%d,0,", UC(t[0]), UC(t[1]), UC(t[2]), UC(t[3])); starttime = time(NULL); if (verbose || debugging) printf("Initiating TCP ftp bounce scan against %s (%s)\n", current_name, inet_ntoa(target)); for(i=0; portarray[i]; i++) { snprintf(command, 512, "PORT %s%i\r\n", targetstr, portarray[i]); if (send(sd, command, strlen(command), 0) < 0 ) { perror("send in bounce_scan"); if (retriesleft) { if (verbose || debugging) printf("Our ftp proxy server hung up on us! retrying\n"); retriesleft--; close(sd); ftp->sd = ftp_anon_connect(ftp); if (ftp->sd < 0) return *ports; sd = ftp->sd; i--; } else { fprintf(stderr, "Our socket descriptor is dead and we are out of retries. Giving up.\n"); close(sd); ftp->sd = -1; return *ports; } } else { /* Our send is good */ /* 잘 보냈다면 */ res = recvtime(sd, recvbuf, 2048,15); if (res <= 0) perror("recv problem from ftp bounce server\n"); else { /* our recv is good */ /* 잘 받았다면 */ recvbuf[res] = '\0'; if (debugging) printf("result of port query on port %i: %s", portarray[i], recvbuf); if (recvbuf[0] == '5') { if (portarray[i] > 1023) { fprintf(stderr, "Your ftp bounce server sucks, it won't let us feed bogus ports!\n"); exit(1); } else { fprintf(stderr, "Your ftp bounce server doesn't allow priviliged ports, skipping them.\n"); while(portarray[i] && portarray[i] < 1024) i++; if (!portarray[i]) { fprintf(stderr, "And you didn't want to scan any unpriviliged ports. Giving up.\n"); /* close(sd); ftp->sd = -1; return *ports;*/ /* screw this gentle return crap! This is an emergency! */ /* 문제가 있군. */ exit(1); } } } else /* Not an error message */ /* 에러 메시지가 없을 경우 */ if (send(sd, "LIST\r\n", 6, 0) > 0 ) { res = recvtime(sd, recvbuf, 2048,12); if (res <= 0) perror("recv problem from ftp bounce server\n"); else { recvbuf[res] = '\0'; if (debugging) printf("result of LIST: %s", recvbuf); if (!strncmp(recvbuf, "500", 3)) { /* fuck, we are not aligned properly */ /* 알맞게 정렬이 안 됐다. */ if (verbose || debugging) printf("misalignment detected ... correcting.\n"); res = recvtime(sd, recvbuf, 2048,10); } if (recvbuf[0] == '1' || recvbuf[0] == '2') { if (verbose || debugging) printf("Port number %i appears good.\n", portarray[i]); addport(ports, portarray[i], IPPROTO_TCP, NULL); if (recvbuf[0] == '1') { res = recvtime(sd, recvbuf, 2048,5); recvbuf[res] = '\0'; if ((res > 0) && debugging) printf("nxt line: %s", recvbuf); } } } } } } } if (debugging || verbose) printf("Scanned %d ports in %ld seconds via the Bounce scan.\n", number_of_ports, time(NULL) - starttime); return *ports; } /* parse a URL stype ftp string of the form user:pass@server:portno */ /* 사용자에 있는 문장에서 URL을 검색 */ int parse_bounce(struct ftpinfo *ftp, char *url) { char *p = url,*q, *s; if ((q = strrchr(url, '@'))) /*we have username and/or pass */ /* 사용자를 받거나 그냥 넘어가거나 */ { *(q++) = '\0'; if ((s = strchr(q, ':'))) { /* has portno */ *(s++) = '\0'; strncpy(ftp->server_name, q, MAXHOSTNAMELEN); ftp->port = atoi(s); } else strncpy(ftp->server_name, q, MAXHOSTNAMELEN); if ((s = strchr(p, ':'))) { /* User AND pass given */ /* 사용자가 패스워드를 지정할때 */ *(s++) = '\0'; strncpy(ftp->user, p, 63); strncpy(ftp->pass, s, 255); } else { /* Username ONLY given */ /* 사용자 명만 줄때 */ printf("Assuming %s is a username, and using the default password: %s\n", p, ftp->pass); strncpy(ftp->user, p, 63); } } else /* no username or password given */ /* 사용자명과 패스워드를 안 줄때 */ if ((s = strchr(url, ':'))) { /* portno is given */ /* 포트 번호를 줄때 */ *(s++) = '\0'; strncpy(ftp->server_name, url, MAXHOSTNAMELEN); ftp->port = atoi(s); } else /* default case, no username, password, or portnumber */ /* 기본 경우 사용자 명 , 패스워드 , 포트번호도 안 주었을 때 */ strncpy(ftp->server_name, url, MAXHOSTNAMELEN); ftp->user[63] = ftp->pass[255] = ftp->server_name[MAXHOSTNAMELEN] = 0; return 1; } /* * I'll bet you've never seen this function before (yeah right)! * standard swiped checksum routine. */ /* 이런 함수를 본적이 없을걸요! 기본적인 checksum 루틴 */ unsigned short in_cksum(unsigned short *ptr,int nbytes) { register long sum; /* assumes long == 32 bits */ /* long은 32비트 */ u_short oddbyte; register u_short answer; /* assumes u_short == 16 bits */ /* assume u_short는 16비트 */ /* * 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. */ /* 알고리즘은 간단합니다. 32비트 가산기를 이용하고 순차적인 16비트 워드를 더합니다. 상위 비트에서 하위 16비트로 접습니다. */ sum = 0; while (nbytes > 1) { sum += *ptr++; nbytes -= 2; } /* mop up an odd byte, if necessary */ /* 가능하면 홀수바이트를 없앤다. */ if (nbytes == 1) { oddbyte = 0; /* make sure top half is zero */ /* 0으로 만든다. */ *((u_char *) &oddbyte) = *(u_char *)ptr; /* one byte only */ /* 한 바이트만 */ sum += oddbyte; } /* * Add back carry outs from top 16 bits to low 16 bits. */ /* 상위 16비트에서 하위 16비트로 다시 더한다. */ sum = (sum >> 16) + (sum & 0xffff); /* add high-16 to low-16 */ /* 상위를 하위로 */ sum += (sum >> 16); /* add carry */ /* 캐리를 더한다. */ answer = ~sum; /* ones-complement, then truncate to 16 bits */ /* 16비트로 연결한다. */ return(answer); } <--> 역자 왈: 번역해 놓고 보니 너무 부족한 부분이 많군요. 잘 이해가 안 되시는 분이나 이게 잘못 번역이 된 부분이 있다면 지적해 주세요. 문서에 적어드리겠습니다. 이문서는 역시 GNU/GPL로 배포가 됩니다. 다른 곳에 쓰실려면 메일 좀 띄우고 써 주세요.