Introdução ao libSRTP

Este pacote fornece uma implementação do Protocolo de Transporte em Tempo Real Seguro (SRTP), da Transformação de Segurança Universal (UST) e de um núcleo criptográfico de suporte. A API do SRTP é documentada em include/srtp.h, e a biblioteca está em libsrtp2.a (após a compilação).

Este documento descreve o libSRTP, a biblioteca Open Source Secure RTP da Cisco Systems, Inc. RTP é o Protocolo de Transporte em Tempo Real, um padrão IETF para o transporte de dados em tempo real, como telefonia, áudio e vídeo, definido pelo RFC 3550. O Secure RTP (SRTP) é um perfil RTP que fornece confidencialidade aos dados RTP e autenticação ao cabeçalho e à carga útil do RTP. O SRTP é um padrão IETF, definido no RFC 3711, e foi desenvolvido no Grupo de Trabalho de Transporte de Áudio/Vídeo (AVT) da IETF. Esta biblioteca suporta todos os recursos obrigatórios do SRTP, mas não todos os recursos opcionais. Consulte a seção Recursos Suportados para obter informações mais detalhadas.

Este documento também é usado para gerar os arquivos de documentação na pasta /doc/, onde uma referência mais detalhada à API do libSRTP e às funções relacionadas pode ser criada (requer a instalação do doxygen.). O material de referência é criado automaticamente a partir de comentários embutidos em alguns dos arquivos de cabeçalho C. A documentação é organizada em módulos para melhorar sua clareza. Esses módulos não correspondem diretamente a arquivos. Um núcleo criptográfico subjacente fornece grande parte da funcionalidade básica do libSRTP, mas é em grande parte não documentado porque faz seu trabalho nos bastidores.

Contato

• [email protected] lista de e-mails geral para notícias / anúncios / discussões. Esta é uma lista aberta; consulte https://lists.packetizer.com/mailman/listinfo/libsrtp para se inscrever.

• [email protected] para divulgar problemas de segurança à equipe de manutenção do libsrtp. Esta é uma lista fechada, mas qualquer pessoa pode enviar mensagens para ela.

Conteúdo

• Introdução ao libSRTP
• Contato
  • Conteúdo
• Licença e Aviso Legal
• Visão Geral do libSRTP
  • Fundamentos do RTP Seguro
  • Recursos Suportados
  • Notas de Implementação
• Instalando e Compilando o libSRTP
  • Alterando a Configuração de Compilação
  • Usando o Visual Studio
• Aplicações
  • Código de Exemplo
• Créditos
• Referências

Licença e Aviso Legal

O libSRTP é distribuído sob a seguinte licença, que está incluída na distribuição do código-fonte. Ela é reproduzida no manual no caso de você ter obtido a biblioteca de outra fonte.

Copyright (c) 2001-2017 Cisco Systems, Inc. Todos os direitos reservados.

A redistribuição e o uso, em formato de código-fonte e binário, com ou sem modificação, são permitidos desde que as seguintes condições sejam atendidas:

• As redistribuições do código-fonte devem manter o aviso de direitos autorais acima, esta lista de condições e o aviso legal a seguir.
• As redistribuições em formato binário devem reproduzir o aviso de direitos autorais acima, esta lista de condições e o aviso legal a seguir na documentação e/ou em outros materiais fornecidos com a distribuição.
• Nem o nome da Cisco Systems, Inc. nem os nomes de seus contribuidores podem ser usados para endossar ou promover produtos derivados deste software sem permissão prévia específica por escrito.

