mac_aessecurity.c

zigbee location examples

/*******************************************************************************************************
 *                                                                                                     *
 *        **********                                                                                   *
 *       ************                                                                                  *
 *      ***        ***                                                                                 *
 *      ***   +++   ***                                                                                *
 *      ***   + +   ***                                                                                *
 *      ***   +                         CHIPCON CC2430 INTEGRATED 802.15.4 MAC AND PHY                 *
 *      ***   + +   ***                              MAC-AESSECURITY.C                                 *
 *      ***   +++   ***                                                                                *
 *      ***        ***                                                                                 *
 *       ************                                                                                  *
 *        **********                                                                                   *
 *                                                                                                     *
 *******************************************************************************************************
 * CONFIDENTIAL                                                                                        *
 * The use of this file is restricted by the signed MAC software license agreement.                    *
 *                                                                                                     *
 * Copyright Chipcon AS, 2005                                                                          *
 *******************************************************************************************************/
#include "mac_headers.h"
#include <string.h>

extern BOOL                    XDATA currentAesFinished;
extern BYTE                    XDATA currentAesTransferCount;

__near_func __interrupt void  AesIsr (void);

static void AppendFrameKeyAndSource (DWORD          frameCounter,
                                     BYTE           keySequenceCounter,
                                     ADDRESS XDATA  *extendedSourceAddress,
                                     BYTE XDATA     *bytes);
static void AppendUToEncryptedMessage (BYTE         noOfBytes,
                                       BYTE XDATA   *u,
                                       BYTE XDATA   *messageLength,
                                       BYTE XDATA   *message);
static void BuildAesCtrInputBlock (DWORD            frameCounter,
                                   BYTE             keySequenceCounter,
                                   ADDRESS XDATA    *extendedSourceAddress,
                                   BYTE XDATA       *iv);
static void BuildAuthenticationData (B0 XDATA   *b0,
                                     BYTE       authenticationLength,
                                     BYTE XDATA *authenticationData,
                                     BYTE XDATA *additionalLength,
                                     BYTE XDATA *additionalAuthData);
static void BuildA0 (DWORD          frameCounter,
                     BYTE           keySequenceCounter,
                     ADDRESS XDATA  *extendedAddress,
                     A0 XDATA       *a0);
static void BuildB0 (BYTE           messageLength,
                     OUTPUT_MODE    outputMode,
                     DWORD          frameCounter,
                     BYTE           keySequenceCounter,
                     ADDRESS XDATA  *extendedAddress,
                     B0 XDATA       *b0);
static void CompareTAndMacTag (BYTE                     integrityLength,
                               INTEGRITY_CODE XDATA     *t,
                               INTEGRITY_CODE XDATA     *macTag,
                               BOOL XDATA               *result);
static void ConvertOutputModeToNoOfBytes (OUTPUT_MODE outputMode, BYTE XDATA *bytesInOutput);
static void LoadIv (AES_MODE   aesMode,
                    IV XDATA   *iv,
                    BOOL XDATA *result);
static void LoadKey (AES_MODE   aesMode,
                     KEY XDATA  *key,
                     BOOL XDATA *result);
static void PerformCcmCbcMac (AES_CCM_DATA XDATA *aesCcmData,
                              BYTE XDATA         *mac,
                              BOOL XDATA         *result);
static void SetupAesRead (BYTE         noOfBytes,
                          BYTE XDATA   *bytes);
static void SetupAesWrite (BYTE         noOfBytes,
                           BYTE XDATA   *bytes);
static void StartAes (AES_MODE  aesMode, AES_COMMAND    aesCommand);
static void WriteAndReadAes (AES_MODE        aesMode,
                             AES_COMMAND     aesCommand,
                             BYTE            noOfBytes,
                             BYTE XDATA      *bytesIn,
                             BYTE XDATA      *bytesOut,
                             BOOL XDATA      *result);
static void WriteToAes (AES_MODE        aesMode,
                        AES_COMMAND     aesCommand,
                        BYTE            noOfBytes,
                        BYTE XDATA      *bytes,
                        BOOL XDATA      *result);
static void ZeroPadData (BYTE XDATA *noOfBytes, BYTE XDATA *bytesIn);

IV XDATA iv0 =
    {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};

//-------------------------------------------------------------------------------------------------------
//
// Global functions
//
//-------------------------------------------------------------------------------------------------------
//-------------------------------------------------------------------------------------------------------
//
//-------------------------------------------------------------------------------------------------------
void Aes (AES_MODE          aesMode,
          ENCRYPTION_TYPE   encryptionType,
          KEY XDATA         *key,
          IV  XDATA         *iv,
          BYTE              noOfBytes,
          BYTE XDATA        *bytesIn,
          BYTE XDATA        *bytesOut,
          BOOL XDATA        *result)
{
    AES_COMMAND aesCommand;
    BYTE XDATA tempNoOfBytes;

    tempNoOfBytes = noOfBytes;

    if (tempNoOfBytes > MAX_IN_AES)
        *result = FALSE;
    else
    {
        *result = TRUE;
        ZeroPadData ((BYTE *)&tempNoOfBytes, bytesIn);
        LoadKey (aesMode,
                 key,
                 result);

        if (*result)
        {
            if (aesMode != AES_MODE_ECB)
                LoadIv (aesMode,
                        iv,
						result);

            if (*result)
            {

                if (encryptionType == ENCRYPTION_TYPE_ENCRYPT)
                   aesCommand = AES_COMMAND_ENCRYPT_BLOCK;
               else
                   aesCommand = AES_COMMAND_DECRYPT_BLOCK;

                WriteAndReadAes (aesMode,
                                 aesCommand,
                                 tempNoOfBytes,
                                 bytesIn,
                                 bytesOut,
                                 result);
            }

        }

    }

}

