Java Hash类代码示例

import org.apache.shiro.crypto.hash.Hash; //导入依赖的package包/类
private static Hash calculateHash(String password) {
    ByteSource privateSalt = ByteSource.Util.bytes(PRIVATE_SALT_BYTES);
    DefaultHashService hashService = new DefaultHashService();
    hashService.setPrivateSalt(privateSalt);
    hashService.setGeneratePublicSalt(true);
    hashService.setHashIterations(ITERATIONS);

    HashRequest.Builder builder = new HashRequest.Builder();
    builder.setSource(ByteSource.Util.bytes(password));

    Hash hash = hashService.computeHash(builder.build());

    log.info("Hash algorithm {}, iterations {}, public salt {}", hash.getAlgorithmName(), hash.getIterations(), hash.getSalt());

    return hash;
}
 

import org.apache.shiro.crypto.hash.Hash; //导入依赖的package包/类
public String format(Hash hash) {
    if (hash == null) {
        return null;
    }

    String algorithmName = hash.getAlgorithmName();
    ByteSource salt = hash.getSalt();
    int iterations = hash.getIterations();
    StringBuilder sb = new StringBuilder(MCF_PREFIX).append(algorithmName).append(TOKEN_DELIMITER).append(iterations).append(TOKEN_DELIMITER);

    if (salt != null) {
        sb.append(salt.toBase64());
    }

    sb.append(TOKEN_DELIMITER);
    sb.append(hash.toBase64());

    return sb.toString();
}
 

import org.apache.shiro.crypto.hash.Hash; //导入依赖的package包/类
public boolean passwordsMatch(Object plaintext, Hash saved) {
    ByteSource plaintextBytes = createByteSource(plaintext);

    if (saved == null || saved.isEmpty()) {
        return plaintextBytes == null || plaintextBytes.isEmpty();
    } else {
        if (plaintextBytes == null || plaintextBytes.isEmpty()) {
            return false;
        }
    }

    HashRequest request = buildHashRequest(plaintextBytes, saved);

    Hash computed = this.hashService.computeHash(request);

    return saved.equals(computed);
}
 

import org.apache.shiro.crypto.hash.Hash; //导入依赖的package包/类
public boolean doCredentialsMatch(AuthenticationToken token, AuthenticationInfo info) {

        PasswordService service = ensurePasswordService();

        Object submittedPassword = getSubmittedPassword(token);
        Object storedCredentials = getStoredPassword(info);
        assertStoredCredentialsType(storedCredentials);

        if (storedCredentials instanceof Hash) {
            Hash hashedPassword = (Hash)storedCredentials;
            HashingPasswordService hashingService = assertHashingPasswordService(service);
            return hashingService.passwordsMatch(submittedPassword, hashedPassword);
        }
        //otherwise they are a String (asserted in the 'assertStoredCredentialsType' method call above):
        String formatted = (String)storedCredentials;
        return passwordService.passwordsMatch(submittedPassword, formatted);
    }
 

import org.apache.shiro.crypto.hash.Hash; //导入依赖的package包/类
@Override
protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {
	if (token instanceof UsernamePasswordToken) {
		final UsernamePasswordToken upToken = (UsernamePasswordToken)token;
		final String username = upToken.getUsername();

		final UserStorage storage = UsersPlugin.getInstance().getStorage();
		final DB db = storage.getTxMaker().makeTx();
		try {
			final User user = storage.getUserMap(db).get(username);
			if (user == null) {
				return null;
			}
			Hash hash = new Shiro1CryptFormat().parse(user.getHashedPassword());
			return new UserInfo(user.getUsername(), hash);
		} finally {
			db.close();
		}
	}
	return null;
}
 

