Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

Bibliothèque Secure Sockets

Présentation

Vous pouvez utiliser la bibliothèque FreeRTOS Secure Sockets pour créer des applications intégrées qui communiquent en toute sécurité. Cette bibliothèque a été conçue pour faciliter les premiers pas des développeurs logiciels aux expériences de programmation réseau diverses.

La bibliothèque FreeRTOS Secure Sockets est basée sur l'interface des sockets de Berkeley, avec une option de communication sécurisée supplémentaire par le protocole TLS. Pour plus d'informations sur les différences entre la bibliothèque FreeRTOS Secure Sockets et l'interface des sockets Berkeley, SOCKETS_SetSockOpt consultez la référence de l'API Secure Sockets.

Dépendances et exigences

La bibliothèque FreeRTOS Secure Sockets dépend d'une pile TCP/IP et d'une implémentation TLS. Les ports pour FreeRTOS répondent à ces dépendances de trois manières :

Le diagramme de dépendance ci-dessous montre l'implémentation de référence incluse dans la bibliothèque FreeRTOS Secure Sockets. Cette implémentation de référence prend en charge TLS et TCP/IP sur Ethernet et le Wi-Fi avec FreeRTOS+TCP et mbedTLS comme dépendances. Pour plus d'informations sur la couche TLS FreeRTOS, consultez.  : acte de révision dans un pipeline se poursuivant d'une étape à l'autre dans un flux de travail.

Fonctionnalités

Les fonctionnalités de la bibliothèque FreeRTOS Secure Sockets incluent :

Résolution des problèmes

Codes d’erreur

Les codes d'erreur renvoyés par la bibliothèque FreeRTOS Secure Sockets sont des valeurs négatives. Pour plus d'informations sur chaque code d'erreur, consultez Codes d'erreur Secure Sockets dans la Référence d'API Secure Sockets.

Developer Support

La bibliothèque FreeRTOS Secure Sockets inclut deux macros d'assistance pour gérer les adresses IP :

Restrictions liées à l'utilisation

Seuls les sockets TCP sont pris en charge par la bibliothèque FreeRTOS Secure Sockets. Les sockets UDP ne sont pas pris en charge.

APIs Les serveurs ne sont pas pris en charge par la bibliothèque FreeRTOS Secure Sockets, à l'exception d'une implémentation IP légère (LWiP) de l'API côté serveur. Bind APIs Les clients sont pris en charge.

Initialisation

Pour utiliser la bibliothèque FreeRTOS Secure Sockets, vous devez initialiser la bibliothèque et ses dépendances. Pour initialiser la bibliothèque Secure Sockets, utilisez le code suivant dans votre application :

BaseType_t xResult = pdPASS;
xResult = SOCKETS_Init();

Les bibliothèques dépendantes doivent être initialisées séparément. Par exemple, si FreeRTOS+TCP est une dépendance, vous devez également invoquer FreeRTOS_IPInit dans votre application.

Référence d’API

Pour une référence complète de l'API, consultez la section Référence de l'API Secure Sockets.

Exemple d’utilisation

Le code suivant connecte un client à un serveur.

#include "aws_secure_sockets.h"

#define configSERVER_ADDR0                     127
#define configSERVER_ADDR1                     0
#define configSERVER_ADDR2                     0
#define configSERVER_ADDR3                     1
#define configCLIENT_PORT                      443

/* Rx and Tx timeouts are used to ensure the sockets do not wait too long for
 * missing data. */
static const TickType_t xReceiveTimeOut = pdMS_TO_TICKS( 2000 );
static const TickType_t xSendTimeOut = pdMS_TO_TICKS( 2000 );

