Einführung in libSRTP

Dieses Paket bietet eine Implementierung des Secure Real-time Transport Protocol (SRTP), der Universal Security Transform (UST) und eines unterstützenden kryptografischen Kernels. Die SRTP-API ist in include/srtp.h dokumentiert, und die Bibliothek liegt in libsrtp2.a (nach der Kompilierung) vor.

Dieses Dokument beschreibt libSRTP, die Open-Source-Bibliothek für sicheres RTP von Cisco Systems, Inc. RTP ist das Real-time Transport Protocol, ein IETF-Standard für die Übertragung von Echtzeitdaten wie Telefonie, Audio und Video, definiert durch RFC 3550. Secure RTP (SRTP) ist ein RTP-Profil, das Vertraulichkeit für RTP-Daten und Authentifizierung für den RTP-Header und die Nutzdaten bietet. SRTP ist ein IETF-Standard, definiert in RFC 3711, und wurde in der IETF Audio/Video Transport (AVT) Working Group entwickelt. Diese Bibliothek unterstützt alle obligatorischen Funktionen von SRTP, aber nicht alle optionalen Funktionen. Siehe den Abschnitt Unterstützte Funktionen für weitere Informationen.

Dieses Dokument wird auch verwendet, um die Dokumentationsdateien im Ordner /doc/ zu erzeugen, in dem eine detailliertere Referenz zur libSRTP-API und zu verwandten Funktionen erstellt werden kann (erfordert die Installation von doxygen.). Das Referenzmaterial wird automatisch aus Kommentaren erzeugt, die in einige der C-Header-Dateien eingebettet sind. Die Dokumentation ist in Module gegliedert, um ihre Klarheit zu verbessern. Diese Module entsprechen nicht direkt den Dateien. Ein zugrunde liegender kryptografischer Kernel stellt einen Großteil der grundlegenden Funktionalität von libSRTP bereit, ist jedoch weitgehend undokumentiert, weil er seine Arbeit im Hintergrund erledigt.

Kontakt

• [email protected] allgemeine Mailingliste für Nachrichten / Ankündigungen / Diskussionen. Dies ist eine offene Liste, siehe https://lists.packetizer.com/mailman/listinfo/libsrtp zum Anmelden.

• [email protected] zur Meldung von Sicherheitsproblemen an das libsrtp-Wartungsteam. Dies ist eine geschlossene Liste, aber jeder kann eine Nachricht senden.

Inhaltsverzeichnis

• Einführung in libSRTP
• Kontakt
  • Inhaltsverzeichnis
• Lizenz und Haftungsausschluss
• libSRTP-Überblick
  • Hintergrund zu Secure RTP
  • Unterstützte Funktionen
  • Implementierungshinweise
• Installation und Build von libSRTP
  • Build-Konfiguration ändern
  • Verwendung von Visual Studio
• Anwendungen
  • Beispielcode
• Danksagungen
• Referenzen

Lizenz und Haftungsausschluss

libSRTP wird unter der folgenden Lizenz vertrieben, die in der Quellcode-Distribution enthalten ist. Sie wird im Handbuch wiedergegeben, falls Sie die Bibliothek aus einer anderen Quelle erhalten haben.

Copyright (c) 2001-2017 Cisco Systems, Inc. Alle Rechte vorbehalten.

Die Weiterverbreitung und Verwendung in Quell- und Binärform, mit oder ohne Änderungen, ist gestattet, sofern die folgenden Bedingungen erfüllt sind:

• Weiterverbreitungen des Quellcodes müssen den obigen Copyright-Hinweis, diese Liste von Bedingungen und den folgenden Haftungsausschluss enthalten.
• Weiterverbreitungen in Binärform müssen den obigen Copyright-Hinweis, diese Liste von Bedingungen und den folgenden Haftungsausschluss in der Dokumentation und/oder anderen Materialien, die mit der Distribution bereitgestellt werden, wiedergeben.
• Weder der Name von Cisco Systems, Inc. noch die Namen seiner Mitwirkenden dürfen verwendet werden, um Produkte zu unterstützen oder zu bewerben, die aus dieser Software ohne vorherige ausdrückliche schriftliche Genehmigung abgeleitet wurden.

