Examples

Talk is cheap. Show me the code!

Below there are some implementation examples

Note

All communication between AnnA and the Client travels with 3DES symmetric encryption using CBC (Cipher Block Chaining) mode with block size of 64 and key size of 192 bytes

See more about the encryption AnnA uses

C#/.NET Framework

Tip

For .NET Framework and .NET applications you may want to use the AnnA.Services package available at: https://www.nuget.org/packages/AnnA.Services

  string decKey = "DECRYPTION_KEY";
  string encKey = "ENCRYPTION_KEY";
  string IV = form.Get("ANNAEXEC"); // IV that AnnA will send to you

  // Get post variables values (if any)
  string anotherVar = Decrypt3DES(form.Get("AnotherVar"), decKey, IV);

  string containers = JsonConvert.SerializeObject(
    new List<object>
    {
        new
        {
            PropName = "Container001",
            PropValue = new List<object>
            {
                new
                {
                    PropName = "Type",
                    PropValue = "MESSAGE"
                },
                new
                {
                    PropName = "Phrase",
                    PropValue = "The value of AnotherVar is: " + anotherVar
                }
            }
        }
    }
  );

  // Generate new IV
  TripleDESCryptoServiceProvider cryptoServiceProvider = new TripleDESCryptoServiceProvider();
  cryptoServiceProvider.GenerateIV();
  string newBase64IV = Convert.ToBase64String(cryptoServiceProvider.IV);

  string encryptedContainers = Encrypt3DES(containers, encKey, newBase64IV);
  string newEncryptedBase64IV = Encrypt3DES(newBase64IV, decKey, IV);

  var response = new HttpResponseMessage(HttpStatusCode.OK);
  response.Content = new StringContent(encryptedContainers + IV + newEncryptedBase64IV, Encoding.UTF8, "text/plain");

  return response;

C#/.NET

Tip

For .NET Framework and .NET applications you may want to use the AnnA.Services package available at: https://www.nuget.org/packages/AnnA.Services

  string decKey = "DECRYPTION_KEY";
  string encKey = "ENCRYPTION_KEY";
  string IV = Request.Form["ANNAEXEC"]; // IV that AnnA will send to you

  // Get post variables values (if any)
  string anotherVar = Decrypt3DES(Request.Form["AnotherVar"], decKey, IV);

  string containers = JsonConvert.SerializeObject(
      new List<object>()
      {
          new
          {
              PropName = "Container001",
              PropValue = new List<object>()
              {
                  new
                  {
                      PropName = "Type",
                      PropValue = "MESSAGE"
                  },
                  new
                  {
                      PropName = "Phrase",
                      PropValue = ("The value of AnotherVar is: " + anotherVar)
                  }
              }
          }
      }
  );

  // Generate new IV
  var cryptoServiceProvider = TripleDES.Create();
  cryptoServiceProvider.GenerateIV();

  string newBase64IV = Convert.ToBase64String(cryptoServiceProvider.IV);
  string encryptedContainers = Encrypt3DES(containers, encKey, newBase64IV);
  string newEncryptedBase64IV = Encrypt3DES(newBase64IV, decKey, IV);

  return encryptedContainers + IV + newEncryptedBase64IV;

Java

