| Internetprotokollfamilie |
|---|
| Anwendungsschicht |
| Transportschicht |
| Internetschicht |
| Verbindungsschicht |
Das Constrained Application Protocol ( CoAP ) ist ein spezielles , UDP-basiertes Internet-Anwendungsprotokoll für ressourcenbeschränkte Geräte, wie in RFC 7252 (veröffentlicht 2014) definiert. Es ermöglicht diesen ressourcenbeschränkten Geräten, sogenannten „Knoten“, die Kommunikation mit dem Internet über ähnliche Protokolle. CoAP ist für die Kommunikation zwischen Geräten im selben ressourcenbeschränkten Netzwerk (z. B. energiearme, verlustbehaftete Netzwerke), zwischen Geräten und allgemeinen Knoten im Internet sowie zwischen Geräten in verschiedenen ressourcenbeschränkten Netzwerken, die beide mit dem Internet verbunden sind, konzipiert. CoAP wird auch über andere Mechanismen wie SMS in Mobilfunknetzen genutzt.
CoAP ist ein Anwendungsschichtprotokoll, das für ressourcenbeschränkte Internetgeräte wie Knoten in drahtlosen Sensornetzwerken entwickelt wurde . CoAP lässt sich leicht in HTTP übersetzen und so einfach ins Web integrieren. Gleichzeitig erfüllt es spezielle Anforderungen wie Multicast- Unterstützung, sehr geringen Overhead und Einfachheit. [ 1 ] [ 2 ] Multicast, geringer Overhead und Einfachheit sind wichtig für das Internet der Dinge (IoT) und die Maschine-zu-Maschine -Kommunikation (M2M), da diese Geräte häufig eingebettet sind und deutlich weniger Speicher und Stromversorgung als herkömmliche Internetgeräte besitzen. Daher ist Effizienz von großer Bedeutung. CoAP ist auf den meisten Geräten lauffähig, die UDP oder ein UDP-Äquivalent unterstützen.
Die Arbeitsgruppe „Constrained RESTful Environments“ ( CoRE ) der Internet Engineering Task Force ( IETF ) hat die wichtigsten Standardisierungsarbeiten für dieses Protokoll durchgeführt. Um das Protokoll für IoT- und M2M-Anwendungen geeignet zu machen, wurden verschiedene neue Funktionen hinzugefügt.
Spezifikation
Der Kern des Protokolls ist in RFC 7252 spezifiziert . Es wurden verschiedene Erweiterungen vorgeschlagen, insbesondere:
- RFC 7641 (2015) Beobachtung von Ressourcen im Constrained Application Protocol
- RFC 7959 (2016) Blockweise Übertragungen im Constrained Application Protocol (CoAP)
- RFC 8323 (2018) CoAP (Constrained Application Protocol) über TCP, TLS und WebSockets
- RFC 8974 (2021) Erweiterte Token und zustandslose Clients im Constrained Application Protocol (CoAP)
Nachrichtenformate
CoAP verwendet zwei Nachrichtentypen, Anfragen und Antworten, mit einem einfachen, binären Header-Format. Standardmäßig ist CoAP an UDP und optional an DTLS gebunden und bietet so ein hohes Maß an Kommunikationssicherheit. Bei Bindung an UDP muss die gesamte Nachricht in ein einzelnes Datagramm passen. Bei Verwendung mit 6LoWPAN gemäß RFC 4944 sollten Nachrichten in einen einzelnen IEEE-802.15.4 -Frame passen, um die Fragmentierung zu minimieren.
Die kürzeste CoAP-Nachricht ist 4 Byte lang, wenn Token, Optionen und Nutzdaten weggelassen werden, d. h. wenn sie nur aus dem CoAP-Header besteht. Auf den Header folgt der Tokenwert (0 bis 8 Byte), dem gegebenenfalls eine Liste von Optionen in einem optimierten Typ-Längen-Wert-Format folgt. Alle Bytes nach Header, Token und Optionen (falls vorhanden) bilden die Nutzdaten der Nachricht. Diese beginnen mit dem ein Byte langen Nutzdatenmarker (0xFF). Die Länge der Nutzdaten ergibt sich aus der Datagrammlänge.
| Oktett- Offset | 0 | 1 | 2 | 3 | |||||||||||||||||||||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| Bit- Offset | 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 | Version | Typ | Tokenlänge | Anfrage-/Antwortcode | Nachrichten-ID | |||||||||||||||||||||||||||
| 8 | 64 | Token (0–8 Bytes) | |||||||||||||||||||||||||||||||
| 12 | 96 | ||||||||||||||||||||||||||||||||
| 16 | 128 | Optionen (falls verfügbar) | |||||||||||||||||||||||||||||||
| 20 | 160 | 1 | 1 | 1 | 1 | 1 | 1 | 1 | 1 | Nutzlast (falls verfügbar) | |||||||||||||||||||||||
CoAP-Header fester Größe
Die ersten 4 Bytes sind in allen CoAP-Datagrammen obligatorisch; sie bilden den Header fester Größe.
Diese Felder können in C mithilfe dieser Makros aus diesen 4 Bytes extrahiert werden:
#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] )Version (ver) (2 Bit)
- Gibt die CoAP-Versionsnummer an.
Typ (2 Bit)
- Dies beschreibt den Nachrichtentyp des Datagramms für den Zwei-Nachrichtentyp-Kontext von Anfrage und Antwort.
- Anfrage
- 0 : Bestätigbar : Diese Nachricht erwartet eine entsprechende Bestätigungsnachricht.
- 1 : Nicht bestätigbar : Diese Nachricht erwartet keine Bestätigungsnachricht.
- Antwort
- 2 : Bestätigung : Diese Nachricht ist eine Antwort, die den Empfang einer bestätigungspflichtigen Nachricht bestätigt.
- 3 : Reset : Diese Meldung bedeutet, dass eine Nachricht empfangen, aber nicht verarbeitet werden konnte.
- Anfrage
Tokenlänge (4 Bit)
- Gibt die Länge des Token-Felds variabler Länge an, das 0–8 Byte lang sein kann.
Anfrage-/Antwortcode (8 Bit)
| 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 |
|---|---|---|---|---|---|---|---|
| Klasse | Code | ||||||
Die drei höchstwertigen Bits bilden eine Zahl, die als „Klasse“ bezeichnet wird und analog zur Klasse der HTTP-Statuscodes ist . Die fünf niederwertigsten Bits bilden einen Code, der weitere Details zur Anfrage oder Antwort enthält. Der gesamte Code wird typischerweise in der Form übermittelt class.code.
Die neuesten CoAP-Anfrage-/Antwortcodes finden Sie unter [1] , wobei die folgende Liste einige Beispiele enthält:
- Methode: 0.XX
- LEER
- ERHALTEN
- POST
- SETZEN
- LÖSCHEN
- BRINGEN
- PATCH
- iPATCH
- Erfolg: 2,XX
- Erstellt
- Gelöscht
- Gültig
- Geändert
- Inhalt
- Weitermachen
- Clientfehler: 4.XX
- Ungültige Anforderung
- Nicht autorisiert
- Schlechte Option
- Verboten
- Nicht gefunden
- Methode nicht zulässig
- Nicht akzeptabel
- Anfrage unvollständig
- Konflikt
- Vorbedingung nicht erfüllt
- Die angeforderte Entität ist zu groß.
- Nicht unterstütztes Inhaltsformat
- Serverfehler: 5.XX
- Interner Serverfehler
- Nicht implementiert
- Schlechtes Gateway
- Dienst nicht verfügbar
- Gateway-Timeout
- Proxying wird nicht unterstützt
- Signalisierungscodes: 7.XX
- Nicht zugewiesen
- CSM
- Klingeln
- Pong
- Freigeben
- Abbrechen
Nachrichten-ID (16 Bit)
- Wird verwendet, um doppelte Nachrichten zu erkennen und Nachrichten vom Typ Bestätigung/Zurücksetzung mit Nachrichten vom Typ Bestätigbar/Nicht bestätigbar abzugleichen.
Token
Jede Anfrage enthält ein Token (das auch leer sein kann), dessen Wert vom Client generiert wurde. Der Server muss jeden Token-Wert unverändert in der entsprechenden Antwort an den Client zurücksenden. Er dient als clientseitiger Identifikator zum Abgleich von Anfragen und Antworten, insbesondere bei gleichzeitigen Anfragen.
Der Abgleich von Anfragen und Antworten erfolgt nicht über die Nachrichten-ID, da eine Antwort in einer separaten Nachricht und die Bestätigung (die die Nachrichten-ID zum Abgleich verwendet) gesendet werden kann. Dies kann beispielsweise geschehen, um erneute Übertragungen zu vermeiden, wenn die Ergebnisermittlung einige Zeit in Anspruch nimmt. Eine solche separate Antwort wird als „getrennte Antwort“ bezeichnet. Im Gegensatz dazu wird die direkte Übermittlung der Antwort in der Bestätigung als „mitgesendete Antwort“ bezeichnet, was aus Effizienzgründen bevorzugt werden sollte.
Option
| Bitposition | |||||||
|---|---|---|---|---|---|---|---|
| 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 |
| Option Delta | Optionslänge | ||||||
| Option Delta erweitert (keine, 8 Bit, 16 Bit) | |||||||
| Optionslänge erweitert (keine, 8 Bit, 16 Bit) | |||||||
| Optionswert | |||||||
Option Delta:
- 0 bis 12: Für Deltawerte zwischen 0 und 12: Stellt den exakten Deltawert zwischen der letzten Options-ID und der gewünschten Options-ID dar, ohne erweiterten Deltawert.
- 13: Für Delta von 13 bis 268: Option Delta Extended ist ein 8-Bit-Wert, der den Option-Delta-Wert minus 13 darstellt.
- 14: Für Delta von 269 bis 65.804: Das erweiterte Optionsdelta ist ein 16-Bit-Wert, der den Optionsdeltawert minus 269 darstellt.
- 15: Reserviert für die Nutzlastmarkierung, bei der das Optionsdelta und die Optionslänge zusammen auf 0xFF gesetzt sind.
Optionslänge:
- 0 bis 12: Für Optionslängen zwischen 0 und 12: Stellt den exakten Längenwert ohne Erweiterungswert für die Optionslänge dar.
- 13: Bei Optionslängen von 13 bis 268: Die erweiterte Optionslänge ist ein 8-Bit-Wert, der die Optionslänge minus 13 darstellt.
- 14: Bei Optionslängen von 269 bis 65.804: Die erweiterte Optionslänge ist ein 16-Bit-Wert, der die Optionslänge minus 269 darstellt.
- 15: Für zukünftige Verwendung reserviert. Es ist ein Fehler, wenn das Feld für die Optionslänge auf 0xFF gesetzt ist.
Optionswert:
- Die Größe des Optionswertfelds wird durch den Wert für die Optionlänge in Bytes definiert.
- Semantik und Format dieses Feldes hängen von der jeweiligen Option ab.
Aktive Protokollimplementierungen
| Name | Programmiersprache | Implementierte CoAP-Version | Client/Server | Implementierte CoAP-Funktionen | Lizenz | Link |
|---|---|---|---|---|---|---|
| Coap | Pfeil | RFC 7252 | Kunde | Blockweise Übertragungen, Beobachten, Multicast, Proxying (teilweise) | 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 | Client + Server | Blockweise Übertragungen, beobachten (teilweise) | MIT | pypi.python.org/pypi/aiocoap |
| Californium | Java | RFC 7252, RFC 7641, RFC 7959 | Client + Server | Beachten Sie: Blockweise Übertragungen, Multicast (seit Version 2.x), DTLS (+ DTLS 1.2 Verbindungs-ID) | EPL+EDL | www.eclipse.org/californium github.com/eclipse/californium |
| CoAPSharp | C#, .NET | RFC 7252 | Client + Server | Kern, Beobachten, Blockieren, RD | MIT | github.com/FemtomaxInc/coapsharp |
| FreeCoAP | C | RFC 7252 | Client + Server + HTTP/CoAP-Proxy | Core, DTLS, Blockweise Übertragungen | BSD | github.com /keith |
| Go-CoAP | Gehen | RFC 7252, RFC 8232, RFC 7641, RFC 7959 | Client + Server | Core, Observe, Blockwise, Multicast, TCP/TLS | Apache-Lizenz 2.0 | github.com/plgd-dev/go-coap |
| java-coap | Java | RFC 7252, RFC 7641, RFC 7959, RFC 8323 | Client + Server | Apache-Lizenz 2.0 | github.com | |
| 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 | Client + Server | Core, Observe, Multicast, Blockweise Übertragungen, Patch/Fetch, OSCORE, (D)TLS | BSD/GPL | https://github.com/obgm/libcoap |
| libcoapy | Python | gleiche Unterstützung wie libcoap | MIT | github.com/anyc/libcoapy | ||
| Lobaro-Coap | C | RFC 7252 | Client + Server | Beachten Sie die blockweisen Übertragungen. | MIT | www.lobaro.com/lobaro-coap |
| microCoAPy | MicroPython | RFC 7252 | Client + Server | Kern | Apache-Lizenz 2.0 | github.com/insighio/microCoAPy |
| nanoCoAP | C | RFC 7252 | Client + Server | Kern, Blockweise Übertragungen, DTLS | LGPL | api.riot-os.org/group__net__nanocoap.html |
| Knoten-Koap | JavaScript | RFC 7252, RFC 7641, RFC 7959 | Client + Server | Kern, Beobachtung, Block | MIT | github.com/mcollina/node-coap |
| Qt CoAP | C++ | RFC 7252 | Kunde | Kern, Beobachtung, Blockweise Übertragungen | GPL, Kommerziell | https://doc.qt.io/qt-6/qtcoap-index.html |
| coap-rs | Rost | RFC 7252 | Client + Server | Core, Multicast, Option „Beobachten“, Antwortcode „ Zu viele Anfragen“ | MIT | github.com/Covertness/coap-rs |
Proxy-Implementierungen
Es gibt Proxy- Implementierungen, die Forward- oder Reverse -Proxy-Funktionalität für das CoAP-Protokoll bereitstellen , sowie Implementierungen, die zwischen Protokollen wie HTTP und CoAP übersetzen.
Die folgenden Projekte bieten Proxy-Funktionalität:
- Squid 3.1.9 mit transparentem HTTP-CoAP-Mapping-Modul
- jcoap-Proxy
- Californium cf-proxy2
- CoAPthon
- FreeCoAP
- libcoap
Projekte, die CoAP verwenden
| Name | Programmiersprache | Implementierte CoAP-Version | Client/Server | Implementierte CoAP-Funktionen | Lizenz | Link |
|---|---|---|---|---|---|---|
| CoAP Shell | Java | RFC 7252 | Kunde | Beachten Sie: Blockweise Übertragungen, DTLS | Apache-Lizenz 2.0 | https://github.com/tzolov/coap-shell |
| Kupfer | JavaScript (Browser-Plugin) | RFC 7252 | Kunde | Beachten Sie die blockweisen Übertragungen. | 3-Klausel-BSD | https://github.com/mkovatsc/Copper https://addons.mozilla.org/firefox/addon/copper-270430/ |
Inaktive Protokollimplementierungen
| Name | Programmiersprache | Implementierte CoAP-Version | Client/Server | Implementierte CoAP-Funktionen | Lizenz | Link |
|---|---|---|---|---|---|---|
| cantcoap | C++/C | RFC 7252 | Client + Server | BSD | https://github.com/staropram/cantcoap | |
| Canopus | Gehen | RFC 7252 | Client + Server | Kern | Apache-Lizenz 2.0 | https://github.com/zubairhamed/canopus |
| CoAP-Implementierung für Go | Gehen | RFC 7252 | Client + Server | Core + Draft abonnieren | MIT | https://github.com/dustin/go-coap |
| CoAP.NET | C# | RFC 7252, coap-13, coap-08, coap-03 | Client + Server | Kern, Beobachtung, Blockweise Übertragungen | 3-Klausel-BSD | https://github.com/smeshlink/CoAP.NET |
| CoAPthon | Python | RFC 7252 | Client + Server + Forward-Proxy + Reverse-Proxy | Beobachtung, Multicast-Servererkennung, CoRE-Link-Format-Parsing, Blockweise | MIT | https://github.com/Tanganelli/CoAPthon |
| eCoAP | C | RFC 7252 | Client + Server | Kern | MIT | https://gitlab.com/jobol/ecoap |
| Erbium für Contiki | C | RFC 7252 | Client + Server | Beachten Sie die blockweisen Übertragungen. | 3-Klausel-BSD | http://www.contiki-os.org/ (er-rest-example) |
| guile-coap | List | RFC 7252, RFC 8323 | Client + Server | GPL-3.0 oder später | https://codeberg.org/eris/guile-coap | |
| iCoAP | Objective-C | RFC 7252 | Kunde | Kern, Beobachtung, Blockweise Übertragungen | MIT | https://github.com/stuffrabbit/iCoAP |
| jCoAP | Java | RFC 7252 | Client + Server | Beachten Sie die blockweisen Übertragungen. | Apache-Lizenz 2.0 | https://code.google.com/p/jcoap/ |
| LibNyoci | C | RFC 7252 | Client + Server | Kern, Beobachtung, Block, DTLS | MIT | https://github.com/darconeous/libnyoci |
| Mikrocoap | C | RFC 7252 | Client + Server | MIT | https://github.com/1248/microcoap | |
| nCoap | Java | RFC 7252 | Client + Server | Beachten Sie: Blockweise Übertragungen, CoRE-Link-Format, Endpoint-ID-Entwurf | BSD | https://github.com/okleine/nCoAP |
| Ruby coap | Rubin | RFC 7252 | Client + Server (David) | Kern, Beobachten, Blockieren, RD | MIT, GPL | https://github.com/nning/coap https://github.com/nning/david |
| Sensinode C Gerätebibliothek | C | RFC 7252 | Client + Server | Kern, Beobachten, Blockieren, RD | Kommerziell | https://silver.arm.com/browse/SEN00 |
| Sensinode Java Gerätebibliothek | Java SE | RFC 7252 | Client + Server | Kern, Beobachten, Blockieren, RD | Kommerziell | https://silver.arm.com/browse/SEN00 |
| Sensinode NanoService-Plattform | Java SE | RFC 7252 | Cloud-Server | Kern, Beobachten, Blockieren, RD | Kommerziell | https://silver.arm.com/browse/SEN00 |
| SwiftCoAP | Schnell | RFC 7252 | Client + Server | Kern, Beobachtung, Blockweise Übertragungen | MIT | https://github.com/stuffrabbit/SwiftCoAP |
| TinyOS CoapBlip | nesC/C | coap-13 | Client + Server | Beachten Sie die blockweisen Übertragungen. | BSD | https://web.archive.org/web/20130312140509/http://docs.tinyos.net/tinywiki/index.php/CoAP |
| txThings | Python (Twisted) | RFC 7252 | Client + Server | Blockweise Übertragungen, beobachten (teilweise) | MIT | https://github.com/mwasilak/txThings/ |
| YaCoAP | C | MIT | https://github.com/RIOT-Makers/YaCoAP |
Kommunikation der CoAP-Gruppe
In many CoAP application domains it is essential to have the ability to address several CoAP resources as a group, instead of addressing each resource individually (e.g. to turn on all the CoAP-enabled lights in a room with a single CoAP request triggered by toggling the light switch). To address this need, the IETF has developed an optional extension for CoAP in the form of an experimental RFC: Group Communication for CoAP - RFC 7390[3] This extension relies on IP multicast to deliver the CoAP request to all group members. The use of multicast has certain benefits such as reducing the number of packets needed to deliver the request to the members. However, multicast also has its limitations such as poor reliability and being cache-unfriendly. An alternative method for CoAP group communication that uses unicasts instead of multicasts relies on having an intermediary where the groups are created. Clients send their group requests to the intermediary, which in turn sends individual unicast requests to the group members, collects the replies from them, and sends back an aggregated reply to the client.[4]
Security
CoAP defines four security modes:[5]
- NoSec, where DTLS is disabled
- PreSharedKey, where DTLS is enabled, there is a list of pre-shared keys, and each key includes a list of which nodes it can be used to communicate with. Devices must support the AES cipher suite.
- RawPublicKey, where DTLS is enabled and the device uses an asymmetric key pair without a certificate, which is validated out of band. Devices must support the AES cipher suite and Elliptic Curve algorithms for key exchange.
- Certificate, where DTLS is enabled and the device uses X.509 certificates for validation.
Research has been conducted on optimizing DTLS by implementing security associates as CoAP resources rather than using DTLS as a security wrapper for CoAP traffic. This research has indicated that improvements of up to 6.5 times none optimized implementations.[6]
In addition to DTLS, RFC8613[7] defines the Object Security for Constrained RESTful Environments (OSCORE) protocol which provides security for CoAP at the application layer.
Security issues
Although the protocol standard includes provisions for mitigating the threat of DDoS amplification attacks,[8] these provisions are not implemented in practice,[9] resulting in the presence of over 580,000 targets primarily located in China and attacks up to 320 Gbit/s.[10]
See also
Referenzen
- ^ RFC 7252, Constrained Application Protocol (CoAP)
- ^ „ Integration drahtloser Sensornetzwerke in das Web “ , archiviert am 30.08.2017 in der Wayback Machine , Walter, Colitti 2011
- ^ RFC 7390, Gruppenkommunikation für CoAP
- ^ „ Flexible Unicast-basierte Gruppenkommunikation für CoAP-fähige Geräte “, Ishaq, I.; Hoebeke, J.; Van den Abeele, F.; Rossey, J.; Moerman, I. ; Demeester, P. Sensoren 2014
- ^ RFC 7252, Constrained Application Protocol (CoAP)
- ^ Capossele, Angelo; Cervo, Valerio; De Cicco, Gianluca; Petrioli, Chiara (Juni 2015). „Sicherheit als CoAP-Ressource: Eine optimierte DTLS-Implementierung für das IoT“. 2015 IEEE International Conference on Communications (ICC) . IEEE. S. 529–554 . doi : 10.1109/ICC.2015.7248379 . ISBN 978-1-4673-6432-4. S2CID 12568959 .
- ^ Palombini, Francesca; Seitz, Ludwig; Selander, Goeran; Mattsson, John (2019). „Object Security for Constrained RESTful Environments (OSCORE)“ . tools.ietf.org . doi : 10.17487/RFC8613 . S2CID 58380874. Abgerufen am 7. Mai 2021 .
- „ TLS 1.3 wird uns alle retten, und andere Gründe, warum das IoT immer noch unsicher ist“, Dani Grant, 24.12.2017
- ^ „Wenn Maschinen nicht miteinander kommunizieren können: Sicherheits- und Datenschutzprobleme von Datenprotokollen für die Maschinenkommunikation“, Federico Maggi und Rainer Vosseler, 06.12.2018
- ^ „Das CoAP-Protokoll ist der nächste große Schritt im Kampf gegen DDoS-Angriffe“, Catalin Cimpanu, 05.12.2018
Externe Links
- RFC 7252 „Das Constrained Application Protocol (CoAP)“
- coap.me – CoAP-Testserver der Universität Bremen