DIESE SOFTWARE WIRD VON DEN URHEBERRECHTSINHABERN UND MITWIRKENDEN "SO WIE SIE IST" BEREITGESTELLT UND JEGLICHE AUSDRÜCKLICHE ODER STILLSCHWEIGENDE GEWÄHRLEISTUNGEN, EINSCHLIESSLICH, ABER NICHT BESCHRÄNKT AUF DIE STILLSCHWEIGENDEN GEWÄHRLEISTUNGEN DER MARKTGÄNGIGKEIT UND EIGNUNG FÜR EINEN BESTIMMTEN ZWECK WERDEN ABGELEHNT. IN KEINEM FALL HAFTEN DIE URHEBERRECHTSINHABER ODER MITWIRKENDEN FÜR DIREKTE, INDIREKTE, BEILÄUFIGE, BESONDERE, BEISPIELHAFTE ODER FOLGESCHÄDEN (EINSCHLIESSLICH, ABER NICHT BESCHRÄNKT AUF BESCHAFFUNG VON ERSATZGÜTERN ODER DIENSTLEISTUNGEN; NUTZUNGS-, DATEN- ODER GEWINNVERLUSTE; ODER GESCHÄFTSUNTERBRECHUNGEN) WIE AUCH IMMER VERURSACHT UND UNTER JEDER HAFTUNGSTHEORIE, OB IM VERTRAG, AUS GEFÄHRDUNGSHAFTUNG ODER UNERLAUBTER HANDLUNG (EINSCHLIESSLICH FAHRLÄSSIGKEIT ODER ANDEREM) DIE IN IRGENDEINER WEISE AUS DER NUTZUNG DIESER SOFTWARE ENTSTEHEN, SELBST WENN AUF DIE MÖGLICHKEIT SOLCHER SCHÄDEN HINGEWIESEN WURDE.

libSRTP-Überblick

libSRTP stellt Funktionen zum Schützen von RTP und RTCP bereit. RTP-Pakete können verschlüsselt und authentifiziert werden (mithilfe der Funktion srtp_protect()), wodurch sie zu SRTP-Paketen werden. Ebenso können SRTP-Pakete entschlüsselt und ihre Authentifizierung verifiziert werden (mithilfe der Funktion srtp_unprotect()), wodurch sie zu RTP-Paketen werden. Ähnliche Funktionen wenden Sicherheit auf RTCP-Pakete an.

Der Typedef srtp_stream_t verweist auf eine Struktur, die den gesamten Zustand eines SRTP-Streams enthält, einschließlich der Schlüssel und Parameter für Chiffrier- und Nachrichtenauthentifizierungsfunktionen sowie der Anti-Replay-Daten. Ein bestimmtes srtp_stream_t enthält die Informationen, die zum Schutz eines bestimmten RTP- und RTCP-Streams erforderlich sind. Dieser Datentyp ist absichtlich undurchsichtig, um die libSRTP-API besser von ihrer Implementierung zu trennen.

Innerhalb einer SRTP-Sitzung kann es mehrere Streams geben, die jeweils von einem bestimmten Absender stammen. Jede Quelle verwendet einen eigenen Stream-Kontext, um den RTP- und RTCP-Stream zu schützen, den sie erzeugt. Der Typedef srtp_t verweist auf eine Struktur, die den gesamten Zustand einer SRTP-Sitzung enthält. Es können mehrere Stream-Kontexte mit einem einzigen srtp_t verknüpft sein. Ein Stream-Kontext kann nicht unabhängig von einem srtp_t existieren, obwohl natürlich ein srtp_t erstellt werden kann, das nur einen einzigen Stream-Kontext enthält. Ein Gerät, das an einer SRTP-Sitzung teilnimmt, muss für jede Quelle in dieser Sitzung einen Stream-Kontext besitzen, damit es die Daten verarbeiten kann, die es von jedem Absender empfängt.

