端口扫描分析(附代码)

  操作系统 端口扫描分析
来源：自绿色兵团

端口扫描分析（一）常用的网络相关命令
来源/作者：Oliver


　　一个端口就是一个潜在的通信通道，也就是一个入侵通道。对目标计算机进行端口扫描，能得到许多有用的信息。进行扫描的方法很多，可以是手工进行扫描，也可以用端口扫描软件进行。
　　在手工进行扫描时，需要熟悉各种命令。对命令执行后的输出进行分析。用扫描软件进行扫描时，许多扫描器软件都有分析数据的功能。
　　通过端口扫描，可以得到许多有用的信息，从而发现系统的安全漏洞。
　　下面首先介绍几个常用网络命令，对端口扫描原理进行介绍，然后提供一个简单的扫描程序。第一节　几个常用网络相关命令
Ping命令经常用来对TCP/IP网络进行诊断。通过目标计算机发送一个数据包，让它将这个数据包反送回来，如果返回的数据包和发送的数据包一致，那就是说你的PING命令成功了。通过这样对返回的数据进行分析，就能判断计算机是否开着，或者这个数据包从发送到返回需要多少时间。

一。几个常用网络相关命令
1.Ping命令的基本格式：
　　　　ping hostname

　　其中hostname是目标计算机的地址。Ping还有许多高级使用，下面就是一个例子。
C:> ping -f hostname
　　这条命令给目标机器发送大量的数据，从而使目标计算机忙于回应。在Windows 95的计算机上，使用下面的方法：
c:/windows/ping -l 65500 saddam_hussein's.computer.mil
　　这样做了之后，目标计算机有可能会挂起来，或从新启动。由于 -l 65510 产生一个巨大的数据包。由于要求返回一个同样的数据包，会使目标计算机反应不过来。
　　在Linux计算机上，可以编写一个程序来实现上述方法。
#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netdb.h>
#include <netinet/in.h>
#include <netinet/in_systm.h>
#include <netinet/ip.h>
#include <netinet/ip_icmp.h>
　
/*
* If your kernel doesn't muck with raw packets, #define REALLY_RAW.
* This is probably only Linux.
*/
#ifdef REALLY_RAW
#define FIX(x)　htons(x)
#else
#define FIX(x)　(x)
#endif
　
int
main(int argc, char **argv)
{
　　　　int s;
　　　　char buf[1500];
　　　　struct ip *ip = (struct ip *)buf;
　　　　struct icmp *icmp = (struct icmp *)(ip + 1);
　　　　struct hostent *hp;
　　　　struct sockaddr_in dst;
　　　　int offset;
　　　　int on = 1;
　
　　　　bzero(buf, sizeof buf);
if ((s = socket(AF_INET, SOCK_RAW, IPPROTO_IP)) < 0) {
　　　　　　　　perror("socket");
　　　　　　　　exit(1);
　　　　}
　　　　if (setsockopt(s, IPPROTO_IP, IP_HDRINCL, &on, sizeof(on)) < 0) {
　　　　　　　　perror("IP_HDRINCL");
　　　　　　　　exit(1);
　　　　}
　　　　if (argc != 2) {
　　　　　　　　fprintf(stderr, "usage: %s hostname/n", argv[0]);
　　　　　　　　exit(1);
　　　　}
　　　　if ((hp = gethostbyname(argv[1])) == NULL) {
　　　　　　　　if ((ip->ip_dst.s_addr = inet_addr(argv[1])) == -1) {
　　　　　　　　　　　　fprintf(stderr, "%s: unknown host/n", argv[1]);
　　　　　　　　}
　　　　} else {
　　　　　　　　bcopy(hp->h_addr_list[0], &ip->ip_dst.s_addr, hp->h_length);
　　　　}

　　　　printf("Sending to %s/n", inet_ntoa(ip->ip_dst));
　　　　ip->ip_v = 4;
　　　　ip->ip_hl = sizeof *ip >> 2;
　　　　ip->ip_tos = 0;
　　　　ip->ip_len = FIX(sizeof buf);
　　　　ip->ip_id = htons(4321);
　　　　ip->ip_off = FIX(0);
　　　　ip->ip_ttl = 255;
　　　　ip->ip_p = 1;
　　　　ip->ip_sum = 0;　　　　　　　　 /* kernel fills in */
　　　　ip->ip_src.s_addr = 0;　　　　　/* kernel fills in */
　
　　　　dst.sin_addr = ip->ip_dst;
　　　　dst.sin_family = AF_INET;
　
　　　　icmp->icmp_type = ICMP_ECHO;
　　　　icmp->icmp_code = 0;
　　　　icmp->icmp_cksum = htons(~(ICMP_ECHO << 8));
　　　　　　　　/* the checksum of all 0's is easy to compute */

　　　　for (offset = 0; offset < 65536; offset += (sizeof buf - sizeof *ip)) {
　　　　　　　　ip->ip_off = FIX(offset >> 3);
　　　　　　　　if (offset < 65120)
　　　　　　　　　　　　ip->ip_off |= FIX(IP_MF);
　　　　　　　　else
　　　　　　　　　　　　ip->ip_len = FIX(418);　/* make total 65538 */
　　　　　　　　if (sendto(s, buf, sizeof buf, 0, (struct sockaddr *)&dst,
　　　　　　　　　　　　　　　　　　　　sizeof dst) < 0) {
　　　　　　　　　　　　fprintf(stderr, "offset %d: ", offset);
　　　　　　　　　　　　perror("sendto");
　　　　　　　　}
　　　　　　　　if (offset == 0) {
　　　　　　　　　　　　icmp->icmp_type = 0;
　　　　　　　　　　　　icmp->icmp_code = 0;
　　　　　　　　　　　　icmp->icmp_cksum = 0;
　　　　　　　　}
　　　　}
}

