Example usage for org.apache.shiro.crypto.hash DefaultHashService DefaultHashService

List of usage examples for org.apache.shiro.crypto.hash DefaultHashService DefaultHashService

  1. HOME
  2. Java
  3. org.apache.shiro
  4. org.apache.shiro.crypto.hash.*
  5. DefaultHashService
  6. DefaultHashService

Introduction

In this page you can find the example usage for org.apache.shiro.crypto.hash DefaultHashService DefaultHashService.

Prototype

public DefaultHashService()

Source Link

Document

Constructs a new DefaultHashService instance with the following defaults:
  • #setHashAlgorithmName(String) hashAlgorithmName = SHA-512
  • #setHashIterations(int) hashIterations = 1
  • #setRandomNumberGenerator(org.apache.shiro.crypto.RandomNumberGenerator) randomNumberGenerator = new SecureRandomNumberGenerator ()
  • #setGeneratePublicSalt(boolean) generatePublicSalt = false

If this hashService will be used for password hashing it is recommended to set the #setPrivateSalt(ByteSource) privateSalt and significantly increase the number of #setHashIterations(int) hashIterations .

Usage

From source file:CryptoTest.java

License:Apache License

@Test
public void test_hashingService() {
    log.info("*** test_hashingService ***");
    final DefaultHashService hashService = new DefaultHashService();

    final SecureRandomNumberGenerator secureRandomNumberGenerator = new SecureRandomNumberGenerator();
    secureRandomNumberGenerator.setDefaultNextBytesSize(64);
    final ByteSource privateSalt = secureRandomNumberGenerator.nextBytes();
    final ByteSource publicSalt = secureRandomNumberGenerator.nextBytes();

    log.info("privateSalt .length = {}", privateSalt.getBytes().length);

    hashService.setHashAlgorithmName("SHA-512");
    hashService.setHashIterations(1024 * 64);
    hashService.setPrivateSalt(privateSalt);
    hashService.setRandomNumberGenerator(secureRandomNumberGenerator);
    hashService.setGeneratePublicSalt(true);

    final HashRequest hashRequest = new HashRequest.Builder().setSource("password").setSalt(publicSalt).build();
    final Hash hash = hashService.computeHash(hashRequest);
    log.info("hash.salt : {}", hash.getSalt());
    log.info("publicSalt : {}", publicSalt);
    log.info("hash Base64 : {}", hash.toBase64());
    final String hash1 = hashService.computeHash(hashRequest).toBase64();
    final String hash2 = hashService.computeHash(hashRequest).toBase64();
    log.info("hash1 Base64 : {}", hash1);
    log.info("hash2 Base64 : {}", hash2);
    Assert.assertEquals(hash1, hash2);//from  w  w  w  .j av a  2  s  .c o  m

    Sha512Hash encodedPassword = new Sha512Hash("password", publicSalt, 1024 * 64);
    Sha512Hash encodedPassword2 = new Sha512Hash(encodedPassword.getBytes(), privateSalt, 1024 * 64);
    log.info("encodedPassword Base64 : {}", encodedPassword.toBase64());
    log.info("encodedPassword2 Base64 : {}", encodedPassword2.toBase64());

    Sha512Hash encodedPassword3 = new Sha512Hash("password", publicSalt, 1024 * 64);
    Sha512Hash encodedPassword4 = new Sha512Hash(encodedPassword3.getBytes(), privateSalt, 1024 * 64);
    log.info("encodedPassword3 Base64 : {}", encodedPassword3.toBase64());
    log.info("encodedPassword4 Base64 : {}", encodedPassword4.toBase64());

    Assert.assertEquals(encodedPassword2, encodedPassword4);
}

From source file:CryptoTest.java

License:Apache License