In libSRTP wird eine Sitzung mit der Funktion srtp_create() erstellt. Die in der Sitzung umzusetzende Richtlinie wird dieser Funktion als undurchsichtiger srtp_policy_t-Handle übergeben. Ein einzelner Richtlinien-Handle beschreibt eine Stream-Richtlinie. Um mehrere Streams zu konfigurieren, erstellen Sie eine Sitzung und fügen Sie mit srtp_stream_add() weitere Richtlinien hinzu.

Ein Richtlinien-Handle wird mit Funktionen vom Typ srtp_policy_set_* konfiguriert. Mindestens umfasst dies die SSRC-Auswahl, die Profilauswahl und das Schlüssel-/Salz- Material. Das Profil konfiguriert die RTP/RTCP-Krypto-Richtlinieneinstellungen, während der SSRC-Selektor festlegt, wie und wo diese Richtlinie angewendet wird.

Hintergrund zu Secure RTP

In diesem Abschnitt betrachten wir SRTP und führen einige Begriffe ein, die in libSRTP verwendet werden. Eine RTP-Sitzung wird durch ein Paar von Ziel- Transportadressen definiert, das heißt eine Netzwerkadresse plus ein Paar von UDP- Ports für RTP und RTCP. RTCP, das RTP-Kontrollprotokoll, wird verwendet, um die Teilnehmer einer RTP-Sitzung zu koordinieren, z. B. um Rückmeldungen von Empfängern an Absender zu geben. Eine SRTP-Sitzung ist ähnlich definiert; es ist lediglich eine RTP-Sitzung, für die das SRTP- Profil verwendet wird. Eine SRTP-Sitzung besteht aus dem Verkehr, der an die SRTP- oder SRTCP-Zieltransportadressen gesendet wird. Jeder Teilnehmer einer Sitzung wird durch eine Synchronisationsquellen- (SSRC-)Kennung identifiziert. Einige Teilnehmer senden möglicherweise keinen SRTP-Verkehr; sie werden als Empfänger bezeichnet, auch wenn sie SRTCP-Verkehr senden, wie zum Beispiel Empfängerberichte.

RTP ermöglicht es mehreren Quellen, während derselben Sitzung RTP- und RTCP-Verkehr zu senden. Die Synchronisationsquellen-Kennung (SSRC) wird verwendet, um diese Quellen zu unterscheiden. In libSRTP bezeichnen wir den SRTP- und SRTCP- Verkehr einer bestimmten Quelle als Stream. Jeder Stream hat seine eigene SSRC, Sequenznummer, Rollover-Zähler und andere Daten. Eine bestimmte Auswahl an Optionen, kryptografischen Mechanismen und Schlüsseln wird als Richtlinie bezeichnet. Auf jeden Stream innerhalb einer Sitzung kann eine eigene Richtlinie angewendet werden.

Eine einzelne Richtlinie kann für alle Streams einer bestimmten Sitzung verwendet werden, der Fall jedoch, in dem ein einzelner Schlüssel über mehrere Streams geteilt wird, erfordert Sorgfalt. Wenn Schlüsselteilung verwendet wird, müssen die SSRC-Werte, die die Streams identifizieren, unterschiedlich sein. Diese Anforderung kann durch die Konvention durchgesetzt werden, dass jeder SRTP- und SRTCP-Schlüssel nur von einem einzigen Absender zur Verschlüsselung verwendet wird. Mit anderen Worten, der Schlüssel wird nur über Streams geteilt, die von einem bestimmten Gerät stammen (natürlich müssen andere SRTP-Teilnehmer den Schlüssel zur Entschlüsselung verwenden). libSRTP unterstützt diese Durchsetzung, indem es den Fall erkennt, in dem ein Schlüssel sowohl für eingehende als auch für ausgehende Daten verwendet wird.

