Java Code Examples for java.security.DigestOutputStream#write()

/**
 * Test #1 for <code>write(int)</code> method<br>
 *
 * Assertion: writes the byte to the output stream<br>
 * Assertion: updates associated digest<br>
 */
public final void testWriteint01()
    throws IOException {
    for (int k=0; k<algorithmName.length; k++) {
        try {
            MessageDigest md = MessageDigest.getInstance(algorithmName[k]);
            ByteArrayOutputStream bos = new ByteArrayOutputStream(MY_MESSAGE_LEN);
            DigestOutputStream dos = new DigestOutputStream(bos, md);
            for (int i=0; i<MY_MESSAGE_LEN; i++) {
                dos.write(myMessage[i]);
            }
            // check that bytes have been written correctly
            assertTrue("write", Arrays.equals(MDGoldenData.getMessage(), bos.toByteArray()));
            // check that associated digest has been updated properly
            assertTrue("update", Arrays.equals(dos.getMessageDigest().digest(),
                                               MDGoldenData.getDigest(algorithmName[k])));
            return;
        } catch (NoSuchAlgorithmException e) {
            // allowed failure
        }
    }
    fail(getName() + ": no MessageDigest algorithms available - test not performed");
}
 

/**
 * Test #1 for <code>write(byte[],int,int)</code> method<br>
 *
 * Assertion: put bytes into output stream<br>
 *
 * Assertion: updates associated digest<br>
 */
public final void test_write$BII_1() throws IOException {
    for (int k=0; k<algorithmName.length; k++) {
        try {
            ByteArrayOutputStream bos = new ByteArrayOutputStream(MY_MESSAGE_LEN);
            MessageDigest md = MessageDigest.getInstance(algorithmName[k]);
            DigestOutputStream dos = new DigestOutputStream(bos, md);

            // write message at once
            dos.write(myMessage, 0, MY_MESSAGE_LEN);

            // check write
            assertTrue("write", Arrays.equals(myMessage, bos.toByteArray()));
            // check that associated digest has been updated properly
            assertTrue("update", Arrays.equals(dos.getMessageDigest().digest(),
                                               MDGoldenData.getDigest(algorithmName[k])));
            return;
        } catch (NoSuchAlgorithmException e) {
            // allowed failure
        }
    }
    fail(getName() + ": no MessageDigest algorithms available - test not performed");
}
 

/**
 * java.io.DigestOutputStream#write(byte[], int, int)
 */
public void test_write$BII_7()
    throws IOException, NoSuchAlgorithmException {
    Support_OutputStream sos = new Support_OutputStream(MY_MESSAGE_LEN);
    MessageDigest md = MessageDigest.getInstance(algorithmName[0]);
    DigestOutputStream dos = new DigestOutputStream(sos, md);

    dos.write(myMessage, 0, MY_MESSAGE_LEN);

    try {
        // Support_OutputStream throws an IOException if the internal
        // buffer is full, which it should be now.
        dos.write(myMessage, 0, MY_MESSAGE_LEN);
        fail("Test 1: IOException expected.");
    } catch (IOException e) {
        // Expected.
    }
}
 

/**
 * java.security.DigestOutputStream#on(boolean)
 */
public void test_onZ() throws Exception {
    // Test for method void java.security.DigestOutputStream.on(boolean)
    DigestOutputStream dos = new DigestOutputStream(
            new ByteArrayOutputStream(), MessageDigest.getInstance("SHA"));
    dos.on(false);
    byte digestArray[] = { 23, 43, 44 };
    dos.write(digestArray, 1, 1);
    byte digestResult[] = dos.getMessageDigest().digest();
    byte expected[] = { -38, 57, -93, -18, 94, 107, 75, 13, 50, 85,
            -65, -17, -107, 96, 24, -112, -81, -40, 7, 9 };
    assertTrue("Digest did not return expected result.",
               Arrays.equals(digestResult, expected));
    // now turn on processing and re-run
    dos.on(true);
    dos.write(digestArray, 1, 1);
    digestResult = dos.getMessageDigest().digest();
    byte expected1[] = { -87, 121, -17, 16, -52, 111, 106, 54, -33,
            107, -118, 50, 51, 7, -18, 59, -78, -30, -37, -100 };

    assertTrue("Digest did not return expected result.",
               Arrays.equals(digestResult, expected1));
}
 

