owner-nrf52sdk/nRF5_SDK_15.3.0/external/infineon/optiga/dtls/DtlsWindowing.c

/**
* MIT License
*
* Copyright (c) 2018 Infineon Technologies AG
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE
*
*
* \file
*
* \brief   This file implements the APIs, types used in the
*          for DTLS windowing.
*
* \addtogroup  grMutualAuth
* @{
*/

#include <stdint.h>
#include "optiga/dtls/DtlsWindowing.h"
#include "optiga/dtls/DtlsRecordLayer.h"

#ifdef MODULE_ENABLE_DTLS_MUTUAL_AUTH

/// @cond hidden

///Maximum window size supported
#define MAX_WINDOW_SIZE 64

/// @endcond

/**
 * Implementation for Record Replay Detection.<br>
 * Return status as #OCP_RL_WINDOW_IGNORE if record is already received or record sequence number is less then lower bound of window.<br>
 * Under some erroneous conditions, error codes from Record Layer can also be returned.<br>
 *
 * \param[in]   PpsWindow   Pointer to the structure that contains details required for windowing like
 *                          record sequence number, lower and higher boundaries.
 *
 * \retval      OCP_RL_WINDOW_UPDATED       Valid record is received and window is updated.
 * \retval      OCP_RL_WINDOW_MOVED         Valid record is received and window is updated and moved.
 * \retval      OCP_RL_WINDOW_IGNORE        Failure in execution and record already received.
 *
 */
