As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

Biblioteca de Secure Sockets

Visão geral

Você pode usar a biblioteca Free RTOS Secure Sockets para criar aplicativos incorporados que se comunicam com segurança. A biblioteca foi projetada para facilitar a integração de desenvolvedores de software de várias bases de programação de rede.

A biblioteca Free RTOS Secure Sockets é baseada na interface de soquetes Berkeley, com uma opção adicional de comunicação segura por protocolo. TLS Para obter informações sobre as diferenças entre a biblioteca Free RTOS Secure Sockets e a interface de soquetes Berkeley, consulte a Secure Sockets SOCKETS_SetSockOpt Reference. API

Dependências e requisitos

A biblioteca Free RTOS Secure Sockets depende de uma pilha TCP /IP e de uma implementação. TLS O Ports for Free RTOS atende a essas dependências de uma das três maneiras:

O diagrama de dependências abaixo mostra a implementação de referência incluída na biblioteca Free RTOS Secure Sockets. Essa implementação de referência suporta TLS TCP e/IP sobre Ethernet e Wi-Fi com Free RTOS + TCP e mbed TLS como dependências. Para obter mais informações sobre a RTOS TLS camada Livre, consulteTransport Layer Security.

Recursos

Os recursos gratuitos da biblioteca RTOS Secure Sockets incluem:

Solução de problemas

Códigos de erro

Os códigos de erro que a biblioteca Free RTOS Secure Sockets retorna são valores negativos. Para obter mais informações sobre cada código de erro, consulte Códigos de erro do Secure Sockets na Referência do Secure Sockets API.

Suporte ao desenvolvedor

A biblioteca Free RTOS Secure Sockets inclui duas macros auxiliares para lidar com endereços IP:

Restrições de uso

Somente TCP soquetes são suportados pela biblioteca Free RTOS Secure Sockets. UDPsoquetes não são suportados.

APIsOs servidores não são suportados pela biblioteca Free RTOS Secure Sockets, exceto por uma implementação de IP leve (LWIP) do lado do servidor. Bind API O cliente APIs é suportado.

Inicialização

Para usar a biblioteca Free RTOS Secure Sockets, você precisa inicializar a biblioteca e suas dependências. Para inicializar a biblioteca de Secure Sockets, use o seguinte código na aplicação:

BaseType_t xResult = pdPASS;
xResult = SOCKETS_Init();

As bibliotecas dependentes devem ser inicializadas separadamente. Por exemplo, se Free RTOS + TCP for uma dependência, você também precisará invocar FreeRTOS_IPInitem seu aplicativo.

Referência do API

Para obter uma API referência completa, consulte Secure Sockets API Reference.

Exemplo de uso

O código a seguir conecta um cliente a um servidor.

#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 );
}

Para obter um exemplo completo, consulte Demonstração do cliente Echo de Secure Sockets.

Portabilidade

O Free RTOS Secure Sockets depende de uma pilha TCP /IP e de uma implementação. TLS Dependendo da pilha, para transferir a biblioteca de Secure Sockets, será necessário transferir alguns dos seguintes:

Para obter mais informações sobre portabilidade, consulte Porting the Secure Sockets Library no Free RTOS Porting Guide.