CODEWITHSUNDEEP
rustaescbc-moderust-crypto
Scarface
Scarface

Reputation: 407

Rust AES CBC Decryption Failing - UnPad Error

I have written a Rust code to decrypt a string/s which is encrypted by a Java program. But I am seeing error when decrypting some strings.

In java program, it uses following functions to encrypt and decrypt.

import javax.crypto.Cipher;
import javax.crypto.spec.IvParameterSpec;


private static final byte[] IV_BYTES = new byte[16];
private static final IvParameterSpec IV_PARAMETER_SPEC = new IvParameterSpec(IV_BYTES);
protected static final String AES_CBC_PKCS5_PADDING = "AES/CBC/PKCS5Padding";

private static void initEncr() {
        try {
            cipherEnc.set(Cipher.getInstance(AES_CBC_PKCS5_PADDING));
            cipherEnc.get().init(Cipher.ENCRYPT_MODE, getDek(), IV_PARAMETER_SPEC);
        } catch (Throwable e) {
            throw new UDFException("Error initializing encrypt cipher: " + e.getMessage(), e);
        }
    }

private static void initDecr() {
        try {
            cipherDec.set(Cipher.getInstance(AES_CBC_PKCS5_PADDING));
            cipherDec.get().init(Cipher.DECRYPT_MODE, getDek(), IV_PARAMETER_SPEC);
        } catch (Throwable e) {
            throw new UDFException("Error initializing decrypt cipher: " + e.getMessage(), e);
        }
    }

I have two implementations of Rust code to decrypt a string

  1. Which is rust-crypto lib, which is deprecated and not maintained any more(last commit was 8 years ago).
  2. aes and cbc lib from RustCrypto repo which is latest and actively maintained.

I am trying to decrypt below strings

string1:

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

string2

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

script1 was successful in decrypting the string, but script2 is failing with Unpad error. Error: called Result::unwrap() on an Err value: UnpadError at d_str.unwrap() line.

I want to use script2 as it is actively maintained and recommended.

Script1

dependencies:
base64 = "0.22.0"
rust-crypto = "^0.2"

extern crate crypto;

use crypto::{ buffer, aes, blockmodes };
use crypto::buffer::{ ReadBuffer, WriteBuffer, BufferResult };
use base64::prelude::*;
use crypto::symmetriccipher::Decryptor;


struct Decrypt {
    key: Vec<u8>,
    iv: [u8; 16],
}

impl Decrypt {

    fn new(key: &str) -> Self {
        Self {
            key: BASE64_STANDARD.decode(key).unwrap(),
            iv: [0; 16], // Default value for iv
        }
    }

    fn decryptor(&self) -> Box<dyn Decryptor>{
        let mut decryptor = aes::cbc_decryptor(
            aes::KeySize::KeySize256,
            self.key.as_slice(),
            &self.iv,
            blockmodes::PkcsPadding);
        decryptor
    }

    fn decrypt(&self, encrypted_data: &str) -> String {

        let encrypted_data = BASE64_STANDARD.decode(encrypted_data).unwrap();

        let mut decryptor = self.decryptor();

        let mut final_result = Vec::<u8>::new();
        let mut read_buffer = buffer::RefReadBuffer::new(encrypted_data.as_slice());
        let mut buffer = [0; 4096];
        let mut write_buffer = buffer::RefWriteBuffer::new(&mut buffer);

        loop {
            let result = decryptor.decrypt(&mut read_buffer, &mut write_buffer, true).unwrap();
            final_result.extend(write_buffer.take_read_buffer().take_remaining().iter().map(|&i| i));
            match result {
                BufferResult::BufferUnderflow => break,
                BufferResult::BufferOverflow => { }
            }
        }

        String::from_utf8(final_result).unwrap()
    }
}

Script2

dependencies:
aes = "0.8.4"
base64 = "0.22.1"
cbc = "0.1.2"

use aes::Aes256;
use aes::cipher::{block_padding::Pkcs7, BlockDecryptMut, KeyIvInit};

type Aes256CbcDec = cbc::Decryptor<aes::Aes256>;

use base64::prelude::*;
use cbc::Decryptor;



struct Decrypt {
    key: Vec<u8>,
    iv: [u8; 16],
}

impl Decrypt {

    fn new(key: &str) -> Self {
        Self {
            key: BASE64_STANDARD.decode(key).unwrap(),
            iv: [0; 16], // Default value for iv
        }
    }

    fn decryptor(&self) -> Decryptor<Aes256>{
        let decryptor = Aes256CbcDec::new_from_slices(
            self.key.as_slice(),
            &self.iv,
        ).unwrap();
        decryptor
    }

    fn decrypt(&self, encrypted_data: &str) -> String {

        let encrypted_data = BASE64_STANDARD.decode(encrypted_data).unwrap();

        let mut decryptor = self.decryptor();
        let mut buf = [0u8; 4096];
        let d_str = decryptor.decrypt_padded_b2b_mut::<Pkcs7>(&encrypted_data,
                                                              &mut buf);
        let  res = d_str.unwrap().to_vec();

        String::from_utf8(res).unwrap()
    }
}

Upvotes: -1

Views: 493

Answers (1)

Scarface
Scarface

Reputation: 407

I found out that the UnPad error is occurring due to limited amount of buffer size. In script2 the buffer size is set to 4096 , but the encrypted string length is more than that. TO address the issue, I have changed the code to use dynamic buffer size based on the length of encrypted string and passed this buffer to decryption object..

let buf_size = encrypted_data.len();
let mut buf = vec![0u8; buf_size];
let d_str = match decryptor.decrypt_padded_b2b_mut::<Pkcs7>(&encrypted_data,
                                                              &mut buf) {
            Ok(ds) => ds,
            Err(err) => {
                println!("decryption error: {:?}", err);
                return Err(DecryptError::DecryptError)
            }
        };
let  final_result = d_str.to_vec();

String::from_utf8(final_result).map_err(DecryptError::Utf8Error)

This change solved the UnPad Error.

Upvotes: 0

Related Questions