So I have finally got this working. I stopped being lazy and spent the time to actually read and understand what the MaapiCrypto.decrypt method is doing. Decryption is the reverse of encryption so by understanding the decryption method, we can write an encryption method to get the data in the format that the decrypt method expects and can handle.
The (interesting part of the) decrypt method (and bcopy method that the decrypt method uses) is defined as follows - from MaapiCrypto.java:
private void bcopy(byte[] to, byte[] from, int tostart, int fromstart, int length) {
for (int i = 0; i < length; i++) {
to[tostart + i] = from[fromstart + i];
}
}
public String decrypt(String encryptedString) throws MaapiException {
...
try {
// Decode base64 to get bytes
decodedBytes = Base64.decode(encryptedString.substring(3));
if (encryptedString.charAt(1) == '8') {
IV = new byte[16];
bcopy(IV, decodedBytes, 0, 0, 16);
encryptedBytesLength = decodedBytes.length - 16;
encryptedBytes = new byte[encryptedBytesLength];
bcopy(encryptedBytes, decodedBytes, 0, 16,
encryptedBytesLength);
} else {
// old-style with fixed ivec, "shouldn't happen"
IV = aesIV;
encryptedBytes = decodedBytes;
}
AesEncrypter aesEnc = new AesEncrypter(aesKey, IV);
decryptedStr = aesEnc.decrypt(encryptedBytes);
...
So my last post and the NSO documentation, we know that the encrypted string starts with the "$8$" prefix. The line below is stripping out this prefix and decoding the string from Base64 encoding - therefore we know that the last thing two things we need to do when creating our encrypted strings are to encode it in Base64 and then add the "$8$" prefix.
decodedBytes = Base64.decode(encryptedString.substring(3));
We then fall into the first if case because our prefix string has '8' at index = 1. This section of the code is separating the initial 16 bytes into an IV (Initialization Vector) byte array from the remaining bytes, the encryptedBytes, by using the bcopy method. So now we know our encrypted data is a byte array of the initialization vector used to encrypt the data (16 bytes long) followed by the encrypted data itself. We also know that the encryption algorithm is AES/CFB128 from my last post and the NSO documentation (and looking at the AesEncrypter implementation), so we have enough information to write our own encrypt method, as follows:
private static String encrypt(Maapi maapi, String str) throws Exception {
MaapiCrypto crypto = new MaapiCrypto(maapi);
byte[] IV;
byte[] encryptedBytes;
byte[] encodedBytes;
IV = new byte[16];
new Random().nextBytes(IV);
IvParameterSpec ivSpec = new IvParameterSpec(IV);
SecretKeySpec skeySpec = new SecretKeySpec(crypto.getAesKey(), "AES");
Cipher cipher = Cipher.getInstance("AES/CFB/NoPadding");
cipher.init(Cipher.ENCRYPT_MODE, skeySpec, ivSpec);
encryptedBytes = cipher.doFinal(str.getBytes());
encodedBytes = new byte[encryptedBytes.length + 16];
bcopy(encodedBytes, IV, 0, 0, 16);
bcopy(encodedBytes, encryptedBytes, 16, 0, encryptedBytes.length);
return "$8$" + Base64.encodeBytes(encodedBytes);
}
This method takes a Maapi instance and the string to encrypt as input arguments. Using the input Maapi instance, we create a CryptoMaapi instance, this is to get the AES keys to encrypt the input string with shortly. We then create and initialize an initialization vector (IV) 16 bytes long with random values. This IV and the AES keys from the CryptoMaapi instance are used to initialize a cipher using the AES/CFB128 algorithm. This cipher is then used to encrypt our input string into the encryptedBytes byte array. The encodedBytes byte array is then initialized to be the length of the encryptedBytes plus the IV byte arrays. The next two calls to bcopy pack the encodedBytes byte array with first the IV and then the encryptedBytes. All we need to do then is return this encryptedBytes byte array encoded as Base64 with the expected "$8$" prefix and we're done.
To test this you can use the CryptoMaapi.decrypt() method and verify that it returns your initial input string.
I am unsure why the CryptoMaapi class doesn't contain an encrypt method, IMO it really should and it would look very similar to the above. Would appreciate if someone from NSO could comment on this.
As a side note, in my post above, I was missing the Base64.encodeBytes() function calls. The old encryption method I was using (with "$4$" prefix) work but this isn't accepted by the Maapi API when sent in the ConfBuf; only strings with the "$8$" prefix/IV packed byte array encryption method appear to be accepted.
