private byte[] cipherKey;
private CipherService cipherService = new AesCipherService();

public byte[] encrypt(byte[] serialized) {
    ByteSource byteSource = cipherService.encrypt(serialized, cipherKey);
    return byteSource.getBytes();
}

public byte[] decrypt(byte[] encrypted) {
    ByteSource byteSource = cipherService.decrypt(encrypted, cipherKey);
    return byteSource.getBytes();
}

public class AesCipherService extends DefaultBlockCipherService {
    private static final String ALGORITHM_NAME = "AES";

    public AesCipherService() {
        super("AES");
        this.setMode(OperationMode.GCM);
        this.setStreamingMode(OperationMode.GCM);
        this.setPaddingScheme(PaddingScheme.NONE);
    }

    protected AlgorithmParameterSpec createParameterSpec(byte[] iv, boolean streaming) {
        return (AlgorithmParameterSpec)((!streaming || !OperationMode.GCM.name().equals(this.getStreamingModeName())) && (streaming || !OperationMode.GCM.name().equals(this.getModeName())) ? super.createParameterSpec(iv, streaming) : new GCMParameterSpec(this.getKeySize(), iv));
    }
}

public ByteSource encrypt(byte[] plaintext, byte[] key) {
    byte[] ivBytes = null;
    boolean generate = this.isGenerateInitializationVectors(false);
    if (generate) {
        ivBytes = this.generateInitializationVector(false);
        if (ivBytes == null || ivBytes.length == 0) {
            throw new IllegalStateException("Initialization vector generation is enabled - generated vector cannot be null or empty.");
        }
    }

    return this.encrypt(plaintext, key, ivBytes, generate);
}

protected byte[] generateInitializationVector(boolean streaming) {
    int size = this.getInitializationVectorSize();
    String msg;
    if (size <= 0) {
        msg = "initializationVectorSize property must be greater than zero.  This number is typically set in the " + CipherService.class.getSimpleName() + " subclass constructor.  Also check your configuration to ensure that if you are setting a value, it is positive.";
        throw new IllegalStateException(msg);
    } else if (size % 8 != 0) {
        msg = "initializationVectorSize property must be a multiple of 8 to represent as a byte array.";
        throw new IllegalStateException(msg);
    } else {
        int sizeInBytes = size / 8;
        byte[] ivBytes = new byte[sizeInBytes];
        SecureRandom random = this.ensureSecureRandom();
        random.nextBytes(ivBytes);
        return ivBytes;
    }
}

private ByteSource encrypt(byte[] plaintext, byte[] key, byte[] iv, boolean prependIv) throws CryptoException {
        int MODE = true;
        byte[] output;
        if (prependIv && iv != null && iv.length > 0) {
            byte[] encrypted = this.crypt(plaintext, key, iv, 1);
            output = new byte[iv.length + encrypted.length];
            System.arraycopy(iv, 0, output, 0, iv.length);
            System.arraycopy(encrypted, 0, output, iv.length, encrypted.length);
        } else {
            output = this.crypt(plaintext, key, iv, 1);
        }

        if (log.isTraceEnabled()) {
            log.trace("Incoming plaintext of size " + (plaintext != null ? plaintext.length : 0) + ".  Ciphertext byte array is size " + (output != null ? output.length : 0));
        }

        return Util.bytes(output);
    }

public ByteSource decrypt(byte[] ciphertext, byte[] key) throws CryptoException {
    byte[] encrypted = ciphertext;
    byte[] iv = null;
    if (this.isGenerateInitializationVectors(false)) {
        try {
            int ivSize = this.getInitializationVectorSize();
            int ivByteSize = ivSize / 8;
            iv = new byte[ivByteSize];
            System.arraycopy(ciphertext, 0, iv, 0, ivByteSize);
            int encryptedSize = ciphertext.length - ivByteSize;
            encrypted = new byte[encryptedSize];
            System.arraycopy(ciphertext, ivByteSize, encrypted, 0, encryptedSize);
        } catch (Exception var8) {
            String msg = "Unable to correctly extract the Initialization Vector or ciphertext.";
            throw new CryptoException(msg, var8);
        }
    }

    return this.decrypt(encrypted, key, iv);
}

private ByteSource decrypt(byte[] ciphertext, byte[] key, byte[] iv) throws CryptoException {
        if (log.isTraceEnabled()) {
            log.trace("Attempting to decrypt incoming byte array of length " + (ciphertext != null ? ciphertext.length : 0));
        }

        byte[] decrypted = this.crypt(ciphertext, key, iv, 2);
        return decrypted == null ? null : Util.bytes(decrypted);
    }

    private Cipher newCipherInstance(boolean streaming) throws CryptoException {
        String transformationString = this.getTransformationString(streaming);

        try {
            return Cipher.getInstance(transformationString);
        } catch (Exception var5) {
            String msg = "Unable to acquire a Java JCA Cipher instance using " + Cipher.class.getName() + ".getInstance( \"" + transformationString + "\" ). " + this.getAlgorithmName() + " under this configuration is required for the " + this.getClass().getName() + " instance to function.";
            throw new CryptoException(msg, var5);
        }
    }

import os,base64,uuid
from Crypto.Cipher import AES
def decode(s):
    global key
    BS   = AES.block_size
    mode =  AES.MODE_GCM
    cipher=base64.b64decode(s)
    iv=cipher[0:16]
    enc=cipher[16:-16]
    tag=cipher[-16:]
    decryptor = AES.new(base64.b64decode(key), mode, iv)
    plaintext=decryptor.decrypt_and_verify(enc,tag)
    print("decode_plaintext:")
    print(plaintext)
    base64_plaintext=base64.b64encode(plaintext).decode()
    print ("\nbase64_plaintext:\n"+base64_plaintext+"\n")
    return base64_plaintext