Examples with DigestException java.security.DigestException used on opensource projects

Example 26 with DigestException

use of java.security.DigestException in project robovm by robovm.

the class DigestExceptionTest method testDigestException09.

/**
     * Test for <code>DigestException(String, Throwable)</code> constructor
     * Assertion: constructs DigestException when <code>cause</code> is not
     * null <code>msg</code> is not null
     */
public void testDigestException09() {
    DigestException tE;
    for (int i = 0; i < msgs.length; i++) {
        tE = new DigestException(msgs[i], tCause);
        String getM = tE.getMessage();
        String toS = tCause.toString();
        if (msgs[i].length() > 0) {
            assertTrue("getMessage() must contain ".concat(msgs[i]), getM.indexOf(msgs[i]) != -1);
            if (!getM.equals(msgs[i])) {
                assertTrue("getMessage() should contain ".concat(toS), getM.indexOf(toS) != -1);
            }
        }
        assertNotNull("getCause() must not return null", tE.getCause());
        assertEquals("getCause() must return ".concat(tCause.toString()), tE.getCause(), tCause);
    }
}

Example 27 with DigestException

use of java.security.DigestException in project robovm by robovm.

the class MessageDigest1Test method testSHAProvider.

/**
     * Tests SHA MessageDigest provider
     */
public void testSHAProvider() {
    MessageDigest md = null;
    try {
        md = MessageDigest.getInstance("SHA");
    } catch (NoSuchAlgorithmException e) {
        fail("unexpected exception: " + e);
    }
    byte[] bytes = new byte[] { 1, 1, 1, 1, 1 };
    // testing combination with provider
    try {
        // offset < 0
        md.update(bytes, -1, 1);
        fail("No expected IndexOutOfBoundsException");
    } catch (IndexOutOfBoundsException e) {
    }
    try {
        md.update(bytes, 1, -1);
        fail("No expected IndexOutOfBoundsException");
    } catch (IndexOutOfBoundsException e) {
    }
    //Regression for Harmony-1148
    try {
        md = MessageDigest.getInstance("SHA");
    } catch (NoSuchAlgorithmException e) {
        fail("unexpected exception: " + e);
    }
    try {
        // offset < 0
        md.digest(bytes, 0, -1);
        fail("No expected DigestException");
    } catch (DigestException e) {
    }
    try {
        // len < 0
        md.digest(bytes, -1, 0);
        fail("No expected DigestException");
    } catch (DigestException e) {
    }
    try {
        md = MessageDigest.getInstance("UnknownDigest");
        fail("expected NoSuchAlgorithmException");
    } catch (NoSuchAlgorithmException e) {
    // ok
    }
}

Example 28 with DigestException

use of java.security.DigestException in project android_frameworks_base by AOSPA.

the class ApkSignatureSchemeV2Verifier method computeContentDigests.

