Python加密/Android解密

Question

我写了两个代码，一个是用Python做的，另一个是在Android（Eclipse）上做的，用于加密和解密。

现在我想用Python加密我的数据，然后把它发送到Android上去解密。

怎么才能让这两个不同的平台进行数据的加密和解密呢？每个平台都有自己的一套加密和解密的方法，那我该怎么让它们互相沟通，发送数据，并且让Android提取出准确的信息呢？

需要帮助！！

Answer 1

TLS可以用来安全地传输数据，而且它的使用方式是兼容的。

Python的ssl服务器端

如果你还使用http协议进行通信，那么已经有一些高级库可以帮你处理所有复杂的细节；你只需要提供客户端和服务器的证书，然后发出合适的请求就行了。

安卓的Https连接

这样可以避免你重新实现很多安全功能，比如前向保密，这些功能实现起来可能很麻烦。

Answer 2

Android Code:
public static final int SALT_LENGTH = 20;
public static final int PBE_ITERATION_COUNT = 1000;

private static final String RANDOM_ALGORITHM = "SHA1PRNG";
private static final String PBE_ALGORITHM = "PBEWithSHA256And256BitAES-CBC-BC";
private static final String CIPHER_ALGORITHM = "AES/CBC/PKCS5Padding";

private static final String TAG = Act.class.getSimpleName();

@Override
public void onCreate(Bundle savedInstanceState) {

    super.onCreate(savedInstanceState);
    setContentView(R.layout.main);

    try {

        String password = "password";
        String plainText = "plaintext message to be encrypted";

        // byte[] salt = generateSalt();
        byte[] salt = "dfghjklpoiuytgftgyhj".getBytes();
        Log.i(TAG, "Salt: " + salt.length + " " + HexEncoder.toHex(salt));
        PBEKeySpec pbeKeySpec = new PBEKeySpec(password.toCharArray(), salt, PBE_ITERATION_COUNT, 256);
        SecretKeyFactory factory = SecretKeyFactory.getInstance(PBE_ALGORITHM);
        SecretKey tmp = factory.generateSecret(pbeKeySpec);
        SecretKey secret = new SecretKeySpec(tmp.getEncoded(), "AES");
        byte[] key = secret.getEncoded();
        Log.i(TAG, "Key: " + HexEncoder.toHex(key));

        // PBEParameterSpec pbeParamSpec = new PBEParameterSpec(salt, ITERATION_COUNT);

        Cipher encryptionCipher = Cipher.getInstance(CIPHER_ALGORITHM);

        // byte[] encryptionSalt = generateSalt();
        // Log.i(TAG, "Encrypted Salt: " + encryptionSalt.length + " " + HexEncoder.toHex(encryptionSalt));
        // PBEParameterSpec pbeParamSpec = new PBEParameterSpec(encryptionSalt, 1000);
        // byte[] iv = params.getParameterSpec(IvParameterSpec.class).getIV();
        Log.i(TAG, encryptionCipher.getParameters() + " ");
        byte[] iv = generateIv();
        IvParameterSpec ivspec = new IvParameterSpec(iv);

        encryptionCipher.init(Cipher.ENCRYPT_MODE, secret, ivspec);
        byte[] encryptedText = encryptionCipher.doFinal(plainText.getBytes());
        Log.i(TAG, "Encrypted: " + HexEncoder.toHex(encryptedText));

        Cipher decryptionCipher = Cipher.getInstance(CIPHER_ALGORITHM);
        decryptionCipher.init(Cipher.DECRYPT_MODE, secret, ivspec);
        byte[] decryptedText = decryptionCipher.doFinal(encryptedText);
        Log.i(TAG, "Decrypted: " + new String(decryptedText));

    } catch (Exception e) {
        e.printStackTrace();
    }

}

private byte[] generateSalt() throws NoSuchAlgorithmException {
    SecureRandom random = SecureRandom.getInstance(RANDOM_ALGORITHM);
    byte[] salt = new byte[SALT_LENGTH];
    random.nextBytes(salt);
    return salt;
}

private byte[] generateIv() throws NoSuchAlgorithmException {
    SecureRandom random = SecureRandom.getInstance(RANDOM_ALGORITHM);
    byte[] iv = new byte[16];
    random.nextBytes(iv);
    return iv;
}

}

Answer 3

Python代码：

def encrypt_file(key, in_filename, out_filename=None, chunksize=64*1024):
    if not out_filename:
        out_filename = in_filename + '.enc'

    iv = ''.join(chr(random.randint(0, 0xFF)) for i in range(16))
    encryptor = AES.new(key, AES.MODE_CBC, iv)
    filesize = os.path.getsize(in_filename)

    with open(in_filename, 'rb') as infile:
        with open(out_filename, 'wb') as outfile:
            outfile.write(struct.pack('<Q', filesize))
            outfile.write(iv)

            while True:
                chunk = infile.read(chunksize)
                if len(chunk) == 0:
                    break
                elif len(chunk) % 16 != 0:
                    chunk += ' ' * (16 - len(chunk) % 16)

                outfile.write(encryptor.encrypt(chunk))

def decrypt_file(key, in_filename, out_filename=None, chunksize=24*1024):
    if not out_filename:
        out_filename = os.path.splitext(in_filename)[0]

    with open(in_filename, 'rb') as infile:
        origsize = struct.unpack('<Q', infile.read(struct.calcsize('Q')))[0]
        iv = infile.read(16)
        decryptor = AES.new(key, AES.MODE_CBC, iv)

        with open(out_filename, 'wb') as outfile:
            while True:
                chunk = infile.read(chunksize)
                if len(chunk) == 0:
                    break
                outfile.write(decryptor.decrypt(chunk))

            outfile.truncate(origsize)