Unterstützte Funktionen

Diese Bibliothek unterstützt alle obligatorisch zu implementierenden Funktionen von SRTP (wie in RFC 3711 definiert). Einige dieser Funktionen können zur Laufzeit ausgewählt (oder abgewählt) werden, indem eine geeignete Richtlinie mit einem srtp_policy_t-Handle festgelegt wird. Einige andere Verhaltensweisen des Protokolls können angepasst werden, indem ein geeigneter Ereignishandler für die außergewöhnlichen Ereignisse definiert wird; siehe den Abschnitt SRTPevents in der erzeugten Dokumentation.

Einige Optionen, die in der SRTP-Spezifikation beschrieben sind, werden nicht unterstützt. Dazu gehören

• Schlüsselableitungsraten ungleich null,
• die Chiffre F8,
• die Verwendung des Paketindex zur Auswahl zwischen Hauptschlüsseln.

Der Benutzer sollte sich darüber im Klaren sein, dass diese Bibliothek missbraucht werden kann, und dass das Ergebnis sein kann, dass das von ihr gebotene Sicherheitsniveau unzureichend ist. Wenn Sie eine Funktion mit dieser Bibliothek implementieren, sollten Sie den Abschnitt „Security Considerations“ von RFC 3711 lesen. Darüber hinaus ist es wichtig, dass Sie die in Abschnitt Lizenz und Haftungsausschluss dargelegten Bedingungen lesen und verstehen.

Diese Bibliothek unterstützt auch die AES-GCM-Authenticated-Encryption-Methoden, die in RFC 7714 beschrieben sind.

Implementierungshinweise

• Es ist möglich zu konfigurieren, mit welchem Drittanbieter-Krypto-Backend (z. B. openssl/nss/etc.) libSRTP erstellt wird. Wenn kein Drittanbieter-Backend festgelegt ist, stellt libSRTP eine interne Implementierung von AES und Sha1 bereit. Die interne Implementierung unterstützt nur AES-128 & AES-256. Um also AES-192 oder die AES-GCM-Chiffrengruppe zu verwenden, muss ein Drittanbieter-Krypto-Backend konfiguriert werden. Aus diesem und aus Performance-Gründen wird dringend empfohlen, ein Drittanbieter-Krypto-Backend zu verwenden.

• Die Funktion srtp_protect() geht davon aus, dass der Puffer, der das RTP-Paket enthält, über genügend zugewiesenen Speicher verfügt, sodass das Authentifizierungs- Tag an das Ende dieses Pakets geschrieben werden kann. Wenn diese Annahme nicht zutrifft, kommt es zu Speicherkorruption.

• Automatisierte Tests für die Kryptofunktionen werden über die Funktionen cipher_type_self_test() und auth_type_self_test() bereitgestellt. Diese Funktionen sollten verwendet werden, um jeden Port dieses Codes auf eine neue Plattform zu testen.

• Der Replay-Schutz ist im Krypto-Engine enthalten, und Tests dafür werden bereitgestellt.

• Diese Implementierung stellt Aufrufe zum Initialisieren, Schützen und Entschützen von RTP-Paketen bereit und macht so wenige Annahmen wie möglich darüber, wie diese Funktionen aufgerufen werden. Beispielsweise wird vom Aufrufer nicht erwartet, die Pakete in der richtigen Reihenfolge zu liefern (obwohl, wenn sie mehr als 65k außerhalb der Reihenfolge aufgerufen werden, die Synchronisierung verloren geht).

• Die Sequenznummer im RTP-Paket wird als die unteren 16 Bits des lokalen Paketindex des Absenders verwendet. Beachten Sie, dass RTP seine Sequenznummer an einer zufälligen Stelle beginnt und die SRTP-Schicht einfach bei ihrem ersten Aufruf zu dieser Nummer springt. Eine frühere Version dieser Bibliothek verwendete anfängliche Sequenznummern, die kleiner als 32.768 sind; dieser Trick ist nicht mehr erforderlich, da die Funktion rdbx_estimate_index(...) ab Version 1.0.1 intelligenter gemacht wurde.

