如何用java语言实现端口扫描器
使用 DatagramSocket(int port) 建立socket（套间字）服务。
将数据打包到DatagramPacket中去
通过socket服务发送 （send() *** ）
关闭资源
public static void main(String[] args) {
DatagramSocket ds = null; //建立套间字udpsocket服务
try {
ds = new DatagramSocket(8999); //实例化套间字，指定自己的port
} catch (SocketException e) {
System.out.println("Cannot open port!");
System.exit(1);
}
byte[] buf= "Hello, I am sender!".getBytes(); //数据
InetAddress destination = null ;
try {
destination = InetAddress.getByName("192.168.1.5"); //需要发送的地址
} catch (UnknownHostException e) {
System.out.println("Cannot open findhost!");
System.exit(1);
}
DatagramPacket dp =
new DatagramPacket(buf, buf.length, destination , 10000);
//打包到DatagramPacket类型中（DatagramSocket的send() *** 接受此类，注意10000是接受地址的端口，不同于自己的端口！）
try {
ds.send(dp); //发送数据
} catch (IOException e) {
}
ds.close();
}
}
接收步骤：
使用 DatagramSocket(int port) 建立socket（套间字）服务。（我们注意到此服务即可以接收，又可以发送），port指定监视接受端口。
定义一个数据包（DatagramPacket），储存接收到的数据，使用其中的 *** 提取传送的内容
通过DatagramSocket 的receive *** 将接受到的数据存入上面定义的包中
使用DatagramPacket的 *** ，提取数据。
关闭资源。
import java.net.*;
public class Rec {
public static void main(String[] args) throws Exception {
DatagramSocket ds = new DatagramSocket(10000); //定义服务，监视端口上面的发送端口，注意不是send本身端口
byte[] buf = new byte[1024];//接受内容的大小，注意不要溢出
DatagramPacket dp = new DatagramPacket(buf,0,buf.length);//定义一个接收的包
ds.receive(dp);//将接受内容封装到包中
String data = new String(dp.getData(), 0, dp.getLength());//利用getData() *** 取出内容
System.out.println(data);//打印内容
ds.close();//关闭资源
}
}
端口扫描器的用法?
扫描器使用 *** 大家好很高兴你能进如我们的第四课！由先在起所有的课将由我来主讲，由于课程涉及
的是 *** 更高安全问题，所以我不得不警告各位，你要清楚的认识到你在干什么，其实
第四课的内容我们换了又换，有很多是一些攻击性很强的，我不得不CUT，所以次文才迟
迟出来！！同时我也希望进入这一课时的学友能多多的帮助其它人！
在INTERNET安全领域，扫描器可以说是黑客的基本武器，
一个好的TCP端口扫描器相当与几百个合法用户的口令及
密码是等同的，这样说一点也不过分！
1，什么是扫描器
扫描器是一种自动检测远程或本地主机安全性弱点的程序，
通过使用扫描器你可一不留痕迹的发现远程服务器的各种TCP
端口的分配及提供的服务！和它们的软件版本！这就能让我们
间接的或直观的了解到远程主机所存在的安全问题。
2，工作原理
扫描器通过选用远程TCP/IP不同的端口的服务，并记录目标
给予的回答，通过这种 *** ，可以搜集到很多关于目标主机的
各种有用的信息（比如：是否能用匿名登陆！是否有可写的FTP
目录，是否能用TELNET，HTTPD是用ROOT还是nobady在跑！）
3，扫描器的运行平台！
尽管大多数的工作站是用UNIX的，由于UNIX的应用软件的可移殖
性，如今的扫描器以有了支持各种平台，这一点大大方便了许多
单机的用户！但同时也带来了更多的 *** 安全问题，这句老话我想
大家一定是听到过很多次！------ *** 安全刻不容缓！！！
4，扫描器能干什么？
扫描器并不是一个直接的攻击 *** 漏洞的程序，它不同于第二课中
的许多NUCK程序！它仅仅能帮助我们发现目标机的某些内在的弱点
而这些现存的弱点可能是（请看清楚可能是，并非一定）破坏目标
机安全关键，但是我想说明的是对于一个刚刚入们的黑客人来说
这些数据对他来说无疑是一个毫无价值的数据 *** ！，而对一个
掌握和精通各种 *** 应用程序的漏洞的黑客来说这就不仅仅是一个简单
的数据 *** ！他的价值远超过几百个有用的帐号！-------知识需要
积累！！！
5，种类
1。NNS( *** 安全扫描器）
用PERL编写，工作在Sunos4.1.3
进行下面的常规的扫描
Sendmail ,TFTP,匿名FTP，Hosts.equive，Xhost
增强扫描
Apple Talk,
Novell
LAN管理员 ***
取得指定域的列表或报告！
用PING命令确定指定主机是否是活性的，
扫描目标机端口
报告指定地址的漏洞
你可以到这个地址下载
2.STROBE(超级优化TCP端口检测程序）
它是一个TCP端口的扫描器，能快速的识别指定机器上正运行
什么服务，
用于扫描 *** 漏洞
SATAN(安全管理员的 *** 分析工具）
扫描远程主机的许多已知的漏洞
FTPD中可写的目录
NFS
NIS
PSH
SENDMAIL
X服务
Jakal（秘密扫描器）
可以不留痕迹的扫描
IdenTCPscan
CONNECT 扫描TFTP服务器子网
ESPScan 扫描FSP服务器
XSCAN
实例扫描
或用关键字搜寻！你能了解到更多的情况！
1，UNIX平台的SAFEsuite
safesuite的组成，INTERNET，WEB，防火墙扫描！
safesuite的攻击，sendmail,FTP,NNTP,TELNET,RPC,NFS.
ISS的开发小组在最新的版本里还增设了IP欺骗和拒绝服务的攻击，用以支持对主机安全
性的分析。
可以运行的平台：Sun OS 4.1.3 up,SoLaris 2.0 up,HP/UX9.05 up,IBM AIIX 3.2.5 u
p
Linux 1.2.x,Linux1.3.x,Linux 1.3.76+
安装：
解压后拷贝到指定的目录，你可用下面的命令来解！
tar -xvf ISS_XXX.tar
运行ISS.install开始安装！
由于扫描的结果太长我就不一一写出来了！！大家可以多试试！很多有用的安全信息都
在这些扫描结果里！！通过MIT的X窗口系统标准配置运行如SAVEsuite，X窗口的管理程
序是FVWM。
Network Toolbox
用于WINDOWS 95上的TCP/IP的应用程序，
默认扫描端口是！14个TCP/IP端口，
port 9,13,21,25,,37,79,80,110,111,512,513,514,
你可以通过设置属性来改变默认的配置！！
我不知道我上述的下载地址是否还有效！但我想你可一到一些国外著名的黑客站找到你
想要的一切！！
课后作业，请把你扫描的信息告诉我们，我们将在下一课拿出一些信息来加以分析，安
全漏洞出在哪里！并对各种可能发生的漏洞加以分析！！
怎么用BAT文件做端口扫描器
首先，给你更正一下，估计是你看了别人的教程或者软件，让你以为BAT可以扫端口，严格意义上说批处理文件BAT是不能真正意义上实现扫端口功能，即使有也是利用TELNET。而且是单线程。是没任何意义的。你看到的我估计是S扫描器，然后别人做成一个批处理，比如流行的扫135，1433，3389或者其他溢出都喜欢用S扫描器，因为它速度一流，而且是命令下操作适合做成BAT文件批量处理。而输出扫描结果这个比较简单，就是写几行批处理来提取S扫描器生成的结果Result.txt文件，然后输出到5.txt中。就这么简单。这些代码网上有现成的，如果你有需要可以给我留言，适当的给你分享分享！
如何用C++编写简易端口扫描器（要详细步骤）
#includewinsock2.h
#includestdio.h
#include time.h//计时需要用到的头文件
#pragma comment(lib,"ws2_32.lib")
#include time.h//计时需要用到的头文件
clock_t start,end;//程序运行的起始和结束时间
float costtime;//程序耗时
void usage(void)
{
printf("\tusage: tcpscan RemoteIP StartPort-EndPort\n");
printf("\tExample: tcpscan 192.168.1.1 80-100\n");
}
int main(int argc,char **argv)
{
char *host;
int startport,endport;
char *p;
if(argc!=3)
{
usage();
return 0;
}
p=argv[2];//处理端口参数
if(strstr(argv[2],"-"))
{ startport=atoi(argv[2]);
for(;*p;)
if(*(p++)=='-')break;
endport=atoi(p);
if(startport1 || endport65535)
{ printf("Port Error!\n");
return 0;
}
}
host=argv[1];
WSADATA ws;
SOCKET s;
struct sockaddr_in addr;
int result;
long lresult;
lresult=WSAStartup(MAKEWORD(1,1), ws);
addr.sin_family =AF_INET;
addr.sin_addr.s_addr =inet_addr(host);
start=clock();//开始计时
for (int i=startport;iendport;i++)
{
s=socket(AF_INET, SOCK_STREAM, 0);
addr.sin_port = htons(i);
if(s==INVALID_SOCKET)break;
result=connect(s, (struct sockaddr*)addr,sizeof(addr));
if(result==0)
{
printf("%s %d\n",host,i);
closesocket(s);
}
}
end=clock();//计时结束
costtime= (float)(end - start) / CLOCKS_PER_SEC; //转换时间格式
printf("Cost time:%f second",costtime);//显示耗时
WSACleanup();
}
如何用Scapy写一个端口扫描器
常见的端口扫描类型有：
1. TCP 连接扫描
2. TCP SYN 扫描(也称为半开放扫描或stealth扫描)
3. TCP 圣诞树(Xmas Tree)扫描
4. TCP FIN 扫描
5. TCP 空扫描(Null)
6. TCP ACK 扫描
7. TCP 窗口扫描
8. UDP 扫描
下面先讲解每种扫描的原理，随后提供具体实现代码。
TCP 连接扫描
客户端与服务器建立 TCP 连接要进行一次三次握手，如果进行了一次成功的三次握手，则说明端口开放。
客户端想要连接服务器80端口时，会先发送一个带有 SYN 标识和端口号的 TCP 数据包给服务器(本例中为80端口)。如果端口是开放的，则服务器会接受这个连接并返回一个带有 SYN 和 ACK 标识的数据包给客户端。随后客户端会返回带有 ACK 和 RST 标识的数据包，此时客户端与服务器建立了连接。如果完成一次三次握手，那么服务器上对应的端口肯定就是开放的。
当客户端发送一个带有 SYN 标识和端口号的 TCP 数据包给服务器后，如果服务器端返回一个带 RST 标识的数据包，则说明端口处于关闭状态。
代码：
#! /usr/bin/python
import logging
logging.getLogger("scapy.runtime").setLevel(logging.ERROR)
from scapy.all import *
dst_ip = "10.0.0.1"
src_port = RandShort()
dst_port=80
tcp_connect_scan_resp = sr1(IP(dst=dst_ip)/TCP(sport=src_port,dport=dst_port,flags="S"),timeout=10)
if(str(type(tcp_connect_scan_resp))=="type 'NoneType'"):
print "Closed"
elif(tcp_connect_scan_resp.haslayer(TCP)):
if(tcp_connect_scan_resp.getlayer(TCP).flags == 0x12):
send_rst = sr(IP(dst=dst_ip)/TCP(sport=src_port,dport=dst_port,flags="AR"),timeout=10)
print "Open"
elif (tcp_connect_scan_resp.getlayer(TCP).flags == 0x14):
print "Closed"
TCP SYN 扫描
这个技术同 TCP 连接扫描非常相似。同样是客户端向服务器发送一个带有 SYN 标识和端口号的数据包，如果目标端口开发，则会返回带有 SYN 和 ACK 标识的 TCP 数据包。但是，这时客户端不会返回 RST+ACK 而是返回一个只带有 RST 标识的数据包。这种技术主要用于躲避防火墙的检测。
如果目标端口处于关闭状态，那么同之前一样，服务器会返回一个 RST 数据包。
代码：
#! /usr/bin/python
import logging
logging.getLogger("scapy.runtime").setLevel(logging.ERROR)
from scapy.all import *
dst_ip = "10.0.0.1"
src_port = RandShort()
dst_port=80
stealth_scan_resp = sr1(IP(dst=dst_ip)/TCP(sport=src_port,dport=dst_port,flags="S"),timeout=10)
if(str(type(stealth_scan_resp))=="type 'NoneType'"):
print "Filtered"
elif(stealth_scan_resp.haslayer(TCP)):
if(stealth_scan_resp.getlayer(TCP).flags == 0x12):
send_rst = sr(IP(dst=dst_ip)/TCP(sport=src_port,dport=dst_port,flags="R"),timeout=10)
print "Open"
elif (stealth_scan_resp.getlayer(TCP).flags == 0x14):
print "Closed"
elif(stealth_scan_resp.haslayer(ICMP)):
if(int(stealth_scan_resp.getlayer(ICMP).type)==3 and int(stealth_scan_resp.getlayer(ICMP).code) in [1,2,3,9,10,13]):
print "Filtered"
TCP 圣诞树(Xmas Tree)扫描
在圣诞树扫描中，客户端会向服务器发送带有 PSH,FIN,URG 标识和端口号的数据包给服务器。如果目标端口是开放的，那么不会有任何来自服务器的回应。
如果服务器返回了一个带有 RST 标识的 TCP 数据包，那么说明端口处于关闭状态。
但如果服务器返回了一个 ICMP 数据包，其中包含 ICMP 目标不可达错误类型3以及 ICMP 状态码为1，2，3，9，10或13，则说明目标端口被过滤了无法确定是否处于开放状态。
代码：
#! /usr/bin/python
import logging
logging.getLogger("scapy.runtime").setLevel(logging.ERROR)
from scapy.all import *
dst_ip = "10.0.0.1"
src_port = RandShort()
dst_port=80
xmas_scan_resp = sr1(IP(dst=dst_ip)/TCP(dport=dst_port,flags="FPU"),timeout=10)
if (str(type(xmas_scan_resp))=="type 'NoneType'"):
print "Open|Filtered"
elif(xmas_scan_resp.haslayer(TCP)):
if(xmas_scan_resp.getlayer(TCP).flags == 0x14):
print "Closed"
elif(xmas_scan_resp.haslayer(ICMP)):
if(int(xmas_scan_resp.getlayer(ICMP).type)==3 and int(xmas_scan_resp.getlayer(ICMP).code) in [1,2,3,9,10,13]):
print "Filtered"
TCP FIN扫描
FIN 扫描会向服务器发送带有 FIN 标识和端口号的 TCP 数据包。如果没有服务器端回应则说明端口开放。
如果服务器返回一个 RST 数据包，则说明目标端口是关闭的。
如果服务器返回了一个 ICMP 数据包，其中包含 ICMP 目标不可达错误类型3以及 ICMP 代码为1，2，3，9，10或13，则说明目标端口被过滤了无法确定端口状态。
代码：
#! /usr/bin/python
import logging
logging.getLogger("scapy.runtime").setLevel(logging.ERROR)
from scapy.all import *
dst_ip = "10.0.0.1"
src_port = RandShort()
dst_port=80
fin_scan_resp = sr1(IP(dst=dst_ip)/TCP(dport=dst_port,flags="F"),timeout=10)
if (str(type(fin_scan_resp))=="type 'NoneType'"):
print "Open|Filtered"
elif(fin_scan_resp.haslayer(TCP)):
if(fin_scan_resp.getlayer(TCP).flags == 0x14):
print "Closed"
elif(fin_scan_resp.haslayer(ICMP)):
if(int(fin_scan_resp.getlayer(ICMP).type)==3 and int(fin_scan_resp.getlayer(ICMP).code) in [1,2,3,9,10,13]):
print "Filtered"
TCP 空扫描(Null)
在空扫描中，客户端发出的 TCP 数据包仅仅只会包含端口号而不会有其他任何的标识信息。如果目标端口是开放的则不会回复任何信息。
如果服务器返回了一个 RST 数据包，则说明目标端口是关闭的。
如果返回 ICMP 错误类型3且代码为1，2，3，9，10或13的数据包，则说明端口被服务器过滤了。
代码：
#! /usr/bin/python
import logging
logging.getLogger("scapy.runtime").setLevel(logging.ERROR)
from scapy.all import *
dst_ip = "10.0.0.1"
src_port = RandShort()
dst_port=80
null_scan_resp = sr1(IP(dst=dst_ip)/TCP(dport=dst_port,flags=""),timeout=10)
if (str(type(null_scan_resp))=="type 'NoneType'"):
print "Open|Filtered"
elif(null_scan_resp.haslayer(TCP)):
if(null_scan_resp.getlayer(TCP).flags == 0x14):
print "Closed"
elif(null_scan_resp.haslayer(ICMP)):
if(int(null_scan_resp.getlayer(ICMP).type)==3 and int(null_scan_resp.getlayer(ICMP).code) in [1,2,3,9,10,13]):
print "Filtered"
TCP ACK扫描
ACK 扫描不是用于发现端口开启或关闭状态的，而是用于发现服务器上是否存在有状态防火墙的。它的结果只能说明端口是否被过滤。再次强调，ACK 扫描不能发现端口是否处于开启或关闭状态。
客户端会发送一个带有 ACK 标识和端口号的数据包给服务器。如果服务器返回一个带有 RST 标识的 TCP 数据包，则说明端口没有被过滤，不存在状态防火墙。
如果目标服务器没有任何回应或者返回ICMP 错误类型3且代码为1，2，3，9，10或13的数据包，则说明端口被过滤且存在状态防火墙。
#! /usr/bin/python
import logging
logging.getLogger("scapy.runtime").setLevel(logging.ERROR)
from scapy.all import *
dst_ip = "10.0.0.1"
src_port = RandShort()
dst_port=80
ack_flag_scan_resp = sr1(IP(dst=dst_ip)/TCP(dport=dst_port,flags="A"),timeout=10)
if (str(type(ack_flag_scan_resp))=="type 'NoneType'"):
print "Stateful firewall presentn(Filtered)"
elif(ack_flag_scan_resp.haslayer(TCP)):
if(ack_flag_scan_resp.getlayer(TCP).flags == 0x4):
print "No firewalln(Unfiltered)"
elif(ack_flag_scan_resp.haslayer(ICMP)):
if(int(ack_flag_scan_resp.getlayer(ICMP).type)==3 and int(ack_flag_scan_resp.getlayer(ICMP).code) in [1,2,3,9,10,13]):
print "Stateful firewall presentn(Filtered)"
TCP窗口扫描
TCP 窗口扫描的流程同 ACK 扫描类似，同样是客户端向服务器发送一个带有 ACK 标识和端口号的 TCP 数据包，但是这种扫描能够用于发现目标服务器端口的状态。在 ACK 扫描中返回 RST 表明没有被过滤，但在窗口扫描中，当收到返回的 RST 数据包后，它会检查窗口大小的值。如果窗口大小的值是个非零值，则说明目标端口是开放的。
如果返回的 RST 数据包中的窗口大小为0，则说明目标端口是关闭的。
代码：
#! /usr/bin/python
import logging
logging.getLogger("scapy.runtime").setLevel(logging.ERROR)
from scapy.all import *
dst_ip = "10.0.0.1"
src_port = RandShort()
dst_port=80
window_scan_resp = sr1(IP(dst=dst_ip)/TCP(dport=dst_port,flags="A"),timeout=10)
if (str(type(window_scan_resp))=="type 'NoneType'"):
print "No response"
elif(window_scan_resp.haslayer(TCP)):
if(window_scan_resp.getlayer(TCP).window == 0):
print "Closed"
elif(window_scan_resp.getlayer(TCP).window 0):
print "Open"
UDP扫描
TCP 是面向连接的协议，而UDP则是无连接的协议。
面向连接的协议会先在客户端和服务器之间建立通信信道，然后才会开始传输数据。如果客户端和服务器之间没有建立通信信道，则不会有任何产生任何通信数据。
无连接的协议则不会事先建立客户端和服务器之间的通信信道，只要客户端到服务器存在可用信道，就会假设目标是可达的然后向对方发送数据。
客户端会向服务器发送一个带有端口号的 UDP 数据包。如果服务器回复了 UDP 数据包，则目标端口是开放的。
如果服务器返回了一个 ICMP 目标不可达的错误和代码3，则意味着目标端口处于关闭状态。
如果服务器返回一个 ICMP 错误类型3且代码为1，2，3，9，10或13的数据包，则说明目标端口被服务器过滤了。
但如果服务器没有任何相应客户端的 UDP 请求，则可以断定目标端口可能是开放或被过滤的，无法判断端口的最终状态。
代码：
#! /usr/bin/python
import logging
logging.getLogger("scapy.runtime").setLevel(logging.ERROR)
from scapy.all import *
dst_ip = "10.0.0.1"
src_port = RandShort()
dst_port=53
dst_timeout=10
def udp_scan(dst_ip,dst_port,dst_timeout):
udp_scan_resp = sr1(IP(dst=dst_ip)/UDP(dport=dst_port),timeout=dst_timeout)
if (str(type(udp_scan_resp))=="type 'NoneType'"):
retrans = []
for count in range(0,3):
retrans.append(sr1(IP(dst=dst_ip)/UDP(dport=dst_port),timeout=dst_timeout))
for item in retrans:
if (str(type(item))!="type 'NoneType'"):
udp_scan(dst_ip,dst_port,dst_timeout)
return "Open|Filtered"
elif (udp_scan_resp.haslayer(UDP)):
return "Open"
elif(udp_scan_resp.haslayer(ICMP)):
if(int(udp_scan_resp.getlayer(ICMP).type)==3 and int(udp_scan_resp.getlayer(ICMP).code)==3):
return "Closed"
elif(int(udp_scan_resp.getlayer(ICMP).type)==3 and int(udp_scan_resp.getlayer(ICMP).code) in [1,2,9,10,13]):
return "Filtered"
print udp_scan(dst_ip,dst_port,dst_timeout)
下面解释下上述代码中的一些函数和变量：
RandShort()：产生随机数
type()：获取数据类型
sport：源端口号
dport：目标端口号
timeout：等待相应的时间
haslayer()：查找指定层：TCP或UDP或ICMP
getlayer()：获取指定层：TCP或UDP或ICMP
以上扫描的概念可以被用于“多端口扫描”，源码可以参考这里：
Scapy 是一个非常好用的工具，使用它可以非常简单的构建自己的数据包，还可以很轻易的处理数据包的发送和相应。
（译者注：上述所有代码均在Kali 2.0下测试通过，建议读者在Linux环境下测试代码，如想在Windows上测试，请参见 Scapy官方文档 配置好scapy环境）
怎么 *** 一个BAT的端口扫描器
@echo off
setlocal enabledelayedexpansion
title 端口扫描器 by 风旋碧浪
color 4fMODE con: COLS=50 LINES=12
echo.echo 开始扫描，需要时间，请稍候……
(echo.echo 端口号 进程名称
echo.echo TCP协议: )端口查看.txt
echo.echo 正在扫描TCP协议……
for /f "skip=4 tokens=2,5" %%a in ('netstat -ano -p TCP') do (
for /f "tokens=2 delims=:" %%A in ("%%a") do set TCP端口=%%A
for /f "skip=2 delims=, tokens=1" %%A in ('tasklist /fi "PID eq %%b" /FO CSV') do set TCP进程=%%~A
echo !TCP端口! !TCP进程!端口查看.txt
)
echo UDP协议: 端口查看.txt
echo.echo 正在扫描UDP协议……
for /f "skip=4 tokens=2,4" %%a in ('netstat -ano -p UDP') do (
for /f "tokens=2 delims=:" %%A in ("%%a") do set UDP端口=%%A
for /f "skip=2 delims=, tokens=1" %%A in ('tasklist /fi "PID eq %%b" /FO CSV') do set UDP进程=%%~A
echo !UDP端口! !UDP进程!端口查看.txt
)
echo.echo.echo 扫描结束！请查看《端口查看.txt》文件！
pausenul
0条大神的评论