compcrypt.c

Go to the documentation of this file.

/** \file compress.c]

  \brief Implements compression and decompression

******************************************************************************/

#include "evl.h"
#include "cryp.h"

/**AutomaticStart*************************************************************/

/*---------------------------------------------------------------------------*/
/* Static function prototypes                                                */
/*---------------------------------------------------------------------------*/

static Cryp_Aes_t *computeAes (void **functionStatePtr, void *functionArgument);
static void swap (Evl_Manager_t *mgr, Pkt_ProcessPkt_t *pp, void **functionStatePtr, void *functionArgument);
static void printPayload (Evl_Manager_t *mgr, Pkt_ProcessPkt_t *pp, void **functionStatePtr, void *functionArgument);
static void morphSrcIp (Evl_Manager_t *mgr, Pkt_ProcessPkt_t *pp, void **functionStatePtr, void *functionArgument);

/**AutomaticEnd***************************************************************/

/**
  * \brief Compress/decompress a packet - changes argument, assumes
  * enough memory has been allocated in the packet itself.  Leaves
  * only the ethernet header uncompressed.  Using the LZO algorithm on 
  * a single packet at a time.
  *
  *     function prototype action->ucodeFunction( mgr, pp, & action->ucodeFunctionState );
  */

int
Ucode_CompressDecompress (Pkt_EthernetHdr_t * pkt,
              int length, bool doCompress)
{
  char tmpbuf[1518];        /// \todo replace by maximum sized header
  int newLength = 1518;
  char *payload = ((char *) pkt) + sizeof (Pkt_EthernetHdr_t);
  int payloadLength = length - sizeof (Pkt_EthernetHdr_t);

  memcpy (tmpbuf, payload, payloadLength);
  if (doCompress == true)
    {
      /// \todo commented out because of linker problems
      // compress( tmpbuf, & newLength, payload, payloadLength );
    }
  else
    {
      /// \todo commented out because of linker problems
      // uncompress( tmpbuf, & newLength, payload, payloadLength );
    }
  memcpy (payload, tmpbuf, newLength);

  return newLength + sizeof (Pkt_EthernetHdr_t);
}


/**
  * \brief Decompress a packet.
  */

int
Ucode_Decompress (Evl_Manager_t * mgr,
          Pkt_ProcessPkt_t * pp, void **functionStatePtr)
{
  Pkt_EthernetHdr_t *pkt = pp->pkt;
  int length = pp->length;
  if (pkt->type == Pkt_L3ProtComp_c)
    {
      int result = Ucode_CompressDecompress (pkt, length, false);
      pkt->type = Pkt_L3ProtIp_c;
    }
  else
    {
      // nothing to do here
      return length;
    }
}


/**
  * \brief Compress a packet.
  *
  * Assuming packet is IP - in particular we set a new ethernet
  * type field to denote the packet is compressed, and to revert
  *     we must know what the orig type was.  (Perhaps we can play tricks
  * with setting a single bit?)
  */

int
Ucode_Compress (Evl_Manager_t * mgr,
        Pkt_ProcessPkt_t * pp, void **functionStatePtr)
{
  Pkt_EthernetHdr_t *pkt = pp->pkt;
  int length = pp->length;
  /// \todo choosing this size to ensure no overruns.
  /// 
  /// will change with jumbo frames.
  /// see discussion about max increase in pkt size with lzo here
  /// http://www.oberhumer.com/opensource/lzo/lzofaq.php
  char tmpbuf[2048];
  memcpy (tmpbuf, pkt, length);
  int newLength =
    Ucode_CompressDecompress ((Pkt_EthernetHdr_t *) tmpbuf, length, true);
  if (newLength >= length)
    {
      // do nothing
      return length;
    }
  else
    {
      char *pktPayload = ((char *) pkt) + sizeof (Pkt_EthernetHdr_t);
      char *tmpBufPayload = ((char *) tmpbuf) + sizeof (Pkt_EthernetHdr_t);
      memcpy (pktPayload, tmpBufPayload,
          newLength - sizeof (Pkt_EthernetHdr_t));
      pkt->type = Pkt_L3ProtComp_c; // to mark it as compressed
      return newLength;
    }
}


/**
  * \brief  Encrypt a packet. 
  *
  * Only for Ip packets.  Keeps header intact, does aes on payload.  Not going
  * to encrypt payload shorter than 16 bytes.
  *
  * Returns 1 on succ encrypt, 0 on payload being too short.
  * 
  */

