Example usage for java.security DigestOutputStream getMessageDigest

List of usage examples for java.security DigestOutputStream getMessageDigest

  1. HOME
  2. Java
  3. java
  4. java.security.*
  5. DigestOutputStream
  6. getMessageDigest

Introduction

In this page you can find the example usage for java.security DigestOutputStream getMessageDigest.

Prototype

public MessageDigest getMessageDigest()

Source Link

Document

Returns the message digest associated with this stream.

Usage

From source file:MainClass.java

public static void main(String[] args) throws Exception {
    Security.addProvider(new BouncyCastleProvider());
    byte[] input = "www.java2s.com".getBytes();
    System.out.println("input     : " + new String(input));
    MessageDigest hash = MessageDigest.getInstance("SHA1");

    ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(input);
    DigestInputStream digestInputStream = new DigestInputStream(byteArrayInputStream, hash);
    ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();

    int ch;/*from www.jav a  2  s.co m*/
    while ((ch = digestInputStream.read()) >= 0) {
        byteArrayOutputStream.write(ch);
    }

    byte[] newInput = byteArrayOutputStream.toByteArray();
    System.out.println("in digest : " + new String(digestInputStream.getMessageDigest().digest()));

    byteArrayOutputStream = new ByteArrayOutputStream();
    DigestOutputStream digestOutputStream = new DigestOutputStream(byteArrayOutputStream, hash);
    digestOutputStream.write(newInput);
    digestOutputStream.close();

    System.out.println("out digest: " + new String(digestOutputStream.getMessageDigest().digest()));
}

From source file:MainClass.java

static void performOutputTest() throws Exception {
    MessageDigest md = MessageDigest.getInstance("SHA");
    FileOutputStream fout = new FileOutputStream("sha-results.txt");
    DigestOutputStream out = new DigestOutputStream(fout, md);
    byte[] b = "testCase".getBytes();
    out.write(b, 0, b.length);//  w  ww .ja  va 2  s. co  m
    md = out.getMessageDigest();
    String s = new String(md.digest());
    System.out.println("Calculated result: " + s);
}

From source file:com.threadswarm.imagefeedarchiver.processor.RssItemProcessor.java