@Test
public void test_hashingService_usingRandomSalts() {
    log.info("*** test_hashingService_usingRandomSalts ***");
    final DefaultHashService hashService = new DefaultHashService();

    final SecureRandomNumberGenerator secureRandomNumberGenerator = new SecureRandomNumberGenerator();
    secureRandomNumberGenerator.setDefaultNextBytesSize(64);
    final ByteSource privateSalt = secureRandomNumberGenerator.nextBytes();

    hashService.setHashAlgorithmName("SHA-512");
    hashService.setHashIterations(1024 * 128);
    hashService.setPrivateSalt(privateSalt);
    hashService.setRandomNumberGenerator(secureRandomNumberGenerator);
    hashService.setGeneratePublicSalt(true);

    final HashRequest hashRequest = new HashRequest.Builder().setSource("password").build();
    final StopWatch stopWatch = new StopWatch();
    stopWatch.start();//from w w w .j  a v a2  s.  c o  m
    final Hash hash = hashService.computeHash(hashRequest);
    stopWatch.stop();
    final byte[] hashBytes = hash.getBytes();

    log.info("hashBytes length = {}", hashBytes.length);
    log.info("hash Base64 length = {}", hash.toBase64().length());
    log.info("hash time: {}", stopWatch.getTime());
    log.info("hash.salt : {}", hash.getSalt());
    final ByteSource salt = hash.getSalt();
    log.info("salt : {}", salt);
    log.info("hash Base64 : {}", hash.toBase64());

    final String hash1 = hashService
            .computeHash(new HashRequest.Builder().setSource("password").setSalt(salt).build()).toBase64();
    final String hash2 = hashService
            .computeHash(new HashRequest.Builder().setSource("password").setSalt(salt).build()).toBase64();
    log.info("hash1 Base64 : {}", hash1);
    log.info("hash2 Base64 : {}", hash2);
    Assert.assertEquals(hash1, hash2);

    Sha512Hash encodedPassword = new Sha512Hash("password", salt, 1024 * 64);
    Sha512Hash encodedPassword2 = new Sha512Hash(encodedPassword.getBytes(), privateSalt, 1024 * 64);
    log.info("encodedPassword Base64 : {}", encodedPassword.toBase64());
    log.info("encodedPassword2 Base64 : {}", encodedPassword2.toBase64());

    Sha512Hash encodedPassword3 = new Sha512Hash("password", salt, 1024 * 64);
    Sha512Hash encodedPassword4 = new Sha512Hash(encodedPassword3.getBytes(), privateSalt, 1024 * 64);
    log.info("encodedPassword3 Base64 : {}", encodedPassword3.toBase64());
    log.info("encodedPassword4 Base64 : {}", encodedPassword4.toBase64());

    Assert.assertEquals(encodedPassword2, encodedPassword4);

    hashService.setHashIterations(1024 * 127);

}

From source file:CryptoTest.java

License:Apache License

@Test
public void test_secureRandomNumberGenerator_nextBytesSize() {
    log.info("*** test_secureRandomNumberGenerator_nextBytesSize ***");
    final DefaultHashService hashService = new DefaultHashService();
    final SecureRandomNumberGenerator secureRandomNumberGenerator = new SecureRandomNumberGenerator();
    secureRandomNumberGenerator.setDefaultNextBytesSize(8);
    final ByteSource privateSalt = secureRandomNumberGenerator.nextBytes();
    log.info("privateSalt = {}", privateSalt);
    log.info("privateSalt byte length = {}", privateSalt.getBytes().length);

    hashService.setHashAlgorithmName("SHA-512");
    hashService.setHashIterations(1024 * 128);
    hashService.setPrivateSalt(privateSalt);
    hashService.setRandomNumberGenerator(secureRandomNumberGenerator);
    hashService.setGeneratePublicSalt(true);

    final HashRequest hashRequest = new HashRequest.Builder().setSource("password").build();
    final Hash hash = hashService.computeHash(hashRequest);

    final DefaultHashService hashService2 = new DefaultHashService();
    final SecureRandomNumberGenerator secureRandomNumberGenerator2 = new SecureRandomNumberGenerator();
    secureRandomNumberGenerator2.setDefaultNextBytesSize(16);

    hashService2.setHashAlgorithmName("SHA-512");
    hashService2.setHashIterations(1024 * 128);
    hashService2.setPrivateSalt(privateSalt);
    hashService2.setRandomNumberGenerator(secureRandomNumberGenerator2);
    hashService2.setGeneratePublicSalt(true);

    final HashRequest hashRequest2 = new HashRequest.Builder().setSource("password").setSalt(hash.getSalt())
            .build();/*from   w  ww  .j a v a2 s . c  o  m*/
    final Hash hash2 = hashService.computeHash(hashRequest2);

    log.info("hash = {}", hash.toBase64());
    log.info("hash2 = {}", hash2.toBase64());

    Assert.assertEquals(hash2.toBase64(), hash.toBase64());
}

From source file:base.web.ShiroDbRealm.java

License:Apache License

/**
 * ??spring/shiro.xml?credentialsMatcher <br/>
 * //from w w  w .  ja v  a2  s . c om
 * ?SHA-256Base64?1024<br/>
 * SHA-256Base64??(44?)Hex??64?<br/>
 * ?SHA-384?SHA-512????
 * 
 * @author Junas.Cheung
 */
public String encrytPassword(String password) {
    // ????
    String hashAlgorithmName = ConfigUtil.getValue("password.hash.algorithm.name");
    int iterations = ConfigUtil.getIntValue("password.iterations");
    boolean isStoredHex = ConfigUtil.getBooleanValue("password.is.stored.hex");
    // 
    DefaultHashService hashService = new DefaultHashService();
    // 
    hashService.setHashAlgorithmName(hashAlgorithmName);
    // 
    hashService.setHashIterations(iterations);
    // ?
    ByteSource byteSource = ByteSource.Util.bytes(password);
    Hash hash = hashService.computeHash(new HashRequest.Builder().setSource(byteSource).build());
    // ?Hash
    return isStoredHex ? hash.toHex() : hash.toBase64();
}

