[mirror_edk2.git] / NetworkPkg / IpSecDxe / IpSecSaEngine.c

/** @file\r
  IPsec inbound and outbound traffic processing.\r
\r
  Copyright (c) 2009 - 2010, Intel Corporation. All rights reserved.<BR>\r
\r
  This program and the accompanying materials\r
  are licensed and made available under the terms and conditions of the BSD License\r
  which accompanies this distribution.  The full text of the license may be found at\r
  http://opensource.org/licenses/bsd-license.php.\r
\r
  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
\r
**/\r
\r
#include "IpSecImpl.h"\r
#include "IpSecDebug.h"\r
#include "IpSecCryptIo.h"\r
\r
extern LIST_ENTRY     mConfigData[IPsecConfigDataTypeMaximum];\r
\r
/**\r
  The call back function of NetbufFromExt.\r
\r
  @param[in]  Arg            The argument passed from the caller.\r
\r
**/\r
VOID\r
EFIAPI\r
IpSecOnRecyclePacket (\r
  IN VOID                            *Arg\r
  )\r
{\r
}\r
\r
/**\r
  This is a Notification function. It is called when the related IP6_TXTOKEN_WRAP\r
  is released.\r
\r
  @param[in]  Event              The related event.\r
  @param[in]  Context            The data passed by the caller.\r
\r
**/\r
VOID\r
EFIAPI\r
IpSecRecycleCallback (\r
  IN EFI_EVENT                       Event,\r
  IN VOID                            *Context\r
  )\r
{\r
  IPSEC_RECYCLE_CONTEXT *RecycleContext;\r
\r
  RecycleContext = (IPSEC_RECYCLE_CONTEXT *) Context;\r
\r
  if (RecycleContext->FragmentTable != NULL) {\r
    FreePool (RecycleContext->FragmentTable);\r
  }\r
\r
  if (RecycleContext->PayloadBuffer != NULL) {\r
    FreePool (RecycleContext->PayloadBuffer);\r
  }\r
\r
  FreePool (RecycleContext);\r
  gBS->CloseEvent (Event);\r
\r
}\r
\r
/**\r
  Calculate the extension header of IP. The return length only doesn't contain\r
  the fixed IP header length.\r
\r
  @param[in]  IpHead             Points to an IP head to be calculated.\r
  @param[in]  LastHead           Points to the last header of the IP header.\r
\r
  @return The length of the extension header.\r
\r
**/\r
UINT16\r
IpSecGetPlainExtHeadSize (\r
  IN VOID                             *IpHead,\r
  IN UINT8                            *LastHead\r
  )\r
{\r
  UINT16  Size;\r
\r
  Size = (UINT16) (LastHead - (UINT8 *) IpHead);\r
\r
  if (Size > sizeof (EFI_IP6_HEADER)) {\r
    //\r
    // * (LastHead+1) point the last header's length but not include the first\r
    // 8 octers, so this formluation add 8 at the end.\r
    //\r
    Size = (UINT16) (Size - sizeof (EFI_IP6_HEADER) + *(LastHead + 1) + 8);\r
  } else {\r
    Size = 0;\r
  }\r
\r
  return Size;\r
}\r
\r
/**\r
  Authenticate the IpSec Payload and store the result in the IcvBuffer.\r
\r
  @param[in]      BufferToAuth    The buffer to be Authenticated.\r
  @param[in]      AuthSize        The size of the buffer to be Authenticated.\r
  @param[in, out] IcvBuffer       The buffer to store the ICV.\r
  @param[in]      IcvSize         The size of ICV.\r
  @param[in]      Key             The Key passed to the CryptLib to generate a\r
                                  CRYPT_HANDLE.\r
  @param[in]      AuthAlgId       The Authentication Algorithm ID.\r
\r
  @retval EFI_UNSUPPORTED     If the AuthAlg is not in the support list.\r
  @retval EFI_SUCCESS         Authenticated the payload successfully.\r
  @retval otherwise           Authentication of the payload failed.\r
**/\r
EFI_STATUS\r
IpSecAuthPayload (\r
  IN     UINT8                           *BufferToAuth,\r
  IN     UINTN                           AuthSize,\r
  IN OUT UINT8                           *IcvBuffer,\r
  IN     UINTN                           IcvSize,\r
  IN     VOID                            *Key,\r
  IN     UINT8                           AuthAlgId\r
  )\r
{\r
  switch (AuthAlgId) {\r
    case EFI_IPSEC_AALG_NONE :\r
    case EFI_IPSEC_AALG_NULL :\r
        return EFI_SUCCESS;\r
\r
    default:\r
        return EFI_UNSUPPORTED;\r
  }\r
}\r
\r
/**\r
  Verify if the Authentication payload is correct.\r
\r
  @param[in]  EspBuffer          Points to the ESP wrapped buffer.\r
  @param[in]  EspSize            The size of the ESP wrapped buffer.\r
  @param[in]  SadEntry           The related SAD entry to store the authentication\r
                                 algorithm key.\r
  @param[in]  IcvSize            The length of ICV.\r
\r
  @retval EFI_SUCCESS        The authentication data is correct.\r
  @retval EFI_ACCESS_DENIED  The authentication data is not correct.\r
\r
**/\r
EFI_STATUS\r
IpSecEspAuthVerifyPayload (\r
  IN UINT8                           *EspBuffer,\r
  IN UINTN                           EspSize,\r
  IN IPSEC_SAD_ENTRY                 *SadEntry,\r
  IN UINTN                           *IcvSize\r
  )\r
{\r
  EFI_STATUS  Status;\r
  UINTN       AuthSize;\r
  UINT8       IcvBuffer[12];\r
\r
  //\r
  // Calculate the size of authentication payload.\r
  //\r
  *IcvSize  = IpSecGetIcvLength (SadEntry->Data->AlgoInfo.EspAlgoInfo.AuthAlgoId);\r
  AuthSize  = EspSize - *IcvSize;\r
\r
  //\r
  // Calculate the icv buffer and size of the payload.\r
  //\r
  Status = IpSecAuthPayload (\r
             EspBuffer,\r
             AuthSize,\r
             IcvBuffer,\r
             *IcvSize,\r
             SadEntry->Data->AlgoInfo.EspAlgoInfo.AuthKey,\r
             SadEntry->Data->AlgoInfo.EspAlgoInfo.AuthAlgoId\r
             );\r
  if (EFI_ERROR (Status)) {\r
    return Status;\r
  }\r
  //\r
  // Compare the calculated icv and the appended original icv.\r
  //\r
  if (CompareMem (EspBuffer + AuthSize, IcvBuffer, *IcvSize) == 0) {\r
    return EFI_SUCCESS;\r
  }\r
\r
  DEBUG ((DEBUG_ERROR, "Error auth verify payload\n"));\r
  return EFI_ACCESS_DENIED;\r
}\r
\r
/**\r
  ESP Decrypt the payload.\r
\r
  @param[in, out] PayloadBuffer      Pointer to the buffer containing the ESP wrapped;\r
                                     to be decrypted on input, and plaintext on return. The\r
                                     number of bytes of data to be decrypted is\r
                                     specified by EncryptSize.\r
  @param[in]      EncryptSize        The size of the PayloadBuffer as input.\r
  @param[in]      SadEntry           The related SAD entry.\r
  @param[in]      IvSize             The size of IV.\r
  @param[out]     PlainPayloadSize   Contains the return value of decrypted size.\r
  @param[out]     PaddingSize        Contains the return value of Padding size.\r
  @param[out]     NextHeader         Contains the return value of the last protocol header\r
                                     of the IP packet.\r
\r
  @retval EFI_UNSUPPORTED    The Algorithm pointed to by the SAD entry is not supported.\r
  @retval EFI_SUCCESS        The operation completed successfully.\r
\r
**/\r
EFI_STATUS\r
IpSecEspDecryptPayload (\r
  IN OUT UINT8                       *PayloadBuffer,\r
  IN     UINTN                       EncryptSize,\r
  IN     IPSEC_SAD_ENTRY             *SadEntry,\r
  IN     UINTN                       *IvSize,\r
     OUT UINTN                       *PlainPayloadSize,\r
     OUT UINTN                       *PaddingSize,\r
     OUT UINT8                       *NextHeader\r
  )\r
{\r
  EFI_ESP_TAIL *EspTail;\r
\r
  switch (SadEntry->Data->AlgoInfo.EspAlgoInfo.EncAlgoId) {\r
    case EFI_IPSEC_EALG_NULL:\r
      EspTail            = (EFI_ESP_TAIL *) (PayloadBuffer + EncryptSize - sizeof (EFI_ESP_TAIL));\r
      *PaddingSize       = EspTail->PaddingLength;\r
      *NextHeader        = EspTail->NextHeader;\r
      *PlainPayloadSize  = EncryptSize - EspTail->PaddingLength - sizeof (EFI_ESP_TAIL);\r
      break;\r
\r
    case EFI_IPSEC_EALG_3DESCBC:\r
    case EFI_IPSEC_EALG_AESCBC:\r
      //\r
      // TODO: support these algorithm\r
      //\r
      return EFI_UNSUPPORTED;\r
    default :\r
      return EFI_UNSUPPORTED;\r
  }\r
\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
  ESP Encrypt the payload.\r
\r
  @param[in, out] BufferToEncrypt Pointer to the buffer containing plaintext to be\r
                                  encrypted on input, and ciphertext on return. The\r
                                  number of bytes of data to be encrypted is\r
                                  specified by EncryptSize.\r
  @param[in, out] EncryptSize     The size of the plaintext on input, and the size of the\r
                                  ciphertext on return.\r
  @param[in]      IvBuffer        Points to IV data.\r
  @param[in]      IvSize          Size of IV.\r
  @param[in]      SadEntry        Related SAD entry.\r
\r
  @retval EFI_UNSUPPORTED    The Algorithm pointed by SAD entry is not supported.\r
  @retval EFI_SUCCESS        The operation completed successfully.\r
\r
**/\r
EFI_STATUS\r
IpSecEspEncryptPayload (\r
  IN OUT UINT8                       *BufferToEncrypt,\r
  IN OUT UINTN                       EncryptSize,\r
  IN     UINT8                       *IvBuffer,\r
  IN     UINTN                       IvSize,\r
  IN     IPSEC_SAD_ENTRY             *SadEntry\r
  )\r
{\r
  switch (SadEntry->Data->AlgoInfo.EspAlgoInfo.EncAlgoId) {\r
    case EFI_IPSEC_EALG_NULL:\r
      return EFI_SUCCESS;\r
\r
    case EFI_IPSEC_EALG_3DESCBC:\r
    case EFI_IPSEC_EALG_AESCBC:\r
      //\r
      // TODO: support these algorithms\r
      //\r
      return EFI_UNSUPPORTED;\r
    default :\r
      return EFI_UNSUPPORTED;\r
\r
  }\r
}\r
\r
/**\r
  The actual entry to relative function processes the inbound traffic of ESP header.\r
\r
  This function is the subfunction of IpSecProtectInboundPacket(). It checks the\r
  received packet security property and trim the ESP header and then returns without\r
  an IPsec protected IP Header and FramgmentTable.\r
\r
  @param[in]      IpVersion          The version of IP.\r
  @param[in, out] IpHead             Points to the IP header containing the ESP header\r
                                     to be trimed on input, and without ESP header\r
                                     on return.\r
  @param[out]     LastHead           The Last Header in IP header on return.\r
  @param[in]      OptionsBuffer      Pointer to the options buffer. It is optional.\r
  @param[in]      OptionsLength      Length of the options buffer. It is optional.\r
  @param[in, out] FragmentTable      Pointer to a list of fragments in the form of IPsec\r
                                     protected on input, and without IPsec protected\r
                                     on return.\r
  @param[in]      FragmentCount      The number of fragments.\r
  @param[out]     SpdEntry           Pointer to contain the address of SPD entry on return.\r
  @param[out]     RecycleEvent       The event for recycling of resources.\r
\r
  @retval EFI_SUCCESS              The operation was successful.\r
  @retval EFI_ACCESS_DENIED        One or more following conditions is TRUE:\r
                                   - ESP header was not found.\r
                                   - The related SAD entry was not found.\r
                                   - The related SAD entry does not support the ESP protocol.\r
  @retval EFI_OUT_OF_RESOURCES     The required system resource can't be allocated.\r
\r
**/\r
EFI_STATUS\r
IpSecEspInboundPacket (\r
  IN     UINT8                       IpVersion,\r
  IN OUT VOID                        *IpHead,\r
     OUT UINT8                       *LastHead,\r
  IN     VOID                        *OptionsBuffer, OPTIONAL\r
  IN     UINT32                      OptionsLength,  OPTIONAL\r
  IN OUT EFI_IPSEC_FRAGMENT_DATA     **FragmentTable,\r
  IN     UINT32                      *FragmentCount,\r
     OUT IPSEC_SPD_ENTRY             **SpdEntry,\r
     OUT EFI_EVENT                   *RecycleEvent\r
  )\r
{\r
  EFI_STATUS            Status;\r
  NET_BUF               *Payload;\r
  UINTN                 EspSize;\r
  UINTN                 IvSize;\r
  UINTN                 PlainPayloadSize;\r
  UINTN                 PaddingSize;\r
  UINTN                 IcvSize;\r
  UINT8                 *ProcessBuffer;\r
  EFI_IP_ADDRESS        DestIp;\r
  EFI_ESP_HEADER        *EspHeader;\r
  EFI_ESP_TAIL          *EspTail;\r
  EFI_IPSEC_SA_ID       *SaId;\r
  IPSEC_SAD_DATA        *SadData;\r
  IPSEC_SAD_ENTRY       *SadEntry;\r
  IPSEC_RECYCLE_CONTEXT *RecycleContext;\r
  UINT32                Spi;\r
  UINT8                 NextHeader;\r
  UINT16                IpSecHeadSize;\r
\r
  Status            = EFI_SUCCESS;\r
  Payload           = NULL;\r
  ProcessBuffer     = NULL;\r
  RecycleContext    = NULL;\r
  *RecycleEvent     = NULL;\r
  PlainPayloadSize  = 0;\r
  NextHeader        = 0;\r
  //\r
  // Build netbuf from fragment table first.\r
  //\r
  Payload = NetbufFromExt (\r
              (NET_FRAGMENT *) *FragmentTable,\r
              *FragmentCount,\r
              0,\r
              sizeof (EFI_ESP_HEADER),\r
              IpSecOnRecyclePacket,\r
              NULL\r
              );\r
  if (Payload == NULL) {\r
    Status = EFI_OUT_OF_RESOURCES;\r
    goto ON_EXIT;\r
  }\r
  //\r
  // Get the esp size and eso header from netbuf.\r
  //\r
  EspSize   = Payload->TotalSize;\r
  EspHeader = (EFI_ESP_HEADER *) NetbufGetByte (Payload, 0, NULL);\r
  if (EspHeader == NULL) {\r
    Status = EFI_ACCESS_DENIED;\r
    goto ON_EXIT;\r
  }\r
  //\r
  // Parse destination address from ip header.\r
  //\r
  ZeroMem (&DestIp, sizeof (EFI_IP_ADDRESS));\r
  if (IpVersion == IP_VERSION_4) {\r
    CopyMem (\r
      &DestIp,\r
      &((IP4_HEAD *) IpHead)->Dst,\r
      sizeof (IP4_ADDR)\r
      );\r
  } else {\r
    CopyMem (\r
      &DestIp,\r
      &((EFI_IP6_HEADER *) IpHead)->DestinationAddress,\r
      sizeof (EFI_IPv6_ADDRESS)\r
      );\r
  }\r
  //\r
  // Lookup sad entry according to the spi and dest address.\r
  //\r
  Spi       = NTOHL (EspHeader->Spi);\r
  SadEntry  = IpSecLookupSadBySpi (Spi, &DestIp);\r
  if (SadEntry == NULL) {\r
    Status = EFI_ACCESS_DENIED;\r
    goto ON_EXIT;\r
  }\r
\r
  SaId    = SadEntry->Id;\r
  SadData = SadEntry->Data;\r
\r
  //\r
  // Only support esp protocol currently.\r
  //\r
  if (SaId->Proto != EfiIPsecESP) {\r
    Status = EFI_ACCESS_DENIED;\r
    goto ON_EXIT;\r
  }\r
\r
  if (!SadData->ManualSet) {\r
    //\r
    // TODO: Check sa lifetime and sequence number\r
    //\r
  }\r
  //\r
  // Allocate buffer for decryption and authentication by esp.\r
  //\r
  ProcessBuffer = AllocateZeroPool (EspSize);\r
  if (ProcessBuffer == NULL) {\r
    Status = EFI_OUT_OF_RESOURCES;\r
    goto ON_EXIT;\r
  }\r
\r
  NetbufCopy (Payload, 0, (UINT32) EspSize, ProcessBuffer);\r
\r
  //\r
  // Authenticate the esp wrapped buffer by the sad entry if has auth key.\r
  //\r
  IcvSize = 0;\r
  if (SadData->AlgoInfo.EspAlgoInfo.AuthKey != NULL) {\r
    Status = IpSecEspAuthVerifyPayload (\r
               ProcessBuffer,\r
               EspSize,\r
               SadEntry,\r
               &IcvSize\r
               );\r
    if (EFI_ERROR (Status)) {\r
      goto ON_EXIT;\r
    }\r
  }\r
  //\r
  // Decrypt the payload by the sad entry if has decrypt key.\r
  //\r
  IvSize = 0;\r
  if (SadData->AlgoInfo.EspAlgoInfo.EncKey != NULL) {\r
    Status = IpSecEspDecryptPayload (\r
               ProcessBuffer + sizeof (EFI_ESP_HEADER),\r
               EspSize - sizeof (EFI_ESP_HEADER) - IcvSize,\r
               SadEntry,\r
               &IvSize,\r
               &PlainPayloadSize,\r
               &PaddingSize,\r
               &NextHeader\r
               );\r
    if (EFI_ERROR (Status)) {\r
      goto ON_EXIT;\r
    }\r
  } else {\r
    EspTail           = (EFI_ESP_TAIL *) (ProcessBuffer + EspSize - IcvSize - sizeof (EFI_ESP_TAIL));\r
    PaddingSize       = EspTail->PaddingLength;\r
    NextHeader        = EspTail->NextHeader;\r
    PlainPayloadSize  = EspSize - sizeof (EFI_ESP_HEADER) - IvSize - IcvSize - sizeof (EFI_ESP_TAIL) - PaddingSize;\r
  }\r
  //\r
  // TODO: handle anti-replay window\r
  //\r
  //\r
  // Decryption and authentication with esp has been done, so it's time to\r
  // reload the new packet, create recycle event and fixup ip header.\r
  //\r
  RecycleContext = AllocateZeroPool (sizeof (IPSEC_RECYCLE_CONTEXT));\r
  if (RecycleContext == NULL) {\r
    Status = EFI_OUT_OF_RESOURCES;\r
    goto ON_EXIT;\r
  }\r
\r
  Status = gBS->CreateEvent (\r
                  EVT_NOTIFY_SIGNAL,\r
                  TPL_NOTIFY,\r
                  IpSecRecycleCallback,\r
                  RecycleContext,\r
                  RecycleEvent\r
                  );\r
  if (EFI_ERROR (Status)) {\r
    goto ON_EXIT;\r
  }\r
  //\r
  // TODO: Who take responsible to handle the original fragment table?\r
  //\r
  *FragmentTable = AllocateZeroPool (sizeof (EFI_IPSEC_FRAGMENT_DATA));\r
  if (*FragmentTable == NULL) {\r
    Status = EFI_OUT_OF_RESOURCES;\r
    goto ON_EXIT;\r
  }\r
\r
  RecycleContext->PayloadBuffer       = ProcessBuffer;\r
  RecycleContext->FragmentTable       = *FragmentTable;\r
  (*FragmentTable)[0].FragmentBuffer  = ProcessBuffer + sizeof (EFI_ESP_HEADER) + IvSize;\r
  (*FragmentTable)[0].FragmentLength  = (UINT32) PlainPayloadSize;\r
  *FragmentCount                      = 1;\r
\r
  //\r
  // Update the total length field in ip header since processed by esp.\r
  //\r
  if (IpVersion == IP_VERSION_4) {\r
    ((IP4_HEAD *) IpHead)->TotalLen = HTONS ((UINT16) (((IP4_HEAD *) IpHead)->HeadLen + PlainPayloadSize));\r
  } else {\r
    IpSecHeadSize                              = IpSecGetPlainExtHeadSize (IpHead, LastHead);\r
    ((EFI_IP6_HEADER *) IpHead)->PayloadLength = HTONS ((UINT16)(IpSecHeadSize + PlainPayloadSize));\r
  }\r
  //\r
  // Update the next layer field in ip header since esp header inserted.\r
  //\r
  *LastHead = NextHeader;\r
\r
  //\r
  // Update the spd association of the sad entry.\r
  //\r
  *SpdEntry = SadData->SpdEntry;\r
\r
ON_EXIT:\r
  if (Payload != NULL) {\r
    NetbufFree (Payload);\r
  }\r
\r
  if (EFI_ERROR (Status)) {\r
    if (ProcessBuffer != NULL) {\r
      FreePool (ProcessBuffer);\r
    }\r
\r
    if (RecycleContext != NULL) {\r
      FreePool (RecycleContext);\r
    }\r
\r
    if (*RecycleEvent != NULL) {\r
      gBS->CloseEvent (*RecycleEvent);\r
    }\r
  }\r
\r
  return Status;\r
}\r
\r
/**\r
  The actual entry to the relative function processes the output traffic using the ESP protocol.\r
\r
  This function is the subfunction of IpSecProtectOutboundPacket(). It protected\r
  the sending packet by encrypting its payload and inserting ESP header in the orginal\r
  IP header, then return the IpHeader and IPsec protected Fragmentable.\r
\r
  @param[in]      IpVersion          The version of IP.\r
  @param[in, out] IpHead             Points to IP header containing the orginal IP header\r
                                     to be processed on input, and inserted ESP header\r
                                     on return.\r
  @param[in]      LastHead           The Last Header in IP header.\r
  @param[in]      OptionsBuffer      Pointer to the options buffer. It is optional.\r
  @param[in]      OptionsLength      Length of the options buffer. It is optional.\r
  @param[in, out] FragmentTable      Pointer to a list of fragments to be protected by\r
                                     IPsec on input, and with IPsec protected\r
                                     on return.\r
  @param[in]      FragmentCount      The number of fragments.\r
  @param[in]      SadEntry           The related SAD entry.\r
  @param[out]     RecycleEvent       The event for recycling of resources.\r
\r
  @retval EFI_SUCCESS              The operation was successful.\r
  @retval EFI_OUT_OF_RESOURCES     The required system resources can't be allocated.\r
\r
**/\r
EFI_STATUS\r
IpSecEspOutboundPacket (\r
  IN UINT8                           IpVersion,\r
  IN OUT VOID                        *IpHead,\r
  IN     UINT8                       *LastHead,\r
  IN     VOID                        *OptionsBuffer, OPTIONAL\r
  IN     UINT32                      OptionsLength,  OPTIONAL\r
  IN OUT EFI_IPSEC_FRAGMENT_DATA     **FragmentTable,\r
  IN     UINT32                      *FragmentCount,\r
  IN     IPSEC_SAD_ENTRY             *SadEntry,\r
     OUT EFI_EVENT                   *RecycleEvent\r
  )\r
{\r
  EFI_STATUS            Status;\r
  UINTN                 Index;\r
  EFI_IPSEC_SA_ID       *SaId;\r
  IPSEC_SAD_DATA        *SadData;\r
  IPSEC_RECYCLE_CONTEXT *RecycleContext;\r
  UINT8                 *ProcessBuffer;\r
  UINTN                 BytesCopied;\r
  INTN                  EncryptBlockSize;// Size of encryption block, 4 bytes aligned and >= 4\r
  UINTN                 EspSize;         // Total size of esp wrapped ip payload\r
  UINTN                 IvSize;          // Size of IV, optional, might be 0\r
  UINTN                 PlainPayloadSize;// Original IP payload size\r
  UINTN                 PaddingSize;     // Size of padding\r
  UINTN                 EncryptSize;     // Size of data to be encrypted, start after IV and\r
                                         // stop before ICV\r
  UINTN                 IcvSize;         // Size of ICV, optional, might be 0\r
  UINT8                 *RestOfPayload;  // Start of Payload after IV\r
  UINT8                 *Padding;        // Start address of padding\r
  EFI_ESP_HEADER        *EspHeader;      // Start address of ESP frame\r
  EFI_ESP_TAIL          *EspTail;        // Address behind padding\r
\r
  Status          = EFI_ACCESS_DENIED;\r
  SaId            = SadEntry->Id;\r
  SadData         = SadEntry->Data;\r
  ProcessBuffer   = NULL;\r
  RecycleContext  = NULL;\r
  *RecycleEvent   = NULL;\r
\r
  if (!SadData->ManualSet &&\r
      SadData->AlgoInfo.EspAlgoInfo.EncKey == NULL &&\r
      SadData->AlgoInfo.EspAlgoInfo.AuthKey == NULL\r
      ) {\r
    //\r
    // Invalid manual sad entry configuration.\r
    //\r
    goto ON_EXIT;\r
  }\r
  //\r
  // Calculate enctrypt block size, need iv by default and 4 bytes alignment.\r
  //\r
  EncryptBlockSize  = 4;\r
\r
  if (SadData->AlgoInfo.EspAlgoInfo.EncKey != NULL) {\r
    EncryptBlockSize  = IpSecGetEncryptBlockSize (SadEntry->Data->AlgoInfo.EspAlgoInfo.EncAlgoId);\r
\r
    if (EncryptBlockSize < 0 || (EncryptBlockSize != 1 && EncryptBlockSize % 4 != 0)) {\r
      goto ON_EXIT;\r
    }\r
  }\r
  //\r
  // Calculate the plain payload size accroding to the fragment table.\r
  //\r
  PlainPayloadSize = 0;\r
  for (Index = 0; Index < *FragmentCount; Index++) {\r
    PlainPayloadSize += (*FragmentTable)[Index].FragmentLength;\r
  }\r
  //\r
  // Calculate icv size, optional by default and 4 bytes alignment.\r
  //\r
  IcvSize = 0;\r
  if (SadData->AlgoInfo.EspAlgoInfo.AuthKey != NULL) {\r
    IcvSize = IpSecGetIcvLength (SadEntry->Data->AlgoInfo.EspAlgoInfo.AuthAlgoId);\r
    if (IcvSize % 4 != 0) {\r
      goto ON_EXIT;\r
    }\r
  }\r
  //\r
  // Calcuate the total size of esp wrapped ip payload.\r
  //\r
  IvSize        = IpSecGetEncryptIvLength (SadEntry->Data->AlgoInfo.EspAlgoInfo.EncAlgoId);\r
  EncryptSize   = (PlainPayloadSize + sizeof (EFI_ESP_TAIL) + EncryptBlockSize - 1) / EncryptBlockSize * EncryptBlockSize;\r
  PaddingSize   = EncryptSize - PlainPayloadSize - sizeof (EFI_ESP_TAIL);\r
  EspSize       = sizeof (EFI_ESP_HEADER) + IvSize + EncryptSize + IcvSize;\r
\r
  ProcessBuffer = AllocateZeroPool (EspSize);\r
  if (ProcessBuffer == NULL) {\r
    Status = EFI_OUT_OF_RESOURCES;\r
    goto ON_EXIT;\r
  }\r
  //\r
  // Calculate esp header and esp tail including header, payload and padding.\r
  //\r
  EspHeader     = (EFI_ESP_HEADER *) ProcessBuffer;\r
  RestOfPayload = (UINT8 *) (EspHeader + 1) + IvSize;\r
  Padding       = RestOfPayload + PlainPayloadSize;\r
  EspTail       = (EFI_ESP_TAIL *) (Padding + PaddingSize);\r
\r
  //\r
  // Fill the sn and spi fields in esp header.\r
  //\r
  EspHeader->SequenceNumber = HTONL ((UINT32) SadData->SequenceNumber + 1);\r
  EspHeader->Spi            = HTONL (SaId->Spi);\r
\r
  //\r
  // Copy the rest of payload (after iv) from the original fragment buffer.\r
  //\r
  BytesCopied = 0;\r
  for (Index = 0; Index < *FragmentCount; Index++) {\r
    CopyMem (\r
      (RestOfPayload + BytesCopied),\r
      (*FragmentTable)[Index].FragmentBuffer,\r
      (*FragmentTable)[Index].FragmentLength\r
      );\r
    BytesCopied += (*FragmentTable)[Index].FragmentLength;\r
  }\r
  //\r
  // Fill the padding buffer by natural number sequence.\r
  //\r
  for (Index = 0; Index < PaddingSize; Index++) {\r
    Padding[Index] = (UINT8) (Index + 1);\r
  }\r
  //\r
  // Fill the padding length and next header fields in esp tail.\r
  //\r
  EspTail->PaddingLength  = (UINT8) PaddingSize;\r
  EspTail->NextHeader     = *LastHead;\r
\r
  //\r
  // Generate iv at random by crypt library.\r
  //\r
  Status = IpSecGenerateIv (\r
             (UINT8 *) (EspHeader + 1),\r
             IvSize\r
             );\r
\r
\r
  if (EFI_ERROR (Status)) {\r
    goto ON_EXIT;\r
  }\r
  //\r
  // Encrypt the payload (after iv) by the sad entry if has encrypt key.\r
  //\r
  if (SadData->AlgoInfo.EspAlgoInfo.EncKey != NULL) {\r
    Status = IpSecEspEncryptPayload (\r
               RestOfPayload,\r
               EncryptSize,\r
               (UINT8 *) (EspHeader + 1),\r
               IvSize,\r
               SadEntry\r
               );\r
    if (EFI_ERROR (Status)) {\r
      goto ON_EXIT;\r
    }\r
  }\r
  //\r
  // Authenticate the esp wrapped buffer by the sad entry if has auth key.\r
  //\r
  if (SadData->AlgoInfo.EspAlgoInfo.AuthKey != NULL) {\r
    Status = IpSecAuthPayload (\r
               ProcessBuffer,\r
               EspSize - IcvSize,\r
               ProcessBuffer + EspSize - IcvSize,\r
               IcvSize,\r
               SadEntry->Data->AlgoInfo.EspAlgoInfo.AuthKey,\r
               SadEntry->Data->AlgoInfo.EspAlgoInfo.AuthAlgoId\r
               );\r
    if (EFI_ERROR (Status)) {\r
      goto ON_EXIT;\r
    }\r
  }\r
  //\r
  // Encryption and authentication with esp has been done, so it's time to\r
  // reload the new packet, create recycle event and fixup ip header.\r
  //\r
  RecycleContext = AllocateZeroPool (sizeof (IPSEC_RECYCLE_CONTEXT));\r
  if (RecycleContext == NULL) {\r
    Status = EFI_OUT_OF_RESOURCES;\r
    goto ON_EXIT;\r
  }\r
\r
  Status = gBS->CreateEvent (\r
                  EVT_NOTIFY_SIGNAL,\r
                  TPL_NOTIFY,\r
                  IpSecRecycleCallback,\r
                  RecycleContext,\r
                  RecycleEvent\r
                  );\r
  if (EFI_ERROR (Status)) {\r
    goto ON_EXIT;\r
  }\r
  //\r
  // TODO: Who take responsible to handle the original fragment table?\r
  //\r
  *FragmentTable = AllocateZeroPool (sizeof (EFI_IPSEC_FRAGMENT_DATA));\r
  if (*FragmentTable == NULL) {\r
    Status = EFI_OUT_OF_RESOURCES;\r
    goto ON_EXIT;\r
  }\r
\r
  RecycleContext->FragmentTable       = *FragmentTable;\r
  RecycleContext->PayloadBuffer       = ProcessBuffer;\r
  (*FragmentTable)[0].FragmentBuffer  = ProcessBuffer;\r
  (*FragmentTable)[0].FragmentLength  = (UINT32) EspSize;\r
  *FragmentCount                      = 1;\r
\r
  //\r
  // Update the total length field in ip header since processed by esp.\r
  //\r
  if (IpVersion == IP_VERSION_4) {\r
    ((IP4_HEAD *) IpHead)->TotalLen = HTONS ((UINT16) (((IP4_HEAD *) IpHead)->HeadLen + EspSize));\r
  } else {\r
    ((EFI_IP6_HEADER *) IpHead)->PayloadLength = (UINT16) (IpSecGetPlainExtHeadSize (IpHead, LastHead) + EspSize);\r
  }\r
  //\r
  // Update the next layer field in ip header since esp header inserted.\r
  //\r
  *LastHead = IPSEC_ESP_PROTOCOL;\r
\r
  //\r
  // Increase the sn number in sad entry according to rfc4303.\r
  //\r
  SadData->SequenceNumber++;\r
\r
ON_EXIT:\r
  if (EFI_ERROR (Status)) {\r
    if (ProcessBuffer != NULL) {\r
      FreePool (ProcessBuffer);\r
    }\r
\r
    if (RecycleContext != NULL) {\r
      FreePool (RecycleContext);\r
    }\r
\r
    if (*RecycleEvent != NULL) {\r
      gBS->CloseEvent (*RecycleEvent);\r
    }\r
  }\r
\r
  return Status;\r
}\r
\r
/**\r
  This function processes the inbound traffic with IPsec.\r
\r
  It checks the received packet security property, trims the ESP/AH header, and then\r
  returns without an IPsec protected IP Header and FragmentTable.\r
\r
  @param[in]      IpVersion          The version of IP.\r
  @param[in, out] IpHead             Points to IP header containing the ESP/AH header\r
                                     to be trimed on input, and without ESP/AH header\r
                                     on return.\r
  @param[in]      LastHead           The Last Header in IP header on return.\r
  @param[in]      OptionsBuffer      Pointer to the options buffer. It is optional.\r
  @param[in]      OptionsLength      Length of the options buffer. It is optional.\r
  @param[in, out] FragmentTable      Pointer to a list of fragments in form of IPsec\r
                                     protected on input, and without IPsec protected\r
                                     on return.\r
  @param[in]      FragmentCount      The number of fragments.\r
  @param[out]     SpdEntry           Pointer to contain the address of SPD entry on return.\r
  @param[out]     RecycleEvent       The event for recycling of resources.\r
\r
  @retval EFI_SUCCESS              The operation was successful.\r
  @retval EFI_UNSUPPORTED          The IPSEC protocol is not supported.\r
\r
**/\r
EFI_STATUS\r
IpSecProtectInboundPacket (\r
  IN     UINT8                       IpVersion,\r
  IN OUT VOID                        *IpHead,\r
  IN     UINT8                       *LastHead,\r
  IN     VOID                        *OptionsBuffer, OPTIONAL\r
  IN     UINT32                      OptionsLength,  OPTIONAL\r
  IN OUT EFI_IPSEC_FRAGMENT_DATA     **FragmentTable,\r
  IN     UINT32                      *FragmentCount,\r
     OUT IPSEC_SPD_ENTRY             **SpdEntry,\r
     OUT EFI_EVENT                   *RecycleEvent\r
  )\r
{\r
  if (*LastHead == IPSEC_ESP_PROTOCOL) {\r
    //\r
    // Process the esp ipsec header of the inbound traffic.\r
    //\r
    return IpSecEspInboundPacket (\r
             IpVersion,\r
             IpHead,\r
             LastHead,\r
             OptionsBuffer,\r
             OptionsLength,\r
             FragmentTable,\r
             FragmentCount,\r
             SpdEntry,\r
             RecycleEvent\r
             );\r
  }\r
  //\r
  // The other protocols are not supported.\r
  //\r
  return EFI_UNSUPPORTED;\r
}\r
\r
/**\r
  This function processes the output traffic with IPsec.\r
\r
  It protected the sending packet by encrypting it payload and inserting ESP/AH header\r
  in the orginal IP header, then returns the IpHeader and IPsec protected Fragmentable.\r
\r
  @param[in]      IpVersion          The version of IP.\r
  @param[in, out] IpHead             Points to IP header containing the orginal IP header\r
                                     to be processed on input, and inserted ESP/AH header\r
                                     on return.\r
  @param[in]      LastHead           The Last Header in the IP header.\r
  @param[in]      OptionsBuffer      Pointer to the options buffer. It is optional.\r
  @param[in]      OptionsLength      Length of the options buffer. It is optional.\r
  @param[in, out] FragmentTable      Pointer to a list of fragments to be protected by\r
                                     IPsec on input, and with IPsec protected\r
                                     on return.\r
  @param[in]      FragmentCount      The number of fragments.\r
  @param[in]      SadEntry           The related SAD entry.\r
  @param[out]     RecycleEvent       The event for recycling of resources.\r
\r
  @retval EFI_SUCCESS              The operation was successful.\r
  @retval EFI_UNSUPPORTED          If the IPSEC protocol is not supported.\r
\r
**/\r
EFI_STATUS\r
IpSecProtectOutboundPacket (\r
  IN     UINT8                       IpVersion,\r
  IN OUT VOID                        *IpHead,\r
  IN     UINT8                       *LastHead,\r
  IN     VOID                        *OptionsBuffer, OPTIONAL\r
  IN     UINT32                      OptionsLength,  OPTIONAL\r
  IN OUT EFI_IPSEC_FRAGMENT_DATA     **FragmentTable,\r
  IN     UINT32                      *FragmentCount,\r
  IN     IPSEC_SAD_ENTRY             *SadEntry,\r
     OUT EFI_EVENT                   *RecycleEvent\r
  )\r
{\r
  if (SadEntry->Id->Proto == EfiIPsecESP) {\r
    //\r
    // Process the esp ipsec header of the outbound traffic.\r
    //\r
    return IpSecEspOutboundPacket (\r
             IpVersion,\r
             IpHead,\r
             LastHead,\r
             OptionsBuffer,\r
             OptionsLength,\r
             FragmentTable,\r
             FragmentCount,\r
             SadEntry,\r
             RecycleEvent\r
             );\r
  }\r
  //\r
  // The other protocols are not supported.\r
  //\r
  return EFI_UNSUPPORTED;\r
}\r