private void downloadRssMediaContent(ProcessedRssItem processedItem, RssMediaContent mediaContent) {
    DownloadStatus downloadStatus = DownloadStatus.FAILED;
    HttpEntity responseEntity = null;//from  w w  w .j a  va  2s  .  c  om
    try {
        String targetUrlString = mediaContent.getUrlString();
        if (forceHttps)
            targetUrlString = FeedUtils.rewriteUrlStringToHttps(targetUrlString);

        URI targetURI = FeedUtils.getUriFromUrlString(targetUrlString);

        boolean freshURI = processedURISet.add(targetURI);
        if (!freshURI) {
            LOGGER.warn("Skipping previously processed URI: {}", targetURI);
            return; //abort processing
        }

        LOGGER.info("Attempting to download {}", targetURI);
        HttpGet imageGet = new HttpGet(targetURI);

        for (Header header : headerList)
            imageGet.addHeader(header);

        HttpResponse imageResponse = httpClient.execute(imageGet);

        String originalFileName = StringUtils.stripStart(targetURI.toURL().getFile(), "/");
        originalFileName = StringUtils.replace(originalFileName, "/", "_");
        File outputFile = getOutputFile(originalFileName);

        long expectedContentLength = FeedUtils.calculateBestExpectedContentLength(imageResponse, mediaContent);
        responseEntity = imageResponse.getEntity();

        BufferedInputStream bis = null;
        DigestOutputStream fos = null;
        int bytesRead = 0;
        try {
            bis = new BufferedInputStream(responseEntity.getContent());
            fos = new DigestOutputStream(new FileOutputStream(outputFile), MessageDigest.getInstance("SHA"));

            byte[] buffer = new byte[8192];
            while ((bytesRead = bis.read(buffer, 0, buffer.length)) != -1) {
                fos.write(buffer, 0, bytesRead);
            }
            fos.flush();

            MessageDigest messageDigest = fos.getMessageDigest();
            byte[] digestBytes = messageDigest.digest();
            String digestString = Hex.encodeHexString(digestBytes);
            LOGGER.info("Downloaded - {} (SHA: {})", targetURI, digestString);

            processedItem.setDownloadDate(new Date());
            downloadStatus = DownloadStatus.COMPLETED;
            processedItem.setHash(digestString);
            processedItem.setFilename(outputFile.toString());
        } catch (ConnectionClosedException e) {
            LOGGER.error("An Exception was thrown while attempting to read HTTP entity content", e);
        } catch (NoSuchAlgorithmException e) {
            LOGGER.error("The SHA-1 hashing algorithm is not available on this JVM", e);
        } finally {
            IOUtils.closeQuietly(bis);
            IOUtils.closeQuietly(fos);
            EntityUtils.consumeQuietly(responseEntity);
            if (downloadStatus == DownloadStatus.FAILED
                    || (outputFile.exists() && outputFile.length() != expectedContentLength)) {
                LOGGER.warn("Deleted partial/failed file: {}", outputFile);
                outputFile.delete();
                processedItem.setDownloadStatus(DownloadStatus.FAILED);
            }
        }
    } catch (IOException e) {
        LOGGER.error("An Exception was thrown while attempting to download image content", e);
    } catch (URISyntaxException e) {
        LOGGER.error("The supplied URI, {}, violates syntax rules", e);
    } finally {
        EntityUtils.consumeQuietly(responseEntity);
    }

    processedItem.setDownloadStatus(downloadStatus);
    itemDAO.save(processedItem);
}

From source file:com.jpeterson.littles3.StorageEngine.java

/**
 * Write/*from w w  w  .j  a va 2 s. co  m*/
 * 
 * @param req
 *            the HttpServletRequest object that contains the request the
 *            client made of the servlet
 * @param resp
 *            the HttpServletResponse object that contains the response the
 *            servlet returns to the client
 * @throws IOException
 *             if an input or output error occurs while the servlet is
 *             handling the PUT request
 * @throws ServletException
 *             if the request for the PUT cannot be handled
 */