ESTE SOFTWARE É FORNECIDO PELOS DETENTORES DOS DIREITOS AUTORAIS E CONTRIBUIDORES "COMO ESTÁ" E QUAISQUER GARANTIAS EXPRESSAS OU IMPLÍCITAS, INCLUINDO, MAS NÃO SE LIMITANDO A, AS GARANTIAS IMPLÍCITAS DE COMERCIABILIDADE E ADEQUAÇÃO A UM FIM ESPECÍFICO SÃO REJEITADAS. EM NENHUM CASO OS DETENTORES DOS DIREITOS AUTORAIS OU CONTRIBUIDORES SERÃO RESPONSÁVEIS POR QUAISQUER DANOS DIRETOS, INDIRETOS, INCIDENTAIS, ESPECIAIS, EXEMPLARES OU CONSEQUENTES (INCLUINDO, MAS NÃO SE LIMITANDO A, AQUISIÇÃO DE BENS OU SERVIÇOS SUBSTITUTOS; PERDA DE USO, DADOS OU LUCROS; OU INTERRUPÇÃO DE NEGÓCIOS) INDEPENDENTEMENTE DA CAUSA E SOB QUALQUER TEORIA DE RESPONSABILIDADE, SEJA EM CONTRATO, RESPONSABILIDADE ESTRITA OU ATO ILÍCITO (INCLUINDO NEGLIGÊNCIA OU OUTROS), DECORRENTES DE QUALQUER FORMA DO USO DESTE SOFTWARE, MESMO SE AVISADO DA POSSIBILIDADE DE TAIS DANOS.

Visão Geral do libSRTP

O libSRTP fornece funções para proteger RTP e RTCP. Os pacotes RTP podem ser criptografados e autenticados (usando a função srtp_protect()), transformando-os em pacotes SRTP. Da mesma forma, os pacotes SRTP podem ser descriptografados e ter sua autenticação verificada (usando a função srtp_unprotect()), transformando-os em pacotes RTP. Funções semelhantes aplicam segurança aos pacotes RTCP.

O typedef srtp_stream_t aponta para uma estrutura que contém todo o estado associado a um fluxo SRTP, incluindo as chaves e os parâmetros para as funções de cifra e autenticação de mensagem e os dados anti-replay. Um srtp_stream_t específico contém as informações necessárias para proteger um determinado fluxo RTP e RTCP. Esse tipo de dado é intencionalmente opaco para separar melhor a API do libSRTP de sua implementação.

Dentro de uma sessão SRTP, pode haver vários fluxos, cada um originado de um remetente específico. Cada origem usa um contexto de fluxo distinto para proteger o fluxo RTP e RTCP que está originando. O typedef srtp_t aponta para uma estrutura que contém todo o estado associado a uma sessão SRTP. Pode haver vários contextos de fluxo associados a um único srtp_t. Um contexto de fluxo não pode existir de forma independente de um srtp_t, embora, é claro, um srtp_t possa ser criado contendo apenas um único contexto de fluxo. Um dispositivo que participa de uma sessão SRTP deve ter um contexto de fluxo para cada origem nessa sessão, para que possa processar os dados que recebe de cada remetente.

No libSRTP, uma sessão é criada usando a função srtp_create(). A política a ser implementada na sessão é passada para essa função como um manipulador opaco srtp_policy_t. Um único manipulador de política descreve uma política de fluxo. Para configurar vários fluxos, crie uma sessão e adicione políticas adicionais com srtp_stream_add().

Um manipulador de política é configurado com funções srtp_policy_set_*. No mínimo, isso inclui seleção de SSRC, seleção de perfil e material de chave/sal. O perfil configura as definições da política criptográfica RTP/RTCP, enquanto o seletor de SSRC identifica como e onde essa política é aplicada.

Fundamentos do RTP Seguro

Nesta seção, revisamos o SRTP e introduzimos alguns termos usados no libSRTP. Uma sessão RTP é definida por um par de endereços de transporte de destino, ou seja, um endereço de rede mais um par de portas UDP para RTP e RTCP. O RTCP, o protocolo de controle RTP, é usado para coordenar os participantes de uma sessão RTP, por exemplo, para fornecer feedback dos receptores aos remetentes. Uma sessão SRTP é definida de forma semelhante; é apenas uma sessão RTP na qual o perfil SRTP está sendo usado. Uma sessão SRTP consiste no tráfego enviado para os endereços de transporte de destino SRTP ou SRTCP. Cada participante de uma sessão é identificado por um identificador de fonte de sincronização (SSRC). Alguns participantes podem não enviar nenhum tráfego SRTP; eles são chamados de receptores, mesmo que enviem tráfego SRTCP, como relatórios de receptor.