import org.apache.shiro.crypto.hash.Hash; //导入依赖的package包/类
private static boolean verifyPassword(byte[] originalHash, ByteSource publicSalt, String password) {
    ByteSource privateSalt = ByteSource.Util.bytes(PRIVATE_SALT_BYTES);
    DefaultHashService hashService = new DefaultHashService();
    hashService.setPrivateSalt(privateSalt);
    hashService.setHashIterations(ITERATIONS);

    HashRequest.Builder builder = new HashRequest.Builder();
    builder.setSource(ByteSource.Util.bytes(password));
    builder.setSalt(publicSalt);

    Hash comparisonHash = hashService.computeHash(builder.build());

    log.info("password: {}", password);
    log.info("1 hash: {}", Hex.encodeToString(originalHash));
    log.info("2 hash: {}", comparisonHash.toHex());

    return Arrays.equals(originalHash, comparisonHash.getBytes());
}
 

import org.apache.shiro.crypto.hash.Hash; //导入依赖的package包/类
public Hash hashPassword(Object plaintext) {
    ByteSource plaintextBytes = createByteSource(plaintext);
    if (plaintextBytes == null || plaintextBytes.isEmpty()) {
        return null;
    }
    HashRequest request = createHashRequest(plaintextBytes);
    return hashService.computeHash(request);
}
 

import org.apache.shiro.crypto.hash.Hash; //导入依赖的package包/类
protected HashRequest buildHashRequest(ByteSource plaintext, Hash saved) {
    //keep everything from the saved hash except for the source:
    return new HashRequest.Builder().setSource(plaintext)
            //now use the existing saved data:
            .setAlgorithmName(saved.getAlgorithmName())
            .setSalt(saved.getSalt())
            .setIterations(saved.getIterations())
            .build();
}
 

import org.apache.shiro.crypto.hash.Hash; //导入依赖的package包/类
private void assertStoredCredentialsType(Object credentials) {
    if (credentials instanceof String || credentials instanceof Hash) {
        return;
    }

    String msg = "Stored account credentials are expected to be either a " +
            Hash.class.getName() + " instance or a formatted hash String.";
    throw new IllegalArgumentException(msg);
}
 

import org.apache.shiro.crypto.hash.Hash; //导入依赖的package包/类
@Test
public void testHash() {
  String password = "testpassword";
  Hash hash = underTest.hashPassword(password);

  assertThat(underTest.passwordsMatch(password, hash), is(true));
}
 

import org.apache.shiro.crypto.hash.Hash; //导入依赖的package包/类
@Override
public Hash computeHash(HashRequest request) {
    SimpleHash result = new SimpleHash(request.getAlgorithmName());
    result.setSalt(request.getSalt());
    result.setIterations(request.getIterations());
    result.setBytes(request.getSource().getBytes());
    return result;
}
 

import org.apache.shiro.crypto.hash.Hash; //导入依赖的package包/类
@Override
protected AuthenticationInfo createAuthenticationInfo(AuthenticationToken token, 
      Object ldapPrincipal,
      Object ldapCredentials, LdapContext ldapContext) throws NamingException {
  HashRequest.Builder builder = new HashRequest.Builder();
  Hash credentialsHash = hashService
        .computeHash(builder.setSource(token.getCredentials())
              .setAlgorithmName(HASHING_ALGORITHM).build());
  return new SimpleAuthenticationInfo(token.getPrincipal(), 
        credentialsHash.toHex(), credentialsHash.getSalt(),
        getName());
}
 

import org.apache.shiro.crypto.hash.Hash; //导入依赖的package包/类
public void setPassword(ByteSource password, long minstolive) {
    timeout = System.currentTimeMillis() + minstolive * 60 * 1000;
    HashRequest request = new HashRequest.Builder()
        .setSource(password)
        .setSalt( getSalt() )
        .build();
    Hash hash = realm.getHashService().computeHash(request);
    this.password = hash.toHex();
}
 

import org.apache.shiro.crypto.hash.Hash; //导入依赖的package包/类
public static void main(String[] args) {
    String password = "SHA-512 hash sample text";

    Hash hash = calculateHash(password);
    boolean correct = verifyPassword(hash.getBytes(), hash.getSalt(), password);

    log.info("Entered password is correct: {}", correct);
}
 

import org.apache.shiro.crypto.hash.Hash; //导入依赖的package包/类
@Transient
@Override
public ByteSource getCredentialsSalt() {
    return Hash.Util.bytes(passwordSalt);
}