@SuppressWarnings("unchecked")
public void methodPut(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    OutputStream out = null;

    try {
        S3ObjectRequest or;

        try {
            or = S3ObjectRequest.create(req, resolvedHost(),
                    (Authenticator) getWebApplicationContext().getBean(BEAN_AUTHENTICATOR));
        } catch (InvalidAccessKeyIdException e) {
            e.printStackTrace();
            resp.sendError(HttpServletResponse.SC_FORBIDDEN, "InvalidAccessKeyId");
            return;
        } catch (InvalidSecurityException e) {
            e.printStackTrace();
            resp.sendError(HttpServletResponse.SC_FORBIDDEN, "InvalidSecurity");
            return;
        } catch (RequestTimeTooSkewedException e) {
            e.printStackTrace();
            resp.sendError(HttpServletResponse.SC_FORBIDDEN, "RequestTimeTooSkewed");
            return;
        } catch (SignatureDoesNotMatchException e) {
            e.printStackTrace();
            resp.sendError(HttpServletResponse.SC_FORBIDDEN, "SignatureDoesNotMatch");
            return;
        } catch (AuthenticatorException e) {
            e.printStackTrace();
            resp.sendError(HttpServletResponse.SC_FORBIDDEN, "InvalidSecurity");
            return;
        }
        logger.debug("S3ObjectRequest: " + or);

        CanonicalUser requestor = or.getRequestor();

        if (or.getKey() != null) {
            String value;
            long contentLength;
            MessageDigest messageDigest = MessageDigest.getInstance("MD5");
            DigestOutputStream digestOutputStream = null;
            S3Object oldS3Object = null;
            S3Object s3Object;
            StorageService storageService;
            Bucket bucket;
            String bucketName = or.getBucket();
            String key = or.getKey();

            if (!isValidKey(key)) {
                resp.sendError(HttpServletResponse.SC_BAD_REQUEST, "KeyTooLong");
                return;
            }

            storageService = (StorageService) getWebApplicationContext().getBean(BEAN_STORAGE_SERVICE);

            if (req.getParameter(PARAMETER_ACL) != null) {
                // write access control policy
                Acp acp;
                CanonicalUser owner;
                s3Object = storageService.load(bucketName, key);

                if (s3Object == null) {
                    resp.sendError(HttpServletResponse.SC_NOT_FOUND, "NoSuchKey");
                    return;
                }

                acp = s3Object.getAcp();
                try {
                    acp.canWrite(requestor);
                } catch (AccessControlException e) {
                    resp.sendError(HttpServletResponse.SC_FORBIDDEN, "AccessDenied");
                    return;
                }

                // save owner
                owner = acp.getOwner();

                try {
                    acp = Acp.decode(req.getInputStream());
                } catch (IOException e) {
                    e.printStackTrace();
                    resp.sendError(HttpServletResponse.SC_BAD_REQUEST, "MalformedACLError");
                    return;
                }

                // maintain owner
                acp.setOwner(owner);

                s3Object.setAcp(acp);

                storageService.store(s3Object);
            } else {
                // make sure requestor can "WRITE" to the bucket
                try {
                    bucket = storageService.loadBucket(bucketName);
                    bucket.canWrite(requestor);
                } catch (AccessControlException e) {
                    resp.sendError(HttpServletResponse.SC_FORBIDDEN, "AccessDenied");
                    return;
                } catch (DataAccessException e) {
                    resp.sendError(HttpServletResponse.SC_NOT_FOUND, "NoSuchBucket");
                    return;
                }

                try {
                    oldS3Object = storageService.load(bucket.getName(), key);
                } catch (DataRetrievalFailureException e) {
                    // ignore
                }

                // create a new S3Object for this request to store an object
                try {
                    s3Object = storageService.createS3Object(bucket, key, requestor);
                } catch (DataAccessException e) {
                    resp.sendError(HttpServletResponse.SC_NOT_FOUND, "NoSuchBucket");
                    return;
                }

                out = s3Object.getOutputStream();
                digestOutputStream = new DigestOutputStream(out, messageDigest);

                // Used instead of req.getContentLength(); because Amazon
                // limit is 5 gig, which is bigger than an int
                value = req.getHeader("Content-Length");
                if (value == null) {
                    resp.sendError(HttpServletResponse.SC_LENGTH_REQUIRED, "MissingContentLength");
                    return;
                }
                contentLength = Long.valueOf(value).longValue();

                if (contentLength > 5368709120L) {
                    resp.sendError(HttpServletResponse.SC_BAD_REQUEST, "EntityTooLarge");
                    return;
                }

                long written = 0;
                int count;
                byte[] b = new byte[4096];
                ServletInputStream in = req.getInputStream();

                while (((count = in.read(b, 0, b.length)) > 0) && (written < contentLength)) {
                    digestOutputStream.write(b, 0, count);
                    written += count;
                }
                digestOutputStream.flush();

                if (written != contentLength) {
                    // transmission truncated
                    if (out != null) {
                        out.close();
                        out = null;
                    }
                    if (digestOutputStream != null) {
                        digestOutputStream.close();
                        digestOutputStream = null;
                    }
                    // clean up
                    storageService.remove(s3Object);
                    resp.sendError(HttpServletResponse.SC_BAD_REQUEST, "IncompleteBody");
                    return;
                }

                s3Object.setContentDisposition(req.getHeader("Content-Disposition"));
                s3Object.setContentLength(contentLength);
                s3Object.setContentMD5(req.getHeader("Content-MD5"));
                value = req.getContentType();
                logger.debug("Put - Content-Type: " + value);
                if (value == null) {
                    value = S3Object.DEFAULT_CONTENT_TYPE;
                }
                s3Object.setContentType(value);
                logger.debug("Put - get content-type: " + s3Object.getContentType());
                s3Object.setLastModified(System.currentTimeMillis());

                // metadata
                int prefixLength = HEADER_PREFIX_USER_META.length();
                String name;
                for (Enumeration headerNames = req.getHeaderNames(); headerNames.hasMoreElements();) {
                    String headerName = (String) headerNames.nextElement();
                    if (headerName.startsWith(HEADER_PREFIX_USER_META)) {
                        name = headerName.substring(prefixLength).toLowerCase();
                        for (Enumeration headers = req.getHeaders(headerName); headers.hasMoreElements();) {
                            value = (String) headers.nextElement();
                            s3Object.addMetadata(name, value);
                        }
                    }
                }

                // calculate ETag, hex encoding of MD5
                value = new String(Hex.encodeHex(digestOutputStream.getMessageDigest().digest()));
                resp.setHeader("ETag", value);
                s3Object.setETag(value);

                grantCannedAccessPolicies(req, s3Object.getAcp(), requestor);

                // NOTE: This could be reengineered to have a two-phase
                // commit.
                if (oldS3Object != null) {
                    storageService.remove(oldS3Object);
                }
                storageService.store(s3Object);
            }
        } else if (or.getBucket() != null) {
            StorageService storageService;
            Bucket bucket;

            storageService = (StorageService) getWebApplicationContext().getBean(BEAN_STORAGE_SERVICE);

            if (req.getParameter(PARAMETER_ACL) != null) {
                // write access control policy
                Acp acp;
                CanonicalUser owner;

                logger.debug("User is providing new ACP for bucket " + or.getBucket());

                try {
                    bucket = storageService.loadBucket(or.getBucket());
                } catch (DataAccessException e) {
                    resp.sendError(HttpServletResponse.SC_NOT_FOUND, "NoSuchBucket");
                    return;
                }

                acp = bucket.getAcp();
                try {
                    acp.canWrite(requestor);
                } catch (AccessControlException e) {
                    resp.sendError(HttpServletResponse.SC_FORBIDDEN, "AccessDenied");
                    return;
                }

                // save owner
                owner = acp.getOwner();

                try {
                    acp = Acp.decode(req.getInputStream());
                } catch (IOException e) {
                    e.printStackTrace();
                    resp.sendError(HttpServletResponse.SC_BAD_REQUEST, "MalformedACLError");
                    return;
                }

                // maintain owner
                acp.setOwner(owner);

                bucket.setAcp(acp);

                logger.debug("Saving bucket ACP");
                logger.debug("ACP: " + Acp.encode(bucket.getAcp()));

                storageService.storeBucket(bucket);
            } else {
                // validate bucket
                String bucketName = or.getBucket();

                if (!isValidBucketName(bucketName)) {
                    resp.sendError(HttpServletResponse.SC_BAD_REQUEST, "InvalidBucketName");
                    return;
                }

                try {
                    bucket = storageService.createBucket(bucketName, requestor);
                } catch (BucketAlreadyExistsException e) {
                    resp.sendError(HttpServletResponse.SC_CONFLICT, "BucketAlreadyExists");
                    return;
                }

                grantCannedAccessPolicies(req, bucket.getAcp(), requestor);

                storageService.storeBucket(bucket);
            }
        }
    } catch (NoSuchAlgorithmException e) {
        e.printStackTrace();
        logger.error("Unable to use MD5", e);
        resp.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR, "InternalError");
    } catch (IOException e) {
        e.printStackTrace();
        throw e;
    } finally {
        if (out != null) {
            out.close();
            out = null;
        }
    }
}

