/** * 获取文件的 MD5 */ public static String encode(File file) { try { MessageDigest messageDigest = MessageDigest.getInstance("MD5"); FileInputStream inputStream = new FileInputStream(file); DigestInputStream digestInputStream = new DigestInputStream(inputStream, messageDigest); //必须把文件读取完毕才能拿到md5 byte[] buffer = new byte[4096]; while (digestInputStream.read(buffer) > -1) { } MessageDigest digest = digestInputStream.getMessageDigest(); digestInputStream.close(); byte[] md5 = digest.digest(); StringBuilder sb = new StringBuilder(); for (byte b : md5) { sb.append(String.format("%02X", b)); } return sb.toString().toLowerCase(); } catch (Exception e) { e.printStackTrace(); } return null; }
@Override public PutObjectResult putObject(PutObjectRequest putObjectRequest) throws AmazonClientException, AmazonServiceException { String blobName = putObjectRequest.getKey(); DigestInputStream stream = (DigestInputStream) putObjectRequest.getInputStream(); if (blobs.containsKey(blobName)) { throw new AmazonS3Exception("[" + blobName + "] already exists."); } blobs.put(blobName, stream); // input and output md5 hashes need to match to avoid an exception String md5 = Base64.encodeAsString(stream.getMessageDigest().digest()); PutObjectResult result = new PutObjectResult(); result.setContentMd5(md5); return result; }
public static String digest(InputStream input, String algorithm) throws IOException, NoSuchAlgorithmException { Stopwatch sw = Stopwatch.createStarted(); int bufferSize = 256 * 1024; MessageDigest messageDigest = MessageDigest.getInstance(algorithm); try (DigestInputStream digestInputStream = new DigestInputStream(input, messageDigest);) { byte[] buffer = new byte[bufferSize]; while (digestInputStream.read(buffer) > 0) { ; } messageDigest = digestInputStream.getMessageDigest(); byte[] resultByteArray = messageDigest.digest(); return byteArrayToHex(resultByteArray); } finally { sw.stop(); } }
@Rpc(description = "Compute MD5 hash on a content URI. Return the MD5 has has a hex string.") public String fileMd5Hash(String uri) throws IOException, NoSuchAlgorithmException { Uri uri_ = Uri.parse(uri); ParcelFileDescriptor pfd = mContext.getContentResolver().openFileDescriptor(uri_, "r"); MessageDigest md = MessageDigest.getInstance("MD5"); int length = (int) pfd.getStatSize(); byte[] buf = new byte[length]; ParcelFileDescriptor.AutoCloseInputStream stream = new ParcelFileDescriptor.AutoCloseInputStream(pfd); DigestInputStream dis = new DigestInputStream(stream, md); try { dis.read(buf, 0, length); return Utils.bytesToHexString(md.digest()); } finally { dis.close(); stream.close(); } }
/** * * @param inputStream * @return * @throws NoSuchAlgorithmException * @throws IOException */ public static Md5Result generateChecksum(InputStream inputStream) throws NoSuchAlgorithmException, IOException { Md5Result md5 = new Md5Result(); MessageDigest md = MessageDigest.getInstance("MD5"); DigestInputStream dis = new DigestInputStream(inputStream, md); byte[] dataBytes = new byte[4096]; int nread = 0; while ((nread = dis.read(dataBytes)) != -1) { md5.contentLength += nread; }; dis.close(); long startNs = System.nanoTime(); md5.md5 = generateChecksumFromDigest(md.digest()); md5.generatingTimeNs = System.nanoTime() - startNs; return md5; }
/** * Find definitions by name. * * @param name the name of the definition to find. * @return A list of all definitions that happen to have the name (from multiple jars?) */ @Override public List<DefinitionModel> lookup(String name) { List<DefinitionModel> output = new ArrayList<>(); for (Resource resource : resourceLocator.getEntries(name)) { try (DigestInputStream digestInputStream = new DigestInputStream(resource.getInputStream(), getSha256Digest()); Reader reader = new InputStreamReader(digestInputStream, StandardCharsets.UTF_8)) { DefinitionModel definitionModel = gson.fromJson(reader, DefinitionModel.class); definitionModel.setSourceLocation(resource.getLocation()); definitionModel.setSha256(bytesToHex(digestInputStream.getMessageDigest().digest())); output.add(definitionModel); } catch (IOException ex) { return null; } } return output; }
/** * @source http://stackoverflow.com/a/304350 */ private static byte[] hash(String alg, InputStream in) throws Exception { MessageDigest md = MessageDigest.getInstance(alg); DigestInputStream dis = new DigestInputStream(new BufferedInputStream(in), md); try { byte[] buffer = new byte[1024]; while (true) { int readCount = dis.read(buffer); if (readCount < 0) { break; } } return md.digest(); } finally { in.close(); } }
private static boolean checkSHA256(File provingKey, Component parent) throws IOException { MessageDigest sha256; try { sha256 = MessageDigest.getInstance("SHA-256"); } catch (NoSuchAlgorithmException impossible) { throw new IOException(impossible); } try (InputStream is = new BufferedInputStream(new FileInputStream(provingKey))) { ProgressMonitorInputStream pmis = new ProgressMonitorInputStream(parent,"Verifying proving key",is); pmis.getProgressMonitor().setMaximum(PROVING_KEY_SIZE); pmis.getProgressMonitor().setMillisToPopup(10); DigestInputStream dis = new DigestInputStream(pmis, sha256); byte [] temp = new byte[0x1 << 13]; while(dis.read(temp) >= 0); byte [] digest = sha256.digest(); return SHA256.equalsIgnoreCase(DatatypeConverter.printHexBinary(digest)); } }
public static byte[] calculateSHA256Digest(byte[] input) throws IOException { try { MessageDigest sha256 = MessageDigest.getInstance("SHA-256"); DigestInputStream dis = new DigestInputStream(new ByteArrayInputStream(input), sha256); byte [] temp = new byte[0x1 << 13]; byte[] digest; while(dis.read(temp) >= 0); { digest = sha256.digest(); } return digest; } catch (NoSuchAlgorithmException impossible) { throw new IOException(impossible); } }
private static boolean checkSHA256(File provingKey, Component parent) throws IOException { MessageDigest sha256; try { sha256 = MessageDigest.getInstance("SHA-256"); } catch (NoSuchAlgorithmException impossible) { throw new RuntimeException(impossible); } try (InputStream is = new BufferedInputStream(new FileInputStream(provingKey))) { ProgressMonitorInputStream pmis = new ProgressMonitorInputStream(parent,"Verifying proving key",is); pmis.getProgressMonitor().setMaximum(PROVING_KEY_SIZE); pmis.getProgressMonitor().setMillisToPopup(10); DigestInputStream dis = new DigestInputStream(pmis, sha256); byte [] temp = new byte[0x1 << 13]; while(dis.read(temp) >= 0); byte [] digest = sha256.digest(); return SHA256.equalsIgnoreCase(DatatypeConverter.printHexBinary(digest)); } }
public static Checksums calculate(InputStream content) throws IOException { Assert.notNull(content, "Content must not be null"); try { DigestInputStream sha1 = new DigestInputStream(content, MessageDigest.getInstance("SHA-1")); DigestInputStream md5 = new DigestInputStream(sha1, MessageDigest.getInstance("MD5")); StreamUtils.drain(md5); return new Checksums(getDigestHex(sha1), getDigestHex(md5)); } catch (Exception ex) { throw new RuntimeException(ex); } finally { content.close(); } }
protected void writeRenameReadCompare(Path path, long len) throws IOException, NoSuchAlgorithmException { // If len > fs.s3n.multipart.uploads.block.size, // we'll use a multipart upload copy MessageDigest digest = MessageDigest.getInstance("MD5"); OutputStream out = new BufferedOutputStream( new DigestOutputStream(fs.create(path, false), digest)); for (long i = 0; i < len; i++) { out.write('Q'); } out.flush(); out.close(); assertTrue("Exists", fs.exists(path)); // Depending on if this file is over 5 GB or not, // rename will cause a multipart upload copy Path copyPath = path.suffix(".copy"); fs.rename(path, copyPath); assertTrue("Copy exists", fs.exists(copyPath)); // Download file from S3 and compare the digest against the original MessageDigest digest2 = MessageDigest.getInstance("MD5"); InputStream in = new BufferedInputStream( new DigestInputStream(fs.open(copyPath), digest2)); long copyLen = 0; while (in.read() != -1) {copyLen++;} in.close(); assertEquals("Copy length matches original", len, copyLen); assertArrayEquals("Digests match", digest.digest(), digest2.digest()); }
protected byte[] hash(InputStream input) throws SdkClientException { try { MessageDigest md = getMessageDigestInstance(); @SuppressWarnings("resource") DigestInputStream digestInputStream = new SdkDigestInputStream( input, md); byte[] buffer = new byte[1024]; while (digestInputStream.read(buffer) > -1) { ; } return digestInputStream.getMessageDigest().digest(); } catch (Exception e) { throw new SdkClientException( "Unable to compute hash while signing request: " + e.getMessage(), e); } }
protected byte[] hash(InputStream input) throws SdkClientException { try { MessageDigest md = getMessageDigestInstance(); @SuppressWarnings("resource") DigestInputStream digestInputStream = new SdkDigestInputStream( input, md); byte[] buffer = new byte[1024]; while (digestInputStream.read(buffer) > -1) ; return digestInputStream.getMessageDigest().digest(); } catch (Exception e) { throw new SdkClientException( "Unable to compute hash while signing request: " + e.getMessage(), e); } }
/** * Uploads a part of a multipart upload. * * @param bucketName in which to upload * @param fileName of the file to upload * @param uploadId id of the upload * @param partNumber number of the part to store * @param inputStream file data to be stored * @param useV4Signing If {@code true}, V4-style signing is enabled. * @return the md5 hash of this part * @throws IOException if file could not be read to calculate digest */ public String putPart(final String bucketName, final String fileName, final String uploadId, final String partNumber, final InputStream inputStream, final boolean useV4Signing) throws IOException { try (DigestInputStream digestingInputStream = new DigestInputStream(wrapStream(inputStream, useV4Signing), MessageDigest.getInstance("MD5"))) { inputStreamToFile(digestingInputStream, Paths.get(rootFolder.getAbsolutePath(), bucketName, fileName, uploadId, partNumber + PART_SUFFIX)); return new String(Hex.encodeHex(digestingInputStream.getMessageDigest().digest())); } catch (final NoSuchAlgorithmException e) { throw new IllegalStateException(e); } }
static String md5sum(InputStream input) throws IOException { BufferedInputStream in = new BufferedInputStream(input); try { MessageDigest e = MessageDigest.getInstance("MD5"); DigestInputStream digestInputStream = new DigestInputStream(in, e); boolean bytesRead = false; byte[] buffer = new byte[8192]; while(digestInputStream.read(buffer) != -1) { // CHECKSTYLE:OFF EmptyStatement ; // CHECKSTYLE:ON } ByteArrayOutputStream md5out = new ByteArrayOutputStream(); md5out.write(e.digest()); String var7 = md5out.toString(); return var7; } catch (NoSuchAlgorithmException var11) { throw new IllegalStateException("MD5 algorithm is not available: " + var11); } finally { in.close(); } }
private static CompletableFuture<String> computeMd5(Path path) { return CompletableFuture.supplyAsync(() -> { try { MessageDigest md = MessageDigest.getInstance("MD5"); // Possibly use a different hashing algorithm try (InputStream is = Files.newInputStream(path); DigestInputStream dis = new DigestInputStream(is, md)) { int readByte; do { readByte = dis.read(); } while(readByte != -1); } byte[] bytes = md.digest(); return HexBin.encode(bytes); } catch (IOException | NoSuchAlgorithmException e) { throw new RuntimeException(e); } }, MineskinSponge.getInstance().getAsyncExecutor()); }
public String getMd5(File f) throws IOException { FileInputStream in = new FileInputStream(f); DigestInputStream di = new DigestInputStream(in, md); byte[] buffer = new byte[bufferSize]; while (di.read(buffer) > 0) ; md = di.getMessageDigest(); di.close(); in.close(); byte[] digest = md.digest(); return byteArrayToHex(digest); }
/** * Hashes the given data from the {@link InputStream} and returns the hash * as hex string. If the input is {@code null} the {@link #NULL_HASH} is * returned. * * @param stream The stream with the data to be hashed. * @return The hash as hex string or if the input is {@code null} * {@link #NULL_HASH}. * @throws IOException If reading from the given {@link InputStream} failed. */ public static final String hash(InputStream stream) throws IOException { if (stream == null) { return NULL_HASH; } MessageDigest digest = getMd5Digest(); try (DigestInputStream digestInputStream = new DigestInputStream(stream, digest)) { while (digestInputStream.read() != -1) { // Nothing to do here, the read is all we need. } } return createHexString(digest.digest()); }
public static String hashFile(File file) throws NoSuchAlgorithmException, IOException { MessageDigest md = MessageDigest.getInstance("MD5"); try (InputStream is = Files.newInputStream(Paths.get(file.getAbsolutePath()))) { DigestInputStream ds = new DigestInputStream(is, md); byte[] input = new byte[1024]; // Read the stream to the end to get the md5 while (ds.read(input) != -1) { } byte[] hash = md.digest(); StringBuilder sb = new StringBuilder(); for (byte b : hash) { sb.append(String.format("%02X", b)); } return sb.toString(); } }
/** * Constructs a new MCRContentInputStream * * @param in * the InputStream to read from * @throws MCRConfigurationException * if java classes supporting MD5 checksums are not found */ public MCRContentInputStream(InputStream in) throws MCRException { super(null); digest = buildMD5Digest(); DigestInputStream dis = new DigestInputStream(in, digest); MCRBlockingInputStream bis = new MCRBlockingInputStream(dis, headerSize); byte[] buffer = new byte[headerSize]; try { int num = bis.read(buffer, 0, buffer.length); header = new byte[Math.max(0, num)]; if (num > 0) { System.arraycopy(buffer, 0, header, 0, num); } } catch (IOException ex) { String msg = "Error while reading content input stream header"; throw new MCRException(msg, ex); } this.in = bis; }
public static byte[] computeFileDigest(final String fileName) throws IOException { try { final FileInputStream fis = new FileInputStream(fileName); final MessageDigest md = MessageDigest.getInstance("SHA-256"); final DigestInputStream dis = new DigestInputStream(fis, md); final int readLen = 128; final byte[] readBytes = new byte[readLen]; while (dis.read(readBytes) != -1) { } dis.close(); return md.digest(); } catch (NoSuchAlgorithmException e) { // shouldn't get here since we hardcode the algorithm. } return null; }
/** * Generate a SHA.1 Hash for a given file. * @param file the file to hash * @return the hash value as a String * @throws IOException if the file cannot be read */ public static String sha1Hash(File file) throws IOException { try { DigestInputStream inputStream = new DigestInputStream( new FileInputStream(file), MessageDigest.getInstance("SHA-1")); try { byte[] buffer = new byte[4098]; while (inputStream.read(buffer) != -1) { // Read the entire stream } return bytesToHex(inputStream.getMessageDigest().digest()); } finally { inputStream.close(); } } catch (NoSuchAlgorithmException ex) { throw new IllegalStateException(ex); } }
public static byte[] md5Hash(File file) throws IOException { MessageDigest digest = getMd5Digest(); FileInputStream fStream = new FileInputStream(file); BufferedInputStream bStream = new BufferedInputStream(fStream); DigestInputStream blobStream = new DigestInputStream(bStream, digest); byte[] buffer = new byte[BYTE_BUFFER_SIZE]; int num = 0; do { num = blobStream.read(buffer); } while (num > 0); bStream.close(); return digest.digest(); }
boolean inSolr() throws IOException, SolrServerException { // Check Solr to see if the file has already been index by getting the md5 checksum // of the file and doing a Solr query using that checksum. Don't run FITS if the // file already exists. try (InputStream inputStream = Files.newInputStream(this.getFile())) { byte[] buffer = new byte[8192]; DigestInputStream digestInputStream = new DigestInputStream(inputStream, messageDigest); try { while (digestInputStream.read(buffer) != -1) ; } finally { digestInputStream.close(); } SolrQuery md5Query = new SolrQuery(); md5Query.setQuery("md5checksum:" + DatatypeConverter.printHexBinary(messageDigest.digest()).toLowerCase()); QueryResponse queryResponse = solrClient.query(md5Query); if (queryResponse.getResults().getNumFound() == 0) { this.status = false; } else{ this.status = true; } } return this.status; }
/** * Calculates digest for a file using provided algorithm. */ public static byte[] digest(final File file, MessageDigest algorithm) throws IOException { algorithm.reset(); FileInputStream fis = new FileInputStream(file); BufferedInputStream bis = new BufferedInputStream(fis); DigestInputStream dis = new DigestInputStream(bis, algorithm); try { while (dis.read() != -1) { } } finally { StreamUtil.close(fis); } return algorithm.digest(); }
@Nullable private String getApkDigestSha256() { try { FileInputStream fis = new FileInputStream(context.getPackageCodePath()); MessageDigest md = MessageDigest.getInstance(SHA_256); try { DigestInputStream dis = new DigestInputStream(fis, md); byte[] buffer = new byte[2048]; while (dis.read(buffer) != -1) { // } dis.close(); } finally { fis.close(); } return Base64.encodeToString(md.digest(), Base64.NO_WRAP); } catch (IOException | NoSuchAlgorithmException e) { return null; } }
public static String calculateMD5(InputStream in) throws Exception { DigestInputStream ds = new DigestInputStream(in, MessageDigest.getInstance("MD5")); while (ds.read() != -1) { } byte[] md5bytes = ds.getMessageDigest().digest(); StringBuilder sb = new StringBuilder(); for (byte md5byte : md5bytes) { String hexBiChars = String.format("%02x", md5byte); sb.append(hexBiChars); } return sb.toString(); }
/** * Generate a SHA 512 checksum from the given file and asynchronously return the hex encoded hash as a string. * * @param path */ public static String hash(String path) { try { MessageDigest md = MessageDigest.getInstance("SHA-512"); try (InputStream is = Files.newInputStream(Paths.get(path)); DigestInputStream mis = new DigestInputStream(is, md)) { byte[] buffer = new byte[4096]; while (mis.read(buffer) >= 0) { } } byte[] digest = md.digest(); return bytesToHex(digest); } catch (Exception e) { log.error("Error while hashing file {" + path + "}", e); throw error(INTERNAL_SERVER_ERROR, "node_error_upload_failed", e); } }
/** * Generate hash bytes for the specified stream, using specified algorithm * * @param inputStream Data stream * @param algorithm Hashing algorithm * @return Hash bytes */ @NonNull public static byte[] generateHashBytes(@NonNull InputStream inputStream, @NonNull String algorithm) { try { DigestInputStream digestStream = new DigestInputStream(inputStream, MessageDigest.getInstance(algorithm)); byte[] buffer = new byte[BUFFER_SIZE]; for (; ; ) { if (digestStream.read(buffer) < 0) { break; } } return digestStream.getMessageDigest().digest(); } catch (NoSuchAlgorithmException | IOException e) { throw new RuntimeException(e); } finally { CommonUtils.close(inputStream); } }
/** * If the checksum for the file has changed, then update the checksum and return true. else return false */ protected boolean haveFilesBeenChanged(final String filePath, byte[] checksum) { try (InputStream is = Files.newInputStream(Paths.get(filePath)); DigestInputStream digestInputStream = new DigestInputStream(is, md)) { while (digestInputStream.read() != -1) { ; // do nothing, just read until the EoF } } catch (IOException ignored) { //this is best effort, if we couldn't read the file, assume its the same LOGGER.warn("Error reading file " + filePath, ignored); return false; } byte[] digest = md.digest(); if (!Arrays.equals(checksum, digest)) { //they aren't the same, overwrite old checksum checksum = digest; return true; } return false; }
public static String getHash(File file, String algorithm) throws NoSuchAlgorithmException, IOException { MessageDigest digest = MessageDigest.getInstance(algorithm); digest.reset(); BufferedInputStream is = new BufferedInputStream(new FileInputStream(file)); DigestInputStream digestInputStream = new DigestInputStream(is,digest); byte[] bytes = new byte[1024]; //noinspection StatementWithEmptyBody while (digestInputStream.read(bytes) != -1) { } digestInputStream.close(); return convertByteArrayToHexString(digest.digest()); }
private String md5(File file) throws IOException { try { MessageDigest md = MessageDigest.getInstance("MD5"); InputStream is = new FileInputStream(file); DigestInputStream dis = new DigestInputStream(is, md); byte[] buffer = new byte[4096]; while(dis.read(buffer) >= 0) {} byte[] bytes = md.digest(); char[] hexChars = new char[bytes.length * 2]; for (int j = 0; j < bytes.length; j++) { int v = bytes[j] & 0xFF; hexChars[j * 2] = hexArray[v >>> 4]; hexChars[j * 2 + 1] = hexArray[v & 0x0F]; } return new String(hexChars); } catch(NoSuchAlgorithmException e) { throw new Error(e); } }
/** * Compute the SHA1 digest of the given file. * @param fileName the filename * @return the digest string + the filename * @throws IOException on error */ static String computeDigest(String fileName) throws IOException { try (FileInputStream fis = new FileInputStream(fileName); DigestInputStream din = new DigestInputStream(fis, MessageDigest.getInstance("SHA1"))) { byte[] buffer = new byte[8192]; while (true) { if (din.read(buffer) < 0) { break; } } byte[] digest = din.getMessageDigest().digest(); StringBuilder sb = new StringBuilder(); for (byte b : digest) { sb.append(String.format("%02X", b & 0xFF)); } sb.append(" ").append(fileName).append("\r\n"); return sb.toString(); } catch (NoSuchAlgorithmException ex) { Exceptions.add(ex); } return ""; }