2.Tracert命令用来跟踪一个消息从一台计算机到另一台计算机所走的路径，比方说从你的计算机走到浙江信息超市。在DOS窗口下，命令如下：
C:/WINDOWS>tracert 202.96.102.4

Tracing route to 202.96.102.4 over a maximum of 30 hops

　1　　84 ms　　82 ms　　95 ms　202.96.101.57
　2　 100 ms　 100 ms　　95 ms　0fa1.1-rtr1-a-hz1.zj.CN.NET [202.96.101.33]
　3　　95 ms　　90 ms　 100 ms　202.101.165.1
　4　　90 ms　　90 ms　　90 ms　202.107.197.98
　5　　95 ms　　90 ms　　99 ms　202.96.102.4
　6　　90 ms　　95 ms　 100 ms　202.96.102.4

Trace complete.

　　上面的这些输出代表什么意思？左边的数字是该路由通过的计算机数目。"150 ms"是指向那台计算机发送消息的往返时间，单位是微秒。由于每条消息每次的来回的时间不一样，tracert将显示来回时间三次。"*"表示来回时间太长，tracert将这个时间“忘掉了”。在时间信息到来后，计算机的名字信息也到了。开始是一种便于人们阅读的格式， 接着是数字格式。

C:/WINDOWS>tracert　152.163.199.56

Tracing route to dns-aol.ANS.NET [198.83.210.28]over a maximum of 30 hops:

　1　 124 ms　 106 ms　 105 ms　202.96.101.57
　2　　95 ms　　95 ms　　90 ms　0fa1.1-rtr1-a-hz1.zj.CN.NET [202.96.101.33]
　3　 100 ms　　90 ms　 100 ms　202.101.165.1
　4　　90 ms　　95 ms　　95 ms　202.97.18.241
　5　 105 ms　 105 ms　 100 ms　202.97.18.93
　6　 100 ms　　99 ms　 100 ms　202.97.10.37
　7　 135 ms　　98 ms　 100 ms　202.97.9.78
　8　 760 ms　 725 ms　 768 ms　gip-ftworth-4-serial8-3.gip.net [204.59.178.53]
　9　 730 ms　 750 ms　 715 ms　gip-ftworth-4-serial8-3.gip.net [204.59.178.53]
10　 750 ms　 785 ms　 772 ms　144.232.11.9
11　 740 ms　 800 ms　 735 ms　sl-bb11-pen-2-0.sprintlink.NET [144.232.8.158]
12　 790 ms　 800 ms　 735 ms　sl-nap2-pen-4-0-0.sprintlink.net [144.232.5.66]
13　 770 ms　 800 ms　 800 ms　p219.t3.ans.net [192.157.69.13]
14　 775 ms　 820 ms　 780 ms　h14-1.t60-6.Reston.t3.ANS.NET [140.223.17.18]
15　 780 ms　 800 ms　 800 ms　h11-1.t60-2.Reston.t3.ANS.NET [140.223.25.34]
16　 790 ms　 795 ms　 800 ms　h14-1.t104-0.Atlanta.t3.ANS.NET [140.223.65.18]
17　　 *　　 h14-1.t104-0.Atlanta.t3.ANS.NET [140.223.65.18]　reports: Destination host unreachable.

Trace complete.

3.rusers和finger
　　这两个都是Unix命令。通过这两个命令，你能收集到目标计算机上的有关用户的消息。
使用rusers命令，产生的结果如下示意：
gajake　　　 snark.wizard.com:ttyp1　Nov 13 15:42　7:30 (remote)
root　　　　 snark.wizard.com:ttyp2　Nov 13 14:57　7:21 (remote)
robo　　　　 snark.wizard.com:ttyp3　Nov 15 01:04　01 (remote)
angel111　　 snark.wizard.com:ttyp4　Nov14 23:09　　　 (remote)
pippen　　　 snark.wizard.com:ttyp6 Nov 14 15:05　　　　 (remote)
root　　　　 snark.wizard.com:ttyp5 Nov 13 16:03　　7:52 (remote)
gajake　　　 snark.wizard.com:ttyp7 Nov 14 20:20　　2:59 (remote)
dafr　　　　 snark.wizard.com:ttyp15Nov　3 20:09　　4:55 (remote)
dafr　　　　 snark.wizard.com:ttyp1 Nov 14 06:12　 19:12 (remote)
dafr　　　　 snark.wizard.com:ttyp19Nov 14 06:12　 19:02 (remote)

　　最左边的是通过远程登录的用户名。还包括上次登录时间，使用的SHELL类型等等信息。
　　使用finger可以产生类似下面的结果：
user S00　PPP ppp-122-pm1.wiza　Thu Nov 14 21:29:30 - still logged in
user S15　PPP ppp-119-pm1.wiza　Thu Nov 14 22:16:35 - still logged in
user S04　PPP ppp-121-pm1.wiza　Fri Nov 15 00:03:22 - still logged in
user S03　PPP ppp-112-pm1.wiza　Thu Nov 14 22:20:23 - still logged in
user S26　PPP ppp-124-pm1.wiza　Fri Nov 15 01:26:49 - still logged in
user S25　PPP ppp-102-pm1.wiza　Thu Nov 14 23:18:00 - still logged in
user S17　PPP ppp-115-pm1.wiza　Thu Nov 14 07:45:00 - still logged in
user S-1　0.0.0.0　　　　　 Sat Aug 10 15:50:03 - still logged in
user S23　PPP ppp-103-pm1.wiza　Fri Nov 15 00:13:53 - still logged in
user S12　PPP ppp-111-pm1.wiza　Wed Nov 13 16:58:12 - still logged in
　　这个命令能显示用户的状态。该命令是建立在客户/服务模型之上的。用户通过客户端软件向服务器请求信息，然后解释这些信息，提供给用户。在服务器上一般运行一个叫做fingerd的程序，根据服务器的机器的配置，能向客户提供某些信息。如果考虑到保护这些个人信息的话，有可能许多服务器不提供这个服务，或者只提供一些无关的信息。