From source file:nu.kelvin.jfileshare.ajax.FileReceiverServlet.java

@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    HttpSession session = req.getSession();
    UserItem currentUser = (UserItem) session.getAttribute("user");
    if (currentUser != null && ServletFileUpload.isMultipartContent(req)) {
        Conf conf = (Conf) getServletContext().getAttribute("conf");
        // keep files of up to 10 MiB in memory 10485760
        FileItemFactory factory = new DiskFileItemFactory(10485760, new File(conf.getPathTemp()));
        ServletFileUpload upload = new ServletFileUpload(factory);
        upload.setSizeMax(conf.getFileSizeMax());

        // set file upload progress listener
        FileUploadListener listener = new FileUploadListener();
        session.setAttribute("uploadListener", listener);
        upload.setProgressListener(listener);

        File tempFile = File.createTempFile(String.format("%05d-", currentUser.getUid()), null,
                new File(conf.getPathTemp()));
        tempFile.deleteOnExit();/*from  w w w  . j  a  va2 s . c om*/
        try {
            FileItem file = new FileItem();

            /* iterate over all uploaded items */
            FileItemIterator it = upload.getItemIterator(req);
            FileOutputStream filestream = null;

            while (it.hasNext()) {
                FileItemStream item = it.next();
                String name = item.getFieldName();
                InputStream instream = item.openStream();
                DigestOutputStream outstream = null;

                if (item.isFormField()) {
                    String value = Streams.asString(instream);
                    // logger.info(name + " : " + value);
                    /* not the file upload. Maybe the password field? */
                    if (name.equals("password") && !value.equals("")) {
                        logger.info("Uploaded file has password set");
                        file.setPwPlainText(value);
                    }
                    instream.close();
                } else {
                    // This is the file you're looking for
                    file.setName(item.getName());
                    file.setType(
                            item.getContentType() == null ? "application/octet-stream" : item.getContentType());
                    file.setUid(currentUser.getUid());

                    try {
                        filestream = new FileOutputStream(tempFile);
                        MessageDigest md = MessageDigest.getInstance("MD5");
                        outstream = new DigestOutputStream(filestream, md);
                        long filesize = IOUtils.copyLarge(instream, outstream);

                        if (filesize == 0) {
                            throw new Exception("File is empty.");
                        }
                        md = outstream.getMessageDigest();
                        file.setMd5sum(toHex(md.digest()));
                        file.setSize(filesize);

                    } finally {
                        if (outstream != null) {
                            try {
                                outstream.close();
                            } catch (IOException ignored) {
                            }
                        }
                        if (filestream != null) {
                            try {
                                filestream.close();
                            } catch (IOException ignored) {
                            }
                        }
                        if (instream != null) {
                            try {
                                instream.close();
                            } catch (IOException ignored) {
                            }
                        }
                    }
                }
            }
            /* All done. Save the new file */
            if (conf.getDaysFileExpiration() != 0) {
                file.setDaysToKeep(conf.getDaysFileExpiration());
            }
            if (file.create(ds, req.getRemoteAddr())) {
                File finalFile = new File(conf.getPathStore(), Integer.toString(file.getFid()));
                tempFile.renameTo(finalFile);
                logger.log(Level.INFO, "User {0} storing file \"{1}\" in the filestore",
                        new Object[] { currentUser.getUid(), file.getName() });
                req.setAttribute("msg",
                        "File <strong>\"" + Helpers.htmlSafe(file.getName())
                                + "\"</strong> uploaded successfully. <a href='" + req.getContextPath()
                                + "/file/edit/" + file.getFid() + "'>Click here to edit file</a>");
                req.setAttribute("javascript", "parent.uploadComplete('info');");
            } else {
                req.setAttribute("msg", "Unable to contact the database");
                req.setAttribute("javascript", "parent.uploadComplete('critical');");
            }
        } catch (SizeLimitExceededException e) {
            tempFile.delete();
            req.setAttribute("msg", "File is too large. The maximum size of file uploads is "
                    + FileItem.humanReadable(conf.getFileSizeMax()));
            req.setAttribute("javascript", "parent.uploadComplete('warning');");
        } catch (FileUploadException e) {
            tempFile.delete();
            req.setAttribute("msg", "Unable to upload file");
            req.setAttribute("javascript", "parent.uploadComplete('warning');");
        } catch (Exception e) {
            tempFile.delete();
            req.setAttribute("msg",
                    "Unable to upload file. ".concat(e.getMessage() == null ? "" : e.getMessage()));
            req.setAttribute("javascript", "parent.uploadComplete('warning');");
        } finally {
            session.setAttribute("uploadListener", null);
        }
        ServletContext app = getServletContext();
        RequestDispatcher disp = app.getRequestDispatcher("/templates/AjaxDummy.jsp");
        disp.forward(req, resp);
    }
}

