java反哈希_Java构建HashCode相同字符串算法

import java.math.BigDecimal;

import java.util.Random;

/**

* “中间相遇法”是生日攻击的一种变形，它不比较Hash值，而是比较链中的中间变量。这种攻击主要适用于攻击具有分组链结构的Hash方案。

* 中间相遇攻击的基本原理为

* ：将消息分成两部分，对伪造消息的第一部分从初试值开始逐步向中间阶段产生r1个变量；对伪造消息的第二部分从Hash结果开始逐步退回中间阶段产生r2个变量

* 。在中间阶段有一个匹配的概率与生日攻击成功的概率一样。

*/

public class HashCollide {

/**

* 拼凑字符的起始值(最后实际值可能为 collideCharBase +- mulBase)

*/

private int collideCharBase;

/**

* 中间变量

*/

private BigDecimal collideCharBase_decimal;

/**

* 中间变量

*/

private BigDecimal mulBase_decimal_pow;

/**

* 拼凑字符串长度

*/

private int collideCharLength;

/**

* hash算法中采用的乘积值 (hash' = hash * mulBase + char[i])

*/

private long mulBase;

/**

* 中间变量

*/

private BigDecimal mulBase_decimal;

/**

* 中间变量

*/

private long mulBase_desc;

/**

* 中间变量

*/

private BigDecimal mulBase_desc_decimal;

/**

* 2的轮回...

*/

private final long INT_ROUTE_NUMBER = 2l << 32;

/**

* 还是2的轮回...

*/

private final BigDecimal DECIMAL_ROUTE_NUMBER = new BigDecimal(

INT_ROUTE_NUMBER);

/**

* 不知道干啥的,好奇怪

*/

private final Random random = new Random(System.nanoTime());

/**

* 测试你的char数组能吧srcHash变成什么样子

*

* @param srcHash

* @param collide

* @return

*/

public int hashCodeTest(int srcHash, char collide[]) {

int h = srcHash;

int len = collide.length;

for (int i = 0; i < len; i++) {

h = (int) mulBase * h + collide[i];

}

return h;

}

/**

* 根据这个类构造时设置的参数输出hash

*

* @param srcString

* @return

*/

public int hashCodeTest(String srcString) {

char[] chars = srcString.toCharArray();

int h = 0;

int len = chars.length;

for (int i = 0; i < len; i++) {

h = (int) mulBase * h + chars[i];

}

return h;

}

/**

* 将一个decimal的值通过取余转换成一个属于int范围的long

*

* @param data

* @return

*/

private long fixDecimal(BigDecimal data) {

// 求余数

BigDecimal sub = data.divideToIntegralValue(DECIMAL_ROUTE_NUMBER

.multiply(DECIMAL_ROUTE_NUMBER));

// 可能为负数,修正为long类型之后再次求余

long val = data.subtract(sub).longValue();

val += INT_ROUTE_NUMBER;

val = val % INT_ROUTE_NUMBER;

if (val < 0) // val应该不会小于0

val += INT_ROUTE_NUMBER;

return val;

}

/**

* 把val转换为正序的char数组,用以表示一个n位k进制数据

*

* @param val

* @return

*/

private char[] offsetToArray(long val) {

char[] stk = new char[collideCharLength];

int pos = 0;

while (val != 0) { // 进制转换,得到反序列

stk[pos++] = (char) (val % (mulBase) + collideCharBase);

val = val / mulBase;

}

int fillZero = collideCharLength - pos; // 补零的个数

char[] collides = new char[collideCharLength];

int i = 0;

while (i < fillZero) { // 高位补零

collides[i++] = (char) collideCharBase;

}

while (i < collideCharLength) { // 逐位反向输出

collides[i] = stk[pos - i + fillZero - 1]; // pos - ( i - fillZero )

++i;

}

return collides;

}

/**

* 根据hash的src和target生成一组序列，使原串后面附加序列字符后的hash与target相同

*

* @param src

* @param target

* @param collideCharBase

* @param n

* @return

*/

private char[] genCollisionArray(int src, int target) {

long hx = mulBase_desc * src + collideCharBase;

BigDecimal halfCal = mulBase_decimal_pow.multiply(new BigDecimal(hx)) // 中间变量

.subtract(collideCharBase_decimal);

BigDecimal left = halfCal.divide(mulBase_desc_decimal); // 依然是中间变量

BigDecimal fix = new BigDecimal(target).subtract(left); // 还是中间变量,不过这次是修正数据

long fixedDecimal = fixDecimal(fix);

return offsetToArray(fixedDecimal);

}

/**

* 构造函数

*

* @param collideCharBase

* 拼凑字符的起始值(最后实际值可能为 collideCharBase +- mulBase)

* @param collideCharLength

* 拼凑字符串长度

* @param mulBase

* hash算法中采用的乘积值 (hash' = hash * mulBase + char[i])

*/

public HashCollide(int collideCharBase, int collideCharLength, int mulBase) {

this.mulBase = mulBase;

this.mulBase_decimal = new BigDecimal(mulBase);

this.mulBase_desc = mulBase - 1;

this.mulBase_desc_decimal = new BigDecimal(mulBase - 1);

this.mulBase_decimal_pow = mulBase_decimal.pow(collideCharLength);

this.collideCharBase = collideCharBase;

this.collideCharBase_decimal = new BigDecimal(collideCharBase);

this.collideCharLength = collideCharLength;

}

/**

* ...

*

* @param source

* @param targetHash

* @return

*/

public String collide(String source, int targetHash) {

int hashSrc = source.hashCode();

char[] collide = this.genCollisionArray(hashSrc, targetHash);

return source.concat(new String(collide));

}

/**

* ...

*

* @return

*/

public String randomString(int length) {

char[] chars = new char[length];

for (int i = 0; i < length; ++i) {

chars[i] = (char) (50 + random.nextInt(32 + 26 + 15));

}

return new String(chars);

}

public static void main(String[] args) {

System.out.println("NH]n;

System.out.println("W@3Lb=SIr`\\h?KT5?ayLtd37y]x=\\Pcibr4O4SaKubhJ_M`lqEbjk;5ycYmZp^cm".hashCode());

System.out.println("====================");

HashCollide collide = new HashCollide(85, 7, 31);

for (int i = 0; i < 6; ++i) {

String a = collide.randomString(57);    //控制长度

//String b = collide.collide(a, 912366222);

String b = collide.collide(a, 123456);

System.out.print(b);

System.out.print("==");

System.out.println(b.hashCode());

if (b.hashCode() != 123456) {

System.err.println("ERROR :: src = " + a);

System.err.println("ERROR :: dst = " + b);

System.exit(1);

}

}

}

}