public String getDigestAlgorithm() { return digest.getAlgorithm(); } }
/** * Construct a new instance. * * @param delegate the delegate message digest * @param bytes the truncation size */ public TruncatedMessageDigest(final MessageDigest delegate, final int bytes) { super(delegate.getAlgorithm()); this.delegate = delegate; this.bytes = bytes; }
public String getDigestAlgorithm() { return digest.getAlgorithm(); } }
Object writeReplace() { return new SerializedForm(prototype.getAlgorithm(), bytes, toString); }
Object writeReplace() { return new SerializedForm(prototype.getAlgorithm(), bytes, toString); }
Object writeReplace() { return new SerializedForm(prototype.getAlgorithm(), bytes, toString); }
Object writeReplace() { return new SerializedForm(prototype.getAlgorithm(), bytes, toString); }
private FileChecksum getPFileChecksum(Path f) throws IOException { MessageDigest md5Digest; try { md5Digest = MessageDigest.getInstance("MD5"); MD5Hash md5Hash = new MD5Hash(getMD5Checksum(fs.open(f))); return new PFileChecksum(md5Hash, md5Digest.getAlgorithm()); } catch (Exception e) { throw new IOException(e); } }
@Override public Hasher newHasher() { if (supportsClone) { try { return new MessageDigestHasher((MessageDigest) prototype.clone(), bytes); } catch (CloneNotSupportedException e) { // falls through } } return new MessageDigestHasher(getMessageDigest(prototype.getAlgorithm()), bytes); }
@Override public Hasher newHasher() { if (supportsClone) { try { return new MessageDigestHasher((MessageDigest) prototype.clone(), bytes); } catch (CloneNotSupportedException e) { // falls through } } return new MessageDigestHasher(getMessageDigest(prototype.getAlgorithm()), bytes); }
@Override public Hasher newHasher() { if (supportsClone) { try { return new MessageDigestHasher((MessageDigest) prototype.clone(), bytes); } catch (CloneNotSupportedException e) { // falls through } } return new MessageDigestHasher(getMessageDigest(prototype.getAlgorithm()), bytes); }
@Override public Hasher newHasher() { if (supportsClone) { try { return new MessageDigestHasher((MessageDigest) prototype.clone(), bytes); } catch (CloneNotSupportedException e) { // falls through } } return new MessageDigestHasher(getMessageDigest(prototype.getAlgorithm()), bytes); }
if (actualDigestSizeBytes != expectedDigestSizeBytes) { throw new RuntimeException( "Unexpected output size of " + md.getAlgorithm() + " digest: " + actualDigestSizeBytes);
@Test public void testGetMessageDigest() throws IOException, NoSuchAlgorithmException { Assume.assumeTrue(DigestUtils.isAvailable(messageDigestAlgorithm)); final MessageDigest messageDigest = DigestUtils.getDigest(messageDigestAlgorithm); Assert.assertEquals(messageDigestAlgorithm, messageDigest.getAlgorithm()); }
public String getAlgorithmName() { return digest.getAlgorithm() + "/HMAC"; }
public static ChecksumValue digest(String algorithm, InputStream is) throws NoSuchAlgorithmException, IOException { MessageDigest digest = MessageDigest.getInstance(algorithm); ChecksumValue checksum = null; byte[] buffer = new byte[8192]; int read = 0; while ((read = is.read(buffer)) > 0) { digest.update(buffer, 0, read); } byte[] md5sum = digest.digest(); // TODO make sure this is valid for all types of checksums !?! BigInteger bigInt = new BigInteger(1, md5sum); checksum = new ChecksumValue(digest.getAlgorithm(), getPaddedDigestString(digest,bigInt)); return checksum; }
/** * @param nameSpaceUUID of the namespace, as defined by the * spec. UUID has 4 pre-defined "standard" name space strings * that can be passed to UUID constructor (see example below). * Note that this argument is optional; if no namespace is needed * (for example when name includes namespace prefix), null may be passed. * @param hasher Hashing algorithm to use. */ public NameBasedGenerator(UUID namespace, MessageDigest digester, UUIDType type) { _namespace = namespace; // And default digester SHA-1 if (digester == null) { } if (type == null) { String typeStr = digester.getAlgorithm(); if (typeStr.startsWith("MD5")) { type = UUIDType.NAME_BASED_MD5; } else if (typeStr.startsWith("SHA")) { type = UUIDType.NAME_BASED_SHA1; } else { // Hmmh... error out? Let's default to SHA-1, but log a warning type = UUIDType.NAME_BASED_SHA1; Logger.logWarning("Could not determine type of Digester from '"+typeStr+"'; assuming 'SHA-1' type"); } } _digester = digester; _type = type; }
@Override protected void engineInitVerify(PublicKey publicKey) throws InvalidKeyException { reset(); if (publicKey instanceof EdDSAPublicKey) { key = (EdDSAPublicKey) publicKey; if (digest == null) { // Instantiate the digest from the key parameters try { digest = MessageDigest.getInstance(key.getParams().getHashAlgorithm()); } catch (NoSuchAlgorithmException e) { throw new InvalidKeyException("cannot get required digest " + key.getParams().getHashAlgorithm() + " for private key."); } } else if (!key.getParams().getHashAlgorithm().equals(digest.getAlgorithm())) throw new InvalidKeyException("Key hash algorithm does not match chosen digest"); } else if (publicKey.getClass().getName().equals("sun.security.x509.X509Key")) { // X509Certificate will sometimes contain an X509Key rather than the EdDSAPublicKey itself; the contained // key is valid but needs to be instanced as an EdDSAPublicKey before it can be used. EdDSAPublicKey parsedPublicKey; try { parsedPublicKey = new EdDSAPublicKey(new X509EncodedKeySpec(publicKey.getEncoded())); } catch (InvalidKeySpecException ex) { throw new InvalidKeyException("cannot handle X.509 EdDSA public key: " + publicKey.getAlgorithm()); } engineInitVerify(parsedPublicKey); } else { throw new InvalidKeyException("cannot identify EdDSA public key: " + publicKey.getClass()); } }
@Override protected void engineInitSign(PrivateKey privateKey) throws InvalidKeyException { reset(); if (privateKey instanceof EdDSAPrivateKey) { EdDSAPrivateKey privKey = (EdDSAPrivateKey) privateKey; key = privKey; if (digest == null) { // Instantiate the digest from the key parameters try { digest = MessageDigest.getInstance(key.getParams().getHashAlgorithm()); } catch (NoSuchAlgorithmException e) { throw new InvalidKeyException("cannot get required digest " + key.getParams().getHashAlgorithm() + " for private key."); } } else if (!key.getParams().getHashAlgorithm().equals(digest.getAlgorithm())) throw new InvalidKeyException("Key hash algorithm does not match chosen digest"); digestInitSign(privKey); } else { throw new InvalidKeyException("cannot identify EdDSA private key: " + privateKey.getClass()); } }
@Test public void testSha256() throws Exception { MessageDigest digest = Sha256Hash.getMessageDigest(); Assert.assertEquals(digest.getAlgorithm(), "SHA-256"); Assert.assertNotSame(Sha256Hash.getMessageDigest(), digest); byte[] result = digest.digest("Hello World".getBytes(Charsets.UTF_8)); Assert.assertEquals( "A591A6D40BF420404A011733CFB7B190D62C65BF0BCDA32B57B277D9AD9F146E", BaseEncoding.base16().encode(result)); Assert.assertEquals(32, result.length); }