4.host命令
　　host是一个Unix命令，它的功能和标准的nslookup查询一样。唯一的区别是host命令比较容易理解。host命令的危险性相当大，下面举个使用实例，演示一次对bu.edu的host查询。
host -l -v -t any bu.edu
　　这个命令的执行结果所得到的信息十分多，包括操作系统，机器和网络的很多数据。先看一下基本信息：
Found 1 addresses for BU.EDU
Found 1 addresses for RS0.INTERNIC.NET
Found 1 addresses for SOFTWARE.BU.EDU
Found 5 addresses for RS.INTERNIC.NET
Found 1 addresses for NSEGC.BU.EDU
Trying 128.197.27.7
bu.edu　　86400 IN　　SOA　　BU.EDU HOSTMASTER.BU.EDU(
　　　　　　961112121　　;serial (version)
　　　　　　900　　;refresh period
　　　　　　900　　;retry refresh this often
　　　　　　604800　　;expiration period
　　　　　　86400　　;minimum TTL
　　　　　　)
bu.edu　　86400 IN　　NS　　SOFTWARE.BU.EDU
bu.edu　　86400 IN　　NS　　RS.INTERNIC.NET
bu.edu　　86400 IN　　NS　　NSEGC.BU.EDU
bu.edu　　86400 IN　　A　　128.197.27.7

　　这些本身并没有危险，只是一些机器和它们的DNS服务器。这些信息可以用WHOIS或在注册域名的站点中检索到。但看看下面几行信息：
bu.edu　　86400 IN　　HINFO　　SUN-SPARCSTATION-10/41　　UNIX
PPP-77-25.bu.edu　　86400 IN　　A　　128.197.7.237
PPP-77-25.bu.edu　　86400 IN　　HINFO　　PPP-HOST　　PPP-SW
PPP-77-26.bu.edu　　86400 IN　　A　　128.197.7.238
PPP-77-26.bu.edu　　86400 IN　　HINFO　　PPP-HOST　　PPP-SW
ODIE.bu.edu　　86400 IN　　A　　128.197.10.52
ODIE.bu.edu　　86400 IN　　MX　　10 CS.BU.EDU
ODIE.bu.edu　　86400 IN　　HINFO　　DEC-ALPHA-3000/300LX　　OSF1

从这里，我们马上就发现一台EDC Alpha运行的是OSF1操作系统。在看看：
STRAUSS.bu.edu　　86400 IN　　HINFO　　PC-PENTIUM　　DOS/WINDOWS
BURULLUS.bu.edu　　86400 IN　　HINFO　　SUN-3/50　　UNIX (Ouch)
GEORGETOWN.bu.edu　　86400 IN　　HINFO　　MACINTOSH　　MAC-OS
CHEEZWIZ.bu.edu　　86400 IN　　HINFO　　SGI-INDIGO-2　　UNIX
POLLUX.bu.edu　　86400 IN　　HINFO　　SUN-4/20-SPARCSTATION-SLC　　UNIX
SFA109-PC201.bu.edu　　86400 IN　　HINFO　　PC　　MS-DOS/WINDOWS
UH-PC002-CT.bu.edu　　86400 IN　　HINFO　　PC-CLONE　　MS-DOS
SOFTWARE.bu.edu　　86400 IN　　HINFO　　SUN-SPARCSTATION-10/30　　UNIX
CABMAC.bu.edu　　86400 IN　　HINFO　　MACINTOSH　　MAC-OS
VIDUAL.bu.edu　　86400 IN　　HINFO　　SGI-INDY　　IRIX
KIOSK-GB.bu.edu　　86400 IN　　HINFO　　GATORBOX　　GATORWARE
CLARINET.bu.edu　　86400 IN　　HINFO　　VISUAL-X-19-TURBO　　X-SERVER
DUNCAN.bu.edu　　86400 IN　　HINFO　　DEC-ALPHA-3000/400　　OSF1
MILHOUSE.bu.edu　　86400 IN　　HINFO　　VAXSTATION-II/GPX　　UNIX
PSY81-PC150.bu.edu　　86400 IN　　HINFO　　PC　　WINDOWS-95
BUPHYC.bu.edu　　86400 IN　　HINFO　　VAX-4000/300　　OpenVMS

