| Pilha de protocolos TCP/IP |
|---|
| Camada de aplicação |
| Camada de transporte |
| Camada de Internet |
| Camada de enlace |
O Protocolo de Aplicação Restrita (mais conhecido pela sigla CoAP, Constrained Application Protocol em inglês) é um protocolo de aplicação de internet especializado baseado em UDP para dispositivos restritos, conforme definido na RFC 7252 (publicada em 2014). Ele permite que esses dispositivos restritos, chamados de "nós", comuniquem-se com a internet em geral usando protocolos semelhantes. O CoAP foi projetado para uso entre dispositivos na mesma rede restrita (por exemplo, redes de baixa potência e com perdas), entre dispositivos e nós gerais na internet e entre dispositivos em diferentes redes restritas, ambas unidas por uma internet. O CoAP também vem sendo utilizado por meio de outros mecanismos, como SMS em redes de comunicação móvel.
O CoAP é um protocolo de camada de aplicação destinado ao uso em dispositivos de internet com recursos restritos, como nós de rede de sensores sem fio. O CoAP foi projetado para traduzir-se facilmente para HTTP para integração simplificada com a web, ao mesmo tempo em que atende a requisitos especializados, como suporte a multicast, overhead (sobrecarga) muito baixo e simplicidade. Multicast, baixo overhead e simplicidade são importantes para a Internet das Coisas (IoT) e para a comunicação máquina a máquina (M2M), que tendem a ser de sistemas embarcados e possuem muito menos memória e capacidade de alimentação do que os dispositivos tradicionais de internet. Portanto, a eficiência é de suma importância. O CoAP pode rodar na maioria dos dispositivos que suportam UDP ou um análogo ao UDP. Ele serve como base para outros serviços de internet, como o DNS sobre CoAP.
O Grupo de Trabalho de Ambientes RESTful Restritos da Internet Engineering Task Force (IETF) (CoRE) realizou o principal trabalho de padronização para este protocolo. Para tornar o protocolo adequado para aplicações de IoT e M2M, várias novas funções foram adicionadas.
O núcleo do protocolo está especificado na RFC 7252. Várias extensões foram propostas, particularmente:
O CoAP utiliza dois tipos de mensagem, requisições e respostas, empregando um formato de cabeçalho binário simples. O CoAP é vinculado por padrão ao UDP e opcionalmente ao DTLS, fornecendo um alto nível de segurança de comunicação. Quando vinculado ao UDP, a mensagem inteira deve caber em um único datagrama. Quando usado com o 6LoWPAN conforme definido na RFC 4944, as mensagens devem caber em um único quadro IEEE 802.15.4 para minimizar a fragmentação.
A menor mensagem CoAP tem 4 bytes de comprimento, se os campos de token, opções e carga útil (payload) forem omitidos, ou seja, se consistir apenas no cabeçalho CoAP. O cabeçalho é seguido pelo valor do token (0 a 8 bytes), que pode ser seguido por uma lista de opções em um formato otimizado de tipo–comprimento–valor (TLV). Quaisquer bytes após o cabeçalho, token e opções (se houver) são considerados a carga útil da mensagem, que é prefixada pelo "marcador de carga útil" de um byte (0xFF). O comprimento da carga útil é implícito pelo comprimento do datagrama.
| Deslocamento de octeto | 0 | 1 | 2 | 3 | |||||||||||||||||||||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| Deslocamento de bit | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | 22 | 23 | 24 | 25 | 26 | 27 | 28 | 29 | 30 | 31 | |
| 4 | 32 | ver | tipo | comp. token | código req./resp. | ID da mensagem | |||||||||||||||||||||||||||
| 8 | 64 | token (0–8 bytes) | |||||||||||||||||||||||||||||||
| 12 | 96 | ||||||||||||||||||||||||||||||||
| 16 | 128 | opções (se disponíveis) | |||||||||||||||||||||||||||||||
| 20 | 160 | 1 | 1 | 1 | 1 | 1 | 1 | 1 | 1 | carga útil (se disponível) | |||||||||||||||||||||||
Os primeiros 4 bytes são obrigatórios em todos os datagramas CoAP; eles constituem o cabeçalho de tamanho fixo.
Esses campos podem ser extraídos desses 4 bytes em C por meio destas macros:
#define COAP_HEADER_VERSION(data) ( (0xC0 & (data)[0]) >> 6 )
#define COAP_HEADER_TYPE(data) ( (0x30 & (data)[0]) >> 4 )
#define COAP_HEADER_TKL(data) ( (0x0F & (data)[0]) >> 0 )
#define COAP_HEADER_CLASS(data) ( ((data)[1] >> 5) & 0x07 )
#define COAP_HEADER_CODE(data) ( ((data)[1] >> 0) & 0x1F )
#define COAP_HEADER_MID(data) ( ((data)[2] << 8) | (data)[3] )
| 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 |
|---|---|---|---|---|---|---|---|
| Classe | Código | ||||||
Os três bits mais significativos formam um número conhecido como "classe", que é análogo à classe de códigos de status HTTP. Os cinco bits menos significativos formam um código que comunica mais detalhes sobre a requisição ou resposta. O código inteiro é tipicamente comunicado na forma classe.código.
Você pode encontrar os códigos mais recentes de requisição/resposta do CoAP em , embora a lista abaixo forneça alguns exemplos:
Cada requisição carrega um token (mas pode ter comprimento zero) cujo valor foi gerado pelo cliente. O servidor deve ecoar cada valor de token sem qualquer modificação de volta para o cliente na resposta correspondente. Ele destina-se ao uso como um identificador local do cliente para associar requisições e respostas, especialmente para requisições concorrentes.
A associação de requisições e respostas não é feita com o ID da mensagem porque uma resposta pode ser enviada em uma mensagem diferente do reconhecimento (que usa o ID da mensagem para associação). Por exemplo, isso pode ser feito para evitar retransmissões se a obtenção do resultado levar algum tempo. Essa resposta separada é chamada de "resposta separada" (separate response). Em contrapartida, transmitir a resposta diretamente no reconhecimento é chamado de "resposta acoplada" ou "resposta embutida/piggybacked" (piggybacked response), que deve ser preferida por motivos de eficiência.
| Posição do bit | |||||||
|---|---|---|---|---|---|---|---|
| 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 |
| Delta da opção | Comprimento da opção | ||||||
| Delta da opção estendido (nenhum, 8 bits, 16 bits) | |||||||
| Comprimento da opção estendido (nenhum, 8 bits, 16 bits) | |||||||
| Valor da opção | |||||||
Delta da opção:
Comprimento da opção:
Valor da opção:
| Nome | Linguagem de Programação | Versão do CoAP Implementada | Cliente/Servidor | Recursos do CoAP Implementados | Licença | Link |
|---|---|---|---|---|---|---|
| coap | Dart | RFC 7252 | Cliente | Transferências em blocos (Blockwise), Observe, Multicast, Proxy (parcial) | MIT | https://github.com/shamblett/coap |
| aiocoap | Python 3 | RFC 7252, RFC 7641, RFC 7959, RFC 8323, RFC 7967, RFC 8132, RFC 9176, RFC 8613, RFC 9528 | Cliente + Servidor | Transferências em blocos, Observe (parcial) | MIT | pypi |
| Californium | Java | RFC 7252, RFC 7641, RFC 7959 | Cliente + Servidor | Observe, Transferências em blocos, Multicast (desde 2.x), DTLS (+ ID de Conexão DTLS 1.2) | EPL+EDL | www |
| CoAPSharp | C#, .NET | RFC 7252 | Cliente + Servidor | Core, Observe, Bloco, RD | MIT | github |
| FreeCoAP | C | RFC 7252 | Cliente + Servidor + Proxy HTTP/CoAP | Core, DTLS, Transferências em blocos | BSD | github |
| Go-CoAP | Go | RFC 7252, RFC 8232, RFC 7641, RFC 7959 | Cliente + Servidor | Core, Observe, Blockwise, Multicast, TCP/TLS | Apache License 2.0 | github |
| java-coap | Java | RFC 7252, RFC 7641, RFC 7959, RFC 8323 | Cliente + Servidor | Apache License 2.0 | github | |
| libcoap | C | RFC 7252, RFC 7390, RFC 7641, RFC 7959, RFC 7967, RFC 8132, RFC 8323, RFC 8516, RFC 8613, RFC 8768, RFC 8974, RFC 9175, RFC 9177 | Cliente + Servidor | Core, Observe, Multicast, Transferências em blocos, Patch/Fetch, OSCORE, (D)TLS | BSD/GPL | https://github.com/obgm/libcoap |
| libcoapy | Python | mesmo suporte que o libcoap | MIT | github | ||
| lobaro-coap | C | RFC 7252 | Cliente + Servidor | Observe, Transferências em blocos | MIT | www |
| microCoAPy | MicroPython | RFC 7252 | Cliente + Servidor | Core | Apache License 2.0 | github |
| nanoCoAP | C | RFC 7252 | Cliente + Servidor | Core, Transferências em blocos, DTLS | LGPL | api |
| node-coap | JavaScript | RFC 7252, | Cliente + Servidor | Core, Observe, Bloco | MIT | github |
| Qt CoAP | C++ | RFC 7252 | Cliente | Core, Observe, Transferências em blocos | GPL, Comercial | https://doc.qt.io/qt-6/qtcoap-index.html |
| coap-rs | Rust | RFC 7252 | Cliente + Servidor | Core, Multicast, opção Observe, Código de resposta Too Many Requests | MIT | github |
Existem implementações de proxy que fornecem funcionalidade de proxy direto (forward proxy) ou reverso (reverse proxy) para o protocolo CoAP, bem como implementações que fazem a tradução entre protocolos como HTTP e CoAP.
Os seguintes projetos fornecem funcionalidade de proxy:
| Nome | Linguagem de programação | Versão do CoAP implementada | Cliente/Servidor | Recursos do CoAP implementados | Licença | Link |
|---|---|---|---|---|---|---|
| CoAP Shell | Java | RFC 7252 | Cliente | Observe, Transferências em blocos, DTLS | Apache License 2.0 | https://github.com/tzolov/coap-shell |
| Copper | JavaScript (plug-in de navegador) | RFC 7252 | Cliente | Observe, Transferências em blocos | 3-clause BSD | https://github.com/mkovatsc/Copper https://addons.mozilla.org/firefox/addon/copper-270430/[ligação inativa] |
| MeteoStation ™ | React, TypeScript | - | Cliente | Sensores meteorológicos | Licença MIT | www.meteostationit.wordpress.com |
| Nome | Linguagem de programação | Versão do CoAP implementada | Cliente/Servidor | Recursos do CoAP implementados | Licença | Link |
|---|---|---|---|---|---|---|
| cantcoap | C++/C | RFC 7252 | Cliente + Servidor | BSD | https://github.com/staropram/cantcoap | |
| Canopus | Go | RFC 7252 | Cliente + Servidor | Core | Apache License 2.0 | https://github.com/zubairhamed/canopus |
| CoAP implementation for Go | Go | RFC 7252 | Cliente + Servidor | Core + Draft Subscribe | MIT | https://github.com/dustin/go-coap |
| CoAP.NET | C# | RFC 7252, coap-13, coap-08, coap-03 | Cliente + Servidor | Core, Observe, Transferências em blocos | 3-clause BSD | https://github.com/smeshlink/CoAP.NET |
| CoAPthon | Python | RFC 7252 | Cliente + Servidor + Proxy Direto + Proxy Reverso | Observe, Descoberta de servidores multicast, Análise de CoRE Link Format, Block-wise | MIT | https://github.com/Tanganelli/CoAPthon |
| eCoAP | C | RFC 7252 | Cliente + Servidor | Core | MIT | https://gitlab.com/jobol/ecoap |
| Erbium for Contiki | C | RFC 7252 | Cliente + Servidor | Observe, Transferências em blocos | 3-clause BSD | http://www.contiki-os.org/ (er-rest-example) |
| guile-coap | Guile | RFC 7252, RFC 8323 | Cliente + Servidor | GPL-3.0-or-later | https://codeberg.org/eris/guile-coap | |
| iCoAP | Objective-C | RFC 7252 | Cliente | Core, Observe, Transferências em blocos | MIT | https://github.com/stuffrabbit/iCoAP |
| jCoAP | Java | RFC 7252 | Cliente + Servidor | Observe, Transferências em blocos | Apache License 2.0 | https://code.google.com/p/jcoap/ |
| LibNyoci | C | RFC 7252 | Cliente + Servidor | Core, Observe, Bloco, DTLS | MIT | https://github.com/darconeous/libnyoci |
| microcoap | C | RFC 7252 | Cliente + Servidor | MIT | https://github.com/1248/microcoap | |
| nCoap | Java | RFC 7252 | Cliente + Servidor | Observe, Transferências em blocos, CoRE Link Format, Endpoint-ID-Draft | BSD | https://github.com/okleine/nCoAP |
| Ruby coap | Ruby | RFC 7252 | Cliente + Servidor (david) | Core, Observe, Bloco, RD | MIT, GPL | https://github.com/nning/coap https://github.com/nning/david |
| Sensinode C Device Library | C | RFC 7252 | Cliente + Servidor | Core, Observe, Bloco, RD | Comercial | https://silver.arm.com/browse/SEN00 |
| Sensinode Java Device Library | Java SE | RFC 7252 | Cliente + Servidor | Core, Observe, Bloco, RD | Comercial | https://silver.arm.com/browse/SEN00 |
| Sensinode NanoService Platform | Java SE | RFC 7252 | Servidor em Nuvem | Core, Observe, Bloco, RD | Comercial | https://silver.arm.com/browse/SEN00 |
| SwiftCoAP | Swift | RFC 7252 | Cliente + Servidor | Core, Observe, Transferências em blocos | MIT | https://github.com/stuffrabbit/SwiftCoAP |
| TinyOS CoapBlip | nesC/C | coap-13 | Cliente + Servidor | Observe, Transferências em blocos | BSD | https://web.archive.org/web/20130312140509/http://docs.tinyos.net/tinywiki/index.php/CoAP |
| txThings | Python (Twisted) | RFC 7252 | Cliente + Servidor | Transferências em blocos, Observe (parcial) | MIT | https://github.com/mwasilak/txThings/ |
| YaCoAP | C | MIT | https://github.com/RIOT-Makers/YaCoAP | |||
Em muitos domínios de aplicação do CoAP, é essencial ter a capacidade de endereçar vários recursos CoAP como um grupo, em vez de endereçar cada recurso individualmente (por exemplo, para acender todas as luzes habilitadas para CoAP em uma sala com uma única requisição CoAP disparada ao acionar o interruptor de luz). Para atender a essa necessidade, o IETF desenvolveu uma extensão opcional para o CoAP na forma de um RFC experimental: Group Communication for CoAP - RFC 7390 Esta extensão depende de IP multicast para entregar a requisição CoAP a todos os membros do grupo. O uso de multicast tem certos benefícios, como a redução do número de pacotes necessários para entregar a requisição aos membros. No entanto, o multicast também tem suas limitações, como baixa confiabilidade e incompatibilidade com cache (cache-unfriendly). Um método alternativo para a comunicação em grupo no CoAP que usa unicasts em vez de multicasts depende de ter um intermediário onde os grupos são criados. Os clientes enviam suas requisições de grupo para o intermediário, que por sua vez envia requisições unicast individuais para os membros do grupo, coleta as respostas deles e envia de volta uma resposta agregada ao cliente.
O CoAP define quatro modos de segurança:
Pesquisas foram conduzidas sobre a otimização do DTLS implementando associações de segurança como recursos CoAP, em vez de usar o DTLS como um invólucro de segurança para o tráfego CoAP. Essa pesquisa indicou melhorias de até 6,5 vezes em relação a implementações não otimizadas.
Além do DTLS, a RFC 8613 define o protocolo Object Security for Constrained RESTful Environments (OSCORE), que fornece segurança para o CoAP na camada de aplicação.
Embora o padrão do protocolo inclua provisões para mitigar a ameaça de ataques de ampliação DDoS, essas provisões não são implementadas na prática, resultando na presença de mais de 580.000 alvos localizados principalmente na China e ataques de até 320 Gbit/s.