本文目录导读：
我来为您详细介绍Java暴力破解的典型案例,主要从密码破解和算法问题求解两个角度展开。
密码暴力破解案例
1 简单数字密码破解
import java.util.ArrayList;
import java.util.List;
public class PasswordBruteForce {
// 破解4位数字密码
public static String crack4DigitPassword(String targetPassword) {
System.out.println("开始破解4位数字密码...");
for (int i = 0; i <= 9999; i++) {
String attempt = String.format("%04d", i);
System.out.println("尝试密码: " + attempt);
if (attempt.equals(targetPassword)) {
System.out.println("破解成功！密码是: " + attempt);
return attempt;
}
}
System.out.println("破解失败");
return null;
}
// 通用密码破解（指定字符集和长度）
public static String crackPassword(String targetPassword,
String charset,
int maxLength) {
System.out.println("开始暴力破解密码...");
System.out.println("字符集: " + charset);
System.out.println("最大长度: " + maxLength);
for (int length = 1; length <= maxLength; length++) {
String result = generateAndCheck(targetPassword, charset,
new StringBuilder(), length);
if (result != null) {
return result;
}
}
return null;
}
private static String generateAndCheck(String target, String charset,
StringBuilder prefix, int remaining) {
if (remaining == 0) {
String attempt = prefix.toString();
System.out.println("尝试: " + attempt);
if (attempt.equals(target)) {
return attempt;
}
return null;
}
for (int i = 0; i < charset.length(); i++) {
prefix.append(charset.charAt(i));
String result = generateAndCheck(target, charset, prefix, remaining - 1);
prefix.deleteCharAt(prefix.length() - 1);
if (result != null) {
return result;
}
}
return null;
}
public static void main(String[] args) {
// 示例1：破解4位数字密码
String password1 = "1234";
crack4DigitPassword(password1);
System.out.println("========================");
// 示例2：破解2位小写字母密码
String password2 = "ab";
String charset = "abcdefghijklmnopqrstuvwxyz";
String result = crackPassword(password2, charset, 2);
if (result != null) {
System.out.println("破解成功！密码是: " + result);
} else {
System.out.println("破解失败");
}
}
}
2 多线程暴力破解
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.atomic.AtomicBoolean;
public class MultiThreadBruteForce {
private static final AtomicBoolean found = new AtomicBoolean(false);
private static volatile String password = null;
public static void multiThreadCrack(String targetPassword,
String charset,
int maxLength,
int threadCount) {
System.out.println("多线程暴力破解开始...");
System.out.println("线程数: " + threadCount);
ExecutorService executor = Executors.newFixedThreadPool(threadCount);
int chunkSize = charset.length() / threadCount;
for (int i = 0; i < threadCount; i++) {
int start = i * chunkSize;
int end = (i == threadCount - 1) ? charset.length() : (i + 1) * chunkSize;
String subCharset = charset.substring(start, end);
executor.submit(new CrackWorker(targetPassword, subCharset, maxLength, i));
}
executor.shutdown();
while (!executor.isTerminated()) {
// 等待所有线程完成
}
if (password != null) {
System.out.println("破解成功！密码是: " + password);
} else {
System.out.println("破解失败");
}
}
static class CrackWorker implements Runnable {
private String targetPassword;
private String charset;
private int maxLength;
private int workerId;
public CrackWorker(String targetPassword, String charset,
int maxLength, int workerId) {
this.targetPassword = targetPassword;
this.charset = charset;
this.maxLength = maxLength;
this.workerId = workerId;
}
@Override
public void run() {
System.out.println("工作线程 " + workerId + " 启动，字符集: " + charset);
for (int length = 1; length <= maxLength && !found.get(); length++) {
generateAndCheck(targetPassword, charset, new StringBuilder(), length);
}
}
private void generateAndCheck(String target, String charset,
StringBuilder prefix, int remaining) {
if (found.get()) return;
if (remaining == 0) {
String attempt = prefix.toString();
if (attempt.equals(target)) {
password = attempt;
found.set(true);
}
return;
}
for (int i = 0; i < charset.length() && !found.get(); i++) {
prefix.append(charset.charAt(i));
generateAndCheck(target, charset, prefix, remaining - 1);
prefix.deleteCharAt(prefix.length() - 1);
}
}
}
public static void main(String[] args) {
String password = "xyz";
String charset = "abcdefghijklmnopqrstuvwxyz";
long startTime = System.currentTimeMillis();
multiThreadCrack(password, charset, 3, 4);
long endTime = System.currentTimeMillis();
System.out.println("耗时: " + (endTime - startTime) + "ms");
}
}
算法问题暴力求解
1 背包问题的暴力解法
import java.util.ArrayList;
import java.util.List;
public class KnapsackBruteForce {
static class Item {
String name;
int weight;
int value;
public Item(String name, int weight, int value) {
this.name = name;
this.weight = weight;
this.value = value;
}
}
// 暴力求解0-1背包问题
public static List<Item> knapsackBruteForce(List<Item> items, int capacity) {
int n = items.size();
int maxValue = 0;
List<Item> bestCombination = new ArrayList<>();
// 枚举所有可能的组合（2^n种）
for (int i = 0; i < (1 << n); i++) {
List<Item> currentCombination = new ArrayList<>();
int currentWeight = 0;
int currentValue = 0;
// 检查当前组合
for (int j = 0; j < n; j++) {
if ((i & (1 << j)) != 0) {
currentCombination.add(items.get(j));
currentWeight += items.get(j).weight;
currentValue += items.get(j).value;
}
}
// 如果当前组合更好且不超过容量
if (currentWeight <= capacity && currentValue > maxValue) {
maxValue = currentValue;
bestCombination = new ArrayList<>(currentCombination);
}
}
return bestCombination;
}
public static void main(String[] args) {
List<Item> items = new ArrayList<>();
items.add(new Item("物品A", 2, 3));
items.add(new Item("物品B", 3, 4));
items.add(new Item("物品C", 4, 5));
items.add(new Item("物品D", 5, 8));
int capacity = 8;
System.out.println("背包容量: " + capacity);
System.out.println("物品列表:");
for (Item item : items) {
System.out.println(" " + item.name + " (重量:" + item.weight +
", 价值:" + item.value + ")");
}
List<Item> bestCombination = knapsackBruteForce(items, capacity);
System.out.println("\n最优组合:");
int totalWeight = 0;
int totalValue = 0;
for (Item item : bestCombination) {
System.out.println(" " + item.name);
totalWeight += item.weight;
totalValue += item.value;
}
System.out.println("总重量: " + totalWeight);
System.out.println("总价值: " + totalValue);
}
}
2 旅行商问题的暴力求解
import java.util.*;
public class TSPBruteForce {
// 暴力求解旅行商问题
public static class TSPResult {
List<Integer> path;
int minDistance;
public TSPResult(List<Integer> path, int minDistance) {
this.path = path;
this.minDistance = minDistance;
}
}
public static TSPResult solveTSP(int[][] distance) {
int n = distance.length;
List<Integer> cities = new ArrayList<>();
for (int i = 1; i < n; i++) {
cities.add(i);
}
int minDistance = Integer.MAX_VALUE;
List<Integer> bestPath = new ArrayList<>();
// 生成所有排列
List<List<Integer>> permutations = new ArrayList<>();
generatePermutations(cities, 0, permutations);
// 计算每种排列的距离
for (List<Integer> perm : permutations) {
int currentDistance = 0;
int currentCity = 0; // 从城市0开始
for (int city : perm) {
currentDistance += distance[currentCity][city];
currentCity = city;
}
// 返回起点
currentDistance += distance[currentCity][0];
if (currentDistance < minDistance) {
minDistance = currentDistance;
bestPath = new ArrayList<>(perm);
}
}
// 构建完整路径
List<Integer> fullPath = new ArrayList<>();
fullPath.add(0);
fullPath.addAll(bestPath);
fullPath.add(0);
return new TSPResult(fullPath, minDistance);
}
private static void generatePermutations(List<Integer> arr,
int index,
List<List<Integer>> result) {
if (index == arr.size() - 1) {
result.add(new ArrayList<>(arr));
return;
}
for (int i = index; i < arr.size(); i++) {
Collections.swap(arr, i, index);
generatePermutations(arr, index + 1, result);
Collections.swap(arr, i, index);
}
}
public static void main(String[] args) {
// 城市间距离矩阵
int[][] distance = {
{0, 10, 15, 20},
{10, 0, 35, 25},
{15, 35, 0, 30},
{20, 25, 30, 0}
};
System.out.println("城市距离矩阵:");
for (int i = 0; i < distance.length; i++) {
System.out.println(Arrays.toString(distance[i]));
}
TSPResult result = solveTSP(distance);
System.out.println("\n最优路径: " + result.path);
System.out.println("最短距离: " + result.minDistance);
System.out.println("\n验证距离计算:");
for (int i = 0; i < result.path.size() - 1; i++) {
int from = result.path.get(i);
int to = result.path.get(i + 1);
System.out.println(from + " -> " + to + " : " + distance[from][to]);
}
}
}
实际应用示例：验证码破解
import java.util.Random;
public class CaptchaBruteForce {
// 模拟的验证码验证函数
public static boolean verifyCaptcha(String captcha) {
// 假设验证码是 "ABC123"
return captcha.equals("ABC123");
}
// 暴力破解4位字母数字验证码
public static String crackCaptcha() {
String chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
System.out.println("开始破解验证码...");
System.out.println("字符集长度: " + chars.length());
int attempts = 0;
long startTime = System.currentTimeMillis();
// 生成所有6位组合（3字母+3数字的简化版）
for (int a = 0; a < 26; a++) {
for (int b = 0; b < 26; b++) {
for (int c = 0; c < 26; c++) {
for (int d = 0; d < 10; d++) {
for (int e = 0; e < 10; e++) {
for (int f = 0; f < 10; f++) {
String captcha = String.format("%c%c%c%d%d%d",
(char)('A' + a),
(char)('A' + b),
(char)('A' + c),
d, e, f);
attempts++;
if (verifyCaptcha(captcha)) {
long endTime = System.currentTimeMillis();
System.out.println("破解成功！");
System.out.println("验证码: " + captcha);
System.out.println("尝试次数: " + attempts);
System.out.println("耗时: " + (endTime - startTime) + "ms");
return captcha;
}
// 进度显示（每10万次）
if (attempts % 100000 == 0) {
System.out.println("已尝试: " + attempts + " 次");
}
}
}
}
}
}
}
return null;
}
public static void main(String[] args) {
String result = crackCaptcha();
if (result == null) {
System.out.println("破解失败");
}
}
}
优化技巧和注意事项
优化技巧：
public class BruteForceOptimization {
// 1. 剪枝优化
public static boolean earlyTermination(String target) {
// 如果发现明显不符合条件，立即停止当前分支
return false; // 示例返回
}
// 2. 启发式搜索
public static List<String> heuristicSearch(String partial) {
List<String> candidates = new ArrayList<>();
// 根据部分信息缩小搜索范围
// 如果知道密码包含特定字符
return candidates;
}
// 3. 字典攻击（常见密码列表）
public static String dictionaryAttack(String target) {
String[] commonPasswords = {
"password", "123456", "12345678", "qwerty",
"admin", "letmein", "welcome", "monkey"
};
for (String pwd : commonPasswords) {
if (pwd.equals(target)) {
return pwd;
}
}
return null;
}
}
注意事项：
- 合法性：只在授权系统上使用
- 性能考虑：暴力破解时间复杂度极高
- 内存管理：避免生成大量中间数据
- 超时机制：设置合理的超时时间
暴力破解是解决问题的最直接方法，但效率极低,实际应用中应该：
- 优先使用更有效的算法（动态规划、回溯等）
- 只在问题规模较小时使用暴力破解
- 结合启发式方法提高效率
- 注意合法合规使用
这些代码示例展示了Java在暴力破解问题中的典型应用,实际开发中要谨慎使用。