　　可见，任何人都能通过在命令行里键入一个命令，就能收集到一个域里的所有计算机的重要信息。而且只化了3秒时间。
　　我们利用上述有用的网络命令，可以收集到许多有用的信息，比方一个域里的名字服务器的地址，一台计算机上的用户名，一台服务器上正在运行什么服务，这个服务是哪个软件提供的，计算机上运行的是什么操作系统。
　　如果你知道目标计算机上运行的操作系统和服务应用程序后，就能利用已经发现的他们的漏洞来进行攻击。如果目标计算机的网络管理员没有对这些漏洞及时修补的话，入侵者能轻而易举的闯入该系统，获得管理员权限，并留下后门。
　　如果入侵者得到目标计算机上的用户名后，能使用口令破解软件，多次试图登录目标计算机。经过尝试后，就有可能进入目标计算机。得到了用户名，就等于得到了一半的进入权限，剩下的只是使用软件进行攻击而已。



　　　　　　　　　　　 端口扫描分析（二）端口扫描途径

　　　　　　　　　　　　　　 来源/作者：Oliver


二。　端口扫描途径
什么是扫描器
　　扫描器是一种自动检测远程或本地主机安全性弱点的程序，通过使用扫描器你可一不留痕迹的发现远程服务器的各种TCP端口的分配及提供的服务和它们的软件版本！这就能让我们间接的或直观的了解到远程主机所存在的安全问题。

工作原理
　　扫描器通过选用远程TCP/IP不同的端口的服务，并记录目标给予的回答，通过这种方法，可以搜集到很多关于目标主机的各种有用的信息（比如：是否能用匿名登陆！是否有可写的FTP目录，是否能用TELNET，HTTPD是用ROOT还是nobady在跑！）

扫描器能干什么？
　　扫描器并不是一个直接的攻击网络漏洞的程序，它仅仅能帮助我们发现目标机的某些内在的弱点。一个好的扫描器能对它得到的数据进行分析，帮助我们查找目标主机的漏洞。但它不会提供进入一个系统的详细步骤。
　　扫描器应该有三项功能：发现一个主机或网络的能力；一旦发现一台主机，有发现什么服务正运行在这台主机上的能力；通过测试这些服务，发现漏洞的能力。
　　编写扫描器程序必须要很多TCP/IP程序编写和C, Perl和或SHELL语言的知识。需要一些Socket编程的背景，一种在开发客户/服务应用程序的方法。开发一个扫描器是一个雄心勃勃的项目，通常能使程序员感到很满意。
　　下面对常用的端口扫描技术做一个介绍。
TCP connect() 扫描
　　这是最基本的TCP扫描。操作系统提供的connect()系统调用，用来与每一个感兴趣的目标计算机的端口进行连接。如果端口处于侦听状态，那么connect()就能成功。否则，这个端口是不能用的，即没有提供服务。这个技术的一个最大的优点是，你不需要任何权限。系统中的任何用户都有权利使用这个调用。另一个好处就是速度。如果对每个目标端口以线性的方式，使用单独的connect()调用，那么将会花费相当长的时间，你可以通过同时打开多个套接字，从而加速扫描。使用非阻塞I/O允许你设置一个低的时间用尽周期，同时观察多个套接字。但这种方法的缺点是很容易被发觉，并且被过滤掉。目标计算机的logs文件会显示一连串的连接和连接是出错的服务消息，并且能很快的使它关闭。

TCP SYN扫描
　　这种技术通常认为是“半开放”扫描，这是因为扫描程序不必要打开一个完全的TCP连接。扫描程序发送的是一个SYN数据包，好象准备打开一个实际的连接并等待反应一样（参考TCP的三次握手建立一个TCP连接的过程）。一个SYN|ACK的返回信息表示端口处于侦听状态。一个RST返回，表示端口没有处于侦听态。如果收到一个SYN|ACK，则扫描程序必须再发送一个RST信号，来关闭这个连接过程。这种扫描技术的优点在于一般不会在目标计算机上留下记录。但这种方法的一个缺点是，必须要有root权限才能建立自己的SYN数据包。

