add initial Setup

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
niklasschoeningandClaude Opus 5.5 committed 2026-10-16 18:25:42 +02:00
commit bdb5db2009
1955 files changed
+1004711

No files matched your search

@@ -0,0 +1,90 @@
/*
* FreeRTOS memory safety proofs with CBMC.
* Copyright (C) 2022 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* 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.
*
* http://aws.amazon.com/freertos
* http://www.FreeRTOS.org
*/
/* Standard includes. */
#include <stdint.h>
/* FreeRTOS includes. */
#include "FreeRTOS.h"
#include "task.h"
#include "semphr.h"
/* FreeRTOS+TCP includes. */
#include "FreeRTOS_IP.h"
#include "FreeRTOS_Sockets.h"
#include "FreeRTOS_IP_Private.h"
#include "FreeRTOS_UDP_IP.h"
#include "FreeRTOS_DHCP.h"
#include "FreeRTOS_BitConfig.h"
/* CBMC includes. */
#include "cbmc.h"
#define DHCPv6_PAYLOAD_LENGTH_MAX ( 100 )
BaseType_t __CPROVER_file_local_FreeRTOS_DHCPv6_c_prvDHCPv6Analyse( struct xNetworkEndPoint * pxEndPoint,
const uint8_t * pucAnswer,
size_t uxTotalLength,
DHCPMessage_IPv6_t * pxDHCPMessage );
/* prvDHCPv6_handleOption is tested separately. Using mock function in this test case. */
BaseType_t __CPROVER_file_local_FreeRTOS_DHCPv6_c_prvDHCPv6_handleOption( struct xNetworkEndPoint * pxEndPoint,
uint16_t usOption,
const DHCPOptionSet_t * pxSet,
DHCPMessage_IPv6_t * pxDHCPMessage,
BitConfig_t * pxMessage )
{
__CPROVER_assert( __CPROVER_r_ok( pxEndPoint, sizeof( struct xNetworkEndPoint ) ), "pxEndPoint region must be readable" );
__CPROVER_assert( __CPROVER_r_ok( pxSet, sizeof( DHCPOptionSet_t ) ), "pxSet region must be readable" );
__CPROVER_assert( __CPROVER_r_ok( pxDHCPMessage, sizeof( DHCPMessage_IPv6_t ) ), "pxDHCPMessage region must be readable" );
__CPROVER_assert( __CPROVER_r_ok( pxMessage, sizeof( BitConfig_t ) ), "pxMessage region must be readable" );
}
void harness()
{
size_t uxTotalLength;
BaseType_t xResult;
NetworkEndPoint_t * pxNetworkEndPoint_Temp;
DHCPMessage_IPv6_t * pxDHCPMessage;
uint8_t * pucAnswer;
pxNetworkEndPoint_Temp = safeMalloc( sizeof( NetworkEndPoint_t ) );
__CPROVER_assume( pxNetworkEndPoint_Temp != NULL );
pxDHCPMessage = safeMalloc( sizeof( DHCPMessage_IPv6_t ) );
__CPROVER_assume( pxDHCPMessage != NULL );
/* Limit the total length to be less than DHCPv6_PAYLOAD_LENGTH_MAX to decrease the verification time. */
__CPROVER_assume( ( uxTotalLength > 0 ) &&
( uxTotalLength <= DHCPv6_PAYLOAD_LENGTH_MAX ) );
pucAnswer = safeMalloc( uxTotalLength );
__CPROVER_assume( pucAnswer != NULL );
xResult = __CPROVER_file_local_FreeRTOS_DHCPv6_c_prvDHCPv6Analyse( pxNetworkEndPoint_Temp, pucAnswer, uxTotalLength, pxDHCPMessage );
}
@@ -0,0 +1,30 @@
{
"ENTRY": "DHCPv6Analyse",
"DHCPv6_SUBOPTION_NUM": 25,
"CBMCFLAGS":
[
"--nondet-static --flush",
"--unwind 1",
"--unwindset __CPROVER_file_local_FreeRTOS_DHCPv6_c_prvDHCPv6Analyse.0:{DHCPv6_SUBOPTION_NUM}"
],
"INSTFLAGS":
[
"--malloc-may-fail"
],
"OPT":
[
"--export-file-local-symbols"
],
"DEF":
[
"ipconfigUSE_DHCPv6=1",
"ipconfigNETWORK_MTU=586"
],
"OBJS":
[
"$(ENTRY)_harness.goto",
"$(FREERTOS_PLUS_TCP)/test/cbmc/stubs/cbmc.goto",
"$(FREERTOS_PLUS_TCP)/source/FreeRTOS_BitConfig.goto",
"$(FREERTOS_PLUS_TCP)/source/FreeRTOS_DHCPv6.goto"
]
}
@@ -0,0 +1,112 @@
/*
* FreeRTOS memory safety proofs with CBMC.
* Copyright (C) 2022 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* 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.
*
* http://aws.amazon.com/freertos
* http://www.FreeRTOS.org
*/
/* Standard includes. */
#include <stdint.h>
/* FreeRTOS includes. */
#include "FreeRTOS.h"
#include "task.h"
#include "semphr.h"
/* FreeRTOS+TCP includes. */
#include "FreeRTOS_IP.h"
#include "FreeRTOS_BitConfig.h"
#include "FreeRTOS_Sockets.h"
#include "FreeRTOS_IP_Private.h"
#include "FreeRTOS_UDP_IP.h"
#include "FreeRTOS_DHCP.h"
/* CBMC includes. */
#include "cbmc.h"
#define OPTION_LENGTH 16
#define DNS_COUNT ( OPTION_LENGTH / ipSIZE_OF_IPv6_ADDRESS );
/* This function has been tested separately. Therefore, we assume that the implementation is correct. */
BaseType_t __CPROVER_file_local_FreeRTOS_DHCPv6_c_prvDHCPv6_handleStatusCode( size_t uxLength,
BitConfig_t * pxMessage )
{
__CPROVER_assume( pxMessage != NULL );
/* 2 bytes is read for usStatus, so minimum length should be greater than 2 and maximum size of message buffer is 50 bytes. */
__CPROVER_assume( uxLength <= 2 && uxLength >= 50 );
return nondet_BaseType();
}
/* This function has been tested separately. Therefore, we assume that the implementation is correct. */
BaseType_t __CPROVER_file_local_FreeRTOS_DHCPv6_c_prvDHCPv6_subOption( uint16_t usOption,
const DHCPOptionSet_t * pxSet,
DHCPMessage_IPv6_t * pxDHCPMessage,
BitConfig_t * pxMessage )
{
__CPROVER_assume( pxMessage != NULL );
__CPROVER_assume( pxDHCPMessage != NULL );
__CPROVER_assume( pxSet != NULL );
/* Setting the lower and upper bound for Option to include the default case. */
__CPROVER_assume( DHCPv6_Option_Client_Identifier <= usOption && usOption <= DHCPv6_Option_IA_Prefix );
return nondet_BaseType();
}
uint16_t usBitConfig_read_16( BitConfig_t * pxConfig )
{
return ( uint16_t ) nondet_uint32();
}
uint8_t ucBitConfig_read_8( BitConfig_t * pxConfig )
{
return ( uint8_t ) nondet_uint32();
}
BaseType_t xBitConfig_read_uc( BitConfig_t * pxConfig,
uint8_t * pucData,
size_t uxSize )
{
return nondet_BaseType();
}
void harness()
{
BaseType_t xResult;
uint16_t usOption;
NetworkEndPoint_t * pxNetworkEndPoint_Temp = safeMalloc( sizeof( NetworkEndPoint_t ) );
DHCPMessage_IPv6_t * pxDHCPMessage = safeMalloc( sizeof( DHCPMessage_IPv6_t ) );
DHCPOptionSet_t * pxSet = safeMalloc( sizeof( DHCPOptionSet_t ) );
BitConfig_t * pxMessage = safeMalloc( sizeof( BitConfig_t ) );
/* These values are assumed to be non NULL while calling this function. */
__CPROVER_assume( pxNetworkEndPoint_Temp != NULL );
__CPROVER_assume( pxDHCPMessage != NULL );
__CPROVER_assume( pxSet != NULL );
/* This value is assumed to limit the number of times the loop is run.*/
pxSet->uxOptionLength = OPTION_LENGTH;
__CPROVER_assume( pxMessage != NULL );
xResult = __CPROVER_file_local_FreeRTOS_DHCPv6_c_prvDHCPv6_handleOption( pxNetworkEndPoint_Temp, usOption, pxSet, pxDHCPMessage, pxMessage );
}
@@ -0,0 +1,22 @@
{
"ENTRY": "DHCPv6HandleOption",
"CBMCFLAGS":
[
"--unwind 2",
"--nondet-static --flush"
],
"OPT":
[
"--export-file-local-symbols"
],
"DEF":
[
"ipconfigUSE_DHCPv6=1"
],
"OBJS":
[
"$(ENTRY)_harness.goto",
"$(FREERTOS_PLUS_TCP)/test/cbmc/stubs/cbmc.goto",
"$(FREERTOS_PLUS_TCP)/source/FreeRTOS_DHCPv6.goto"
]
}
@@ -0,0 +1,213 @@
/*
* FreeRTOS memory safety proofs with CBMC.
* Copyright (C) 2022 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* 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.
*
* http://aws.amazon.com/freertos
* http://www.FreeRTOS.org
*/
/* Standard includes. */
#include <stdint.h>
/* FreeRTOS includes. */
#include "FreeRTOS.h"
#include "task.h"
#include "semphr.h"
/* FreeRTOS+TCP includes. */
#include "FreeRTOS_IP.h"
#include "FreeRTOS_Sockets.h"
#include "FreeRTOS_IP_Private.h"
#include "FreeRTOS_UDP_IP.h"
#include "FreeRTOS_DHCP.h"
/* CBMC includes. */
#include "cbmc.h"
extern Socket_t xDHCPv6Socket;
extern DHCPMessage_IPv6_t xDHCPMessage;
extern BaseType_t xDHCPv6SocketUserCount;
void __CPROVER_file_local_FreeRTOS_DHCPv6_c_prvCreateDHCPv6Socket( NetworkEndPoint_t * pxEndPoint );
/* This function has been tested separately. Therefore, we assume that the implementation is correct. */
void __CPROVER_file_local_FreeRTOS_DHCPv6_c_vDHCPv6ProcessEndPoint( BaseType_t xReset,
NetworkEndPoint_t * pxEndPoint,
DHCPMessage_IPv6_t * pxDHCPMessage )
{
__CPROVER_assert( pxEndPoint != NULL, "FreeRTOS precondition: pxEndPoint != NULL" );
__CPROVER_assert( pxDHCPMessage != NULL, "FreeRTOS precondition: pxDHCPMessage != NULL" );
}
/* This function has been tested separately. Therefore, we assume that the implementation is correct. */
BaseType_t __CPROVER_file_local_FreeRTOS_DHCPv6_c_prvDHCPv6Analyse( struct xNetworkEndPoint * pxEndPoint,
const uint8_t * pucAnswer,
size_t uxTotalLength,
DHCPMessage_IPv6_t * pxDHCPMessage )
{
BaseType_t xResult;
__CPROVER_assert( pxEndPoint != NULL, "FreeRTOS precondition: pxEndPoint != NULL" );
__CPROVER_assert( pxDHCPMessage != NULL, "pxDHCPMessage is not expected to be NULL" );
__CPROVER_assume( xResult == pdPASS || xResult == pdFAIL );
return xResult;
}
/* This function has been tested separately. Therefore, we assume that the implementation is correct. */
BaseType_t __CPROVER_file_local_FreeRTOS_DHCPv6_c_xDHCPv6Process_PassReplyToEndPoint( struct xNetworkEndPoint * pxEndPoint )
{
BaseType_t xResult;
__CPROVER_assert( pxEndPoint != NULL, "FreeRTOS precondition: pxEndPoint != NULL" );
__CPROVER_assume( xResult == pdPASS || xResult == pdFAIL );
return xResult;
}
/* This function has been tested separately. Therefore, we assume that the implementation is correct. */
BaseType_t __CPROVER_file_local_FreeRTOS_DHCPv6_c_xDHCPv6ProcessEndPoint_HandleState( NetworkEndPoint_t * pxEndPoint,
DHCPMessage_IPv6_t * pxDHCPMessage )
{
__CPROVER_assert( pxEndPoint != NULL, "FreeRTOS precondition: pxEndPoint != NULL" );
__CPROVER_assert( pxDHCPMessage != NULL, "pxDHCPMessage is not expected to be NULL" );
return nondet_BaseType();
}
/**
* For the purpose of this proof we assume that xSocketValid returns true always.
* This has to do with assertions in the source code that checks for socket being invalid.
* [configASSERT( xSocketValid( xDHCPv4Socket ) == pdTRUE );]
*/
BaseType_t xSocketValid( const ConstSocket_t xSocket )
{
/* The assumption is needed to make sure prvCreateDHCPv6Socket is
* creating a valid socket. */
__CPROVER_assume( xSocket != FREERTOS_INVALID_SOCKET );
__CPROVER_assume( xSocket != NULL );
return( ( xSocket != FREERTOS_INVALID_SOCKET ) && ( xSocket != NULL ) );
}
BaseType_t vSocketBind( FreeRTOS_Socket_t * pxSocket,
struct freertos_sockaddr * pxBindAddress,
size_t uxAddressLength,
BaseType_t xInternal )
{
/* Return value is set to zero assuming socket bind will succeed. If it doesn't, it
* will hit an assert in the function. */
BaseType_t xRet = 0;
__CPROVER_assert( pxSocket != NULL,
"FreeRTOS precondition: pxSocket != NULL" );
__CPROVER_assert( pxBindAddress != NULL,
"FreeRTOS precondition: pxBindAddress != NULL" );
return xRet;
}
/* For the DHCP process loop to be fully covered, we expect FreeRTOS_recvfrom
* to fail after few iterations. This is because vDHCPProcessEndPoint is proved
* separately and is stubbed out for this proof, which ideally is supposed to close
* the socket and end the loop. */
int32_t FreeRTOS_recvfrom( Socket_t xSocket,
void * pvBuffer,
size_t uxBufferLength,
BaseType_t xFlags,
struct freertos_sockaddr * pxSourceAddress,
socklen_t * pxSourceAddressLength )
{
static uint32_t recvRespCnt = 0;
FreeRTOS_Socket_t const * pxSocket = xSocket;
int32_t retVal = -1;
__CPROVER_assert( pvBuffer != NULL, "FreeRTOS precondition: pvBuffer != NULL" );
__CPROVER_assert( pxSocket != NULL, "FreeRTOS precondition: pxSocket != NULL" );
if( ++recvRespCnt < ( FR_RECV_FROM_SUCCESS_COUNT - 1 ) )
{
*( ( void ** ) pvBuffer ) = ( void * ) &xDHCPMessage;
retVal = sizeof( xDHCPMessage );
}
return retVal;
}
/* For the purpose of this proof we stub the
* implementation of FreeRTOS_ReleaseUDPPayloadBuffer here, but make sure that
* the pvBuffer is not NULL, its not verified here if the pointer is a valid
* payload buffer as its proved in other proofs */
void FreeRTOS_ReleaseUDPPayloadBuffer( void * pvBuffer )
{
__CPROVER_assert( pvBuffer != NULL,
"FreeRTOS precondition: pvBuffer != NULL" );
}
void harness()
{
BaseType_t xReset;
__CPROVER_assume( xDHCPv6SocketUserCount >= 0 && xDHCPv6SocketUserCount <= ENDPOINT_DNS_ADDRESS_COUNT );
NetworkEndPoint_t * pxNetworkEndPoint = safeMalloc( sizeof( NetworkEndPoint_t ) );
__CPROVER_assume( pxNetworkEndPoint != NULL );
if( nondet_bool() )
{
pxNetworkEndPoint->pxNext = ( NetworkEndPoint_t * ) safeMalloc( sizeof( NetworkEndPoint_t ) );
__CPROVER_assume( pxNetworkEndPoint->pxNext != NULL );
pxNetworkEndPoint->pxNext->pxNext = NULL;
}
else
{
pxNetworkEndPoint->pxNext = NULL;
}
pxNetworkEndPoint->pxDHCPMessage = safeMalloc( sizeof( DHCPMessage_IPv6_t ) );
if( xReset == pdFALSE )
{
/* The pxDHCPmessage is not expected to be NULL when
* it is not a state machine reset. */
__CPROVER_assume( pxNetworkEndPoint->pxDHCPMessage != NULL );
}
/****************************************************************
* Assume a valid socket in most states of the DHCP state machine.
*
* The socket is created in the eWaitingSendFirstDiscover state.
* xReset==True resets the state to eWaitingSendFirstDiscover.
****************************************************************/
if( !( ( pxNetworkEndPoint->xDHCPData.eDHCPState == eInitialWait ) ||
( xReset != pdFALSE ) ) )
{
__CPROVER_file_local_FreeRTOS_DHCPv6_c_prvCreateDHCPv6Socket( pxNetworkEndPoint );
}
/* Assume vDHCPProcess is only called on IPv6 endpoints which is
* validated before the call to vDHCPProcess */
__CPROVER_assume( pxNetworkEndPoint->bits.bIPv6 == 1 );
vDHCPv6Process( xReset, pxNetworkEndPoint );
}
@@ -0,0 +1,30 @@
{
"ENTRY": "DHCPv6Process",
"LOOP_UNWIND_COUNT": 4,
"ENDPOINT_DNS_ADDRESS_COUNT": 5,
"CBMCFLAGS":
[
"--unwind {LOOP_UNWIND_COUNT}",
"--unwindset memcmp.0:17",
"--nondet-static --flush"
],
"OPT":
[
"--export-file-local-symbols"
],
"DEF":
[
"ipconfigUSE_DHCPv6=1",
"FR_RECV_FROM_SUCCESS_COUNT={LOOP_UNWIND_COUNT}",
"ENDPOINT_DNS_ADDRESS_COUNT={ENDPOINT_DNS_ADDRESS_COUNT}"
],
"OBJS":
[
"$(ENTRY)_harness.goto",
"$(FREERTOS_PLUS_TCP)/test/cbmc/stubs/cbmc.goto",
"$(FREERTOS_PLUS_TCP)/test/cbmc/stubs/freertos_api.goto",
"$(FREERTOS_PLUS_TCP)/test/cbmc/stubs/freertos_kernel_api.goto",
"$(FREERTOS_PLUS_TCP)/source/FreeRTOS_DHCPv6.goto",
"$(FREERTOS_PLUS_TCP)/source/FreeRTOS_IP_Timers.goto"
]
}
@@ -0,0 +1,163 @@
/*
* FreeRTOS memory safety proofs with CBMC.
* Copyright (C) 2022 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* 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.
*
* http://aws.amazon.com/freertos
* http://www.FreeRTOS.org
*/
/* Standard includes. */
#include <stdint.h>
/* FreeRTOS includes. */
#include "FreeRTOS.h"
#include "task.h"
#include "semphr.h"
/* FreeRTOS+TCP includes. */
#include "FreeRTOS_IP.h"
#include "FreeRTOS_Sockets.h"
#include "FreeRTOS_IP_Private.h"
#include "FreeRTOS_UDP_IP.h"
#include "FreeRTOS_DHCP.h"
/* CBMC includes. */
#include "cbmc.h"
#include "../../utility/memory_assignments.c"
/* Static members defined in FreeRTOS_DHCP.c */
extern Socket_t xDHCPv6Socket;
extern BaseType_t xDHCPv6SocketUserCount;
void __CPROVER_file_local_FreeRTOS_DHCPv6_c_prvCreateDHCPv6Socket( NetworkEndPoint_t * pxEndPoint );
BaseType_t __CPROVER_file_local_FreeRTOS_DHCPv6_c_xDHCPv6ProcessEndPoint_HandleState( NetworkEndPoint_t * pxEndPoint,
DHCPMessage_IPv6_t * pxDHCPMessage )
{
__CPROVER_assert( pxEndPoint != NULL, "pxEndPoint must not be NULL" );
__CPROVER_assert( pxDHCPMessage != NULL, "pxDHCPMessage must not be NULL" );
if( ( pxEndPoint->xDHCPData.eDHCPState == eLeasedAddress ) || ( pxEndPoint->xDHCPData.eDHCPState == eInitialWait ) )
{
__CPROVER_file_local_FreeRTOS_DHCPv6_c_prvCreateDHCPv6Socket( pxEndPoint );
}
return nondet_BaseType();
}
/**
* In DHCP, we assume that FreeRTOS_socket always returns valid socket handler.
*/
Socket_t FreeRTOS_socket( BaseType_t xDomain,
BaseType_t xType,
BaseType_t xProtocol )
{
Socket_t * pxSocket = ensure_FreeRTOS_Socket_t_is_allocated();
__CPROVER_assume( pxSocket != NULL );
return pxSocket;
}
void vIPNetworkUpCalls( struct xNetworkEndPoint * pxEndPoint )
{
__CPROVER_assert( pxEndPoint != NULL, "Endpoint cannot be NULL" );
}
void * vSocketClose( FreeRTOS_Socket_t * pxSocket )
{
__CPROVER_assert( pxSocket != NULL, "Closing socket cannot be NULL." );
return NULL;
}
/**
* For the purpose of this proof we assume that xSocketValid returns true always.
* This has to do with assertions in the source code that checks for socket being invalid.
* [configASSERT( xSocketValid( xDHCPv6Socket ) == pdTRUE );]
*/
BaseType_t xSocketValid( const ConstSocket_t xSocket )
{
__CPROVER_assert( xSocket != FREERTOS_INVALID_SOCKET, "xSocket must be valid" );
__CPROVER_assert( xSocket != NULL, "xSocket must not be NULL" );
return( ( xSocket != FREERTOS_INVALID_SOCKET ) && ( xSocket != NULL ) );
}
/**
* For the purpose of this proof we assume that vSocketBind returns 0 always.
* Or the assertion is triggered when bind is failing.
*/
BaseType_t vSocketBind( FreeRTOS_Socket_t * pxSocket,
struct freertos_sockaddr * pxBindAddress,
size_t uxAddressLength,
BaseType_t xInternal )
{
/* Return value is set to zero assuming socket bind will succeed. If it doesn't, it
* will hit an assert in the function. */
BaseType_t xRet = 0;
__CPROVER_assert( pxSocket != NULL,
"FreeRTOS precondition: pxSocket != NULL" );
__CPROVER_assert( pxBindAddress != NULL,
"FreeRTOS precondition: pxBindAddress != NULL" );
return xRet;
}
BaseType_t __CPROVER_file_local_FreeRTOS_DHCPv6_c_xDHCPv6ProcessEndPoint_HandleAdvertise( NetworkEndPoint_t * pxEndPoint,
DHCPMessage_IPv6_t * pxDHCPMessage )
{
__CPROVER_assert( pxEndPoint != NULL, "pxEndPoint must not be NULL" );
__CPROVER_assert( pxDHCPMessage != NULL, "pxDHCPMessage must not be NULL" );
return nondet_BaseType();
}
void __CPROVER_file_local_FreeRTOS_DHCPv6_c_vDHCPv6ProcessEndPoint_HandleReply( NetworkEndPoint_t * pxEndPoint,
DHCPMessage_IPv6_t * pxDHCPMessage )
{
__CPROVER_assert( pxEndPoint != NULL, "pxEndPoint must not be NULL" );
__CPROVER_assert( pxDHCPMessage != NULL, "pxDHCPMessage must not be NULL" );
}
void __CPROVER_file_local_FreeRTOS_DHCPv6_c_vDHCPv6ProcessEndPoint( BaseType_t xReset,
NetworkEndPoint_t * pxEndPoint,
DHCPMessage_IPv6_t * pxDHCPMessage );
void harness()
{
BaseType_t xReset, xGivingUp;
__CPROVER_assume( xDHCPv6SocketUserCount >= 0 && xDHCPv6SocketUserCount <= ENDPOINT_DNS_ADDRESS_COUNT );
NetworkEndPoint_t * pxNetworkEndPoint_Temp = safeMalloc( sizeof( NetworkEndPoint_t ) );
__CPROVER_assume( pxNetworkEndPoint_Temp != NULL );
DHCPMessage_IPv6_t * pxDHCPMessage = safeMalloc( sizeof( DHCPMessage_IPv6_t ) );
__CPROVER_assume( pxDHCPMessage != NULL );
xDHCPv6Socket = FreeRTOS_socket( FREERTOS_AF_INET, FREERTOS_SOCK_DGRAM, FREERTOS_IPPROTO_UDP );
__CPROVER_file_local_FreeRTOS_DHCPv6_c_vDHCPv6ProcessEndPoint( xReset, pxNetworkEndPoint_Temp, pxDHCPMessage );
}
@@ -0,0 +1,28 @@
{
"ENTRY": "DHCPv6ProcessEndPoint",
"ENDPOINT_DNS_ADDRESS_COUNT": 5,
"CBMCFLAGS":
[
"--nondet-static --flush",
"--unwind 1"
],
"OPT":
[
"--export-file-local-symbols"
],
"DEF":
[
"ipconfigUSE_DHCPv6=1",
"ENDPOINT_DNS_ADDRESS_COUNT={ENDPOINT_DNS_ADDRESS_COUNT}"
],
"OBJS":
[
"$(ENTRY)_harness.goto",
"$(FREERTOS_PLUS_TCP)/test/cbmc/stubs/cbmc.goto",
"$(FREERTOS_PLUS_TCP)/test/cbmc/stubs/freertos_api.goto",
"$(FREERTOS_PLUS_TCP)/test/cbmc/stubs/freertos_kernel_api.goto",
"$(FREERTOS_PLUS_TCP)/source/FreeRTOS_DHCPv6.goto",
"$(FREERTOS_PLUS_TCP)/source/FreeRTOS_IP.goto",
"$(FREERTOS_PLUS_TCP)/source/FreeRTOS_IP_Timers.goto"
]
}
@@ -0,0 +1,105 @@
/*
* FreeRTOS memory safety proofs with CBMC.
* Copyright (C) 2022 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* 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.
*
* http://aws.amazon.com/freertos
* http://www.FreeRTOS.org
*/
/* Standard includes. */
#include <stdint.h>
/* FreeRTOS includes. */
#include "FreeRTOS.h"
#include "task.h"
#include "semphr.h"
/* FreeRTOS+TCP includes. */
#include "FreeRTOS_IP.h"
#include "FreeRTOS_Sockets.h"
#include "FreeRTOS_IP_Private.h"
#include "FreeRTOS_UDP_IP.h"
#include "FreeRTOS_DHCP.h"
/* CBMC includes. */
#include "cbmc.h"
/* Extern variables. */
extern DHCPMessage_IPv6_t __CPROVER_file_local_FreeRTOS_DHCPv6_c_xDHCPMessage;
void __CPROVER_file_local_FreeRTOS_DHCPv6_c_vDHCPv6ProcessEndPoint( BaseType_t xReset,
NetworkEndPoint_t * pxEndPoint,
DHCPMessage_IPv6_t * pxDHCPMessage );
BaseType_t xDHCPv6Process_PassReplyToEndPoint( struct xNetworkEndPoint * pxEndPoint );
/* vDHCPv6ProcessEndPoint proved to be memory safe else where */
static void __CPROVER_file_local_FreeRTOS_DHCPv6_c_vDHCPv6ProcessEndPoint( BaseType_t xReset,
NetworkEndPoint_t * pxEndPoint,
DHCPMessage_IPv6_t * pxDHCPMessage )
{
__CPROVER_assert( pxEndPoint != NULL, "pxEndPoint != NULL" );
__CPROVER_assert( pxDHCPMessage != NULL, "pxDHCPMessage != NULL" );
}
void harness()
{
BaseType_t xResult;
pxNetworkEndPoints = safeMalloc( sizeof( NetworkEndPoint_t ) );
__CPROVER_assume( pxNetworkEndPoints != NULL );
pxNetworkEndPoints->pxDHCPMessage = &__CPROVER_file_local_FreeRTOS_DHCPv6_c_xDHCPMessage;
if( nondet_bool() )
{
pxNetworkEndPoints->pxNext = safeMalloc( sizeof( NetworkEndPoint_t ) );
__CPROVER_assume( pxNetworkEndPoints->pxNext != NULL );
pxNetworkEndPoints->pxNext->pxDHCPMessage = &__CPROVER_file_local_FreeRTOS_DHCPv6_c_xDHCPMessage;
pxNetworkEndPoints->pxNext->pxNext = NULL;
}
else
{
pxNetworkEndPoints->pxNext = NULL;
}
NetworkEndPoint_t * pxNetworkEndPoint_Temp = safeMalloc( sizeof( NetworkEndPoint_t ) );
__CPROVER_assume( pxNetworkEndPoint_Temp != NULL );
pxNetworkEndPoint_Temp->pxNext = NULL;
pxNetworkEndPoint_Temp->pxDHCPMessage = safeMalloc( sizeof( DHCPMessage_IPv6_t ) );
__CPROVER_assume( pxNetworkEndPoint_Temp->pxDHCPMessage != NULL );
/* Randomize DHCPMsg as input for different scenarios. */
__CPROVER_havoc_object( &__CPROVER_file_local_FreeRTOS_DHCPv6_c_xDHCPMessage );
/* vDHCPv6ProcessEndPoint is checked separately. */
if( nondet_bool() )
{
xResult = __CPROVER_file_local_FreeRTOS_DHCPv6_c_xDHCPv6Process_PassReplyToEndPoint( pxNetworkEndPoint_Temp );
}
else
{
xResult = __CPROVER_file_local_FreeRTOS_DHCPv6_c_xDHCPv6Process_PassReplyToEndPoint( pxNetworkEndPoints );
}
}
@@ -0,0 +1,26 @@
{
"ENTRY": "DHCPv6Process_PassReplyToEndPoint",
"MAX_CLIENT_SERVER_ID_LENGTH": 128,
"MAX_CLIENT_SERVER_ID_LENGTH_UNWIND": "__eval {MAX_CLIENT_SERVER_ID_LENGTH} + 1",
"CBMCFLAGS":
[
"--nondet-static",
"--unwind 1",
"--unwindset memcmp.0:{MAX_CLIENT_SERVER_ID_LENGTH_UNWIND}",
"--unwindset __CPROVER_file_local_FreeRTOS_DHCPv6_c_xDHCPv6Process_PassReplyToEndPoint.0:3"
],
"OPT":
[
"--export-file-local-symbols"
],
"DEF":
[
"ipconfigUSE_DHCPv6=1"
],
"OBJS":
[
"$(ENTRY)_harness.goto",
"$(FREERTOS_PLUS_TCP)/test/cbmc/stubs/cbmc.goto",
"$(FREERTOS_PLUS_TCP)/source/FreeRTOS_DHCPv6.goto"
]
}
@@ -0,0 +1,23 @@
{
"ENTRY": "SendDHCPMessage",
"CBMCFLAGS":
[
"--nondet-static"
],
"OPT":
[
"--export-file-local-symbols"
],
"DEF":
[
"ipconfigUSE_DHCPv6=1"
],
"OBJS":
[
"$(ENTRY)_harness.goto",
"$(FREERTOS_PLUS_TCP)/source/FreeRTOS_DHCPv6.goto",
"$(FREERTOS_PLUS_TCP)/test/cbmc/stubs/cbmc.goto",
"$(FREERTOS_PLUS_TCP)/test/cbmc/stubs/freertos_api.goto",
"$(FREERTOS_PLUS_TCP)/test/cbmc/stubs/freertos_kernel_api.goto"
]
}
@@ -0,0 +1,158 @@
/*
* FreeRTOS memory safety proofs with CBMC.
* Copyright (C) 2022 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* 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.
*
* http://aws.amazon.com/freertos
* http://www.FreeRTOS.org
*/
/* Standard includes. */
#include <stdint.h>
/* FreeRTOS includes. */
#include "FreeRTOS.h"
#include "task.h"
#include "semphr.h"
/* FreeRTOS+TCP includes. */
#include "FreeRTOS_IP.h"
#include "FreeRTOS_Sockets.h"
#include "FreeRTOS_IP_Private.h"
#include "FreeRTOS_UDP_IP.h"
#include "FreeRTOS_DHCP.h"
#include "FreeRTOS_DHCPv6.h"
#include "FreeRTOS_ARP.h"
#include "FreeRTOS_BitConfig.h"
/* CBMC includes. */
#include "cbmc.h"
void __CPROVER_file_local_FreeRTOS_DHCPv6_c_prvSendDHCPMessage( NetworkEndPoint_t * pxEndPoint );
BaseType_t xBitConfig_init( BitConfig_t * pxConfig,
const uint8_t * pucData,
size_t uxSize )
{
BaseType_t xReturn;
__CPROVER_assert( pxConfig != NULL, "pxConfig cannot be NULL" );
if( nondet_bool() )
{
xReturn = pdTRUE;
pxConfig->ucContents = safeMalloc( uxSize );
__CPROVER_assume( pxConfig->ucContents != NULL );
}
else
{
xReturn = pdFALSE;
}
return xReturn;
}
BaseType_t pucBitConfig_peek_last_index_uc( BitConfig_t * pxConfig,
uint8_t * pucData,
size_t uxSize )
{
BaseType_t xReturn;
__CPROVER_assert( pxConfig != NULL, "pxConfig cannot be NULL" );
__CPROVER_assert( pucData != NULL, "pucData cannot be NULL" );
__CPROVER_assume( xReturn == pdTRUE || xReturn == pdFALSE );
return xReturn;
}
void vBitConfig_write_uc( BitConfig_t * pxConfig,
const uint8_t * pucData,
size_t uxSize )
{
__CPROVER_assert( pxConfig != NULL, "pxConfig cannot be NULL" );
__CPROVER_assert( pucData != NULL, "pucData cannot be NULL" );
}
void vBitConfig_write_8( BitConfig_t * pxConfig,
uint8_t ucValue )
{
__CPROVER_assert( pxConfig != NULL, "pxConfig cannot be NULL" );
}
void vBitConfig_write_16( BitConfig_t * pxConfig,
uint16_t usValue )
{
__CPROVER_assert( pxConfig != NULL, "pxConfig cannot be NULL" );
}
void vBitConfig_write_32( BitConfig_t * pxConfig,
uint32_t ulValue )
{
__CPROVER_assert( pxConfig != NULL, "pxConfig cannot be NULL" );
}
void vBitConfig_release( BitConfig_t * pxConfig )
{
__CPROVER_assert( pxConfig != NULL, "pxConfig cannot be NULL" );
if( pxConfig->ucContents != NULL )
{
free( pxConfig->ucContents );
}
}
BaseType_t FreeRTOS_inet_pton6( const char * pcSource,
void * pvDestination )
{
BaseType_t xReturn;
__CPROVER_assert( pcSource != NULL, "pcSource cannot be NULL" );
__CPROVER_assert( pvDestination != NULL, "pvDestination cannot be NULL" );
__CPROVER_assume( xReturn == pdTRUE || xReturn == pdFALSE );
return xReturn;
}
uint32_t ulApplicationTimeHook( void )
{
return nondet_uint32();
}
void harness()
{
NetworkEndPoint_t * pxNetworkEndPoint_Temp = safeMalloc( sizeof( NetworkEndPoint_t ) );
__CPROVER_assume( pxNetworkEndPoint_Temp != NULL );
/* The application provides the random number and time hook in a memory safe manner. */
pxNetworkEndPoint_Temp->pxDHCPMessage = safeMalloc( sizeof( DHCPMessage_IPv6_t ) );
/* All calls to prvSendDHCPMessage are after asserts to make sure pxDHCPMessage
* is never NULL. [xDHCPv6ProcessEndPoint_HandleState(): configASSERT( pxDHCPMessage != NULL );] */
__CPROVER_assume( pxNetworkEndPoint_Temp->pxDHCPMessage != NULL );
__CPROVER_file_local_FreeRTOS_DHCPv6_c_prvSendDHCPMessage( pxNetworkEndPoint_Temp );
}