From source file:org.apache.sling.distribution.util.impl.DigestUtils.java

public static String readDigestMessage(DigestOutputStream output) {
    return readDigestMessage(output.getMessageDigest());
}

From source file:org.apache.sling.distribution.util.impl.DigestUtils.java

public static File rewriteDigestMessage(DigestOutputStream digestOutput, File target) throws IOException {
    File targetDigest = new File(target.getParentFile(), target.getName() + '.'
            + digestOutput.getMessageDigest().getAlgorithm().toLowerCase().replace('-', Character.MIN_VALUE));
    rewriteDigestMessage(digestOutput, new FileOutputStream(targetDigest));
    return targetDigest;
}

From source file:org.apache.sling.distribution.util.impl.DigestUtils.java

public static void rewriteDigestMessage(DigestOutputStream digestOutput, OutputStream target)
        throws IOException {
    final Writer writer = new OutputStreamWriter(target);
    try {/*www.  j  av a 2s. c om*/
        readDigest(digestOutput.getMessageDigest(), writer);
    } finally {
        closeQuietly(writer);
        closeQuietly(target);
    }
}

From source file:org.dataconservancy.dcs.lineage.http.support.RequestUtil.java

/**
 * Calculates a MD5 digest over the list of entity ids, suitable for use as an
 * ETag.  If the list is empty, {@code null} is returned.
 *
 * @param entityIds the entities//from www . j  ava2  s . c o  m
 * @return the MD5 digest, or {@code null} if {@code entityIds} is empty.
 */
