srtp: Don't require more input data than what actually is needed
[ffmpeg.git] / libavformat / srtp.c
1 /*
2  * SRTP encryption/decryption
3  * Copyright (c) 2012 Martin Storsjo
4  *
5  * This file is part of Libav.
6  *
7  * Libav is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * Libav is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with Libav; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21
22 #include "libavutil/base64.h"
23 #include "libavutil/aes.h"
24 #include "libavutil/hmac.h"
25 #include "libavutil/intreadwrite.h"
26 #include "libavutil/log.h"
27 #include "rtp.h"
28 #include "srtp.h"
29
30 void ff_srtp_free(struct SRTPContext *s)
31 {
32     if (!s)
33         return;
34     av_freep(&s->aes);
35     if (s->hmac)
36         av_hmac_free(s->hmac);
37     s->hmac = NULL;
38 }
39
40 static void encrypt_counter(struct AVAES *aes, uint8_t *iv, uint8_t *outbuf,
41                             int outlen)
42 {
43     int i, j, outpos;
44     for (i = 0, outpos = 0; outpos < outlen; i++) {
45         uint8_t keystream[16];
46         AV_WB16(&iv[14], i);
47         av_aes_crypt(aes, keystream, iv, 1, NULL, 0);
48         for (j = 0; j < 16 && outpos < outlen; j++, outpos++)
49             outbuf[outpos] ^= keystream[j];
50     }
51 }
52
53 static void derive_key(struct AVAES *aes, const uint8_t *salt, int label,
54                        uint8_t *out, int outlen)
55 {
56     uint8_t input[16] = { 0 };
57     memcpy(input, salt, 14);
58     // Key derivation rate assumed to be zero
59     input[14 - 7] ^= label;
60     memset(out, 0, outlen);
61     encrypt_counter(aes, input, out, outlen);
62 }
63
64 int ff_srtp_set_crypto(struct SRTPContext *s, const char *suite,
65                        const char *params)
66 {
67     uint8_t buf[30];
68
69     ff_srtp_free(s);
70
71     // RFC 4568
72     if (!strcmp(suite, "AES_CM_128_HMAC_SHA1_80") ||
73         !strcmp(suite, "SRTP_AES128_CM_HMAC_SHA1_80")) {
74         s->rtp_hmac_size = s->rtcp_hmac_size = 10;
75     } else if (!strcmp(suite, "AES_CM_128_HMAC_SHA1_32")) {
76         s->rtp_hmac_size = s->rtcp_hmac_size = 4;
77     } else if (!strcmp(suite, "SRTP_AES128_CM_HMAC_SHA1_32")) {
78         // RFC 5764 section 4.1.2
79         s->rtp_hmac_size  = 4;
80         s->rtcp_hmac_size = 10;
81     } else {
82         av_log(NULL, AV_LOG_WARNING, "SRTP Crypto suite %s not supported\n",
83                                      suite);
84         return AVERROR(EINVAL);
85     }
86     if (av_base64_decode(buf, params, sizeof(buf)) != sizeof(buf)) {
87         av_log(NULL, AV_LOG_WARNING, "Incorrect amount of SRTP params\n");
88         return AVERROR(EINVAL);
89     }
90     // MKI and lifetime not handled yet
91     s->aes  = av_aes_alloc();
92     s->hmac = av_hmac_alloc(AV_HMAC_SHA1);
93     if (!s->aes || !s->hmac)
94         return AVERROR(ENOMEM);
95     memcpy(s->master_key, buf, 16);
96     memcpy(s->master_salt, buf + 16, 14);
97
98     // RFC 3711
99     av_aes_init(s->aes, s->master_key, 128, 0);
100
101     derive_key(s->aes, s->master_salt, 0x00, s->rtp_key, sizeof(s->rtp_key));
102     derive_key(s->aes, s->master_salt, 0x02, s->rtp_salt, sizeof(s->rtp_salt));
103     derive_key(s->aes, s->master_salt, 0x01, s->rtp_auth, sizeof(s->rtp_auth));
104
105     derive_key(s->aes, s->master_salt, 0x03, s->rtcp_key, sizeof(s->rtcp_key));
106     derive_key(s->aes, s->master_salt, 0x05, s->rtcp_salt, sizeof(s->rtcp_salt));
107     derive_key(s->aes, s->master_salt, 0x04, s->rtcp_auth, sizeof(s->rtcp_auth));
108     return 0;
109 }
110
111 static void create_iv(uint8_t *iv, const uint8_t *salt, uint64_t index,
112                       uint32_t ssrc)
113 {
114     uint8_t indexbuf[8];
115     int i;
116     memset(iv, 0, 16);
117     AV_WB32(&iv[4], ssrc);
118     AV_WB64(indexbuf, index);
119     for (i = 0; i < 8; i++) // index << 16
120         iv[6 + i] ^= indexbuf[i];
121     for (i = 0; i < 14; i++)
122         iv[i] ^= salt[i];
123 }
124
125 int ff_srtp_decrypt(struct SRTPContext *s, uint8_t *buf, int *lenptr)
126 {
127     uint8_t iv[16] = { 0 }, hmac[20];
128     int len = *lenptr;
129     int ext, av_uninit(seq_largest);
130     uint32_t ssrc, av_uninit(roc);
131     uint64_t index;
132     int rtcp, hmac_size;
133
134     // TODO: Missing replay protection
135
136     if (len < 2)
137         return AVERROR_INVALIDDATA;
138
139     rtcp = RTP_PT_IS_RTCP(buf[1]);
140     hmac_size = rtcp ? s->rtcp_hmac_size : s->rtp_hmac_size;
141
142     if (len < hmac_size)
143         return AVERROR_INVALIDDATA;
144
145     // Authentication HMAC
146     av_hmac_init(s->hmac, rtcp ? s->rtcp_auth : s->rtp_auth, sizeof(s->rtp_auth));
147     // If MKI is used, this should exclude the MKI as well
148     av_hmac_update(s->hmac, buf, len - hmac_size);
149
150     if (!rtcp) {
151         int seq = AV_RB16(buf + 2);
152         uint32_t v;
153         uint8_t rocbuf[4];
154
155         // RFC 3711 section 3.3.1, appendix A
156         seq_largest = s->seq_initialized ? s->seq_largest : seq;
157         v = roc = s->roc;
158         if (seq_largest < 32768) {
159             if (seq - seq_largest > 32768)
160                 v = roc - 1;
161         } else {
162             if (seq_largest - 32768 > seq)
163                 v = roc + 1;
164         }
165         if (v == roc) {
166             seq_largest = FFMAX(seq_largest, seq);
167         } else if (v == roc + 1) {
168             seq_largest = seq;
169             roc = v;
170         }
171         index = seq + (((uint64_t)v) << 16);
172
173         AV_WB32(rocbuf, roc);
174         av_hmac_update(s->hmac, rocbuf, 4);
175     }
176
177     av_hmac_final(s->hmac, hmac, sizeof(hmac));
178     if (memcmp(hmac, buf + len - hmac_size, hmac_size)) {
179         av_log(NULL, AV_LOG_WARNING, "HMAC mismatch\n");
180         return AVERROR_INVALIDDATA;
181     }
182
183     len -= hmac_size;
184     *lenptr = len;
185
186     if (len < 12)
187         return AVERROR_INVALIDDATA;
188
189     if (rtcp) {
190         uint32_t srtcp_index = AV_RB32(buf + len - 4);
191         len -= 4;
192         *lenptr = len;
193
194         ssrc = AV_RB32(buf + 4);
195         index = srtcp_index & 0x7fffffff;
196
197         buf += 8;
198         len -= 8;
199         if (!(srtcp_index & 0x80000000))
200             return 0;
201     } else {
202         int csrc;
203         s->seq_initialized = 1;
204         s->seq_largest     = seq_largest;
205         s->roc             = roc;
206
207         csrc = buf[0] & 0x0f;
208         ext  = buf[0] & 0x10;
209         ssrc = AV_RB32(buf + 8);
210
211         buf += 12;
212         len -= 12;
213
214         buf += 4 * csrc;
215         len -= 4 * csrc;
216         if (len < 0)
217             return AVERROR_INVALIDDATA;
218
219         if (ext) {
220             if (len < 4)
221                 return AVERROR_INVALIDDATA;
222             ext = (AV_RB16(buf + 2) + 1) * 4;
223             if (len < ext)
224                 return AVERROR_INVALIDDATA;
225             len -= ext;
226             buf += ext;
227         }
228     }
229
230     create_iv(iv, rtcp ? s->rtcp_salt : s->rtp_salt, index, ssrc);
231     av_aes_init(s->aes, rtcp ? s->rtcp_key : s->rtp_key, 128, 0);
232     encrypt_counter(s->aes, iv, buf, len);
233
234     return 0;
235 }
236
237 int ff_srtp_encrypt(struct SRTPContext *s, const uint8_t *in, int len,
238                     uint8_t *out, int outlen)
239 {
240     uint8_t iv[16] = { 0 }, hmac[20];
241     uint64_t index;
242     uint32_t ssrc;
243     int rtcp, hmac_size, padding;
244     uint8_t *buf;
245
246     if (len < 8)
247         return AVERROR_INVALIDDATA;
248
249     rtcp = RTP_PT_IS_RTCP(in[1]);
250     hmac_size = rtcp ? s->rtcp_hmac_size : s->rtp_hmac_size;
251     padding = hmac_size;
252     if (rtcp)
253         padding += 4; // For the RTCP index
254
255     if (len + padding > outlen)
256         return 0;
257
258     memcpy(out, in, len);
259     buf = out;
260
261     if (rtcp) {
262         ssrc = AV_RB32(buf + 4);
263         index = s->rtcp_index++;
264
265         buf += 8;
266         len -= 8;
267     } else {
268         int ext, csrc;
269         int seq = AV_RB16(buf + 2);
270
271         if (len < 12)
272             return AVERROR_INVALIDDATA;
273
274         ssrc = AV_RB32(buf + 8);
275
276         if (seq < s->seq_largest)
277             s->roc++;
278         s->seq_largest = seq;
279         index = seq + (((uint64_t)s->roc) << 16);
280
281         csrc = buf[0] & 0x0f;
282         ext = buf[0] & 0x10;
283
284         buf += 12;
285         len -= 12;
286
287         buf += 4 * csrc;
288         len -= 4 * csrc;
289         if (len < 0)
290             return AVERROR_INVALIDDATA;
291
292         if (ext) {
293             if (len < 4)
294                 return AVERROR_INVALIDDATA;
295             ext = (AV_RB16(buf + 2) + 1) * 4;
296             if (len < ext)
297                 return AVERROR_INVALIDDATA;
298             len -= ext;
299             buf += ext;
300         }
301     }
302
303     create_iv(iv, rtcp ? s->rtcp_salt : s->rtp_salt, index, ssrc);
304     av_aes_init(s->aes, rtcp ? s->rtcp_key : s->rtp_key, 128, 0);
305     encrypt_counter(s->aes, iv, buf, len);
306
307     if (rtcp) {
308         AV_WB32(buf + len, 0x80000000 | index);
309         len += 4;
310     }
311
312     av_hmac_init(s->hmac, rtcp ? s->rtcp_auth : s->rtp_auth, sizeof(s->rtp_auth));
313     av_hmac_update(s->hmac, out, buf + len - out);
314     if (!rtcp) {
315         uint8_t rocbuf[4];
316         AV_WB32(rocbuf, s->roc);
317         av_hmac_update(s->hmac, rocbuf, 4);
318     }
319     av_hmac_final(s->hmac, hmac, sizeof(hmac));
320
321     memcpy(buf + len, hmac, hmac_size);
322     len += hmac_size;
323     return buf + len - out;
324 }
325
326 #ifdef TEST
327 #include <stdio.h>
328
329 static const char *aes128_80_key = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmn";
330
331 static const uint8_t rtp_aes128_80[] = {
332     // RTP header
333     0x80, 0xe0, 0x12, 0x34,
334     0x12, 0x34, 0x56, 0x78,
335     0x12, 0x34, 0x56, 0x78,
336     // encrypted payload
337     0x62, 0x69, 0x76, 0xca, 0xc5,
338     // HMAC
339     0xa1, 0xac, 0x1b, 0xb4, 0xa0, 0x1c, 0xd5, 0x49, 0x28, 0x99,
340 };
341
342 static const uint8_t rtcp_aes128_80[] = {
343     // RTCP header
344     0x81, 0xc9, 0x00, 0x07,
345     0x12, 0x34, 0x56, 0x78,
346     // encrypted payload
347     0x8a, 0xac, 0xdc, 0xa5,
348     0x4c, 0xf6, 0x78, 0xa6,
349     0x62, 0x8f, 0x24, 0xda,
350     0x6c, 0x09, 0x3f, 0xa9,
351     0x28, 0x7a, 0xb5, 0x7f,
352     0x1f, 0x0f, 0xc9, 0x35,
353     // RTCP index
354     0x80, 0x00, 0x00, 0x03,
355     // HMAC
356     0xe9, 0x3b, 0xc0, 0x5c, 0x0c, 0x06, 0x9f, 0xab, 0xc0, 0xde,
357 };
358
359 static const char *aes128_32_key = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmn";
360
361 static const uint8_t rtp_aes128_32[] = {
362     // RTP header
363     0x80, 0xe0, 0x12, 0x34,
364     0x12, 0x34, 0x56, 0x78,
365     0x12, 0x34, 0x56, 0x78,
366     // encrypted payload
367     0x62, 0x69, 0x76, 0xca, 0xc5,
368     // HMAC
369     0xa1, 0xac, 0x1b, 0xb4,
370 };
371
372 static const uint8_t rtcp_aes128_32[] = {
373     // RTCP header
374     0x81, 0xc9, 0x00, 0x07,
375     0x12, 0x34, 0x56, 0x78,
376     // encrypted payload
377     0x35, 0xe9, 0xb5, 0xff,
378     0x0d, 0xd1, 0xde, 0x70,
379     0x74, 0x10, 0xaa, 0x1b,
380     0xb2, 0x8d, 0xf0, 0x20,
381     0x02, 0x99, 0x6b, 0x1b,
382     0x0b, 0xd0, 0x47, 0x34,
383     // RTCP index
384     0x80, 0x00, 0x00, 0x04,
385     // HMAC
386     0x5b, 0xd2, 0xa9, 0x9d,
387 };
388
389 static void print_data(const uint8_t *buf, int len)
390 {
391     int i;
392     for (i = 0; i < len; i++)
393         printf("%02x", buf[i]);
394     printf("\n");
395 }
396
397 static int test_decrypt(struct SRTPContext *srtp, const uint8_t *in, int len,
398                         uint8_t *out)
399 {
400     memcpy(out, in, len);
401     if (!ff_srtp_decrypt(srtp, out, &len)) {
402         print_data(out, len);
403         return len;
404     } else
405         return -1;
406 }
407
408 static void test_encrypt(const uint8_t *data, int in_len, const char *suite,
409                          const char *key)
410 {
411     struct SRTPContext enc = { 0 }, dec = { 0 };
412     int len;
413     char buf[1500];
414     ff_srtp_set_crypto(&enc, suite, key);
415     ff_srtp_set_crypto(&dec, suite, key);
416     len = ff_srtp_encrypt(&enc, data, in_len, buf, sizeof(buf));
417     if (!ff_srtp_decrypt(&dec, buf, &len)) {
418         if (len == in_len && !memcmp(buf, data, len))
419             printf("Decrypted content matches input\n");
420         else
421             printf("Decrypted content doesn't match input\n");
422     } else {
423         printf("Decryption failed\n");
424     }
425     ff_srtp_free(&enc);
426     ff_srtp_free(&dec);
427 }
428
429 int main(void)
430 {
431     static const char *aes128_80_suite = "AES_CM_128_HMAC_SHA1_80";
432     static const char *aes128_32_suite = "AES_CM_128_HMAC_SHA1_32";
433     static const char *test_key = "abcdefghijklmnopqrstuvwxyz1234567890ABCD";
434     uint8_t buf[1500];
435     struct SRTPContext srtp = { 0 };
436     int len;
437     ff_srtp_set_crypto(&srtp, aes128_80_suite, aes128_80_key);
438     len = test_decrypt(&srtp, rtp_aes128_80, sizeof(rtp_aes128_80), buf);
439     test_encrypt(buf, len, aes128_80_suite, test_key);
440     test_encrypt(buf, len, aes128_32_suite, test_key);
441     test_decrypt(&srtp, rtcp_aes128_80, sizeof(rtcp_aes128_80), buf);
442     test_encrypt(buf, len, aes128_80_suite, test_key);
443     test_encrypt(buf, len, aes128_32_suite, test_key);
444     ff_srtp_free(&srtp);
445
446     memset(&srtp, 0, sizeof(srtp)); // Clear the context
447     ff_srtp_set_crypto(&srtp, aes128_32_suite, aes128_32_key);
448     test_decrypt(&srtp, rtp_aes128_32, sizeof(rtp_aes128_32), buf);
449     test_decrypt(&srtp, rtcp_aes128_32, sizeof(rtcp_aes128_32), buf);
450     ff_srtp_free(&srtp);
451     return 0;
452 }
453 #endif /* TEST */