try {
    String decKey = "DECRYPTION_KEY";
    String encKey = "ENCRYPTION_KEY";
    String receivedIv = request.getParameter("ANNAEXEC"); // IV that AnnA will send to you

    // Get post variables values (if any)
    String anotherVar = request.getParameter("AnotherVar");

    byte[] ivDecoded = Base64.getDecoder().decode(receivedIv);
    byte[] decKeyDecoded = Base64.getDecoder().decode(decKey);
    byte[] encKeyDecoded = Base64.getDecoder().decode(encKey);

    IvParameterSpec iv = new IvParameterSpec(ivDecoded);
    SecretKey dKey = new SecretKeySpec(decKeyDecoded, "DESede");
    SecretKey eKey = new SecretKeySpec(encKeyDecoded, "DESede");

    String decrypted = decrypt(anotherVar, dKey, iv);

    String finalResponse = "[{";
    finalResponse += "\"PropName\":\"Container001\",";
    finalResponse += "\"PropValue\":\"";
    finalResponse += "  [";
    finalResponse += "      {";
    finalResponse += "          \\\"PropName\\\":\\\"Type\\\",";
    finalResponse += "          \\\"PropValue\\\":\\\"MESSAGE\\\"";
    finalResponse += "      },";
    finalResponse += "      {";
    finalResponse += "          \\\"PropName\\\":\\\"Phrase\\\",";
    finalResponse += "          \\\"PropValue\\\":\\\"The value of AnotherVar is: \\\"" + decrypted + "\\\"";
    finalResponse += "      }";
    finalResponse += "  ]\"";
    finalResponse += "}]";

    byte[] randomBytes = new byte[8];
    new Random().nextBytes(randomBytes);
    final IvParameterSpec newIv = new IvParameterSpec(randomBytes);
    String newEncodedIv = new String(Base64.getEncoder().encode(randomBytes));

    finalResponse = encrypt(finalResponse, eKey, newIv);
    String newEncryptedIv = encrypt(newEncodedIv, dKey, iv);
    finalResponse = finalResponse + receivedIv + newEncryptedIv;

    PrintWriter out = response.getWriter();
    out.print(finalResponse);
} catch (NoSuchAlgorithmException | NoSuchPaddingException | InvalidKeyException | InvalidAlgorithmParameterException | UnsupportedEncodingException | IllegalBlockSizeException | BadPaddingException ex) {
    Logger.getLogger(DESExample.class.getName()).log(Level.SEVERE, null, ex);
}

PHP

  function __output_header__($_data)
  {
      header('Content-Type: application/json; charset=utf-8');
      return $_data;
  }

  if ($_SERVER['REQUEST_METHOD'] !== "POST") {
      __output_header__(false, "Invalid request method", null);
  }

  $DecKey = 'DECRYPTION_KEY';
  $EncKey = 'ENCRYPTION_KEY';
  $ReceivedIv = $_POST['ANNAEXEC']; // IV that AnnA will send to you

  // Get post variables values (if any)
  $MyVar1 = $_POST['AnotherVar'];
  $MyVar1 = decrypt3DES($MyVar1, $DecKey, $ReceivedIv);

  $response   = '[';
  $response   .= '  {';
  $response   .= '    "PropName": "Container001",';
  $response   .= '    "PropValue": "[{\"PropName\":\"Type\",\"PropValue\":\"MESSAGE\"},{\"PropName\":\"Phrase\",\"PropValue\":\"The value of AnotherVar is: \"' + MyVar1 + '\"}]"'
  $response   .= '  }'
  $response   .= ']'

  // Generate new IV
  $ivlen = openssl_cipher_iv_length('des-ede3-cbc');
  $newIv = base64_encode(openssl_random_pseudo_bytes(8));
  $response = encrypt3DES($response, $EncKey, $newIv);

  $newEncryptedIv = encrypt3DES($newIv, $DecKey, $ReceivedIv);

  $response = $response . $ReceivedIv . $newEncryptedIv;

  die(__output_header__($response));

GeneXus

  &DecKEY = 'DECRYPTION_KEY'
  &EncKEY = 'ENCRYPTION_KEY'
  &IVRecebido = &HTTPRequest.GetVariable(!'ANNAEXEC') // IV that AnnA will send to you

  // &CryptoDecrypt is type of "CryptoSymmetricEncrypt"
  &CryptoDecrypt.Algorithm = CryptoEncryptAlgorithm.TripleDES
  &CryptoDecrypt.Key = &DecKEY
  &CryptoDecrypt.IV = &IVRecebido

   // Get post variables values (if any)
  &MyVar1 = &HTTPRequest.GetVariable(!'AnotherVar')
  &MyVar1 = &CryptoDecrypt.Decrypt(&MyVar1)

  &Sdt_PropsContainer = new()

  &Sdt_PropsItem = new()
  &Sdt_PropsItem.PropName = !'Type'
  &Sdt_PropsItem.PropValue = !'MESSAGE'

  &Sdt_PropsContainer.Add(&Sdt_PropsItem)

  &Sdt_PropsItem = new()
  &Sdt_PropsItem.PropName = !'Phrase'
  &Sdt_PropsItem.PropValue = 'O valor de "AnotherVar" é: ' + &MyVar1
  &Sdt_PropsContainer.Add(&Sdt_PropsItem) //Adiciono o Container

  &Sdt_PropsToAnna = new()
  &Sdt_PropsItem = new()
  &Sdt_PropsItem.PropName = !'Container001'
  &Sdt_PropsItem.PropValue = &Sdt_PropsContainer.ToJson()

  &Sdt_PropsToAnna.Add(&Sdt_PropsItem)

  &response = &Sdt_PropsToAnna.ToJson() //JSON de resposta ao AnnA

  // Generate new IV
  &CryptoEncrypt = new()
  &CryptoEncrypt.Algorithm = CryptoEncryptAlgorithm.TripleDES
  &CryptoEncrypt.Key = &EncKEY
  &response = &CryptoEncrypt.Encrypt(&response)
  &IVNovo = &CryptoEncrypt.IV

  &IVNovoEncriptado = &CryptoDecrypt.Encrypt(&IVNovo)

  &response = &response + &IVRecebido + &IVNovoEncriptado

  &HTTPResponse.AddString(&response)