//-------------------------------------------------------------------------------------------------------
//
//-------------------------------------------------------------------------------------------------------
void AesCbcMac (OUTPUT_MODE     outputMode,
                KEY XDATA       *key,
                IV  XDATA       *iv,
                BYTE            noOfBytes,
                BYTE XDATA      *bytes,
                BYTE XDATA      *mac,
                BOOL XDATA      *result)
{
    BYTE XDATA bytesInOutput,
         XDATA tempNoOfBytes,
               i;

    tempNoOfBytes = noOfBytes;

    if (tempNoOfBytes > MAX_IN_AES)
        *result = FALSE;
    else
    {
        *result = TRUE;
        ZeroPadData ((BYTE *)&tempNoOfBytes, bytes);
        LoadKey (AES_MODE_CBC_MAC,
                 key,
                 result);

        if (*result)
        {
            LoadIv  (AES_MODE_CBC_MAC,
                     iv,
                     result);

            if (*result)
            {
                tempNoOfBytes = (BYTE)(tempNoOfBytes - SIXTEEN_BYTES_BLOCK);

                if (tempNoOfBytes > 0)
                    WriteToAes (AES_MODE_CBC_MAC,
                                AES_COMMAND_ENCRYPT_BLOCK,
                                tempNoOfBytes,
                                bytes,
        						result);

                WriteAndReadAes (AES_MODE_CBC,
                                 AES_COMMAND_ENCRYPT_BLOCK,
                                 SIXTEEN_BYTES_BLOCK,
                                 (BYTE *)&(bytes[tempNoOfBytes]),
                                 mac,
                                 result);

                if (*result)
                {
                    ConvertOutputModeToNoOfBytes (outputMode, (BYTE *)&bytesInOutput);

                    if (outputMode != OUTPUT_MODE_RESULT_128)
                    {
                        for ( i = (BYTE)(SIXTEEN_BYTES_BLOCK - bytesInOutput);
                              i < SIXTEEN_BYTES_BLOCK;
                              i++)
                            mac[i] = 0;
                    }
                }
            }
        }
    }
}

//-------------------------------------------------------------------------------------------------------
//
//-------------------------------------------------------------------------------------------------------
void AesCcmDecrypt (AES_CCM_DATA XDATA *aesCcmData,
                    U XDATA            *u,
                    BOOL XDATA         *result)
{
    BYTE           XDATA integrityLength,
                   XDATA messageLength;
    INTEGRITY_CODE XDATA t,
                   XDATA macTag;

    ConvertOutputModeToNoOfBytes (aesCcmData->outputMode, (BYTE *)&integrityLength);
    Aes (AES_MODE_CTR,
         ENCRYPTION_TYPE_DECRYPT,
         &aesCcmData->key,
         (IV *)&aesCcmData->a0,
         integrityLength,
         (BYTE *)u,
         (BYTE *)&t,
         result);

    if (*result)
    {
        messageLength = aesCcmData->ccmData.messageLength;
        ZeroPadData ((BYTE *)&messageLength, aesCcmData->ccmData.message);
        WriteAndReadAes (AES_MODE_CTR,
                         AES_COMMAND_DECRYPT_BLOCK,
                         messageLength,
                         aesCcmData->ccmData.message,
                         aesCcmData->ccmData.message,
                         result);

        if (*result)
        {
            PerformCcmCbcMac (aesCcmData,
                             (BYTE *)&macTag,
                              result);

            if (*result)
            {
                CompareTAndMacTag (integrityLength,
                                   (INTEGRITY_CODE *)&t,
                                   (INTEGRITY_CODE *)&macTag,
                                   result);
            }
        }
    }
}

//-------------------------------------------------------------------------------------------------------
//
//-------------------------------------------------------------------------------------------------------
void AesCcmEncrypt (AES_CCM_DATA XDATA *aesCcmData, BOOL XDATA *result)
{
    BYTE           XDATA noOfBytes,
                   XDATA noOfBytesInU,
                   XDATA messageLength;
    INTEGRITY_CODE XDATA t;
    U XDATA              u;

    PerformCcmCbcMac (aesCcmData,
                      (BYTE *)&t,
                      result);

    if (*result)
    {
        ConvertOutputModeToNoOfBytes (aesCcmData->outputMode, (BYTE *)&noOfBytes);
        noOfBytesInU = noOfBytes;
        Aes (AES_MODE_CTR,
             ENCRYPTION_TYPE_ENCRYPT,
             &aesCcmData->key,
             (IV *)&aesCcmData->a0,
             noOfBytes,
             (BYTE *)&t,
             (BYTE *)&u,
             result);

        if (*result)
        {
            messageLength = aesCcmData->ccmData.messageLength;
            ZeroPadData ((BYTE *)&messageLength, aesCcmData->ccmData.message);
            WriteAndReadAes (AES_MODE_CTR,
                             AES_COMMAND_ENCRYPT_BLOCK,
                             messageLength,