O RTP permite que várias origens enviem tráfego RTP e RTCP durante a mesma sessão. O identificador de fonte de sincronização (SSRC) é usado para distinguir essas origens. No libSRTP, chamamos o tráfego SRTP e SRTCP de uma origem específica de fluxo. Cada fluxo tem seu próprio SSRC, número de sequência, contador de rollover e outros dados. Uma escolha específica de opções, mecanismos criptográficos e chaves é chamada de política. Cada fluxo dentro de uma sessão pode ter uma política distinta aplicada a ele.

Uma única política pode ser usada para todos os fluxos de uma determinada sessão, embora o caso em que uma única chave é compartilhada entre vários fluxos exija cuidado. Quando o compartilhamento de chaves é usado, os valores de SSRC que identificam os fluxos devem ser distintos. Esse requisito pode ser aplicado usando a convenção de que cada chave SRTP e SRTCP é usada para criptografia por apenas um único remetente. Em outras palavras, a chave é compartilhada apenas entre fluxos originados de um dispositivo específico (é claro, outros participantes do SRTP precisarão usar a chave para descriptografia). O libSRTP suporta essa aplicação detectando o caso em que uma chave é usada tanto para dados de entrada quanto de saída.

Recursos Suportados

Esta biblioteca suporta todos os recursos de implementação obrigatória do SRTP (conforme definido no RFC 3711). Alguns desses recursos podem ser selecionados (ou desmarcados) em tempo de execução definindo uma política apropriada usando um manipulador srtp_policy_t. Alguns outros comportamentos do protocolo podem ser adaptados definindo um manipulador de eventos apropriado para os eventos excepcionais; consulte a seção SRTPevents na documentação gerada.

Algumas opções descritas na especificação SRTP não são suportadas. Isso inclui

• taxas de derivação de chave diferentes de zero,
• a cifra F8,
• o uso do índice de pacote para selecionar entre chaves mestras.

O usuário deve estar ciente de que é possível usar mal esta biblioteca e que o resultado pode ser um nível de segurança inadequado. Se você estiver implementando um recurso usando esta biblioteca, vai querer ler a seção Security Considerations do RFC 3711. Além disso, é importante que você leia e compreenda os termos descritos na seção Licença e Aviso Legal.

Esta biblioteca também suporta os métodos de criptografia autenticada AES-GCM descritos no RFC 7714

Notas de Implementação

• É possível configurar qual backend criptográfico de terceiros (ex.: openssl/nss/etc.) será usado na compilação do libSRTP. Se nenhum backend de terceiros for definido, o libSRTP fornece uma implementação interna de AES e Sha1. A implementação interna apenas suporta AES-128 e AES-256; portanto, para usar AES-192 ou o grupo de cifras AES-GCM, um backend criptográfico de terceiros deve ser configurado. Por esse motivo e por questões de desempenho, é altamente recomendável usar um backend criptográfico de terceiros.

• A função srtp_protect() pressupõe que o buffer que contém o pacote rtp tenha armazenamento alocado suficiente para que a tag de autenticação possa ser gravada no final desse pacote. Se essa premissa não for válida, ocorrerá corrupção de memória.

• Testes automatizados para as funções criptográficas são fornecidos por meio das funções cipher_type_self_test() e auth_type_self_test(). Essas funções devem ser usadas para testar cada porta deste código para uma nova plataforma.

• A proteção contra replay está contida no mecanismo criptográfico, e testes para ela são fornecidos.