Python

  from flask import Flask, request, Response
  from flask_ngrok import run_with_ngrok
  import json
  from Crypto.Cipher import AES, DES3, DES
  from Crypto.Util.Padding import pad, unpad
  from Crypto.Random import get_random_bytes
  from base64 import b64encode, b64decode

  # Initialising a web application with flask
  app = Flask(__name__)

  # For this integration example, NGROK was used to emulate a response server
  run_with_ngrok(app)

  # Encryption method
  def encrypt(data, enckey, iv):
      enckey = b64decode(enckey)
      iv = b64decode(iv)
      cipher = DES3.new(enckey, DES3.MODE_CBC, iv)
      ct_bytes = cipher.encrypt(
          pad(bytes(data, encoding='utf-8'), DES3.block_size))
      ciphertext = b64encode(ct_bytes).decode('utf-8')

      return ciphertext


  # Decryption method
  def decrypt(data, deckey, iv):
      try:
          deckey = b64decode(deckey)
          iv = b64decode(iv)
          data = b64decode(data)
          cipher = DES3.new(deckey, DES3.MODE_CBC, iv)
          pt = unpad(cipher.decrypt(data), DES3.block_size)

          return pt

      except (ValueError, KeyError):
          return 'Incorrect decryption'


  # Get POST AnnA
  @app.route('/get-post', methods=['POST'])
  def receber_post():

      # Encryption Keys
      enckey = 'ENCRYPTION_KEY'
      deckey = 'DECRYPTION_KEY'

      # Retrieving the form sent by AnnA
      data = request.form

      # Recovering the received IV
      ivReceived = data.get('ANNAEXEC')

      # Creating the structure of an AnnA message
      nodeMessage = [
          {
              "PropName": "Alias",
              "PropValue": "msg001"
          },
          {
              "PropName": "Type",
              "PropValue": "MESSAGE"
          },
          {
              "PropName": "Phrase",
              "PropValue": "Hello World!"
          }
      ]

      # Creating the container structure
      container = [
          {
              "PropName": "Container001",
              "PropValue": json.dumps(nodeMessage)
          }
      ]

      # Creating a new IV and encrypting it
      key = get_random_bytes(8)
      cipher = DES.new(key, DES3.MODE_CBC)
      newIV = b64encode(cipher.iv).decode('utf-8')

      # Serialising the container structure and encrypting it
      serialisedContainer = json.dumps(container)
      encryptedSerialisedContainer = encrypt(serialisedContainer, enckey, newIV)

      # Encrypting the new IV
      newIVEncrypted = encrypt(newIV, deckey, ivReceived)

      # Configuring response for AnnA
      replyToAnnA = encryptedSerialisedContainer + ivReceived + newIVEncrypted

      # Replying to AnnA
      response = Response(replyToAnnA, content_type='text/plain')

      # Log
      print('\nData received from AnnA:', data)
      print('\nIV Received:', ivReceived)
      print('\n')
      print('\nNode Message:', nodeMessage)
      print('\nContainer:', container)
      print('\nContainer Serialised:', serialisedContainer)
      print('\nContainer Serialised Encrypted:', encryptedSerialisedContainer)
      print('\n')
      print('\nNew IV:', newIV)
      print('\nNew IV Encrypted:', newIVEncrypted)
      print('\n')
      print('\nReply To AnnA:', replyToAnnA)
      print('\nResponse From AnnA:', response)

      return response

  if __name__ == '__main__':
      app.run()