/* PEM-encoded server certificate */
/* The certificate used below is one of the Amazon Root CAs.\
Change this to the certificate of your choice. */
static const char cTlsECHO_SERVER_CERTIFICATE_PEM[] =
"-----BEGIN CERTIFICATE-----\n"
"MIIBtjCCAVugAwIBAgITBmyf1XSXNmY/Owua2eiedgPySjAKBggqhkjOPQQDAjA5\n"
"MQswCQYDVQQGEwJVUzEPMA0GA1UEChMGQW1hem9uMRkwFwYDVQQDExBBbWF6b24g\n"
"Um9vdCBDQSAzMB4XDTE1MDUyNjAwMDAwMFoXDTQwMDUyNjAwMDAwMFowOTELMAkG\n"
"A1UEBhMCVVMxDzANBgNVBAoTBkFtYXpvbjEZMBcGA1UEAxMQQW1hem9uIFJvb3Qg\n"
"Q0EgMzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABCmXp8ZBf8ANm+gBG1bG8lKl\n"
"ui2yEujSLtf6ycXYqm0fc4E7O5hrOXwzpcVOho6AF2hiRVd9RFgdszflZwjrZt6j\n"
"QjBAMA8GA1UdEwEB/wQFMAMBAf8wDgYDVR0PAQH/BAQDAgGGMB0GA1UdDgQWBBSr\n"
"ttvXBp43rDCGB5Fwx5zEGbF4wDAKBggqhkjOPQQDAgNJADBGAiEA4IWSoxe3jfkr\n"
"BqWTrBqYaGFy+uGh0PsceGCmQ5nFuMQCIQCcAu/xlJyzlvnrxir4tiz+OpAUFteM\n"
"YyRIHN8wfdVoOw==\n"
"-----END CERTIFICATE-----\n";

static const uint32_t ulTlsECHO_SERVER_CERTIFICATE_LENGTH = sizeof( cTlsECHO_SERVER_CERTIFICATE_PEM );

void vConnectToServerWithSecureSocket( void )
{
    Socket_t xSocket;
    SocketsSockaddr_t xEchoServerAddress;
    BaseType_t xTransmitted, lStringLength;

    xEchoServerAddress.usPort = SOCKETS_htons( configCLIENT_PORT );
    xEchoServerAddress.ulAddress = SOCKETS_inet_addr_quick( configSERVER_ADDR0,
                                                            configSERVER_ADDR1,
                                                            configSERVER_ADDR2,
                                                            configSERVER_ADDR3 );
                                                            
    /* Create a TCP socket. */
    xSocket = SOCKETS_Socket( SOCKETS_AF_INET, SOCKETS_SOCK_STREAM, SOCKETS_IPPROTO_TCP );
    configASSERT( xSocket != SOCKETS_INVALID_SOCKET );
    
    /* Set a timeout so a missing reply does not cause the task to block indefinitely. */
    SOCKETS_SetSockOpt( xSocket, 0, SOCKETS_SO_RCVTIMEO, &xReceiveTimeOut, sizeof( xReceiveTimeOut ) );
    SOCKETS_SetSockOpt( xSocket, 0, SOCKETS_SO_SNDTIMEO, &xSendTimeOut, sizeof( xSendTimeOut ) );

    /* Set the socket to use TLS. */
    SOCKETS_SetSockOpt( xSocket, 0, SOCKETS_SO_REQUIRE_TLS, NULL, ( size_t ) 0 );
    SOCKETS_SetSockOpt( xSocket, 0, SOCKETS_SO_TRUSTED_SERVER_CERTIFICATE, cTlsECHO_SERVER_CERTIFICATE_PEM, ulTlsECHO_SERVER_CERTIFICATE_LENGTH );

    if( SOCKETS_Connect( xSocket, &xEchoServerAddress, sizeof( xEchoServerAddress ) ) == 0 )
    {
        /* Send the string to the socket. */
        xTransmitted = SOCKETS_Send( xSocket,                         /* The socket receiving. */
                                     ( void * )"some message",        /* The data being sent. */
                                     12,                              /* The length of the data being sent. */
                                     0 );                             /* No flags. */

        if( xTransmitted < 0 )
        {
            /* Error while sending data */
            return;
        }

        SOCKETS_Shutdown( xSocket, SOCKETS_SHUT_RDWR );
    }
    else
    {
        //failed to connect to server
    }

    SOCKETS_Close( xSocket );
}

Pour obtenir un exemple complet, consultez Démonstration du client Secure Sockets Echo.

Portage

Les sockets sécurisés FreeRTOS dépendent d'une pile TCP/IP et d'une implémentation TLS. En fonction de votre pile, pour effectuer le portage de la bibliothèque Secure Sockets, vous devez parfois inclure les éléments suivants :

Pour plus d'informations sur le portage, consultez la section Portage de la bibliothèque Secure Sockets dans le guide de portage de FreeRTOS.