private static byte[][] computeContentDigests(int[] digestAlgorithms, DataSource[] contents) throws DigestException {
    // For each digest algorithm the result is computed as follows:
    // 1. Each segment of contents is split into consecutive chunks of 1 MB in size.
    //    The final chunk will be shorter iff the length of segment is not a multiple of 1 MB.
    //    No chunks are produced for empty (zero length) segments.
    // 2. The digest of each chunk is computed over the concatenation of byte 0xa5, the chunk's
    //    length in bytes (uint32 little-endian) and the chunk's contents.
    // 3. The output digest is computed over the concatenation of the byte 0x5a, the number of
    //    chunks (uint32 little-endian) and the concatenation of digests of chunks of all
    //    segments in-order.
    long totalChunkCountLong = 0;
    for (DataSource input : contents) {
        totalChunkCountLong += getChunkCount(input.size());
    }
    if (totalChunkCountLong >= Integer.MAX_VALUE / 1024) {
        throw new DigestException("Too many chunks: " + totalChunkCountLong);
    }
    int totalChunkCount = (int) totalChunkCountLong;
    byte[][] digestsOfChunks = new byte[digestAlgorithms.length][];
    for (int i = 0; i < digestAlgorithms.length; i++) {
        int digestAlgorithm = digestAlgorithms[i];
        int digestOutputSizeBytes = getContentDigestAlgorithmOutputSizeBytes(digestAlgorithm);
        byte[] concatenationOfChunkCountAndChunkDigests = new byte[5 + totalChunkCount * digestOutputSizeBytes];
        concatenationOfChunkCountAndChunkDigests[0] = 0x5a;
        setUnsignedInt32LittleEndian(totalChunkCount, concatenationOfChunkCountAndChunkDigests, 1);
        digestsOfChunks[i] = concatenationOfChunkCountAndChunkDigests;
    }
    byte[] chunkContentPrefix = new byte[5];
    chunkContentPrefix[0] = (byte) 0xa5;
    int chunkIndex = 0;
    MessageDigest[] mds = new MessageDigest[digestAlgorithms.length];
    for (int i = 0; i < digestAlgorithms.length; i++) {
        String jcaAlgorithmName = getContentDigestAlgorithmJcaDigestAlgorithm(digestAlgorithms[i]);
        try {
            mds[i] = MessageDigest.getInstance(jcaAlgorithmName);
        } catch (NoSuchAlgorithmException e) {
            throw new RuntimeException(jcaAlgorithmName + " digest not supported", e);
        }
    }
    // TODO: Compute digests of chunks in parallel when beneficial. This requires some research
    // into how to parallelize (if at all) based on the capabilities of the hardware on which
    // this code is running and based on the size of input.
    int dataSourceIndex = 0;
    for (DataSource input : contents) {
        long inputOffset = 0;
        long inputRemaining = input.size();
        while (inputRemaining > 0) {
            int chunkSize = (int) Math.min(inputRemaining, CHUNK_SIZE_BYTES);
            setUnsignedInt32LittleEndian(chunkSize, chunkContentPrefix, 1);
            for (int i = 0; i < mds.length; i++) {
                mds[i].update(chunkContentPrefix);
            }
            try {
                input.feedIntoMessageDigests(mds, inputOffset, chunkSize);
            } catch (IOException e) {
                throw new DigestException("Failed to digest chunk #" + chunkIndex + " of section #" + dataSourceIndex, e);
            }
            for (int i = 0; i < digestAlgorithms.length; i++) {
                int digestAlgorithm = digestAlgorithms[i];
                byte[] concatenationOfChunkCountAndChunkDigests = digestsOfChunks[i];
                int expectedDigestSizeBytes = getContentDigestAlgorithmOutputSizeBytes(digestAlgorithm);
                MessageDigest md = mds[i];
                int actualDigestSizeBytes = md.digest(concatenationOfChunkCountAndChunkDigests, 5 + chunkIndex * expectedDigestSizeBytes, expectedDigestSizeBytes);
                if (actualDigestSizeBytes != expectedDigestSizeBytes) {
                    throw new RuntimeException("Unexpected output size of " + md.getAlgorithm() + " digest: " + actualDigestSizeBytes);
                }
            }
            inputOffset += chunkSize;
            inputRemaining -= chunkSize;
            chunkIndex++;
        }
        dataSourceIndex++;
    }
    byte[][] result = new byte[digestAlgorithms.length][];
    for (int i = 0; i < digestAlgorithms.length; i++) {
        int digestAlgorithm = digestAlgorithms[i];
        byte[] input = digestsOfChunks[i];
        String jcaAlgorithmName = getContentDigestAlgorithmJcaDigestAlgorithm(digestAlgorithm);
        MessageDigest md;
        try {
            md = MessageDigest.getInstance(jcaAlgorithmName);
        } catch (NoSuchAlgorithmException e) {
            throw new RuntimeException(jcaAlgorithmName + " digest not supported", e);
        }
        byte[] output = md.digest(input);
        result[i] = output;
    }
    return result;
}

Example 29 with DigestException

use of java.security.DigestException in project android_frameworks_base by ResurrectionRemix.

the class ApkSignatureSchemeV2Verifier method computeContentDigests.