From source file:cn.powerdash.libsystem.common.security.authc.PrivateSaltPasswordService.java

License:Open Source License

public PrivateSaltPasswordService() {
    super();//from   w  w w .  j  a v  a 2s.c  o m
    HashService hashService = getHashService();
    if (hashService instanceof DefaultHashService) {
        ((DefaultHashService) hashService).setPrivateSalt(new SimpleByteSource(PRIVATE_SALT));
    }
    DefaultHashService hashServiceInstance = new DefaultHashService();
    hashServiceInstance.setHashAlgorithmName("MD5");
    this.md5HashService = hashServiceInstance;
    hexHashFormat = new HexFormat();
    this.defaultHashService = super.getHashService();
    defaultHashFormat = super.getHashFormat();
}

From source file:com.azaptree.services.security.domain.config.impl.HashServiceConfig.java

License:Apache License

@Override
public HashService getHashService() {
    if (hashService != null) {
        return hashService;
    }/*ww  w.ja  va  2 s . c o m*/
    final DefaultHashService service = new DefaultHashService();
    service.setGeneratePublicSalt(true);
    service.setPrivateSalt(ByteSource.Util.bytes(privateSalt));
    service.setHashAlgorithmName(hashAlgorithmName);
    service.setHashIterations(hashIterations);

    final SecureRandomNumberGenerator rng = new SecureRandomNumberGenerator();
    rng.setDefaultNextBytesSize(secureRandomNumberGeneratorNextBytesSize);
    final SecureRandom random = new SecureRandom();
    final byte rngSeed[] = new byte[20];
    random.nextBytes(rngSeed);
    rng.setSeed(rngSeed);

    service.setRandomNumberGenerator(rng);
    hashService = service;
    return service;
}

From source file:com.epimorphics.registry.security.BaseRegRealm.java

License:Apache License

public BaseRegRealm() {
    setPermissionResolver(new RegPermissionResolver());
    setCredentialsMatcher(new RegCredentialsMatcher());
    DefaultHashService hashing = new DefaultHashService();
    hashing.setHashAlgorithmName(RegCredentialsMatcher.DEFAULT_ALGORITHM);
    hashing.setHashIterations(RegCredentialsMatcher.DEFAULT_ITERATIONS);
    hashService = hashing;//  w ww.  j av  a  2s . c om
}

From source file:com.github.richardwilly98.esdms.services.SHA512HashProvider.java

License:Open Source License

public SHA512HashProvider() {
    super();// w ww . java2  s.  c om
    service = new DefaultHashService();
    if (log.isTraceEnabled()) {
        log.trace("AlgorithmName: " + service.getHashAlgorithmName());
    }
}

From source file:com.masslink.idea.zigbee.shiro.UserPasswordService.java

License:Apache License

public UserPasswordService() {
    this.hashFormatWarned = false;
    DefaultHashService defaultHashService = new DefaultHashService();
    defaultHashService.setHashAlgorithmName(ALGORITHM);
    defaultHashService.setHashIterations(ITERATIONS);
    defaultHashService.setGeneratePublicSalt(true); //always want generated salts for user passwords to be most secure
    defaultHashService.setPrivateSalt(new SimpleByteSource(SALT));
    this.hashService = defaultHashService;
    this.hashFormat = new Shiro1CryptFormat();
    this.hashFormatFactory = new DefaultHashFormatFactory();
}

From source file:com.mycompany.shirofaces.SHA256.java

public static void main(String args[]) {
    RandomNumberGenerator rng = new SecureRandomNumberGenerator();
    Object salt = rng.nextBytes();
    String hashedPasswordBase64 = new Sha256Hash("juancho18", salt, 1024).toBase64();

    Sha256Hash sha256Hash = new Sha256Hash("juancho18");
    System.out.println("Clave sin salt: " + sha256Hash.toHex());
    System.out.println("Clave con salt : " + hashedPasswordBase64);

    DefaultHashService hashService = new DefaultHashService();
    hashService.setHashIterations(50000); // 500000
    hashService.setHashAlgorithmName(Sha256Hash.ALGORITHM_NAME);
    hashService.setPrivateSalt(new SimpleByteSource("jumarome"));
    hashService.setGeneratePublicSalt(true);

    DefaultPasswordService passwordService = new DefaultPasswordService();
    passwordService.setHashService(hashService);
    String salte = hashService.getPrivateSalt().toBase64();
    String claveMaldita = passwordService.encryptPassword("unaep");
    System.out.println("Miraaa: " + claveMaldita);

    System.out.println("private salt= " + salte);

}