TCP FIN 扫描
　　有的时候有可能SYN扫描都不够秘密。一些防火墙和包过滤器会对一些指定的端口进行监视，有的程序能检测到这些扫描。相反，FIN数据包可能会没有任何麻烦的通过。这种扫描方法的思想是关闭的端口会用适当的RST来回复FIN数据包。另一方面，打开的端口会忽略对FIN数据包的回复。这种方法和系统的实现有一定的关系。有的系统不管端口是否打开，都回复RST，这样，这种扫描方法就不适用了。并且这种方法在区分Unix和NT时，是十分有用的。

IP段扫描
　　这种不能算是新方法，只是其它技术的变化。它并不是直接发送TCP探测数据包，是将数据包分成两个较小的IP段。这样就将一个TCP头分成好几个数据包，从而过滤器就很难探测到。但必须小心。一些程序在处理这些小数据包时会有些麻烦。

TCP 反向 ident扫描
　　ident 协议允许(rfc1413)看到通过TCP连接的任何进程的拥有者的用户名，即使这个连接不是由这个进程开始的。因此你能，举个例子，连接到http端口，然后用identd来发现服务器是否正在以root权限运行。这种方法只能在和目标端口建立了一个完整的TCP连接后才能看到。

FTP 返回攻击
　　FTP协议的一个有趣的特点是它支持代理（proxy）FTP连接。即入侵者可以从自己的计算机a.com和目标主机target.com的FTP server-PI(协议解释器)连接，建立一个控制通信连接。然后，请求这个server-PI激活一个有效的server-DTP(数据传输进程)来给Internet上任何地方发送文件。对于一个User-DTP，这是个推测,尽管RFC明确地定义请求一个服务器发送文件到另一个服务器是可以的。但现在这个方法好象不行了。这个协议的缺点是“能用来发送不能跟踪的邮件和新闻，给许多服务器造成打击，用尽磁盘，企图越过防火墙”。
　　我们利用这个的目的是从一个代理的FTP服务器来扫描TCP端口。这样，你能在一个防火墙后面连接到一个FTP服务器，然后扫描端口（这些原来有可能被阻塞）。如果FTP服务器允许从一个目录读写数据，你就能发送任意的数据到发现的打开的端口。
　　对于端口扫描，这个技术是使用PORT命令来表示被动的User DTP正在目标计算机上的某个端口侦听。然后入侵者试图用LIST命令列出当前目录，结果通过Server-DTP发送出去。如果目标主机正在某个端口侦听，传输就会成功（产生一个150或226的回应）。否则，会出现"425 Can't build data connection: Connection refused."。然后，使用另一个PORT命令，尝试目标计算机上的下一个端口。这种方法的优点很明显，难以跟踪，能穿过防火墙。主要缺点是速度很慢，有的FTP服务器最终能得到一些线索，关闭代理功能。

这种方法能成功的情景：
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

这种方法不能成功的情景：
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.

UDP ICMP端口不能到达扫描
　　这种方法与上面几种方法的不同之处在于使用的是UDP协议。由于这个协议很简单，所以扫描变得相对比较困难。这是由于打开的端口对扫描探测并不发送一个确认，关闭的端口也并不需要发送一个错误数据包。幸运的是，许多主机在你向一个未打开的UDP端口发送一个数据包时，会返回一个ICMP_PORT_UNREACH错误。这样你就能发现哪个端口是关闭的。UDP和ICMP错误都不保证能到达，因此这种扫描器必须还实现在一个包看上去是丢失的时候能重新传输。这种扫描方法是很慢的，因为RFC对ICMP错误消息的产生速率做了规定。同样，这种扫描方法需要具有root权限。

UDP recvfrom()和write() 扫描
　　当非root用户不能直接读到端口不能到达错误时，Linux能间接地在它们到达时通知用户。比如，对一个关闭的端口的第二个write()调用将失败。在非阻塞的UDP套接字上调用recvfrom()时，如果ICMP出错还没有到达时回返回EAGAIN-重试。如果ICMP到达时，返回ECONNREFUSED-连接被拒绝。这就是用来查看端口是否打开的技术。