private byte[] hashContent(ModelNode content) throws IOException {
    byte[] sha1Bytes;
    OutputStream os = new OutputStream() {
        @Override
        public void write(int b) throws IOException {
            // just discard
        }
    };
    synchronized (messageDigest) {
        messageDigest.reset();

        DigestOutputStream dos = new DigestOutputStream(os, messageDigest);
        ByteArrayInputStream bis = new ByteArrayInputStream(content.toString().getBytes(StandardCharsets.UTF_8));
        byte[] bytes = new byte[8192];
        int read;
        while ((read = bis.read(bytes)) > -1) {
            dos.write(bytes, 0, read);
        }

        sha1Bytes = messageDigest.digest();
    }
    return sha1Bytes;
}
 

private static void assertEntityLinesMD5(Results results, Session session, String expectedMD5)
{
    try {
        DigestOutputStream out = md5OutputStream(ByteStreams.nullOutputStream());
        for (List<List<String>> parentAndChildRows : results) {
            out.write(formatRow(parentAndChildRows.get(0), session).getBytes(ISO_8859_1));
        }
        byte[] md5Digest = out.getMessageDigest().digest();
        assertEquals(base16().lowerCase().encode(md5Digest), expectedMD5);
    }
    catch (IOException e) {
        throw Throwables.propagate(e);
    }
}
 

/**
 * Test #2 for <code>write(int)</code> method<br>
 * Test #1 for <code>on(boolean)</code> method<br>
 *
 * Assertion: <code>write(int)</code> must not update digest if it is off<br>
 * Assertion: <code>on(boolean)</code> turns digest functionality on
 * if <code>true</code> passed as a parameter or off if <code>false</code>
 * passed
 */
public final void testWriteint02()
    throws IOException {
    for (int k=0; k<algorithmName.length; k++) {
        try {
            MessageDigest md = MessageDigest.getInstance(algorithmName[k]);
            ByteArrayOutputStream bos = new ByteArrayOutputStream(MY_MESSAGE_LEN);
            DigestOutputStream dos = new DigestOutputStream(bos, md);

            // turn digest off
            dos.on(false);

            for (int i=0; i<MY_MESSAGE_LEN; i++) {
                dos.write(myMessage[i]);
            }

            // check that bytes have been written correctly
            assertTrue("write", Arrays.equals(MDGoldenData.getMessage(), bos.toByteArray()));
            // check that digest value has not been updated by write()
            assertTrue("update", Arrays.equals(dos.getMessageDigest().digest(),
                                               MDGoldenData.getDigest(algorithmName[k]+"_NU")));
            return;
        } catch (NoSuchAlgorithmException e) {
            // allowed failure
        }
    }
    fail(getName() + ": no MessageDigest algorithms available - test not performed");
}
 

/**
 * Test #4 for <code>write(int)</code> method<br>
 *
 * Assertion: broken <code>DigestOutputStream</code>instance:
 * associated <code>MessageDigest</code> not set.
 * <code>write(int)</code> must not work when digest
 * functionality is on
 */
public final void testWriteint04() throws IOException {
    OutputStream os = new ByteArrayOutputStream(MY_MESSAGE_LEN);
    DigestOutputStream dos = new DigestOutputStream(os, null);

    // must result in an exception
    try {
        for (int i=0; i<MY_MESSAGE_LEN; i++) {
            dos.write(myMessage[i]);
        }
        fail("OutputStream not set. write(int) must not work");
    } catch (Exception e) {
        return;
    }
}
 

/**
 * Test #5 for <code>write(int)</code> method<br>
 * Test #2 for <code>on(boolean)</code> method<br>
 *
 * Assertion: broken <code>DigestOutputStream</code>instance:
 * associated <code>MessageDigest</code> not set.
 * <code>write(int)</code> must work when digest
 * functionality is off
 */
public final void testWriteint05() throws IOException {
    ByteArrayOutputStream bos = new ByteArrayOutputStream(MY_MESSAGE_LEN);
    DigestOutputStream dos = new DigestOutputStream(bos, null);
    // set digest functionality to off
    dos.on(false);
    // the following must pass without any exception
    for (int i=0; i<MY_MESSAGE_LEN; i++) {
        dos.write(myMessage[i]);
    }
    // check that bytes have been written correctly
    assertTrue(Arrays.equals(MDGoldenData.getMessage(), bos.toByteArray()));
}
 

/**
 * Test #2 for <code>write(byte[],int,int)</code> method<br>
 *
 * Assertion: put bytes into output stream<br>
 *
 * Assertion: updates associated digest<br>
 */