• Esta implementação fornece chamadas para inicializar, proteger e desproteger pacotes RTP e faz o mínimo possível de suposições sobre como essas funções serão chamadas. Por exemplo, não se espera que o chamador forneça pacotes em ordem (embora, se forem chamados com mais de 65 mil pacotes fora de sequência, a sincronização será perdida).

• O número de sequência no pacote rtp é usado como os 16 bits baixos do índice de pacote local do remetente. Observe que o RTP iniciará seu número de sequência em um local aleatório, e a camada SRTP simplesmente avança para esse número em sua primeira invocação. Uma versão anterior desta biblioteca usava números de sequência iniciais menores que 32.768; esse truque não é mais necessário, pois a função rdbx_estimate_index(...) foi aprimorada a partir da versão 1.0.1.

• A janela de replay para (S)RTCP é fixada em 128 bits de comprimento.

Instalando e Compilando o libSRTP

Para instalar o libSRTP, baixe o lançamento mais recente da distribuição em https://github.com/cisco/libsrtp/releases. Provavelmente você vai querer obter o lançamento mais recente. Descompacte a distribuição e extraia os arquivos-fonte; o diretório no qual os arquivos-fonte serão colocados é chamado libsrtp-A-B-C, onde A é o número da versão, B é o número da versão principal e C é o número da versão secundária.

O libSRTP usa os utilitários GNU autoconf e make (o make do BSD não funcionará; se as duas versões do make estiverem na sua plataforma, você pode invocar o GNU make como gmake.). No diretório libsrtp, execute o script configure e depois make:~~~.txt ./configure [ options ] make

Opção                           | Descrição
-------------------------------|--------------------
\-\-help                   \-h | Mostrar ajuda
\-\-enable-debug-logging       | Ativar log de depuração em todos os módulos
\-\-enable-openssl             | Ativar o mecanismo criptográfico OpenSSL
\-\-enable-nss                 | Ativar o mecanismo criptográfico NSS
\-\-enable-openssl-kdf         | Ativar o algoritmo KDF do OpenSSL
\-\-enable-log-stdout          | Ativar log no stdout
\-\-with-openssl-dir           | Local da instalação do OpenSSL
\-\-with-nss-dir               | Local da instalação do NSS
\-\-with-log-file              | Usar arquivo para log

Por padrão, não há saída de log; o log pode ser habilitado para saída no stdout
ou em um arquivo específico usando as opções do configure.

Este pacote foi testado nas seguintes plataformas: Mac OS X
(powerpc-apple-darwin1.4), Cygwin (i686-pc-cygwin), Solaris
(sparc-sun-solaris2.6), RedHat Linux 7.1 e 9 (i686-pc-linux), e
OpenBSD (sparc-unknown-openbsd2.7).

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

<a name="changing-build-configuration"></a>
## Alterando a Configuração de Build