ICMP echo扫描
　　这并不是真正意义上的扫描。但有时通过ping，在判断在一个网络上主机是否开机时非常有用。

　　　　　　　　　 端口扫描分析（三）一个简单的扫描程序

　　　　　　　　　　　　　　来源/作者：Oliver


　　下面是一个端口扫描器的源程序，功能相当的简单，一个典型的TCP connect()扫描。没有对返回的数据进行分析。
#include <stdio.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <errno.h>
#include <netdb.h>
#include <signal.h>

int main(int argc, char **argv)
{
　int probeport = 0;
　struct hostent *host;
　int err, i, net;
　struct sockaddr_in sa;

　if (argc != 2) {
　　printf("用法: %s hostname/n", argv[0]);
　　exit(1);
　}

　for (i = 1; i < 1024; i++) { //这里有点不是很好，可以将主机地址放在循环外
　　strncpy((char *)&sa, "", sizeof sa);
　　sa.sin_family = AF_INET;
　　if (isdigit(*argv[1]))
　　　sa.sin_addr.s_addr = inet_addr(argv[1]);
　　else if ((host = gethostbyname(argv[1])) != 0)
　　　strncpy((char *)&sa.sin_addr, (char *)host->h_addr, sizeof sa.sin_addr);
　　else {
　　　herror(argv[1]);
　　　exit(2);
　　}
　　sa.sin_port = htons(i);
　　net = socket(AF_INET, SOCK_STREAM, 0);
　　if (net < 0) {
　　　perror("/nsocket");
　　　exit(2);
　　}
　　err = connect(net, (struct sockaddr *) &sa, sizeof sa);
　　if (err < 0) {
　　　printf("%s %-5d %s/r", argv[1], i, strerror(errno));
　　　fflush(stdout);
　　} else {
　　　printf("%s %-5d accepted.　　　　　　　　　　　　　　　 /n", argv[1], i);
　　　if (shutdown(net, 2) < 0) {
　　perror("/nshutdown");
　　exit(2);
　　　}
　　}
　　close(net);
　}
　printf("　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　/r");
　fflush(stdout);
　return (0);
}
下面这个又是一个端口器：
#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include "netdb.h"
struct hostent *gethostbyaddr();
void bad_addr();
main(argc, argv)
　　　　int　　 argc;
　　　　char　　*argv[];
{
　　　　char　　　　　　addr[4];
　　　　int　　　　　　 i, j,
　　　　　　　　　　　　a0, a1, a2, a3,
　　　　　　　　　　　　c,
　　　　　　　　　　　　classB, classC, single, hex;
　　　　char　　　　　　*fmt = "%d.%d.%d";
　　　　char　　　　　　**ptr;
　　　　struct hostent　*host;
　　　　extern char　　 *optarg;
　　　　classB = classC = single = hex = 0;
　　　　while((c = getopt(argc,argv,"bcsx")) != EOF) {
　　　　　　　　switch(c) {
　　　　　　　　case 'b':
　　　　　　　　　　　　classB++;
　　　　　　　　　　　　break;
　　　　　　　　case 'c':
　　　　　　　　　　　　classC++;
　　　　　　　　　　　　break;
　　　　　　　　case 's':
　　　　　　　　　　　　single++;
　　　　　　　　　　　　break;
　　　　　　　　case 'x':
　　　　　　　　　　　　hex++;
　　　　　　　　　　　　break;
　　　　　　　　}
　　　　}
　　　　if(classB == 0 && classC == 0 && single == 0) {
　　　　　　　　fprintf(stderr, "usage: %s [-b||-c||-s] [-x] xxx.xxx[.xxx[.xxx]]/n", argv[0]);
　　　　　　　　exit(1);
　　　　}
　　　　if(classB)
　　　　　　　　if(hex) {
　　　　　　　　　　　　fmt = "%x.%x";
　　　　　　　　　　　　sscanf(argv[3], fmt, &a0, &a1);
　　　　　　　　} else {
　　　　　　　　　　　　fmt = "%d.%d";
　　　　　　　　　　　　sscanf(argv[2], fmt, &a0, &a1);
　　　　　　　　}
　　　　else if(classC)
　　　　　　　　if(hex) {
　　　　　　　　　　　　fmt = "%x.%x.%x";
　　　　　　　　　　　　sscanf(argv[3], fmt, &a0, &a1, &a2);
　　　　　　　　} else {
　　　　　　　　　　　　fmt = "%d.%d.%d";
　　　　　　　　　　　　sscanf(argv[2], fmt, &a0, &a1, &a2);
　　　　　　　　}
　　　　else if(single)
　　　　　　　　if(hex) {
　　　　　　　　　　　　fmt = "%x.%x.%x.%x";
　　　　　　　　　　　　sscanf(argv[3], fmt, &a0, &a1, &a2, &a3);
　　　　　　　　} else {
　　　　　　　　　　　　fmt = "%d.%d.%d.%d";
　　　　　　　　　　　　sscanf(argv[2], fmt, &a0, &a1, &a2, &a3);
　　　　　　　　}
　　　　sscanf(argv[1], fmt, &a0, &a1, &a2);
　　　　addr[0] = (unsigned char)a0;
　　　　addr[1] = (unsigned char)a1;
　　　　if(a0>255||a0<0)
　　　　　　　　bad_addr(a0);
　　　　if(a1>255||a1<0)
　　　　　　　　bad_addr(a1);
　　　　if(classB) {
　　　　　　　　if(hex)
　　　　　　　　　　　　printf("Converting address from hex. (%x.%x)/n", a0, a1);
　　　　　　　　printf("Scanning Class B network %d.%d.../n", a0, a1);
　　　　　　　　while(j!=256) {
　　　　　　　　　　　　a2=j;
　　　　　　　　　　　　addr[2] = (unsigned char)a2;
jmpC:
　　　　　　　　if(classC)
　　　　　　　　　　　　if(hex)
　　　　　　　　　　　　　　　　printf("Converting address from hex. (%x.%x.%x)/n", a0, a1, a2);
　　　　　　　　　　　　printf("Scanning Class C network %d.%d.%d.../n", a0, a1, a2);
　　　　　　　　while(i!=256) {
　　　　　　　　　　　　a3=i;
　　　　　　　　　　　　addr[3] = (unsigned char)a3;
jmpS:
　　　　　　　　　　　　if ((host = gethostbyaddr(addr, 4, AF_INET)) != NULL) {
　　　　　　　　　　　　　　　　printf("%d.%d.%d.%d => %s/n", a0, a1, a2, a3, host->h_name);
　　　　　　　　　　　　　　　　ptr = host->h_aliases;
　　　　　　　　　　　　　　　　while (*ptr != NULL) {
　　　　　　　　　　　　　　　　　　　　printf("%d.%d.%d.%d => %s (alias)/n", a0, a1, a2, a3, *ptr);
　　　　　　　　　　　　　　　　　　　　ptr++;
　　　　　　　　　　　　　　　　}
　　　　　　　　　　　　}
　　　　　　　　　　　　if(single)
　　　　　　　　　　　　　　　　exit(0);
　　　　　　　　　　　　i++;
　　　　　　　　}
　　　　　　　　if(classC)
　　　　　　　　　　　　exit(0);
　　　　　　　　j++;
　　　　　　　　}
　　　　} else if(classC) {
　　　　　　　　addr[2] = (unsigned char)a2;
　　　　　　　　if(a2>255||a2<0)
　　　　　　　　　　　　bad_addr(a2);
　　　　　　　　goto jmpC;
　　　　} else if(single) {
　　　　　　　　addr[2] = (unsigned char)a2;
　　　　　　　　addr[3] = (unsigned char)a3;
　　　　　　　　if(a2>255||a2<0)
　　　　　　　　　　　　bad_addr(a2);
　　　　　　　　if(a3>255||a3<0)
　　　　　　　　　　　　bad_a