SRTCP support
[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 profile thingy (multicast really needs this)
41  * - replay protection
42  *
43  * Useless stuff (because nothing depends on it):
44  * - non-nul key derivation rate
45  * - MKI payload
46  */
47
48 typedef struct srtp_proto_t
49 {
50     gcry_cipher_hd_t cipher;
51     gcry_md_hd_t     mac;
52     uint32_t         salt[4];
53 } srtp_proto_t;
54
55 struct srtp_session_t
56 {
57     srtp_proto_t rtp;
58     srtp_proto_t rtcp;
59     unsigned flags;
60     unsigned kdr;
61     uint32_t rtcp_index;
62     uint32_t rtp_roc;
63     uint16_t rtp_seq;
64     uint8_t  tag_len;
65 };
66
67 enum
68 {
69     SRTP_CRYPT,
70     SRTP_AUTH,
71     SRTP_SALT,
72     SRTCP_CRYPT,
73     SRTCP_AUTH,
74     SRTCP_SALT
75 };
76
77 #ifdef WIN32
78 # include <winsock2.h>
79 #else
80 # include <netinet/in.h>
81 # include <pthread.h>
82 GCRY_THREAD_OPTION_PTHREAD_IMPL;
83 #endif
84
85 static bool libgcrypt_usable = false;
86
87 static void initonce_libgcrypt (void)
88 {
89     if ((gcry_check_version ("1.1.94") == NULL)
90      || gcry_control (GCRYCTL_DISABLE_SECMEM, 0)
91      || gcry_control (GCRYCTL_INITIALIZATION_FINISHED, 0)
92 #ifndef WIN32
93      || gcry_control (GCRYCTL_SET_THREAD_CBS, &gcry_threads_pthread)
94 #endif
95        )
96         return;
97
98     libgcrypt_usable = true;
99 }
100
101 static int init_libgcrypt (void)
102 {
103     int retval;
104 #ifndef WIN32
105     static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
106     static pthread_once_t once = PTHREAD_ONCE_INIT;
107
108     pthread_mutex_lock (&mutex);
109     pthread_once (&once, initonce_libgcrypt);
110     retval = -libgcrypt_usable;
111     pthread_mutex_unlock (&mutex);
112 #else
113 # warning FIXME: This is not thread-safe.
114     if (!libgcrypt_usable)
115         initonce_libgcrypt ();
116     retval = -libgcrypt_usable;
117 #endif
118
119     return retval;
120
121 }
122
123
124 static void proto_destroy (srtp_proto_t *p)
125 {
126     gcry_md_close (p->mac);
127     gcry_cipher_close (p->cipher);
128 }
129
130
131 /**
132  * Releases all resources associated with a Secure RTP session.
133  */
134 void srtp_destroy (srtp_session_t *s)
135 {
136     assert (s != NULL);
137
138     proto_destroy (&s->rtcp);
139     proto_destroy (&s->rtp);
140     free (s);
141 }
142
143
144 static int proto_create (srtp_proto_t *p, int gcipher, int gmd)
145 {
146     if (gcry_cipher_open (&p->cipher, gcipher, GCRY_CIPHER_MODE_CTR, 0) == 0)
147     {
148         if (gcry_md_open (&p->mac, gmd, GCRY_MD_FLAG_HMAC) == 0)
149             return 0;
150         gcry_cipher_close (p->cipher);
151     }
152     return -1;
153 }
154
155
156 /**
157  * Allocates a Secure RTP one-way session.
158  * The same session cannot be used both ways because this would confuse
159  * internal cryptographic counters; it is however of course feasible to open
160  * multiple simultaneous sessions with the same master key.
161  *
162  * @param name cipher-suite name
163  * @param kdr key derivation rate
164  * @param winsize anti-replay windows size (between 64 and 32767 inclusive)
165  *                0 disable replay attack protection (OK for send only)
166  * @param flags OR'ed optional flags.
167  *
168  * @return NULL in case of error
169  */
170 srtp_session_t *
171 srtp_create (const char *name, unsigned flags, unsigned kdr, uint16_t winsize)
172 {
173     assert (name != NULL);
174
175     if (kdr != 0)
176         return NULL; // FIXME: KDR not implemented yet
177     if (winsize != 0)
178         return NULL; // FIXME: replay protection not implemented yet
179
180     uint8_t tag_len;
181     int cipher = GCRY_CIPHER_AES, md = GCRY_MD_SHA1;
182
183     if (strcmp (name, "AES_CM_128_HMAC_SHA1_80") == 0)
184         tag_len = 10;
185     else
186     if (strcmp (name, "AES_CM_128_HMAC_SHA1_32") == 0)
187         tag_len = 4;
188     else
189     // F8_128_HMAC_SHA1_80 is not implemented
190         return NULL;
191
192     if ((flags & ~SRTP_FLAGS_MASK) || (winsize > 32767) || init_libgcrypt ())
193         return NULL;
194
195     srtp_session_t *s = malloc (sizeof (*s));
196     if (s == NULL)
197         return NULL;
198
199     memset (s, 0, sizeof (*s));
200     s->flags = flags;
201     s->kdr = kdr;
202     s->tag_len = tag_len;
203
204     if (proto_create (&s->rtp, cipher, md) == 0)
205     {
206         if (proto_create (&s->rtcp, cipher, md) == 0)
207             return s;
208         proto_destroy (&s->rtp);
209     }
210
211     free (s);
212     return NULL;
213 }
214
215
216 /**
217  * AES-CM key derivation (saltlen = 14 bytes)
218  */
219 static int
220 derive (gcry_cipher_hd_t prf, const void *salt,
221         const uint8_t *r, size_t rlen, uint8_t label,
222         void *out, size_t outlen)
223 {
224     uint8_t iv[16];
225
226     memcpy (iv, salt, 14);
227     iv[14] = iv[15] = 0;
228
229     assert (rlen < 14);
230     iv[13 - rlen] ^= label;
231     for (size_t i = 0; i < rlen; i++)
232         iv[sizeof (iv) - rlen + i] ^= r[i];
233
234     /* TODO: retry with CTR mode */
235     while (outlen >= sizeof (iv))
236     {
237         /* AES */
238         if (gcry_cipher_encrypt (prf, out, sizeof (iv), iv, sizeof (iv)))
239             return EINVAL;
240         outlen -= sizeof (iv);
241         out = ((uint8_t *)out) + sizeof (iv);
242
243         /* Increment IV in network byte order */
244         if (++iv[sizeof (iv) - 1] == 0)
245             ++iv[sizeof (iv) -2];
246     }
247
248     if (outlen > 0)
249     {
250         /* Truncated last AES output block */
251         if (gcry_cipher_encrypt (prf, iv, sizeof (iv), NULL, 0))
252             return -1;
253         memcpy (out, iv, outlen);
254     }
255
256     return 0;
257 }
258
259
260 static int
261 proto_derive (srtp_proto_t *p, gcry_cipher_hd_t prf,
262               const void *salt, size_t saltlen,
263               const uint8_t *r, size_t rlen, bool rtcp)
264 {
265     if (saltlen != 14)
266         return -1;
267
268     uint8_t keybuf[20];
269     uint8_t label = rtcp ? SRTCP_CRYPT : SRTP_CRYPT;
270
271     if (derive (prf, salt, r, rlen, label++, keybuf, 16)
272      || gcry_cipher_setkey (p->cipher, keybuf, 16)
273      || derive (prf, salt, r, rlen, label++, keybuf, 20)
274      || gcry_md_setkey (p->mac, keybuf, 20)
275      || derive (prf, salt, r, rlen, label, p->salt, 14))
276         return -1;
277
278     return 0;
279 }
280
281
282 /**
283  * SRTP/SRTCP cipher/salt/MAC keys derivation.
284  */
285 static int
286 srtp_derive (srtp_session_t *s, const void *key, size_t keylen,
287              const void *salt, size_t saltlen)
288 {
289     gcry_cipher_hd_t prf;
290     uint8_t r[6];
291
292     /* TODO: retry with CTR mode */
293     if (gcry_cipher_open (&prf, GCRY_CIPHER_AES, GCRY_CIPHER_MODE_ECB, 0)
294      || gcry_cipher_setkey (prf, key, keylen))
295         return -1;
296
297     /* RTP key derivation */
298     if (s->kdr != 0)
299     {
300         uint64_t index = (((uint64_t)s->rtp_roc) << 16) | s->rtp_seq;
301         index /= s->kdr;
302
303         for (int i = sizeof (r) - 1; i >= 0; i--)
304         {
305             r[i] = index & 0xff;
306             index = index >> 8;
307         }
308     }
309     else
310         memset (r, 0, sizeof (r));
311
312     if (proto_derive (&s->rtp, prf, salt, saltlen, r, 6, false))
313         return -1;
314
315     /* RTCP key derivation */
316     memcpy (r, &(uint32_t){ htonl (s->rtcp_index) }, 4);
317     if (proto_derive (&s->rtcp, prf, salt, saltlen, r, 4, true))
318         return -1;
319
320     (void)gcry_cipher_close (prf);
321     return 0;
322 }
323
324
325 /**
326  * Sets (or resets) the master key and master salt for a SRTP session.
327  * This must be done at least once before using rtp_send(), rtp_recv(),
328  * rtcp_send() or rtcp_recv(). Also, rekeying is required every
329  * 2^48 RTP packets or 2^31 RTCP packets (whichever comes first),
330  * otherwise the protocol security might be broken.
331  *
332  * @return 0 on success, in case of error:
333  *  EINVAL  invalid or unsupported key/salt sizes combination
334  */
335 int
336 srtp_setkey (srtp_session_t *s, const void *key, size_t keylen,
337              const void *salt, size_t saltlen)
338 {
339     return srtp_derive (s, key, keylen, salt, saltlen) ? EINVAL : 0;
340 }
341
342
343 /** AES-CM encryption/decryption (ctr length = 16 bytes) */
344 static int
345 ctr_crypt (gcry_cipher_hd_t hd, uint32_t *ctr, uint8_t *data, size_t len)
346 {
347     const size_t ctrlen = 16;
348     while (len >= ctrlen)
349     {
350         if (gcry_cipher_setctr (hd, ctr, ctrlen)
351          || gcry_cipher_encrypt (hd, data, ctrlen, NULL, 0))
352             return -1;
353
354         data += ctrlen;
355         len -= ctrlen;
356         ctr[3] = htonl (ntohl (ctr[3]) + 1);
357     }
358
359     if (len > 0)
360     {
361         /* Truncated last block */
362         uint8_t dummy[ctrlen];
363         memcpy (dummy, data, len);
364         memset (dummy + len, 0, ctrlen - len);
365
366         if (gcry_cipher_setctr (hd, ctr, ctrlen)
367          || gcry_cipher_encrypt (hd, dummy, ctrlen, data, ctrlen))
368             return -1;
369         memcpy (data, dummy, len);
370     }
371
372     return 0;
373 }
374
375
376 /** AES-CM for RTP (salt = 14 bytes + 2 nul bytes) */
377 static int
378 rtp_crypt (gcry_cipher_hd_t hd, uint32_t ssrc, uint32_t roc, uint16_t seq,
379            const uint32_t *salt, uint8_t *data, size_t len)
380 {
381     /* Determines cryptographic counter (IV) */
382     uint32_t counter[4];
383     counter[0] = salt[0];
384     counter[1] = salt[1] ^ ssrc;
385     counter[2] = salt[2] ^ htonl (roc);
386     counter[3] = salt[3] ^ htonl (seq << 16);
387
388     /* Encryption */
389     return ctr_crypt (hd, counter, data, len);
390 }
391
392
393 /** Message Authentication and Integrity for RTP */
394 static const uint8_t *
395 rtp_digest (gcry_md_hd_t md, const void *data, size_t len, uint32_t roc)
396 {
397     gcry_md_reset (md);
398     gcry_md_write (md, data, len);
399     gcry_md_write (md, &(uint32_t){ htonl (roc) }, 4);
400     return gcry_md_read (md, 0);
401 }
402
403
404 /**
405  * Encrypts/decrypts a RTP packet and updates SRTP context
406  * (CTR block cypher mode of operation has identical encryption and
407  * decryption function).
408  *
409  * @param buf RTP packet to be en-/decrypted
410  * @param len RTP packet length
411  *
412  * @return 0 on success, in case of error:
413  *  EINVAL  malformatted RTP packet
414  */
415 static int srtp_crypt (srtp_session_t *s, uint8_t *buf, size_t len)
416 {
417     assert (s != NULL);
418
419     if ((len < 12) || ((buf[0] >> 6) != 2))
420         return EINVAL;
421
422     /* Computes encryption offset */
423     uint16_t offset = 12;
424     offset += (buf[0] & 0xf) * 4; // skips CSRC
425
426     if (buf[0] & 0x10)
427     {
428         uint16_t extlen;
429
430         offset += 4;
431         if (len < offset)
432             return EINVAL;
433
434         memcpy (&extlen, buf + offset - 2, 2);
435         offset += htons (extlen); // skips RTP extension header
436     }
437
438     if (len < offset)
439         return EINVAL;
440
441     /* Determines RTP 48-bits counter and SSRC */
442     uint32_t ssrc;
443     memcpy (&ssrc, buf + 8, 4);
444
445     uint16_t seq = (buf[2] << 8) | buf[3];
446     if (((seq - s->rtp_seq) & 0xffff) < 32768)
447     {
448         if (seq < s->rtp_seq)
449             s->rtp_roc++; /* Sequence number wrap */
450     }
451     else
452     {
453         if (seq > s->rtp_seq)
454             s->rtp_roc--;
455     }
456
457     s->rtp_seq = seq;
458
459     if (s->flags & SRTP_UNENCRYPTED)
460         return 0;
461
462     if (rtp_crypt (s->rtp.cipher, ssrc, s->rtp_roc, seq, s->rtp.salt,
463                    buf + offset, len - offset))
464         return EINVAL;
465
466     return 0;
467 }
468
469
470 /**
471  * Turns a RTP packet into a SRTP packet: encrypt it, then computes
472  * the authentication tag and appends it.
473  * Note that you can encrypt packet in disorder.
474  *
475  * @param buf RTP packet to be encrypted/digested
476  * @param lenp pointer to the RTP packet length on entry,
477  *             set to the SRTP length on exit (undefined in case of error)
478  * @param bufsize size (bytes) of the packet buffer
479  *
480  * @return 0 on success, in case of error:
481  *  EINVAL  malformatted RTP packet or internal error
482  *  ENOSPC  bufsize is too small (to add authentication tag)
483  */
484 int
485 srtp_send (srtp_session_t *s, uint8_t *buf, size_t *lenp, size_t bufsize)
486 {
487     size_t len = *lenp;
488     int val = srtp_crypt (s, buf, len);
489     if (val)
490         return val;
491
492     if (s->flags & SRTP_UNAUTHENTICATED)
493         return 0;
494
495     if (bufsize < (len + s->tag_len))
496         return ENOSPC;
497
498     const uint8_t *tag = rtp_digest (s->rtp.mac, buf, len, s->rtp_roc);
499     memcpy (buf + len, tag, s->tag_len);
500     *lenp = len + s->tag_len;
501
502     return 0;
503 }
504
505
506 /**
507  * Turns a SRTP packet into a RTP packet: authenticates the packet,
508  * then decrypts it.
509  *
510  * @param buf RTP packet to be digested/decrypted
511  * @param lenp pointer to the SRTP packet length on entry,
512  *             set to the RTP length on exit (undefined in case of error)
513  *
514  * @return 0 on success, in case of error:
515  *  EINVAL  malformatted SRTP packet
516  *  EACCES  authentication failed (spoofed packet or out-of-sync)
517  */
518 int
519 srtp_recv (srtp_session_t *s, uint8_t *buf, size_t *lenp)
520 {
521     size_t len = *lenp;
522     /* FIXME: anti-replay */
523
524     if (!(s->flags & SRTP_UNAUTHENTICATED))
525     {
526         if (len < s->tag_len)
527             return EINVAL;
528         len -= s->tag_len;
529
530         const uint8_t *tag = rtp_digest (s->rtp.mac, buf, len, s->rtp_roc);
531         if (memcmp (buf + len, tag, s->tag_len))
532             return EACCES;
533
534         *lenp = len;
535     }
536
537     return srtp_crypt (s, buf, len);
538 }
539
540
541 /** AES-CM for RTCP (salt = 14 bytes + 2 nul bytes) */
542 static int
543 rtcp_crypt (gcry_cipher_hd_t hd, uint32_t ssrc, uint32_t index,
544             const uint32_t *salt, uint8_t *data, size_t len)
545 {
546     return rtp_crypt (hd, ssrc, index >> 16, index & 0xffff, salt, data, len);
547 }
548
549
550 /** Message Authentication and Integrity for RTCP */
551 static const uint8_t *
552 rtcp_digest (gcry_md_hd_t md, const void *data, size_t len)
553 {
554     gcry_md_reset (md);
555     gcry_md_write (md, data, len);
556     return gcry_md_read (md, 0);
557 }
558
559
560 /**
561  * Encrypts/decrypts a RTCP packet and updates SRTCP context
562  * (CTR block cypher mode of operation has identical encryption and
563  * decryption function).
564  *
565  * @param buf RTCP packet to be en-/decrypted
566  * @param len RTCP packet length
567  *
568  * @return 0 on success, in case of error:
569  *  EINVAL  malformatted RTCP packet
570  */
571 static int srtcp_crypt (srtp_session_t *s, uint8_t *buf, size_t len)
572 {
573     assert (s != NULL);
574
575     /* 8-bytes unencrypted header, and 4-bytes unencrypted footer */
576     if ((len < 12) || ((buf[0] >> 6) != 2))
577         return EINVAL;
578
579     uint32_t index = s->rtcp_index++;
580     if (index == 0x7fffffff)
581         s->rtcp_index = 0; /* 31-bit wrap */
582
583     if (s->flags & SRTCP_UNENCRYPTED)
584         return 0;
585
586     uint32_t ssrc;
587     memcpy (&ssrc, buf + 4, 4);
588
589     if (rtcp_crypt (s->rtcp.cipher, ssrc, index, s->rtp.salt,
590                     buf + 8, len - 8))
591         return EINVAL;
592     return 0;
593 }
594
595
596 /**
597  * Turns a RTCP packet into a SRTCP packet: encrypt it, then computes
598  * the authentication tag and appends it.
599  *
600  * @param buf RTCP packet to be encrypted/digested
601  * @param lenp pointer to the RTCP packet length on entry,
602  *             set to the SRTCP length on exit (undefined in case of error)
603  * @param bufsize size (bytes) of the packet buffer
604  *
605  * @return 0 on success, in case of error:
606  *  EINVAL  malformatted RTCP packet or internal error
607  *  ENOSPC  bufsize is too small (to add index and authentication tag)
608  */
609 int
610 srtcp_send (srtp_session_t *s, uint8_t *buf, size_t *lenp, size_t bufsize)
611 {
612     size_t len = *lenp;
613     if (bufsize < (len + 4 + s->tag_len))
614         return ENOSPC;
615
616     uint32_t index = s->rtcp_index;
617     if ((s->flags & SRTCP_UNENCRYPTED) == 0)
618         index |= 0x80000000; /* Set Encrypted bit */
619     memcpy (buf + len, &(uint32_t){ htonl (index) }, 4);
620
621     int val = srtcp_crypt (s, buf, len);
622     if (val)
623         return val;
624
625     len += 4; /* Digest SRTCP index too */
626
627     const uint8_t *tag = rtcp_digest (s->rtp.mac, buf, len);
628     memcpy (buf + len, tag, s->tag_len);
629     *lenp = len + s->tag_len;
630     return 0;
631 }
632
633
634 /**
635  * Turns a SRTCP packet into a RTCP packet: authenticates the packet,
636  * then decrypts it.
637  *
638  * @param buf RTCP packet to be digested/decrypted
639  * @param lenp pointer to the SRTCP packet length on entry,
640  *             set to the RTCP length on exit (undefined in case of error)
641  *
642  * @return 0 on success, in case of error:
643  *  EINVAL  malformatted SRTCP packet
644  *  EACCES  authentication failed (spoofed packet or out-of-sync)
645  */
646 int
647 srtcp_recv (srtp_session_t *s, uint8_t *buf, size_t *lenp)
648 {
649     size_t len = *lenp;
650     /* FIXME: anti-replay ?? */
651
652     if (len < (4u + s->tag_len))
653         return EINVAL;
654     len -= s->tag_len;
655
656     const uint8_t *tag = rtcp_digest (s->rtp.mac, buf, len);
657     if (memcmp (buf + len, tag, s->tag_len))
658          return EACCES;
659
660     len -= 4; /* Remove SRTCP index befor decryption */
661     *lenp = len;
662
663     return srtp_crypt (s, buf, len);
664 }
665