public static String calculateDigest(List<String> entityIds) {
    if (entityIds.isEmpty()) {
        return null;
    }

    NullOutputStream nullOut = new NullOutputStream();
    DigestOutputStream digestOut = null;

    try {
        digestOut = new DigestOutputStream(nullOut, MessageDigest.getInstance("MD5"));
        for (String id : entityIds) {
            IOUtils.write(id, digestOut);
        }
        digestOut.close();
    } catch (IOException e) {
        throw new RuntimeException(e.getMessage(), e);
    } catch (NoSuchAlgorithmException e) {
        throw new RuntimeException(e.getMessage(), e);
    }

    return digestToHexString(digestOut.getMessageDigest().digest());
}

From source file:org.dataconservancy.dcs.util.http.ETagCalculator.java

public static String calculate(String id) {
    if (id.isEmpty()) {
        return null;
    }//from  w  ww  .j  av a2 s .co m

    NullOutputStream nullOut = new NullOutputStream();
    DigestOutputStream digestOut = null;

    try {
        digestOut = new DigestOutputStream(nullOut, MessageDigest.getInstance("MD5"));
        IOUtils.write(id, digestOut);
        digestOut.close();
    } catch (IOException e) {
        throw new RuntimeException(e.getMessage(), e);
    } catch (NoSuchAlgorithmException e) {
        throw new RuntimeException(e.getMessage(), e);
    }

    return digestToHexString(digestOut.getMessageDigest().digest());
}