public final void test_write$BII_2() throws IOException {
    // check precondition
    assertEquals(0, MY_MESSAGE_LEN % CHUNK_SIZE);
    for (int k=0; k<algorithmName.length; k++) {
        try {

            ByteArrayOutputStream bos = new ByteArrayOutputStream(MY_MESSAGE_LEN);
            MessageDigest md = MessageDigest.getInstance(algorithmName[k]);
            DigestOutputStream dos = new DigestOutputStream(bos, md);

            // write message by chunks
            for (int i=0; i<MY_MESSAGE_LEN/CHUNK_SIZE; i++) {
                dos.write(myMessage, i*CHUNK_SIZE, CHUNK_SIZE);
            }
            // check write
            assertTrue("write", Arrays.equals(myMessage, bos.toByteArray()));
            // check that associated digest has been updated properly
            assertTrue("update", Arrays.equals(dos.getMessageDigest().digest(),
                    MDGoldenData.getDigest(algorithmName[k])));
            return;
        } catch (NoSuchAlgorithmException e) {
            // allowed failure
        }
    }
    fail(getName() + ": no MessageDigest algorithms available - test not performed");
}
 

/**
 * Test #3 for <code>write(byte[],int,int)</code> method<br>
 *
 * Assertion: put bytes into output stream<br>
 *
 * Assertion: updates associated digest<br>
 */
public final void test_write$BII_3()
    throws NoSuchAlgorithmException,
           IOException {
    // check precondition
    assertTrue(MY_MESSAGE_LEN % (CHUNK_SIZE+1) != 0);

    for (int k=0; k<algorithmName.length; k++) {
        try {
            ByteArrayOutputStream bos = new ByteArrayOutputStream(MY_MESSAGE_LEN);
            MessageDigest md = MessageDigest.getInstance(algorithmName[k]);
            DigestOutputStream dos = new DigestOutputStream(bos, md);

            // write message by chunks
            for (int i=0; i<MY_MESSAGE_LEN/(CHUNK_SIZE+1); i++) {
                dos.write(myMessage, i*(CHUNK_SIZE+1), CHUNK_SIZE+1);
            }
            // write remaining bytes
            dos.write(myMessage,
                    MY_MESSAGE_LEN/(CHUNK_SIZE+1)*(CHUNK_SIZE+1),
                    MY_MESSAGE_LEN % (CHUNK_SIZE+1));
            // check write
            assertTrue("write", Arrays.equals(myMessage, bos.toByteArray()));
            // check that associated digest has been updated properly
            assertTrue("update", Arrays.equals(dos.getMessageDigest().digest(),
                    MDGoldenData.getDigest(algorithmName[k])));
            return;
        } catch (NoSuchAlgorithmException e) {
            // allowed failure
        }
    }
    fail(getName() + ": no MessageDigest algorithms available - test not performed");
}
 

/**
 * Test #4 for <code>write(byte[],int,int)</code> method<br>
 *
 * Assertion: put bytes into output stream<br>
 *
 * Assertion: does not update associated digest if digest
 * functionality is off<br>
 */
public final void test_write$BII_4()
    throws NoSuchAlgorithmException,
           IOException {
    // check precondition
    assertEquals(0, MY_MESSAGE_LEN % CHUNK_SIZE);

    for (int k=0; k<algorithmName.length; k++) {
        try {
            ByteArrayOutputStream bos = new ByteArrayOutputStream(MY_MESSAGE_LEN);
            MessageDigest md = MessageDigest.getInstance(algorithmName[k]);
            DigestOutputStream dos = new DigestOutputStream(bos, md);

            // set digest functionality off
            dos.on(false);

            // write message by chunks
            for (int i=0; i<MY_MESSAGE_LEN/CHUNK_SIZE; i++) {
                dos.write(myMessage, i*CHUNK_SIZE, CHUNK_SIZE);
            }

            // check write
            assertTrue("write", Arrays.equals(myMessage, bos.toByteArray()));
            // check that associated digest has not been updated
            assertTrue("update", Arrays.equals(dos.getMessageDigest().digest(),
                    MDGoldenData.getDigest(algorithmName[k]+"_NU")));
            return;
        } catch (NoSuchAlgorithmException e) {
            // allowed failure
        }
    }
    fail(getName() + ": no MessageDigest algorithms available - test not performed");
}
 

/**
 * Test for <code>on()</code> method<br>
 * Assertion: turns digest functionality on or off
 */