• Das Replay-Fenster für (S)RTCP ist fest auf eine Länge von 128 Bits codiert.

Installation und Build von libSRTP

Um libSRTP zu installieren, laden Sie die neueste Version der Distribution von https://github.com/cisco/libsrtp/releases herunter. Sie möchten wahrscheinlich die aktuellste Version erhalten. Entpacken Sie die Distribution und extrahieren Sie die Quelldateien; das Verzeichnis, in das die Quelldateien abgelegt werden, heißt libsrtp-A-B-C, wobei A die Versionsnummer, B die Hauptversionsnummer und C die Nebenversionsnummer ist.

libSRTP verwendet die GNU-Programme autoconf und make (BSD make funktioniert nicht; wenn beide Versionen von make auf Ihrer Plattform vorhanden sind, können Sie GNU make als gmake aufrufen.). Führen Sie im Verzeichnis libsrtp das Konfigurationsskript und dann make aus:~~~.txt ./configure [ options ] make

Das configure-Skript akzeptiert die folgenden Optionen:

Option                         | Beschreibung
-------------------------------|--------------------
\-\-help                   \-h | Hilfe anzeigen
\-\-enable-debug-logging       | Debug-Logging in allen Modulen aktivieren
\-\-enable-openssl             | OpenSSL-Krypto-Engine aktivieren
\-\-enable-nss                 | NSS-Krypto-Engine aktivieren
\-\-enable-openssl-kdf         | OpenSSL-KDF-Algorithmus aktivieren
\-\-enable-log-stdout          | Logging auf stdout aktivieren
\-\-with-openssl-dir           | Speicherort der OpenSSL-Installation
\-\-with-nss-dir               | Speicherort der NSS-Installation
\-\-with-log-file              | Datei für Logging verwenden

Standardmäßig erfolgt keine Logausgabe. Das Logging kann mithilfe der Konfigurationsoptionen aktiviert werden, um auf stdout oder in eine angegebene Datei ausgegeben zu werden.

Dieses Paket wurde auf den folgenden Plattformen getestet: Mac OS X (powerpc-apple-darwin1.4), Cygwin (i686-pc-cygwin), Solaris (sparc-sun-solaris2.6), RedHat Linux 7.1 und 9 (i686-pc-linux) und OpenBSD (sparc-unknown-openbsd2.7).

--------------------------------------------------------------------------------

<a name="changing-build-configuration"></a>
## Ändern der Build-Konfiguration

