Skip to main content

MTE Fixed Length Add-On Code Samples

Purpose​

Samples expand on our "Examples" by providing longer snippets of code demonstrating entire processes. The objective of an MTE fixed length "Examples" is to provide samples of how to use the MTE fixed length Encoder and MTE Decoder.

The Fixed Length Add-On is a replacement for the core encoder that ensures all messages are encoded to a fixed length. If the input is too long, it will be truncated to the fixed length, if the input is shorter than the fixed length random padding bytes will be added to the end, creating more obfuscation. See code decoder samples for decoding examples.

The Fixed length add-on must be used if using the sequencing verifier with MTE and wish to decode asynchronously or recover from missing MTE packets. For more information, please see the official MTE developer guides.

Simple MTE FLEN Console Demo​

using System;
using System.Text;

namespace MTE {
  class demoCsFlen {

    // The fixed length each MTE packet will be equal.
    // To avoid data loss this number should be larger
    // than any anticipated input data.
    private const int fixedBytes = 8;

    // Command line arguments. Default any that are not passed in:
    // [0] = input data to be tokenized.
    static int Main(string[] args) {
      // Status.
      MteStatus status;

      // Input.
      string input = args.Length > 0 ? args[0] : "hello";

      // Personalization string.
      string personal = "demo";

      // Initialize MTE license. If a license code is not required (e.g., trial
      // mode), this can be skipped. This demo attempts to load the license
      // info from the environment if required.
      MteBase baseObj = new MteBase();
      if (!baseObj.InitLicense("YOUR_COMPANY", "YOUR_LICENSE")) {
        string company = Environment.GetEnvironmentVariable("MTE_COMPANY");
        string license = Environment.GetEnvironmentVariable("MTE_LICENSE");
        if (company == null || license == null ||
            !baseObj.InitLicense(company, license)) {
          status = MteStatus.mte_status_license_error;
          Console.Error.WriteLine("License init error ({0}): {1}",
                                  baseObj.GetStatusName(status),
                                  baseObj.GetStatusDescription(status));
          return (int)status;
        }
      }

      // Output original data.
      Console.WriteLine("Original data: {0}", input);

      // Create the Encoder and Decoder.
      MteFlenEnc encoder = new MteFlenEnc(fixedBytes);
      MteDec decoder = new MteDec();

      // Create all-zero entropy for this demo. The nonce will also be set to 0.
      // This should never be done in real applications.
      int entropyBytes = encoder.GetDrbgsEntropyMinBytes(encoder.GetDrbg());
      byte[] entropy = new byte[entropyBytes];

      // Instantiate the Encoder.
      encoder.SetEntropy(entropy);
      encoder.SetNonce(0);
      status = encoder.Instantiate(personal);
      if (status != MteStatus.mte_status_success) {
        Console.Error.WriteLine("Encoder instantiate error ({0}): {1}",
                                encoder.GetStatusName(status),
                                encoder.GetStatusDescription(status));
        return (int)status;
      }

      // Encode the input.
      string encoded = encoder.EncodeB64(input, out status);
      if (status != MteStatus.mte_status_success) {
        Console.Error.WriteLine("Encode error ({0}): {1}",
                                encoder.GetStatusName(status),
                                encoder.GetStatusDescription(status));
        return (int)status;
      }

      // Display the message.
      Console.WriteLine("Base64 message: {0}", encoded);

      // Instantiate the Decoder.
      decoder.SetEntropy(entropy);
      decoder.SetNonce(0);
      status = decoder.Instantiate(personal);
      if (status != MteStatus.mte_status_success) {
        Console.Error.WriteLine("Decoder instantiate error ({0}): {1}",
                                decoder.GetStatusName(status),
                                decoder.GetStatusDescription(status));
        return (int)status;
      }

      // Decode the message.
      string decoded = decoder.DecodeStrB64(encoded, out status);
      if (decoder.StatusIsError(status)) {
        Console.Error.WriteLine("Decode error ({0}): {1}",
                                decoder.GetStatusName(status),
                                decoder.GetStatusDescription(status));
        return (int)status;
      } else if (status != MteStatus.mte_status_success) {
        Console.Error.WriteLine("Decode warning ({0}): {1}",
                                decoder.GetStatusName(status),
                                decoder.GetStatusDescription(status));
      }

      // Output the decoded data.
      Console.WriteLine("Decoded data: {0}", decoded);

      // Compare the decoded data against the original data.
      if (decoded == input) {
        Console.WriteLine("The original data and decoded data match.");
      } else {
        Console.WriteLine("The original data and decoded data DO NOT match.");
        return -1;
      }

      // Success.
      return 0;
    }
  }
}