public final void testOn() throws IOException {
    for (int k=0; k<algorithmName.length; k++) {
        try {
            ByteArrayOutputStream bos = new ByteArrayOutputStream(MY_MESSAGE_LEN);
            MessageDigest md = MessageDigest.getInstance(algorithmName[k]);
            DigestOutputStream dos = new DigestOutputStream(bos, md);

            // turn digest off
            dos.on(false);

            for (int i=0; i<MY_MESSAGE_LEN-1; i++) {
                dos.write(myMessage[i]);
            }

            // turn digest on
            dos.on(true);

            // read remaining byte
            dos.write(myMessage[MY_MESSAGE_LEN-1]);

            byte[] digest = dos.getMessageDigest().digest();

            // check that digest value has been
            // updated by the last write(int) call
            assertFalse(Arrays.equals(digest,MDGoldenData.getDigest(algorithmName[k])));
            assertFalse(Arrays.equals(digest,MDGoldenData.getDigest(algorithmName[k]+"_NU")));
            return;
        } catch (NoSuchAlgorithmException e) {
            // allowed failure
        }
    }
    fail(getName() + ": no MessageDigest algorithms available - test not performed");
}
 

/**
 * java.security.DigestOutputStream#write(byte[], int, int)
 */
public void test_write$BII_5() throws Exception {
    // Test for method void java.security.DigestOutputStream.write(byte [],
    // int, int)
        DigestOutputStream dos = new DigestOutputStream(
            new ByteArrayOutputStream(), MessageDigest.getInstance("SHA"));
        byte digestArray[] = { 23, 43, 44 };
        dos.write(digestArray, 1, 1);
        byte digestResult[] = dos.getMessageDigest().digest();
        byte expected[] = { -87, 121, -17, 16, -52, 111, 106, 54, -33, 107,
                -118, 50, 51, 7, -18, 59, -78, -30, -37, -100 };

        assertTrue("Digest did not return expected result.",
                   Arrays.equals(digestResult, expected));
}
 

/**
 * java.security.DigestOutputStream#write(int)
 */
public void test_writeI() throws Exception {
    // Test for method void java.security.DigestOutputStream.write(int)
        DigestOutputStream dos = new DigestOutputStream(
            new ByteArrayOutputStream(), MessageDigest.getInstance("SHA"));
        dos.write((byte) 43);
        byte digestResult[] = dos.getMessageDigest().digest();
        byte expected[] = { -87, 121, -17, 16, -52, 111, 106, 54, -33, 107,
                -118, 50, 51, 7, -18, 59, -78, -30, -37, -100 };

        assertTrue("Digest did not return expected result.",
                   Arrays.equals(digestResult, expected));
}
 

@Override
public byte[] addContent(InputStream stream) throws IOException {
    byte[] sha1Bytes;
    Path tmp = File.createTempFile(CONTENT, ".tmp", repoRoot).toPath();
    if (stream != null) {
        try (OutputStream fos = Files.newOutputStream(tmp)) {
            synchronized (messageDigest) {
                messageDigest.reset();
                DigestOutputStream dos = new DigestOutputStream(fos, messageDigest);
                BufferedInputStream bis = new BufferedInputStream(stream);
                byte[] bytes = new byte[8192];
                int read;
                while ((read = bis.read(bytes)) > -1) {
                    dos.write(bytes, 0, read);
                }
                fos.flush();
            }
            sha1Bytes = messageDigest.digest();
        }
    } else {//create a directory instead
        Files.delete(tmp);
        Files.createDirectory(tmp);
        synchronized (messageDigest) {
            messageDigest.reset();
            sha1Bytes = HashUtil.hashPath(messageDigest, tmp);
        }
    }
    final Path realFile = getDeploymentContentFile(sha1Bytes, true);
    if (hasContent(sha1Bytes)) {
        // we've already got this content
        try {
            deleteRecursively(tmp);
        } catch (IOException ioex) {
            DeploymentRepositoryLogger.ROOT_LOGGER.cannotDeleteTempFile(ioex, tmp.toAbsolutePath().toString());
            tmp.toFile().deleteOnExit();
        }
        DeploymentRepositoryLogger.ROOT_LOGGER.debugf("Content was already present in repository at location %s", realFile.toAbsolutePath().toString());
    } else {
        moveTempToPermanent(tmp, realFile);
        DeploymentRepositoryLogger.ROOT_LOGGER.contentAdded(realFile.toAbsolutePath().toString());
    }
    return sha1Bytes;
}