将加密图像以byte []转换为BufferedImage，而不进行解密 [英] Converting encrypted image in byte[] to BufferedImage in java without decrypting
本文介绍了将加密图像以byte []转换为BufferedImage，而不进行解密的处理方法，对大家解决问题具有一定的参考价值，需要的朋友们下面随着小编来一起学习吧！
问题描述
我需要将存储在 byte [] 中的加密图像转换为 BufferedImage 。我使用以下代码：
I need to convert encrypted image stored in byte[] to BufferedImage. I used the following code:
InputStream in = new ByteArrayInputStream(imageInByte);
BufferedImage bImageFromConvert = ImageIO.read(in);
但是bImageFromConvert为null。我googled，发现它的原因，因为图像被加密的ImageIO无法读取它。堆栈溢出中提出的解决方案是解密图像然后转换。但是在我的情况下不适用，因为我需要在这个加密的图像中嵌入一个消息，对于iam使用下面的代码：
But bImageFromConvert is null. I googled and found the reason that its because the image is encrypted ImageIO can't read it. The solutions suggested in stack overflow is to decrypt the image and then convert. But it is not applicable in my case because i need to embed a message in this encrypted image and for that iam using the code below:
public class EmbedMessage {
//BufferedImage sourceImage,embeddedImage;
public static BufferedImage embedMsg(BufferedImage sourceImage,String mess) {
//String mess = "hai";
BufferedImage embeddedImage = sourceImage.getSubimage(0,0,
sourceImage.getWidth(),sourceImage.getHeight());
embedMessage(embeddedImage, mess);
return embeddedImage;
}
private static void embedMessage(BufferedImage img, String mess) {
int messageLength = mess.length();
int imageWidth = img.getWidth(), imageHeight = img.getHeight(),
imageSize = imageWidth * imageHeight;
if(messageLength * 8 + 32 > imageSize) {
return;
}
embedInteger(img, messageLength, 0, 0);
byte b[] = mess.getBytes();
for(int i=0; i<b.length; i++)
embedByte(img, b[i], i*8+32, 0);
}
private static void embedInteger(BufferedImage img, int n, int start, int storageBit) {
int maxX = img.getWidth(), maxY = img.getHeight(),
startX = start/maxY, startY = start - startX*maxY, count=0;
for(int i=startX; i<maxX && count<32; i++) {
for(int j=startY; j<maxY && count<32; j++) {
int rgb = img.getRGB(i, j), bit = getBitValue(n, count);
rgb = setBitValue(rgb, storageBit, bit);
img.setRGB(i, j, rgb);
count++;
}
}
}
private static void embedByte(BufferedImage img, byte b, int start, int storageBit) {
int maxX = img.getWidth(), maxY = img.getHeight(),
startX = start/maxY, startY = start - startX*maxY, count=0;
for(int i=startX; i<maxX && count<8; i++) {
for(int j=startY; j<maxY && count<8; j++) {
int rgb = img.getRGB(i, j), bit = getBitValue(b, count);
rgb = setBitValue(rgb, storageBit, bit);
img.setRGB(i, j, rgb);
count++;
}
}
}
private static int getBitValue(int n, int location) {
int v = n & (int) Math.round(Math.pow(2, location));
return v==0?0:1;
}
private static int setBitValue(int n, int location, int bit) {
int toggle = (int) Math.pow(2, location), bv = getBitValue(n, location);
if(bv == bit)
return n;
if(bv == 0 && bit == 1)
n |= toggle;
else if(bv == 1 && bit == 0)
n ^= toggle;
return n;
}
}
请建议我一种将加密图像转换为 byte array to BufferedImage
Please suggest me a way to convert Encrypted image in byte array to BufferedImage
推荐答案
找到一个解决方案atlast。感谢 http://blog.philippheckel.com/2013/03/02/java-encode-any-byte-array-stream-or-file-into-a-24-bit-bitmap- BMP / 。
Found a solution atlast. Thanks to http://blog.philippheckel.com/2013/03/02/java-encode-any-byte-array-stream-or-file-into-a-24-bit-bitmap-bmp/.
加密的图像不可打开，因为它的标题也被加密。所以为了打开它而不进行解密，我们必须加密只有除头部之外的部分或完全加密图像，并附加另一个标题，使其成为一个新的图像。使用类BitmapEncoder我附加或转换加密的字节数组返回图像如下：
The encrypted image is not openable because its header was also getting encrypted. So in order to open it without decrypting, we have to either encrypt only the portion except header or encrypt the image fully and attach another header so that it becomes a new image.Using the class BitmapEncoder I have attached or converted the encrypted byte array back to image as follows:
File uploadedFile = new File(filePath);
item.write(uploadedFile);
//Convert uploaded image to byte[] for encryption
bFile = new byte[(int) uploadedFile.length()];
try {
FileInputStream fileInputStream = new FileInputStream(uploadedFile);
//convert file into array of bytes
fileInputStream.read(bFile);
fileInputStream.close();
} catch (Exception e) {
e.printStackTrace();
}
//encrypt the byte array
Cipher cipher=Cipher.getInstance("AES");
cipher.init(Cipher.ENCRYPT_MODE, key);
enFile=cipher.doFinal(bFile);
//save encrypted image to database
image.setImage(enFile);
//save this row to database
UploadService ups=new UploadService();
imgid=ups.uploadImage(image);
//Attach bitmap header to the encrypted byte array so that encrypted array can be still recognized as an image and save it to disk
BitmapEncoder.encodeToBitmap(enFile, new File(uploadFolder + File.separator +"encrypted"+fileName));
希望这有助于别人。
Iam粘贴完整的BitmapEncoder.java以避免断开的链接问题：
Iam pasting the full BitmapEncoder.java to avoid broken link problems:
/*
* BitmapEncoder, encodes any byte array, stream or file into a 24-bit bitmap (BMP).
* Copyright (C) 2013 Philipp C. Heckel <philipp.heckel@gmail.com>
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.Arrays;
/**
* Encodes any byte array, stream or file into a 24-bit bitmap (BMP).
*
* The <code>encodeToBitmap()</code>-methods can be used to transform any binary data
* into a rectangular image and stored in the widely supported 24-bit bitmap
* format. The method does not hide, encrypt or compress the source data in any
* way. It merely prepends a bitmap header and transforms the payload as
* specified by the bitmap file format.
*
* <p>The <code>decodeFromBitmap()</code>-methods retrieve the orginal payload from a
* previously encoded bitmap. A bitmap not encoded with this class cannot be read.
*
* <p><b>Example:</b>
*
* <pre>
* // Encode file "/etc/hosts" into file "/tmp/hosts.bmp", and restore it to "/tmp/hosts-restored"
* BitmapEncoder.encodeToBitmap(new File("/etc/hosts"), new File("/tmp/hosts.bmp"));
* BitmapEncoder.decodeFromBitmap(new File("/tmp/hosts.bmp"), new File("/tmp/hosts-restored"));
*
* // Encode 3 bytes into a bitmap file
* BitmapEncoder.encodeToBitmap(new byte[] { 0x01, 0x02, 0x03 }, new File("/tmp/3- bytes.bmp"));
* byte[] threebytes = BitmapEncoder.decodeFromBitmap(new File("/tmp/3-bytes.bmp"));
* </pre>
*
* @author Philipp C. Heckel <philipp.heckel@gmail.com>
* @see http://blog.philippheckel.com/2013/03/02/java-encode-any-byte-array-stream-or-file-into-a-24-bit-bitmap-bmp/
*/
public class BitmapEncoder {
private static final int BMP_SIZE_HEADER= 54; // total header length, 54 bytes
private static final int BMP_SIZE_IMAGE_WIDTH = 4; // size of image width field, 4 bytes
private static final int BMP_SIZE_PAYLOAD_LENGTH = 4; // size of 'horizontal resolution' field, here: payload length, 4 bytes
private static final int BMP_SIZE_BMPUTIL_MAGIC = 4; // size of 'vertical resolution' field, here: payload length, 4 bytes
private static final int BMP_OFFSET_FILESIZE_BYTES = 2; // offset of filesize field, 4 bytes
private static final int BMP_OFFSET_IMAGE_WIDTH = 18; // offset of image width field, 4 bytes
private static final int BMP_OFFSET_IMAGE_HEIGHT = 22; // offset of image height field, 4 bytes
private static final int BMP_OFFSET_IMAGE_DATA_BYTES = 34; // 4 bytes
private static final int BMP_OFFSET_PAYLOAD_LENGTH = 38; // 4 bytes
private static final int BMP_OFFSET_BMPUTIL_MAGIC = 42; // 4 bytes
private static final byte UDEF = 0; // undefined value in bitmap header, to be overwritten by methods
/**
* 24-bit bitmap header
* @see http://www.fastgraph.com/help/bmp_header_format.html
*/
private static final byte[] BMP_HEADER = new byte[] {
/* 00 */ 0x42, 0x4d, // signature, "BM"
/* 02 */ UDEF, UDEF, UDEF, UDEF, // size in bytes, filled dynamically
/* 06 */ 0x00, 0x00, // reserved, must be zero
/* 08 */ 0x00, 0x00, // reserved, must be zero
/* 10 */ 0x36, 0x00, 0x00, 0x00, // offset to start of image data in bytes
/* 14 */ 0x28, 0x00, 0x00, 0x00, // size of BITMAPINFOHEADER structure, must be 40 (0x28)
/* 18 */ UDEF, UDEF, UDEF, UDEF, // image width in pixels, filled dynamically
/* 22 */ UDEF, UDEF, UDEF, UDEF, // image height in pixels, filled dynamically
/* 26 */ 0x01, 0x00, // number of planes, must be 1
/* 28 */ 0x18, 0x00, // number of bits per pixel (1, 4, 8, or 24) -> 24 = 0x18
/* 30 */ 0x00, 0x00, 0x00, 0x00, // compression type (0=none, 1=RLE-8, 2=RLE-4)
/* 34 */ UDEF, UDEF, UDEF, UDEF, // size of image data in bytes (including padding)
/* 38 */ UDEF, UDEF, UDEF, UDEF, // normally: horizontal resolution in pixels per meter (unreliable)
// --> HERE: used to indicate the payload length
/* 42 */ UDEF, UDEF, UDEF, UDEF, // vertical resolution in pixels per meter (unreliable)
// --> HERE: used to mark file as encoded bitmap, see BMPUTIL_MAGIC
/* 46 */ 0x00, 0x00, 0x00, 0x00, // number of colors in image, or zero
/* 50 */ 0x00, 0x00, 0x00, 0x00, // number of important colors, or zero
};
/**
* Magic value to mark files created by this class
*/
private static final byte[] BMPUTIL_MAGIC = new byte[] {
0x30, 0x32, 0x30, 0x35 // mark used in 'vertical resolution' field to mark bmp file, "0205"
};
/**
* Encodes any <code>File</code> into a 24-bit bitmap (BMP) and outputs the image
* to another <code>File</code>.
*
* <p>The method does not hide, encrypt or compress the source data in any
* way. It merely prepends a bitmap header and transforms the payload as
* specified by the bitmap file format.
*
* @param srcFile File to be read pointing to the input data (payload)
* @param destFile File to write the 24-bit bitmap file to
* @throws IOException Thrown if the input/output stream cannot be read/written
*/
public static void encodeToBitmap(File srcFile, File destFile) throws IOException {
encodeToBitmap(new FileInputStream(srcFile), srcFile.length(), new FileOutputStream(destFile));
}
/**
* Encodes any <code>File</code> into a 24-bit bitmap (BMP) and outputs the image
* to another <code>File</code>.
*
* <p>The method does not hide, encrypt or compress the source data in any
* way. It merely prepends a bitmap header and transforms the payload as
* specified by the bitmap file format.
*
* @param srcBytes Byte array of input data (payload)
* @param destStream Stream to write the 24-bit bitmap file to
* @throws IOException Thrown if the input/output stream cannot be read/written
*/
public static void encodeToBitmap(byte[] srcBytes, File destFile) throws IOException {
encodeToBitmap(new ByteArrayInputStream(srcBytes), srcBytes.length, new FileOutputStream(destFile));
}
/**
* Encodes a byte array into a 24-bit bitmap (BMP) and outputs the image
* to an <code>OutputStream</code>.
*
* <p>The method does not hide, encrypt or compress the source data in any
* way. It merely prepends a bitmap header and transforms the payload as
* specified by the bitmap file format.
*
* @param srcBytes Byte array of input data (payload)
* @param destStream Stream to write the 24-bit bitmap file to
* @throws IOException Thrown if the input/output stream cannot be read/written
*/
public static void encodeToBitmap(byte[] srcBytes, OutputStream destStream) throws IOException {
encodeToBitmap(new ByteArrayInputStream(srcBytes), srcBytes.length, destStream);
}
/**
* Encodes an <code>InputStream</code> into a 24-bit bitmap (BMP) and outputs the image
* as byte array.
*
* <p>The method does not hide, encrypt or compress the source data in any
* way. It merely prepends a bitmap header and transforms the payload as
* specified by the bitmap file format.
*
* @param srcStream Stream of input data (payload)
* @param srcStreamLength Length of the input data stream (in bytes)
* @param destStream Stream to write the 24-bit bitmap file to
* @throws IOException Thrown if the input/output stream cannot be read/written
*/
public static void encodeToBitmap(InputStream srcStream, long srcStreamLength, OutputStream destStream) throws IOException {
if (srcStreamLength > Integer.MAX_VALUE) {
throw new IOException("File too big; max. "+Integer.MAX_VALUE+" bytes supported.");
}
// CALCULATE HEADER FIELDS
int imageWidth = (int) Math.ceil(Math.sqrt((double) srcStreamLength / 3)); / / Image width, sqrt(payload/3), divided by 3 because of RGB
int imageHeight = (int) Math.ceil((double) srcStreamLength // Image height, payload / image width / 3
/ (double) imageWidth / 3);
int rowPadding = 4 - (imageWidth*3 % 4); // Padding at row end, row length must be divisible by 4
int filesizeBytes = imageWidth*imageHeight*3 + imageHeight*rowPadding // Total bitmap size, RGB-data + padding-data + header
+ BMP_SIZE_HEADER;
int imageBytesWithPadding = filesizeBytes - BMP_SIZE_HEADER; // Image bytes without header (incl. padding), required field in header
int payloadPadding = (int) (imageWidth*imageHeight*3 - srcStreamLength); // Padding at the end of the image, to make it rectangular
// System.out.println("payloadLength = "+srcStreamLength);
// System.out.println("imageWidth = sqrt(payloadLength/3) = "+imageWidth);
// System.out.println("imageHeight = payloadLength / imageWidth / 3 = "+imageHeight);
// System.out.println("rowPadding = "+rowPadding);
// System.out.println("filesizeBytes = imageWidth*imageHeight*3 + imageHeight*rowPadding + BMP_SIZE_HEADER = "+filesizeBytes);
// System.out.println("imageBytesWithPadding = filesizeBytes - BMP_SIZE_HEADER = "+imageBytesWithPadding);
// System.out.println("payloadPadding = imageWidth*imageHeight*3 - payloadLength = "+payloadPadding);
// WRITE FIELDS TO HEADER
byte[] header = BMP_HEADER.clone(); // Clone bitmap header template, and overwrite with fields
writeIntLE(header, BMP_OFFSET_FILESIZE_BYTES, filesizeBytes);
writeIntLE(header, BMP_OFFSET_IMAGE_WIDTH, imageWidth);
writeIntLE(header, BMP_OFFSET_IMAGE_HEIGHT, imageHeight);
writeIntLE(header, BMP_OFFSET_IMAGE_DATA_BYTES, imageBytesWithPadding);
writeIntLE(header, BMP_OFFSET_PAYLOAD_LENGTH, (int) srcStreamLength);
System.arraycopy(BMPUTIL_MAGIC, 0, header, // Copy magic number to header
BMP_OFFSET_BMPUTIL_MAGIC, BMPUTIL_MAGIC.length);
// WRITE TO STREAM
// Add payload
destStream.write(header, 0, header.length);
// Write other lines (regular width)
byte[] row = new byte[imageWidth*3];
int read;
while ((read = srcStream.read(row)) != -1) {
destStream.write(row, 0, read); // Write payload
destStream.write(new byte[rowPadding]); // Write padding
}
// Write payload padding
destStream.write(new byte[payloadPadding]);
srcStream.close();
destStream.close();
}
/**
* Decodes a 24-bit bitmap previously encoded by this class from
* an <code>InputStream</code> to a byte array.
*
* <p>The method can only read bitmaps that were encoded using one of the
* <code>encodeToBitmap()</code> methods. It will throw an exception if
* any other bitmaps are read.
*
* @param srcStream Stream of input data (24-bit bitmap)
* @return The original data read from the bitmap (payload)
* @throws IOException Thrown if the input/output stream cannot be read/written
*/
public static byte[] decodeFromBitmap(InputStream srcStream) throws IOException {
ByteArrayOutputStream destStream = new ByteArrayOutputStream();
decodeFromBitmap(srcStream, destStream);
return destStream.toByteArray();
}
/**
* Decodes a 24-bit bitmap previously encoded by this class from
* a <code>File</code> to a byte array.
*
* <p>The method can only read bitmaps that were encoded using one of the
* <code>encodeToBitmap()</code> methods. It will throw an exception if
* any other bitmaps are read.
*
* @param srcFile File to be read pointing to the input data (24-bit bitmap)
* @return The original data read from the bitmap (payload)
* @throws IOException Thrown if the input/output stream cannot be read/written
*/
public static byte[] decodeFromBitmap(File srcFile) throws IOException {
ByteArrayOutputStream destStream = new ByteArrayOutputStream();
decodeFromBitmap(new FileInputStream(srcFile), destStream);
return destStream.toByteArray();
}
/**
* Decodes a 24-bit bitmap previously encoded by this class from
* a <code>File</code> to another <code>File</code>.
*
* <p>The method can only read bitmaps that were encoded using one of the
* <code>encodeToBitmap()</code> methods. It will throw an exception if
* any other bitmaps are read.
*
* @param srcFile File to be read pointing to the input data (24-bit bitmap)
* @param destFile File to be written the original data to (payload)
* @throws IOException Thrown if the input/output stream cannot be read/written
*/
public static void decodeFromBitmap(File srcFile, File destFile) throws IOException {
decodeFromBitmap(new FileInputStream(srcFile), new FileOutputStream(destFile));
}
/**
* Decodes a 24-bit bitmap previously encoded by this class from
* an <code>InputStream</code> to an <code>OutputStream</code>.
*
* <p>The method can only read bitmaps that were encoded using one of the
* <code>encodeToBitmap()</code> methods. It will throw an exception if
* any other bitmaps are read.
*
* @param srcStream Stream to be read pointing to the input data (24-bit bitmap)
* @param destStream Stream to be written the original data to (payload)
* @throws IOException Thrown if the input/output stream cannot be read/written
*/
public static void decodeFromBitmap(InputStream srcStream, OutputStream destStream) throws IOException {
// READ HEADER
long bytesRead = 0;
// Skip ahead & read 'image width' field
bytesRead += srcStream.skip(BMP_OFFSET_IMAGE_WIDTH - bytesRead); // Stores the image width, needed for row length and
byte[] imageWidthBytes = new byte[BMP_SIZE_IMAGE_WIDTH]; // row padding calculation
bytesRead += srcStream.read(imageWidthBytes);
int imageWidth = toIntLE(imageWidthBytes);
// Skip ahead & read 'horizontal resolution' field
bytesRead += srcStream.skip(BMP_OFFSET_PAYLOAD_LENGTH - bytesRead); // Stores the payload length, needed for read-loop below
byte[] payloadLengthBytes = new byte[BMP_SIZE_PAYLOAD_LENGTH];
bytesRead += srcStream.read(payloadLengthBytes);
int payloadLength = toIntLE(payloadLengthBytes);
// Skip ahead & read 'vertical resolution' field
bytesRead += srcStream.skip(BMP_OFFSET_BMPUTIL_MAGIC - bytesRead); // Stores the magic field, needed to check if the image was
byte[] magicFieldBytes = new byte[BMP_SIZE_BMPUTIL_MAGIC]; // previously encoded using this class
bytesRead += srcStream.read(magicFieldBytes);
if (!Arrays.equals(BMPUTIL_MAGIC, magicFieldBytes)) {
throw new IOException("Given bitmap does not contain encoded binary data.");
}
// Skip ahead to the actual payload
bytesRead += srcStream.skip(BMP_SIZE_HEADER - bytesRead); // Skip the rest of the header
// READ PAYLOAD
if (payloadLength > 0) {
int rowPaddingLength = 4 - (imageWidth*3 % 4); // Padding at row end, row length must be divisible by 4
int rowLength = imageWidth*3; // Row width is 3x the image width (RGB coding)
// System.out.println("payloadLength = "+payloadLength);
// System.out.println("imageWidth = "+imageWidth);
// System.out.println("rowPaddingLength = "+rowPaddingLength);
// System.out.println("rowLength = "+rowLength);
byte[] row = new byte[rowLength];
int read;
int restOfPayload = payloadLength;
while ((read = srcStream.read(row)) != -1) {
if (restOfPayload >= read) {
destStream.write(row, 0, read); // Write to output stream
srcStream.skip(rowPaddingLength); // Skip bitmap padding (if any)
restOfPayload -= read;
}
else {
destStream.write(row, 0, restOfPayload); // Write the last bytes
break;
}
}
}
srcStream.close();
destStream.close();
}
/**
* Write an integer to a byte array (as little endian) at a
* specific offset.
*/
private static void writeIntLE(byte[] bytes, int startoffset, int value) {
bytes[startoffset] = (byte)(value);
bytes[startoffset+1] = (byte)(value >>> 8);
bytes[startoffset+2] = (byte)(value >>> 16);
bytes[startoffset+3] = (byte)(value >>> 24);
}
/**
* Read an integer value from a 4-byte array (as little endian).
*/
private static int toIntLE(byte[] value) {
return ((value[3] & 0xff) << 24) |
((value[2] & 0xff) << 16) |
((value[1] & 0xff) << 8) |
(value[0] & 0xff);
}
/**
* Encode/decode a bitmap from the command line.
*
* <p><b>Syntax:</b><br />
* <tt>BitmapEncoder encode SRCFILE DESTFILE.bmp<br />
* <tt>BitmapEncoder decode SRCFILE.bmp DESTFILE
*/
public static void main(String[] args) throws IOException {
if (args.length >= 2 && "encode".equals(args[0])) {
BitmapEncoder.encodeToBitmap(new File(args[1]), new File(args[2]));
}
else if (args.length >= 2 && "decode".equals(args[0])) {
BitmapEncoder.decodeFromBitmap(new File(args[1]), new File(args[2]));
}
else {
System.out.println("Usage: BitmapEncoder encode SRCFILE DESTFILE.bmp");
System.out.println(" BitmapEncoder decode SRCFILE.bmp DESTFILE");
}
}
}
这篇关于将加密图像以byte []转换为BufferedImage，而不进行解密的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！
查看全文
