0

我正在尝试加密 android 上的图像，将它们发送到服务器以便处理它们。服务器必须解密收到的消息。我已经在这个问题中发布了代码

我在 Android 端调用了加密函数，在 java 服务器端调用了解密函数（图像通过 TCP 发送）。

但是，我收到错误：

javax.crypto.BadPaddingException: Given final block not properly padded

我在android上输出密钥并得到：

 javax.crypto.spec.SecretKeySpec@652

而在 Java 服务器上（使用 Netbeans 开发）我得到： 

javax.crypto.spec.SecretKeySpec@148dd

我认为填充不同，所以我使用了

AES/ECB/PKCS5Padding

而不是 AES

但 Java 服务器输出错误：

should use AES.

我该如何解决这个问题？

对于在 android 端发送：

 public void send(Bitmap mRgbImage1_array, int port_number)
        throws IOException {

socket = new Socket("192.168.0.107", port_number);
boolean encrypt = HomeScreen.checkbox2.isChecked();
ByteArrayOutputStream stream = new ByteArrayOutputStream();

mRgbImage1_array.compress(CompressFormat.JPEG, 100, stream);
InputStream photoStream = new ByteArrayInputStream(stream.toByteArray());
BufferedInputStream bis = new BufferedInputStream(photoStream);
byte[] mybytearray = new byte[photoStream.available()];
bis.read(mybytearray, 0, mybytearray.length);
photoStream.close();

if(encrypt)
   {
 try {
byte[] dst = Security.encrypt(mybytearray);
mybytearray = new byte[10000];
for(int i=0; i<dst.length;i++)
{
     mybytearray[i] = dst[i];   
}

 } catch (Exception e1) {
    /// TODO Auto-generated catch block
    e1.printStackTrace();
}

}
    os = socket.getOutputStream();
    os.write(mybytearray);
            os.flush();
    os.close();
if (os != null)
{
try {
os.close();
    } 

    catch (IOException e) 
       {
            // TODO Auto-generated catch block
            e.printStackTrace();
    }
 }

}

在 Java 服务器端接收：

    public static void receive(int port_number) {
    boolean received = false;

    Socket socket = null;
    InputStream is = null;
    int bytesRead;
    int current = 0;

    BufferedOutputStream bos = null;
    try {
        if (serverSocket == null) {
            serverSocket = new ServerSocket(port_number);
        }
        System.out.println("Listening :" + port_number);
    } catch (IOException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }

    while (!received) {
        try {
            socket = serverSocket.accept();
            InetAddress ip = socket.getInetAddress();
            String[] ip1 = ip.toString().split("/");
            ip2 = ip1[1];
            System.out.println("ip is " + ip2);
            byte[] mybytearray = new byte[10000000];
            is = socket.getInputStream();
            FileOutputStream fos = new    FileOutputStream("source-image.jpeg");
            bos = new BufferedOutputStream(fos);
            bytesRead = is.read(mybytearray, 0, mybytearray.length);
           current = bytesRead;
            do {
                bytesRead =
                        is.read(mybytearray, current, (mybytearray.length - current));
                if (bytesRead >= 0) {
                    current += bytesRead;
                }

            } while (bytesRead > -1);
if(Networker.should_encrypt)
            {
         try {
     mybytearray = Security1.decrypt(mybytearray);
        } catch (Exception e1) {
            /// TODO Auto-generated catch block
            e1.printStackTrace();
        }
            }
            bos.write(mybytearray, 0, current);
            bos.flush();
            bos.close();

            received = true;
        } catch (IOException ex) {
            Logger.getLogger(MyServer1.class.getName()).log(Level.SEVERE, null, ex);
        } finally {
            if (socket != null) {
                try {
                    socket.close();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
            if (is != null) {
                try {
                    is.close();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }
    }
   }
4

1 回答 1

2

我相信这是问题所在：

mybytearray = Security1.decrypt(mybytearray);

这总是会解密 10000000 个字节，即使您实际上只写入了少量数据。您应该更改decrypt方法以说明要解密多少数据，然后调用doFinal(byte[], int, int).

我还建议尝试以流方式处理加密/解密，而不是预先分配 10MB（这在大多数情况下会很浪费，在其他情况下可能太短），但这是一个更大的变化。

此外，这在加密代码中是一个坏主意：

byte[] mybytearray = new byte[photoStream.available()];
bis.read(mybytearray, 0, mybytearray.length);
photoStream.close();

您假设可用于开始的数量是整个文件。情况可能并非如此。您通常应该循环，从文件流中读取并写入加密流。哦，close()调用应该在 finally 块中。

如果您真的ByteArrayOutputStream想在一次调用中完成所有加密/解密，您可以循环读取文件或网络流并写入available(). 然后用于ByteArrayOutputStream.toByteArray()获取正确大小的字节数组。（诚​​然，这涉及额外的副本。）

于 2012-05-12T17:50:02.123 回答