private static byte[][] computeContentDigests(int[] digestAlgorithms, DataSource[] contents) throws DigestException {
    // For each digest algorithm the result is computed as follows:
    // 1. Each segment of contents is split into consecutive chunks of 1 MB in size.
    //    The final chunk will be shorter iff the length of segment is not a multiple of 1 MB.
    //    No chunks are produced for empty (zero length) segments.
    // 2. The digest of each chunk is computed over the concatenation of byte 0xa5, the chunk's
    //    length in bytes (uint32 little-endian) and the chunk's contents.
    // 3. The output digest is computed over the concatenation of the byte 0x5a, the number of
    //    chunks (uint32 little-endian) and the concatenation of digests of chunks of all
    //    segments in-order.
    long totalChunkCountLong = 0;
    for (DataSource input : contents) {
        totalChunkCountLong += getChunkCount(input.size());
    }
    if (totalChunkCountLong >= Integer.MAX_VALUE / 1024) {
        throw new DigestException("Too many chunks: " + totalChunkCountLong);
    }
    int totalChunkCount = (int) totalChunkCountLong;
    byte[][] digestsOfChunks = new byte[digestAlgorithms.length][];
    for (int i = 0; i < digestAlgorithms.length; i++) {
        int digestAlgorithm = digestAlgorithms[i];
        int digestOutputSizeBytes = getContentDigestAlgorithmOutputSizeBytes(digestAlgorithm);
        byte[] concatenationOfChunkCountAndChunkDigests = new byte[5 + totalChunkCount * digestOutputSizeBytes];
        concatenationOfChunkCountAndChunkDigests[0] = 0x5a;
        setUnsignedInt32LittleEndian(totalChunkCount, concatenationOfChunkCountAndChunkDigests, 1);
        digestsOfChunks[i] = concatenationOfChunkCountAndChunkDigests;
    }
    byte[] chunkContentPrefix = new byte[5];
    chunkContentPrefix[0] = (byte) 0xa5;
    int chunkIndex = 0;
    MessageDigest[] mds = new MessageDigest[digestAlgorithms.length];
    for (int i = 0; i < digestAlgorithms.length; i++) {
        String jcaAlgorithmName = getContentDigestAlgorithmJcaDigestAlgorithm(digestAlgorithms[i]);
        try {
            mds[i] = MessageDigest.getInstance(jcaAlgorithmName);
        } catch (NoSuchAlgorithmException e) {
            throw new RuntimeException(jcaAlgorithmName + " digest not supported", e);
        }
    }
    // TODO: Compute digests of chunks in parallel when beneficial. This requires some research
    // into how to parallelize (if at all) based on the capabilities of the hardware on which
    // this code is running and based on the size of input.
    int dataSourceIndex = 0;
    for (DataSource input : contents) {
        long inputOffset = 0;
        long inputRemaining = input.size();
        while (inputRemaining > 0) {
            int chunkSize = (int) Math.min(inputRemaining, CHUNK_SIZE_BYTES);
            setUnsignedInt32LittleEndian(chunkSize, chunkContentPrefix, 1);
            for (int i = 0; i < mds.length; i++) {
                mds[i].update(chunkContentPrefix);
            }
            try {
                input.feedIntoMessageDigests(mds, inputOffset, chunkSize);
            } catch (IOException e) {
                throw new DigestException("Failed to digest chunk #" + chunkIndex + " of section #" + dataSourceIndex, e);
            }
            for (int i = 0; i < digestAlgorithms.length; i++) {
                int digestAlgorithm = digestAlgorithms[i];
                byte[] concatenationOfChunkCountAndChunkDigests = digestsOfChunks[i];
                int expectedDigestSizeBytes = getContentDigestAlgorithmOutputSizeBytes(digestAlgorithm);
                MessageDigest md = mds[i];
                int actualDigestSizeBytes = md.digest(concatenationOfChunkCountAndChunkDigests, 5 + chunkIndex * expectedDigestSizeBytes, expectedDigestSizeBytes);
                if (actualDigestSizeBytes != expectedDigestSizeBytes) {
                    throw new RuntimeException("Unexpected output size of " + md.getAlgorithm() + " digest: " + actualDigestSizeBytes);
                }
            }
            inputOffset += chunkSize;
            inputRemaining -= chunkSize;
            chunkIndex++;
        }
        dataSourceIndex++;
    }
    byte[][] result = new byte[digestAlgorithms.length][];
    for (int i = 0; i < digestAlgorithms.length; i++) {
        int digestAlgorithm = digestAlgorithms[i];
        byte[] input = digestsOfChunks[i];
        String jcaAlgorithmName = getContentDigestAlgorithmJcaDigestAlgorithm(digestAlgorithm);
        MessageDigest md;
        try {
            md = MessageDigest.getInstance(jcaAlgorithmName);
        } catch (NoSuchAlgorithmException e) {
            throw new RuntimeException(jcaAlgorithmName + " digest not supported", e);
        }
        byte[] output = md.digest(input);
        result[i] = output;
    }
    return result;
}

Example 30 with DigestException

use of java.security.DigestException in project jena by apache.

the class NodeLib method hash.

private static void hash(Hash h, String lex, String lang, String datatype, NodeType nodeType) {
    if (datatype == null)
        datatype = "";
    if (lang == null)
        lang = "";
    String toHash = lex + "|" + lang + "|" + datatype + "|" + nodeType.getName();
    MessageDigest digest;
    try {
        //MessageDigest.getInstance("MD5");
        digest = allocDigest();
        //digest.update(toHash.getBytes("UTF8"));
        digest.update(Bytes.string2bytes(toHash));
        if (h.getLen() == 16)
            // MD5 is 16 bytes.
            digest.digest(h.getBytes(), 0, 16);
        else {
            // 16 bytes.
            byte[] b = digest.digest();
            // Avoid the copy? If length is 16.  digest.digest(bytes, 0, length) needs 16 bytes
            System.arraycopy(b, 0, h.getBytes(), 0, h.getLen());
        }
        deallocDigest(digest);
        return;
    } catch (DigestException ex) {
        Log.error(NodeLib.class, "DigestException", ex);
    }
}