int32_t DtlsCheckReplay(sWindow_d *PpsWindow)
{
    int32_t i4Status = (int32_t) OCP_RL_WINDOW_IGNORE;
    int32_t i4Retval;
    sUint64 sIntermidateVal;

    do
    {
#ifdef ENABLE_NULL_CHECKS
        if((NULL == PpsWindow) || (NULL == PpsWindow->fValidateRecord))
        {
            break;
        }
#endif
        if((MAX_WINDOW_SIZE < PpsWindow->bWindowSize) || (WORD_SIZE > PpsWindow->bWindowSize))
        {
            break;
        }

        //Compare the received sequence number with the Lower window boundary
        i4Retval = CompareUint64(&PpsWindow->sRecvSeqNumber, &PpsWindow->sLowerBound);

        //If sequence number is lesser than the low bound of window
        if(LESSER_THAN == i4Retval)
        {
            break;
        }

        //If sequence number is greater than low bound window
        //Compare the received sequence number with the Higher window boundary
        i4Retval = CompareUint64(&PpsWindow->sRecvSeqNumber, &PpsWindow->sHigherBound);

        //If Sequence number is greater than high bound of the window
        //Slide the window
        if(GREATER_THAN == i4Retval)
        {
            //Record validation
            i4Retval = PpsWindow->fValidateRecord(PpsWindow->pValidateArgs);
            //If record validation fails
            if(OCP_RL_OK != i4Retval)
            {
                if(((int32_t)CMD_LIB_DECRYPT_FAILURE == i4Retval) || ((int32_t)OCP_RL_MALLOC_FAILURE == i4Retval))
                {
                    i4Status = i4Retval;
                }
                break;
            }
            else
            {
                //Calculate the count to slide the window
                //lint --e{534} suppress "The return value check is suppressed as this function always return Success.Only error condition where
                //RecvSeqNumber <  sHigherBound is not possible as it will enter this path only when RecvSeqNumber >  sHigherBound"
                i4Retval = SubtractUint64(&PpsWindow->sRecvSeqNumber, &PpsWindow->sHigherBound, &sIntermidateVal);

                //Slide the window
                i4Retval = ShiftLeftUint64(&PpsWindow->sWindowFrame, sIntermidateVal, PpsWindow->bWindowSize, (uint8_t)MAX_WINDOW_SIZE);
                if(UTIL_SUCCESS != i4Retval)
                {
                    break;
                }
                //Set the sequence number received as the Higher Bound
                PpsWindow->sHigherBound = PpsWindow->sRecvSeqNumber;

                sIntermidateVal.dwHigherByte = DEFAULT_LOWBOUND_DOUBLEWORD ;
                sIntermidateVal.dwLowerByte = (uint32_t)PpsWindow->bWindowSize - 1;

                //Difference of Higher bound and window size is set as lower bound
                i4Retval = SubtractUint64(&PpsWindow->sHigherBound, &sIntermidateVal, &PpsWindow->sLowerBound);
                if(UTIL_SUCCESS != i4Retval)
                {
                    break;
                }
                //Set the bit position of sequence number to 1 which is the MSB of the window frame
                i4Retval = Utility_SetBitUint64(&PpsWindow->sWindowFrame, PpsWindow->bWindowSize, PpsWindow->bWindowSize);
                if(UTIL_SUCCESS != i4Retval)
                {
                    break;
                }

                i4Status = (int32_t) OCP_RL_WINDOW_MOVED;
                break;
            }
        }
        //Compare the received sequence number with the Higher and Lower window boundary
        //lint --e{534} suppress "The return value check is suppressed as this function always return Success.Only error condition where
        //RecvSeqNumber >  sHigherBound is not possible as it will enter this path only when RecvSeqNumber <  sHigherBound"
        //Calculate bit position of sequence number from high bound of the window
        i4Retval = SubtractUint64(&PpsWindow->sHigherBound, &PpsWindow->sRecvSeqNumber, &sIntermidateVal);

        //If window size is equal to 32
        if(WORD_SIZE == PpsWindow->bWindowSize)
        {
            if((MOST_SIGNIFICANT_BIT_HIGH == ((PpsWindow->sWindowFrame.dwHigherByte << (uint32_t)((WORD_SIZE - sIntermidateVal.dwLowerByte) - 1))
            & MOST_SIGNIFICANT_BIT_HIGH)))
            {
                break;
            }
        }
        else
        {
            //Received sequence number is in the lower byte of the window frame
            if((DEFAULT_LOWBOUND_DOUBLEWORD == sIntermidateVal.dwHigherByte) && (sIntermidateVal.dwLowerByte < WORD_SIZE))
            {
                if((MOST_SIGNIFICANT_BIT_HIGH == ((PpsWindow->sWindowFrame.dwLowerByte << (uint32_t)((WORD_SIZE - sIntermidateVal.dwLowerByte) - 1 )) & MOST_SIGNIFICANT_BIT_HIGH)))
                {
                    break;
                }
            }
            //Received sequence number is in the higher byte of the window frame
            else if((DEFAULT_LOWBOUND_DOUBLEWORD == sIntermidateVal.dwHigherByte) && (sIntermidateVal.dwLowerByte >= WORD_SIZE))
            {
                if((MOST_SIGNIFICANT_BIT_HIGH == ((PpsWindow->sWindowFrame.dwHigherByte << (uint32_t)((MAX_WINDOW_SIZE - sIntermidateVal.dwLowerByte) - 1)) & MOST_SIGNIFICANT_BIT_HIGH)))
                {
                    break;
                }
            }
        }
        //Record validation
        i4Retval = PpsWindow->fValidateRecord(PpsWindow->pValidateArgs);
        //If record validation fails
        if(OCP_RL_OK != i4Retval)
        {
            if(((int32_t)CMD_LIB_DECRYPT_FAILURE == i4Retval) || ((int32_t)OCP_RL_MALLOC_FAILURE == i4Retval))
            {
                i4Status = i4Retval;
            }
            break;
        }
        else
        {
            i4Retval = SubtractUint64(&PpsWindow->sRecvSeqNumber, &PpsWindow->sLowerBound,&sIntermidateVal);
            if(UTIL_SUCCESS != i4Retval)
            {
                break;
            }

            //Set the bit position of sequence number to 1
            i4Retval = Utility_SetBitUint64(&PpsWindow->sWindowFrame, PpsWindow->bWindowSize, (uint8_t)sIntermidateVal.dwLowerByte);
            if(UTIL_SUCCESS != i4Retval)
            {
                break;
            }

            if(PpsWindow->bWindowSize > WORD_SIZE)
            {
                PpsWindow->sWindowFrame.dwHigherByte &= MASK_DOUBLE_WORD >> (MAX_WINDOW_SIZE - PpsWindow->bWindowSize);
            }
            i4Status = (int32_t)OCP_RL_WINDOW_UPDATED;
        }
    }while(0);

    return i4Status;
}

#endif /*MODULE_ENABLE_DTLS_MUTUAL_AUTH*/