Para construir o script `./configure` mencionado acima, o libSRTP depende da
ferramenta [automake](https://www.gnu.org/software/automake/).  Como
o `./configure` é construído a partir de `configure.in` pelo automake, se você
fizer alterações na forma como o `./configure` funciona (por exemplo, para
adicionar uma nova dependência de biblioteca), você precisará reconstruir o
`./configure` e fazer o commit da versão atualizada.  Além do próprio automake, você também precisará ter as ferramentas `pkgconfig` instaladas.

Por exemplo, no macOS:```
brew install automake pkgconfig
# Edit configure.in
autoremake -ivf
```
<a name="using-visual-studio"></a>
## Usando o Visual Studio

No Windows, é possível usar o Visual Studio via CMake. O CMake pode ser baixado aqui:
https://cmake.org/ . Para criar arquivos de build do Visual Studio, por exemplo, execute os
seguintes comandos:```
# 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>
## Usando Meson

Em todas as plataformas, incluindo Windows, é possível compilar usando [Meson](https://mesonbuild.com).
As etapas para baixar o Meson estão aqui: https://mesonbuild.com/Getting-meson.html

Para compilar com Meson, você pode fazer algo como:```
# 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
```
Para compilar com Visual Studio, execute os comandos acima de um prompt de comando do Visual Studio
ou execute `vcvarsall.bat` com os argumentos apropriados em
um Prompt de Comando.

Observe que você também pode substituir os comandos acima pelos alvos `ninja`
apropriados: `ninja -C build`, `ninja -C build test`, `ninja -C build install`.

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

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

Vários drivers de teste e um aplicativo srtp simples e portátil estão
incluídos no subdiretório `test/`.

Driver de teste     | Função testada
---------       | -------
kernel_driver   | núcleo criptográfico (cifras, funções de autenticação, rng)
srtp_driver	    | testes em memória do srtp (não usam a rede)
rdbx_driver	    | rdbx (banco de dados de replay estendido)
roc_driver	    | funções de número de sequência estendido
replay_driver	  | banco de dados de replay
cipher_driver	  | cifras
auth_driver	    | funções de hash

O aplicativo `rtpw` é um aplicativo rtp simples que lê palavras de
`/usr/dict/words` e as envia uma a uma usando [s]rtp.
O estabelecimento manual de chaves srtp usa a opção -k; o gerenciamento automatizado de chaves
usando gdoi será adicionado posteriormente.

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

Deve ser escolhida a opção -s (remetente) ou -r (recetor). Os valores dest_ip, dest_port são, respetivamente, o endereço IP e a porta UDP para os quais o dicionário será enviado.

As opções são:

Para obter valores aleatórios de 30 bytes para usar como pares chave/sal , pode usar a seguinte função bash para formatar a saída de /dev/random (onde esse dispositivo estiver disponível).~~~.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 }' }

Um exemplo de uma sessão SRTP usando dois programas rtpw segue:~~~.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
...

Código de Exemplo

Esta seção fornece um exemplo simples de como usar o libSRTP. Aqui assumimos que as funções get_rtp_packet() e send_srtp_packet() estão disponíveis para nós. A primeira coloca um pacote RTP no buffer e retorna o número de octetos gravados nesse buffer. A segunda envia o pacote RTP no buffer, dado o comprimento como seu segundo argumento.~~~.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>
# Créditos

A implementação e a documentação originais da libSRTP foram escritas
por David McGrew, da Cisco Systems, Inc., com o objetivo de promover o uso,
o entendimento e a interoperabilidade do Secure RTP. Michael Jerris
contribuiu com suporte para compilação no MSVC. Andris Pavenis
contribuiu com muitas correções importantes. Brian West contribuiu com alterações para
habilitar a ligação dinâmica. Yves Shumann relatou erros na documentação.
Randell Jesup contribuiu com uma implementação funcional do SRTCP e outras
correções. Steve Underwood contribuiu com alterações de portabilidade para x86_64. Agradecemos também
a Fredrik Thulin, Brian Weis, Mark Baugher, Jeff Chan, Bill
Simon, Douglas Smith, Bill May, Richard Preistley, Joe Tardo e
outros por contribuições, comentários e correções.

Este material de referência, quando aplicável, nesta documentação foi gerado
usando o utilitário doxygen para documentação automática de código-fonte.

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

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

<a name="references"></a>
# Referências

Referências SRTP e ICM
Setembro de 2005

O Secure RTP é definido em [RFC 3711](https://tools.ietf.org/html/rfc3711).
A definição do modo contador está na [Seção 4.1.1](https://tools.ietf.org/html/rfc3711#section-4.1.1).

SHA-1 é definido em [FIPS PUB 180-4](http://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.180-4.pdf).

HMAC é definido em [RFC 2104](https://tools.ietf.org/html/rfc2104)
e vetores de teste HMAC-SHA1 estão disponíveis
em [RFC 2202](https://tools.ietf.org/html/rfc2202#section-3).

O uso de AES-GCM em SRTP é definido em [RFC 7714](https://tools.ietf.org/html/rfc7714).