void
Ucode_Crypto (Cryp_Aes_t * aes, Pkt_ProcessPkt_t * pp, boolean doEncrypt)
{
  Pkt_EthernetHdr_t *anEthpkt = pp->pkt;
  assert (Pkt_EthernetReadL3Type (anEthpkt) == Pkt_L3ProtIp_c);
  int length = pp->length;

  Pkt_IpHdr_t *ip = Pkt_EthernetExtractIp (anEthpkt);
  char *payload = Pkt_IpExtractPayload (ip);
  int bytesToEncode = length - (payload - (char *) anEthpkt);

  if (doEncrypt == true)
    {
      Cryp_AesEncrypt (payload, payload, bytesToEncode, aes);
    }
  else
    {
      Cryp_AesDecrypt (payload, payload, bytesToEncode, aes);
    }
}


/**
  * \brief  Encrypt a packet. 
  * 
  */

void
Ucode_EncryptPkt (Evl_Manager_t * mgr,
          Pkt_ProcessPkt_t * pp,
          void **functionStatePtr, void *functionArgument)
{
  Pkt_EthernetHdr_t *pkt = pp->pkt;
  int length = pp->length;

  Cryp_Aes_t *aes = computeAes (functionStatePtr, functionArgument);

  Ucode_Crypto (aes, pp, true);
  return;
}


/**
  * \brief Get the aes structure from key.
  */

static Cryp_Aes_t *
computeAes (void **functionStatePtr, void *functionArgument)
{
  st_table *hash = (st_table *) * functionStatePtr;
  if (hash == NIL (st_table))
    {
      hash = st_init_table (st_ptrcmp, st_ptrhash);
      *functionStatePtr = hash;
    }
  Cryp_Aes_t *aes;
  char *key = (char *) functionArgument;
  if (!st_lookup (hash, (char *) key, (char **) &aes))
    {
      aes = Cryp_AesAlloc (key);
    }
  return aes;
}

/**
  * \brief  Decrypt a packet. 
  * 
  */

void
Ucode_DecryptPkt (Evl_Manager_t * mgr,
          Pkt_ProcessPkt_t * pp,
          void **functionStatePtr, void *functionArgument)
{
  Pkt_EthernetHdr_t *pkt = pp->pkt;
  int length = pp->length;
  Cryp_Aes_t *aes = computeAes (functionStatePtr, functionArgument);
  Ucode_Crypto (aes, pp, false);
  return;
}

/**
  * \brief  Decrypt a packet. 
  *
  * Directly calls the function Ucode_DecryptPkt - we need to do it this
  * way to be able to export the name decrypt to the sheel
  * 
  */

int
decrypt (Evl_Manager_t * mgr,
     Pkt_ProcessPkt_t * pp,
     void **functionStatePtr, void *functionArgument)
{
  Ucode_DecryptPkt (mgr, pp, functionStatePtr, functionArgument);
  return 0; 
}


/**
  * \brief  Encrypt a packet. 
  *
  * Directly calls the function Ucode_EncryptPkt - we need to do it this
  * way to be able to export the name encrypt to the shell
  * 
  */

int
encrypt ( Evl_Manager_t * mgr,
      Pkt_ProcessPkt_t * pp,
      void **functionStatePtr, 
      void *functionArgument)
{
  Ucode_EncryptPkt (mgr, pp, functionStatePtr, functionArgument);
  return 0; 
}


/** \brief Swap first two payload bytes, used for testing */

static void
swap (Evl_Manager_t * mgr,
      Pkt_ProcessPkt_t * pp, void **functionStatePtr, void *functionArgument)
{
  char *payload = ((char *) pp->pkt) + 54;
  char tmp = *payload;
  *payload = *(payload + 1);
  *(payload + 1) = tmp;
}


/** \brief print payload, packet assumed to be IP, used for testing */

static void
printPayload (Evl_Manager_t * mgr,
          Pkt_ProcessPkt_t * pp,
          void **functionStatePtr, void *functionArgument)
{
  char *payload = ((char *) pp->pkt) + 54;
  printf ("byte 0 = %c, byte 1 = %c; mesg %s\n", *payload, *(payload + 1),
      (char *) functionArgument);
}


/** \brief Change source IP, used for testing */

static void
morphSrcIp (Evl_Manager_t * mgr,
        Pkt_ProcessPkt_t * pp,
        void **functionStatePtr, void *functionArgument)
{
  Pkt_IpHdr_t *ip = ((char *) pp->pkt) + 14;
  ip->sourceIp = 0;
}