2adef546f1821fe7e8d062db1f9e2eacdd9e08fc
[vlc.git] / libs / srtp / srtp.c
1 /*
2  * Secure RTP with libgcrypt
3  * Copyright (C) 2007  RĂ©mi Denis-Courmont <rdenis # simphalempin , com>
4  *
5  * This library is free software; you can redistribute it and/or
6  * modify it under the terms of the GNU Lesser General Public
7  * License as published by the Free Software Foundation; either
8  * version 2.1 of the License, or (at your option) any later version.
9  *
10  * This library is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13  * Lesser General Public License for more details.
14  *
15  * You should have received a copy of the GNU Lesser General Public
16  * License along with this library; if not, write to the Free Software
17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
18  */
19
20 #ifdef HAVE_CONFIG_H
21 # include <config.h>
22 #endif
23
24 #include <stdint.h>
25 #include <stddef.h>
26
27 #include "srtp.h"
28
29 #include <stdbool.h>
30 #include <stdlib.h>
31 #include <assert.h>
32 #include <errno.h>
33
34 #include <gcrypt.h>
35
36 #define debug( ... ) (void)0
37
38 /* TODO:
39  * Useful stuff:
40  * - ROC profil thingy (multicast really needs this)
41  * - replay protection
42  *
43  * Requirements for conformance:
44  * - suites with NULL cipher
45  * - SRTCP
46  *
47  * Useless stuff (because nothing depends on it):
48  * - non-nul key derivation rate
49  * - MKI payload
50  */
51
52 typedef struct srtp_proto_t
53 {
54     gcry_cipher_hd_t cipher;
55     gcry_md_hd_t     mac;
56     uint32_t         salt[4];
57 } srtp_proto_t;
58
59 struct srtp_session_t
60 {
61     srtp_proto_t rtp;
62     srtp_proto_t rtcp;
63     unsigned flags;
64     unsigned kdr;
65     uint32_t rtcp_index;
66     uint32_t rtp_roc;
67     uint16_t rtp_seq;
68     uint8_t  tag_len;
69 };
70
71 enum
72 {
73     SRTP_CRYPT,
74     SRTP_AUTH,
75     SRTP_SALT,
76     SRTCP_CRYPT,
77     SRTCP_AUTH,
78     SRTCP_SALT
79 };
80
81 #ifdef WIN32
82 # include <winsock2.h>
83 #else
84 # include <netinet/in.h>
85 # include <pthread.h>
86 GCRY_THREAD_OPTION_PTHREAD_IMPL;
87 #endif
88
89 static bool libgcrypt_usable = false;
90
91 static void initonce_libgcrypt (void)
92 {
93     if ((gcry_check_version ("1.1.94") == NULL)
94      || gcry_control (GCRYCTL_DISABLE_SECMEM, 0)
95      || gcry_control (GCRYCTL_INITIALIZATION_FINISHED, 0)
96 #ifndef WIN32
97      || gcry_control (GCRYCTL_SET_THREAD_CBS, &gcry_threads_pthread)
98 #endif
99        )
100         return;
101
102     libgcrypt_usable = true;
103 }
104
105 static int init_libgcrypt (void)
106 {
107     int retval;
108 #ifndef WIN32
109     static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
110     static pthread_once_t once = PTHREAD_ONCE_INIT;
111
112     pthread_mutex_lock (&mutex);
113     pthread_once (&once, initonce_libgcrypt);
114     retval = -libgcrypt_usable;
115     pthread_mutex_unlock (&mutex);
116 #else
117 # warning FIXME: This is not thread-safe.
118     if (!libgcrypt_usable)
119         initonce_libgcrypt ();
120     retval = -libgcrypt_usable;
121 #endif
122
123     return retval;
124
125 }
126
127
128 static void proto_destroy (srtp_proto_t *p)
129 {
130     gcry_md_close (p->mac);
131     gcry_cipher_close (p->cipher);
132 }
133
134
135 /**
136  * Releases all resources associated with a Secure RTP session.
137  */
138 void srtp_destroy (srtp_session_t *s)
139 {
140     assert (s != NULL);
141
142     proto_destroy (&s->rtcp);
143     proto_destroy (&s->rtp);
144     free (s);
145 }
146
147
148 static int proto_create (srtp_proto_t *p, int gcipher, int gmd)
149 {
150     if (gcry_cipher_open (&p->cipher, gcipher, GCRY_CIPHER_MODE_CTR, 0) == 0)
151     {
152         if (gcry_md_open (&p->mac, gmd, GCRY_MD_FLAG_HMAC) == 0)
153             return 0;
154         gcry_cipher_close (p->cipher);
155     }
156     return -1;
157 }
158
159
160 /**
161  * Allocates a Secure RTP session.
162  *
163  * @param name cipher-suite name
164  * @param kdr key derivation rate
165  * @param winsize anti-replay windows size (between 64 and 32767 inclusive)
166  *                0 disable replay attack protection (OK for send only)
167  * @param flags OR'ed optional flags.
168  *
169  * @return NULL in case of error
170  */
171 srtp_session_t *
172 srtp_create (const char *name, unsigned flags, unsigned kdr, uint16_t winsize)
173 {
174     assert (name != NULL);
175
176     if (kdr != 0)
177         return NULL; // FIXME: KDR not implemented yet
178     if (winsize != 0)
179         return NULL; // FIXME: replay protection not implemented yet
180
181     uint8_t tag_len;
182     int cipher = GCRY_CIPHER_AES, md = GCRY_MD_SHA1;
183
184     if (strcmp (name, "AES_CM_128_HMAC_SHA1_80") == 0)
185         tag_len = 10;
186     else
187     if (strcmp (name, "AES_CM_128_HMAC_SHA1_32") == 0)
188         tag_len = 4;
189     else
190     // F8_128_HMAC_SHA1_80 is not implemented
191         return NULL;
192
193     if ((flags & ~SRTP_FLAGS_MASK) || (winsize > 32767) || init_libgcrypt ())
194         return NULL;
195
196     srtp_session_t *s = malloc (sizeof (*s));
197     if (s == NULL)
198         return NULL;
199
200     memset (s, 0, sizeof (*s));
201     s->flags = flags;
202     s->kdr = kdr;
203     s->tag_len = tag_len;
204
205     if (proto_create (&s->rtp, cipher, md) == 0)
206     {
207         if (proto_create (&s->rtcp, cipher, md) == 0)
208             return s;
209         proto_destroy (&s->rtp);
210     }
211
212     free (s);
213     return NULL;
214 }
215
216
217 /**
218  * AES-CM key derivation (saltlen = 14 bytes)
219  */
220 static int
221 derive (gcry_cipher_hd_t prf, const void *salt,
222         const uint8_t *r, size_t rlen, uint8_t label,
223         void *out, size_t outlen)
224 {
225     uint8_t iv[16];
226
227     memcpy (iv, salt, 14);
228     iv[14] = iv[15] = 0;
229
230     assert (rlen < 14);
231     iv[13 - rlen] ^= label;
232     for (size_t i = 0; i < rlen; i++)
233         iv[sizeof (iv) - rlen + i] ^= r[i];
234
235     /* TODO: retry with CTR mode */
236     while (outlen >= sizeof (iv))
237     {
238         /* AES */
239         if (gcry_cipher_encrypt (prf, out, sizeof (iv), iv, sizeof (iv)))
240             return EINVAL;
241         outlen -= sizeof (iv);
242         out = ((uint8_t *)out) + sizeof (iv);
243
244         /* Increment IV in network byte order */
245         if (++iv[sizeof (iv) - 1] == 0)
246             ++iv[sizeof (iv) -2];
247     }
248
249     if (outlen > 0)
250     {
251         /* Truncated last AES output block */
252         if (gcry_cipher_encrypt (prf, iv, sizeof (iv), NULL, 0))
253             return -1;
254         memcpy (out, iv, outlen);
255     }
256
257     return 0;
258 }
259
260 #include <stdio.h>
261
262 static int
263 proto_derive (srtp_proto_t *p, gcry_cipher_hd_t prf,
264               const void *salt, size_t saltlen,
265               const uint8_t *r, size_t rlen, bool rtcp)
266 {
267     if (saltlen != 14)
268         return -1;
269
270     uint32_t cipherkey[4], authkey[5];
271     uint8_t label = rtcp ? SRTCP_CRYPT : SRTP_CRYPT;
272
273     if (derive (prf, salt, r, rlen, label++, cipherkey, 16)
274      || gcry_cipher_setkey (p->cipher, cipherkey, 16)
275      || derive (prf, salt, r, rlen, label++, authkey, 20)
276      || gcry_md_setkey (p->mac, authkey, 20)
277      || derive (prf, salt, r, rlen, label++, p->salt, 14))
278         return -1;
279
280     debug (" cipher key: %08x%08x%08x%08x\n auth key: %08x%08x%08x%08x%08x\n",
281             ntohl (cipherkey[0]), ntohl (cipherkey[1]), ntohl (cipherkey[2]),
282             ntohl (cipherkey[3]), ntohl (authkey[0]), ntohl (authkey[1]),
283             ntohl (authkey[2]), ntohl (authkey[3]), ntohl (authkey[4]));
284
285     return 0;
286 }
287
288
289 /**
290  * SRTP/SRTCP cipher/salt/MAC keys derivation.
291  */
292 static int
293 srtp_derive (srtp_session_t *s, const void *key, size_t keylen,
294              const void *salt, size_t saltlen)
295 {
296     gcry_cipher_hd_t prf;
297     uint8_t r[6];
298
299     /* TODO: retry with CTR mode */
300     if (gcry_cipher_open (&prf, GCRY_CIPHER_AES, GCRY_CIPHER_MODE_ECB, 0)
301      || gcry_cipher_setkey (prf, key, keylen))
302         return -1;
303
304     /* RTP key derivation */
305     if (s->kdr != 0)
306     {
307         uint64_t index = (((uint64_t)s->rtp_roc) << 16) | s->rtp_seq;
308         index /= s->kdr;
309
310         for (int i = sizeof (r) - 1; i >= 0; i--)
311         {
312             r[i] = index & 0xff;
313             index = index >> 8;
314         }
315     }
316     else
317         memset (r, 0, sizeof (r));
318
319     if (proto_derive (&s->rtp, prf, salt, saltlen, r, 6, false))
320         return -1;
321
322     /* RTCP key derivation */
323     memcpy (r, &(uint32_t){ htonl (s->rtcp_index) }, 4);
324     if (proto_derive (&s->rtcp, prf, salt, saltlen, r, 4, true))
325         return -1;
326
327     (void)gcry_cipher_close (prf);
328     return 0;
329 }
330
331
332
333 /**
334  * Sets (or resets) the master key and master salt for a SRTP session.
335  * This must be done at least once before using rtp_send(), rtp_recv(),
336  * rtcp_send() or rtcp_recv(). Also, rekeying is required every
337  * 2^48 RTP packets or 2^31 RTCP packets (whichever comes first),
338  * otherwise the protocol security might be broken.
339  *
340  * @return 0 on success, in case of error:
341  *  EINVAL  invalid or unsupported key/salt sizes combination
342  */
343 int
344 srtp_setkey (srtp_session_t *s, const void *key, size_t keylen,
345              const void *salt, size_t saltlen)
346 {
347     return srtp_derive (s, key, keylen, salt, saltlen) ? EINVAL : 0;
348 }
349
350
351 /** AES-CM encryption/decryption (ctr length = 16 bytes) */
352 static int
353 encrypt (gcry_cipher_hd_t hd, uint32_t *ctr, uint8_t *data, size_t len)
354 {
355     const size_t ctrlen = 16;
356     while (len >= ctrlen)
357     {
358         if (gcry_cipher_setctr (hd, ctr, ctrlen)
359          || gcry_cipher_encrypt (hd, data, ctrlen, NULL, 0))
360             return -1;
361
362         data += ctrlen;
363         len -= ctrlen;
364         ctr[3] = htonl (ntohl (ctr[3]) + 1);
365     }
366
367     if (len > 0)
368     {
369         /* Truncated last block */
370         uint8_t dummy[ctrlen];
371         memcpy (dummy, data, len);
372         memset (dummy + len, 0, ctrlen - len);
373
374         if (gcry_cipher_setctr (hd, ctr, ctrlen)
375          || gcry_cipher_encrypt (hd, dummy, ctrlen, data, ctrlen))
376             return -1;
377         memcpy (data, dummy, len);
378     }
379
380     return 0;
381 }
382
383
384 /** AES-CM for RTP (salt = 14 bytes + 2 nul bytes) */
385 static inline int
386 rtp_encrypt (gcry_cipher_hd_t hd, uint32_t ssrc, uint32_t roc, uint16_t seq,
387              const uint32_t *salt, uint8_t *data, size_t len)
388 {
389     /* Determines cryptographic counter (IV) */
390     uint32_t counter[4];
391     counter[0] = salt[0];
392     counter[1] = salt[1] ^ ssrc;
393     counter[2] = salt[2] ^ htonl (roc);
394     counter[3] = salt[3] ^ htonl (seq << 16);
395
396     /* Encryption */
397     return encrypt (hd, counter, data, len);
398 }
399
400
401 /** Message Authentication and Integrity for RTP */
402 static const uint8_t *
403 rtp_digest (gcry_md_hd_t md, const void *data, size_t len, uint32_t roc)
404 {
405     gcry_md_reset (md);
406     gcry_md_write (md, data, len);
407     gcry_md_write (md, &(uint32_t){ htonl (roc) }, 4);
408     return gcry_md_read (md, 0);
409 }
410
411
412 /**
413  * Encrypts/decrypts a RTP packet and updates SRTP context
414  * (CTR block cypher mode of operation has identical encryption and
415  * decryption function).
416  *
417  * @param buf RTP packet to be encrypted/digested
418  * @param len RTP packet length
419  *
420  * @return 0 on success, in case of error:
421  *  EINVAL  malformatted RTP packet
422  */
423 static int srtp_crypt (srtp_session_t *s, uint8_t *buf, size_t len)
424 {
425     assert (s != NULL);
426
427     if ((len < 12) || ((buf[0] >> 6) != 2))
428         return EINVAL;
429
430     /* Computes encryption offset */
431     uint16_t offset = 12;
432     offset += (buf[0] & 0xf) * 4; // skips CSRC
433
434     if (buf[0] & 0x10)
435     {
436         uint16_t extlen;
437
438         offset += 4;
439         if (len < offset)
440             return EINVAL;
441
442         memcpy (&extlen, buf + offset - 2, 2);
443         offset += htons (extlen); // skips RTP extension header
444     }
445
446     if (len < offset)
447         return EINVAL;
448
449     /* Determines RTP 48-bits counter and SSRC */
450     uint32_t ssrc;
451     memcpy (&ssrc, buf + 8, 4);
452
453     uint16_t seq = (buf[2] << 8) | buf[3];
454     if (((seq - s->rtp_seq) & 0xffff) < 32768)
455     {
456         if (seq < s->rtp_seq)
457             s->rtp_roc++; /* Sequence number wrap */
458     }
459     else
460     {
461         if (seq > s->rtp_seq)
462             s->rtp_roc--;
463     }
464
465     s->rtp_seq = seq;
466
467     if (s->flags & SRTP_UNENCRYPTED)
468         return 0;
469
470     if (rtp_encrypt (s->rtp.cipher, ssrc, s->rtp_roc, seq, s->rtp.salt,
471                      buf + offset, len - offset))
472         return EINVAL;
473
474     return 0;
475 }
476
477
478 /**
479  * Turns a RTP packet into a SRTP packet: encrypt it, then computes
480  * the authentication tag and appends it.
481  * Note that you can encrypt packet in disorder.
482  *
483  * @param buf RTP packet to be encrypted/digested
484  * @param lenp pointer to the RTP packet length on entry,
485  *             set to the SRTP length on exit (undefined in case of error)
486  * @param bufsize size (bytes) of the packet buffer
487  *
488  * @return 0 on success, in case of error:
489  *  EINVAL  malformatted RTP packet or internal error
490  *  ENOSPC  bufsize is too small (to add authentication tag)
491  */
492 int
493 srtp_send (srtp_session_t *s, uint8_t *buf, size_t *lenp, size_t bufsize)
494 {
495     size_t len = *lenp;
496     int val = srtp_crypt (s, buf, len);
497     if (val)
498         return val;
499
500     if (s->flags & SRTP_UNAUTHENTICATED)
501         return 0;
502
503     if (bufsize < (len + s->tag_len))
504         return ENOSPC;
505
506     const uint8_t *tag = rtp_digest (s->rtp.mac, buf, len, s->rtp_roc);
507     memcpy (buf + len, tag, s->tag_len);
508     *lenp = len + s->tag_len;
509
510     return 0;
511 }
512
513
514 /**
515  * Turns a SRTP packet into a RTP packet: authenticates the packet,
516  * then decrypts it.
517  *
518  * @param buf RTP packet to be digested/decrypted
519  * @param lenp pointer to the RTP packet length on entry,
520  *             set to the SRTP length on exit (undefined in case of error)
521  *
522  * @return 0 on success, in case of error:
523  *  EINVAL  malformatted SRTP packet
524  *  EACCES  authentication failed (spoofed packet or out-of-sync)
525  */
526 int
527 srtp_recv (srtp_session_t *s, uint8_t *buf, size_t *lenp)
528 {
529     size_t len = *lenp;
530
531     if (!(s->flags & SRTP_UNAUTHENTICATED))
532     {
533         if (len < s->tag_len)
534             return EINVAL;
535         len -= s->tag_len;
536         *lenp = len;
537
538         const uint8_t *tag = rtp_digest (s->rtp.mac, buf, len, s->rtp_roc);
539         debug  (" Auth tag: %08x%08x%04x (wanted)\n"
540                 " Auth tag: %08x%08x%04x (recv'd)\n",
541                 ntohl (((uint32_t *)tag)[0]), ntohl (((uint32_t *)tag)[1]),
542                 ntohs (((uint16_t *)tag)[4]),
543                 ntohl (((uint32_t *)w)[0]), ntohl (((uint32_t *)w)[1]),
544                 ntohs (((uint16_t *)w)[4]));
545         if (memcmp (buf + len, tag, s->tag_len))
546             return EACCES;
547     }
548
549     /* FIXME: anti-replay */
550
551     return srtp_crypt (s, buf, len);
552 }
553