Um das oben genannte `./configure`-Skript zu erstellen, verlässt sich libSRTP auf die [automake](https://www.gnu.org/software/automake/)-Toolchain.  Da `./configure` von automake aus `configure.in` erstellt wird, müssen Sie, wenn Sie Änderungen daran vornehmen, wie `./configure` funktioniert (z. B. um eine neue Bibliotheksabhängigkeit hinzuzufügen), `./configure` neu erstellen und die aktualisierte Version committen.  Zusätzlich zu automake selbst müssen Sie auch die `pkgconfig`-Werkzeuge installiert haben.

Zum Beispiel unter macOS:```
brew install automake pkgconfig
# Edit configure.in
autoremake -ivf
```
<a name="using-visual-studio"></a>
## Visual Studio verwenden

Unter Windows kann man Visual Studio über CMake verwenden. CMake kann hier heruntergeladen werden:
https://cmake.org/ . Um Visual Studio-Builddateien zu erstellen, führt man beispielsweise die folgenden Befehle aus:```
# Create build subdirectory
mkdir build
cd build

# Make project files
cmake .. -G "Visual Studio 15 2017"

# Or for 64 bit project files
cmake .. -G "Visual Studio 15 2017 Win64"
```
<a name="using-meson"></a>
## Mit Meson bauen

Auf allen Plattformen, einschließlich Windows, kann man mit [Meson](https://mesonbuild.com) bauen.
Schritte zum Herunterladen von Meson finden Sie hier: https://mesonbuild.com/Getting-meson.html

Um mit Meson zu bauen, kann man etwa Folgendes tun:```
# Setup the build subdirectory
meson setup --prefix=/path/to/prefix builddir

# Build the project
meson compile -C builddir

# Run tests
meson test -C builddir

# Optionally, install
meson install -C builddir
```
Um mit Visual Studio zu bauen, führen Sie die obigen Befehle in einer Visual Studio-Eingabeaufforderung aus, oder führen Sie `vcvarsall.bat` mit den entsprechenden Argumenten in einer Eingabeaufforderung aus.

Beachten Sie, dass Sie die obigen Befehle auch durch die entsprechenden `ninja`-Ziele ersetzen können: `ninja -C build`, `ninja -C build test`, `ninja -C build install`.

--------------------------------------------------------------------------------

<a name="applications"></a>
# Anwendungen

Mehrere Testtreiber und eine einfache, portable srtp-Anwendung sind im Unterverzeichnis `test/` enthalten.

Testtreiber     | Getestete Funktion
---------       | -------
kernel_driver   | Krypto-Kernel (Chiffren, Auth-Funktionen, RNG)
srtp_driver	    | srtp-In-Memory-Tests (verwendet kein Netzwerk)
rdbx_driver	    | rdbx (erweiterte Replay-Datenbank)
roc_driver	    | erweiterte Sequenznummernfunktionen
replay_driver	  | Replay-Datenbank
cipher_driver	  | Chiffren
auth_driver	    | Hash-Funktionen

Die App `rtpw` ist eine einfache rtp-Anwendung, die Wörter aus
`/usr/dict/words` liest und sie dann einzeln über [s]rtp aussendet.
Die manuelle srtp-Schlüsselvergabe verwendet die Option -k; die automatische Schlüsselverwaltung
mit gdoi wird später hinzugefügt.

Verwendung:~~~.txt
rtpw [[-d <debug>]* [-k|b <key> [-a][-e <key size>][-g]] [-s | -r] dest_ip dest_port] | [-l]

Entweder die Option -s (Sender) oder -r (Empfänger) muss gewählt werden. Die Werte dest_ip, dest_port sind die IP-Adresse und der UDP-Port, an die das Wörterbuch gesendet wird.

Die Optionen sind:

Um zufällige 30-Byte-Werte für die Verwendung als Schlüssel/Salt-Paare zu erhalten, kannst du die folgende Bash-Funktion verwenden, um die Ausgabe von /dev/random zu formatieren (sofern dieses Gerät verfügbar ist).~~~.txt function randhex() { cat /dev/random | od --read-bytes=32 --width=32 -x | awk '{ print $2 $3 $4 $5 $6 $7 $8 $9 $10 $11 $12 $13 $14 $15 $16 }' }

Ein Beispiel für eine SRTP-Sitzung mit zwei rtpw-Programmen folgt:~~~.txt
set k=c1eec3717da76195bb878578790af71c4ee9f859e197a414a78d5abc7451

[sh1]$ test/rtpw -s -k $k -e 128 -a 0.0.0.0 9999
Security services: confidentiality message authentication
set master key/salt to C1EEC3717DA76195BB878578790AF71C/4EE9F859E197A414A78D5ABC7451
setting SSRC to 2078917053
sending word: A
sending word: a
sending word: aa
sending word: aal
...

[sh2]$ test/rtpw -r -k $k -e 128 -a 0.0.0.0 9999
security services: confidentiality message authentication
set master key/salt to C1EEC3717DA76195BB878578790AF71C/4EE9F859E197A414A78D5ABC7451
19 octets received from SSRC 2078917053 word: A
19 octets received from SSRC 2078917053 word: a
20 octets received from SSRC 2078917053 word: aa
21 octets received from SSRC 2078917053 word: aal
...

Beispielcode

Dieser Abschnitt enthält ein einfaches Beispiel für die Verwendung von libSRTP. Hier nehmen wir an, dass die Funktionen get_rtp_packet() und send_srtp_packet() verfügbar sind. Erstere legt ein RTP-Paket in den Puffer und gibt die Anzahl der Oktette zurück, die in diesen Puffer geschrieben wurden. Letztere sendet das RTP-Paket im Puffer, wobei die Länge als zweites Argument übergeben wird.~~~.c srtp_t session; srtp_policy_t policy;

// Set key/salt to predetermined values. uint8_t master_key[16] = {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F}; uint8_t master_salt[14] = {0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D};

// Initialize libSRTP. srtp_init();

// Create and configure an opaque policy handle. srtp_policy_create(&policy); srtp_policy_set_ssrc(policy, (srtp_ssrc_t){ssrc_any_outbound, 0}); srtp_policy_set_profile(policy, srtp_profile_aes128_cm_sha1_80); srtp_policy_add_key(policy, master_key, sizeof(master_key), master_salt, sizeof(master_salt), NULL, 0);

// Allocate and initialize the SRTP session. srtp_create(&session, policy);

srtp_policy_destroy(policy);

// Main loop: get RTP packets, send SRTP packets. while (1) { char rtp_buffer[2048]; size_t rtp_len; char srtp_buffer[2048]; size_t srtp_len = sizeof(srtp_buffer);

rtp_len = get_rtp_packet(rtp_buffer); srtp_protect(session, rtp_buffer, rtp_len, srtp_buffer, &srtp_len); send_srtp_packet(srtp_buffer, srtp_len); }

srtp_dealloc(session); srtp_shutdown();

<a name="credits"></a>
# Danksagungen

Die ursprüngliche Implementierung und Dokumentation von libSRTP wurde
von David McGrew von Cisco Systems, Inc. geschrieben, um die Nutzung,
das Verständnis und die Interoperabilität von Secure RTP zu fördern. Michael Jerris
trug Unterstützung für das Erstellen unter MSVC bei. Andris Pavenis
trug viele wichtige Korrekturen bei. Brian West trug Änderungen bei,
um dynamisches Linken zu ermöglichen. Yves Shumann meldete Dokumentationsfehler.
Randell Jesup trug eine funktionierende SRTCP-Implementierung und weitere
Korrekturen bei. Steve Underwood trug Änderungen für die x86_64-Portabilität bei. Wir danken
auch Fredrik Thulin, Brian Weis, Mark Baugher, Jeff Chan, Bill
Simon, Douglas Smith, Bill May, Richard Preistley, Joe Tardo und
anderen für Beiträge, Kommentare und Korrekturen.

Dieses Referenzmaterial wurde, soweit zutreffend, in dieser Dokumentation
mit dem Doxygen-Dienstprogramm zur automatischen Dokumentation von Quellcode erstellt.

Copyright 2001-2005 von David A. McGrew, Cisco Systems, Inc.

--------------------------------------------------------------------------------

<a name="references"></a>
# Referenzen

SRTP- und ICM-Referenzen
September 2005

Secure RTP ist in [RFC 3711](https://tools.ietf.org/html/rfc3711) definiert.
Die Definition des Zählermodus befindet sich in [Abschnitt 4.1.1](https://tools.ietf.org/html/rfc3711#section-4.1.1).

SHA-1 ist in [FIPS PUB 180-4](http://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.180-4.pdf) definiert.

HMAC ist in [RFC 2104](https://tools.ietf.org/html/rfc2104)
definiert, und HMAC-SHA1-Testvektoren sind verfügbar
in [RFC 2202](https://tools.ietf.org/html/rfc2202#section-3).

Die Verwendung von AES-GCM in SRTP ist in [RFC 7714](https://tools.ietf.org/html/rfc7714) definiert.