lavf: Add a fate test for the SRTP functions
[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         s->hmac_size = 10;
74     } else if (!strcmp(suite, "AES_CM_128_HMAC_SHA1_32")) {
75         s->hmac_size = 4;
76     } else {
77         av_log(NULL, AV_LOG_WARNING, "SRTP Crypto suite %s not supported\n",
78                                      suite);
79         return AVERROR(EINVAL);
80     }
81     if (av_base64_decode(buf, params, sizeof(buf)) != sizeof(buf)) {
82         av_log(NULL, AV_LOG_WARNING, "Incorrect amount of SRTP params\n");
83         return AVERROR(EINVAL);
84     }
85     // MKI and lifetime not handled yet
86     s->aes  = av_aes_alloc();
87     s->hmac = av_hmac_alloc(AV_HMAC_SHA1);
88     if (!s->aes || !s->hmac)
89         return AVERROR(ENOMEM);
90     memcpy(s->master_key, buf, 16);
91     memcpy(s->master_salt, buf + 16, 14);
92
93     // RFC 3711
94     av_aes_init(s->aes, s->master_key, 128, 0);
95
96     derive_key(s->aes, s->master_salt, 0x00, s->rtp_key, sizeof(s->rtp_key));
97     derive_key(s->aes, s->master_salt, 0x02, s->rtp_salt, sizeof(s->rtp_salt));
98     derive_key(s->aes, s->master_salt, 0x01, s->rtp_auth, sizeof(s->rtp_auth));
99
100     derive_key(s->aes, s->master_salt, 0x03, s->rtcp_key, sizeof(s->rtcp_key));
101     derive_key(s->aes, s->master_salt, 0x05, s->rtcp_salt, sizeof(s->rtcp_salt));
102     derive_key(s->aes, s->master_salt, 0x04, s->rtcp_auth, sizeof(s->rtcp_auth));
103     return 0;
104 }
105
106 static void create_iv(uint8_t *iv, const uint8_t *salt, uint64_t index,
107                       uint32_t ssrc)
108 {
109     uint8_t indexbuf[8];
110     int i;
111     memset(iv, 0, 16);
112     AV_WB32(&iv[4], ssrc);
113     AV_WB64(indexbuf, index);
114     for (i = 0; i < 8; i++) // index << 16
115         iv[6 + i] ^= indexbuf[i];
116     for (i = 0; i < 14; i++)
117         iv[i] ^= salt[i];
118 }
119
120 int ff_srtp_decrypt(struct SRTPContext *s, uint8_t *buf, int *lenptr)
121 {
122     uint8_t iv[16] = { 0 }, hmac[20];
123     int len = *lenptr;
124     int ext, seq_largest;
125     uint32_t ssrc, roc;
126     uint64_t index;
127     int rtcp;
128
129     // TODO: Missing replay protection
130
131     if (len < s->hmac_size)
132         return AVERROR_INVALIDDATA;
133
134     rtcp = RTP_PT_IS_RTCP(buf[1]);
135
136     // Authentication HMAC
137     av_hmac_init(s->hmac, rtcp ? s->rtcp_auth : s->rtp_auth, sizeof(s->rtp_auth));
138     // If MKI is used, this should exclude the MKI as well
139     av_hmac_update(s->hmac, buf, len - s->hmac_size);
140
141     if (!rtcp) {
142         int seq = AV_RB16(buf + 2);
143         uint32_t v;
144         uint8_t rocbuf[4];
145
146         // RFC 3711 section 3.3.1, appendix A
147         seq_largest = s->seq_initialized ? s->seq_largest : seq;
148         v = roc = s->roc;
149         if (seq_largest < 32768) {
150             if (seq - seq_largest > 32768)
151                 v = roc - 1;
152         } else {
153             if (seq_largest - 32768 > seq)
154                 v = roc + 1;
155         }
156         if (v == roc) {
157             seq_largest = FFMAX(seq_largest, seq);
158         } else if (v == roc + 1) {
159             seq_largest = seq;
160             roc = v;
161         }
162         index = seq + (((uint64_t)v) << 16);
163
164         AV_WB32(rocbuf, roc);
165         av_hmac_update(s->hmac, rocbuf, 4);
166     }
167
168     av_hmac_final(s->hmac, hmac, sizeof(hmac));
169     if (memcmp(hmac, buf + len - s->hmac_size, s->hmac_size)) {
170         av_log(NULL, AV_LOG_WARNING, "HMAC mismatch\n");
171         return AVERROR_INVALIDDATA;
172     }
173
174     len -= s->hmac_size;
175     *lenptr = len;
176
177     if (len < 12)
178         return AVERROR_INVALIDDATA;
179
180     if (rtcp) {
181         uint32_t srtcp_index = AV_RB32(buf + len - 4);
182         len -= 4;
183         *lenptr = len;
184
185         ssrc = AV_RB32(buf + 4);
186         index = srtcp_index & 0x7fffffff;
187
188         buf += 8;
189         len -= 8;
190         if (!(srtcp_index & 0x80000000))
191             return 0;
192     } else {
193         s->seq_initialized = 1;
194         s->seq_largest     = seq_largest;
195         s->roc             = roc;
196
197         ext  = buf[0] & 0x10;
198         ssrc = AV_RB32(buf + 8);
199
200         buf += 12;
201         len -= 12;
202
203         if (ext) {
204             if (len < 4)
205                 return AVERROR_INVALIDDATA;
206             ext = (AV_RB16(buf + 2) + 1) * 4;
207             if (len < ext)
208                 return AVERROR_INVALIDDATA;
209             len -= ext;
210             buf += ext;
211         }
212     }
213
214     create_iv(iv, rtcp ? s->rtcp_salt : s->rtp_salt, index, ssrc);
215     av_aes_init(s->aes, rtcp ? s->rtcp_key : s->rtp_key, 128, 0);
216     encrypt_counter(s->aes, iv, buf, len);
217
218     return 0;
219 }
220
221 int ff_srtp_encrypt(struct SRTPContext *s, const uint8_t *in, int len,
222                     uint8_t *out, int outlen)
223 {
224     uint8_t iv[16] = { 0 }, hmac[20];
225     uint64_t index;
226     uint32_t ssrc;
227     int rtcp;
228     uint8_t *buf;
229
230     if (len + 14 > outlen)
231         return 0;
232     if (len < 12)
233         return 0;
234
235     memcpy(out, in, len);
236     buf = out;
237
238     rtcp = RTP_PT_IS_RTCP(buf[1]);
239
240     if (rtcp) {
241         ssrc = AV_RB32(buf + 4);
242         index = s->rtcp_index++;
243
244         buf += 8;
245         len -= 8;
246     } else {
247         int ext;
248         int seq = AV_RB16(buf + 2);
249         ssrc = AV_RB32(buf + 8);
250
251         if (seq < s->seq_largest)
252             s->roc++;
253         s->seq_largest = seq;
254         index = seq + (((uint64_t)s->roc) << 16);
255
256         ext = buf[0] & 0x10;
257
258         buf += 12;
259         len -= 12;
260
261         if (ext) {
262             if (len < 4)
263                 return AVERROR_INVALIDDATA;
264             ext = (AV_RB16(buf + 2) + 1) * 4;
265             if (len < ext)
266                 return AVERROR_INVALIDDATA;
267             len -= ext;
268             buf += ext;
269         }
270     }
271
272     create_iv(iv, rtcp ? s->rtcp_salt : s->rtp_salt, index, ssrc);
273     av_aes_init(s->aes, rtcp ? s->rtcp_key : s->rtp_key, 128, 0);
274     encrypt_counter(s->aes, iv, buf, len);
275
276     if (rtcp) {
277         AV_WB32(buf + len, 0x80000000 | index);
278         len += 4;
279     }
280
281     av_hmac_init(s->hmac, rtcp ? s->rtcp_auth : s->rtp_auth, sizeof(s->rtp_auth));
282     av_hmac_update(s->hmac, out, buf + len - out);
283     if (!rtcp) {
284         uint8_t rocbuf[4];
285         AV_WB32(rocbuf, s->roc);
286         av_hmac_update(s->hmac, rocbuf, 4);
287     }
288     av_hmac_final(s->hmac, hmac, sizeof(hmac));
289
290     memcpy(buf + len, hmac, s->hmac_size);
291     len += s->hmac_size;
292     return buf + len - out;
293 }
294
295 #ifdef TEST
296 #include <stdio.h>
297
298 static const char *aes128_80_key = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmn";
299
300 static const uint8_t rtp_aes128_80[] = {
301     // RTP header
302     0x80, 0xe0, 0x12, 0x34,
303     0x12, 0x34, 0x56, 0x78,
304     0x12, 0x34, 0x56, 0x78,
305     // encrypted payload
306     0x62, 0x69, 0x76, 0xca, 0xc5,
307     // HMAC
308     0xa1, 0xac, 0x1b, 0xb4, 0xa0, 0x1c, 0xd5, 0x49, 0x28, 0x99,
309 };
310
311 static const uint8_t rtcp_aes128_80[] = {
312     // RTCP header
313     0x81, 0xc9, 0x00, 0x07,
314     0x12, 0x34, 0x56, 0x78,
315     // encrypted payload
316     0x8a, 0xac, 0xdc, 0xa5,
317     0x4c, 0xf6, 0x78, 0xa6,
318     0x62, 0x8f, 0x24, 0xda,
319     0x6c, 0x09, 0x3f, 0xa9,
320     0x28, 0x7a, 0xb5, 0x7f,
321     0x1f, 0x0f, 0xc9, 0x35,
322     // RTCP index
323     0x80, 0x00, 0x00, 0x03,
324     // HMAC
325     0xe9, 0x3b, 0xc0, 0x5c, 0x0c, 0x06, 0x9f, 0xab, 0xc0, 0xde,
326 };
327
328 static const char *aes128_32_key = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmn";
329
330 static const uint8_t rtp_aes128_32[] = {
331     // RTP header
332     0x80, 0xe0, 0x12, 0x34,
333     0x12, 0x34, 0x56, 0x78,
334     0x12, 0x34, 0x56, 0x78,
335     // encrypted payload
336     0x62, 0x69, 0x76, 0xca, 0xc5,
337     // HMAC
338     0xa1, 0xac, 0x1b, 0xb4,
339 };
340
341 static const uint8_t rtcp_aes128_32[] = {
342     // RTCP header
343     0x81, 0xc9, 0x00, 0x07,
344     0x12, 0x34, 0x56, 0x78,
345     // encrypted payload
346     0x35, 0xe9, 0xb5, 0xff,
347     0x0d, 0xd1, 0xde, 0x70,
348     0x74, 0x10, 0xaa, 0x1b,
349     0xb2, 0x8d, 0xf0, 0x20,
350     0x02, 0x99, 0x6b, 0x1b,
351     0x0b, 0xd0, 0x47, 0x34,
352     // RTCP index
353     0x80, 0x00, 0x00, 0x04,
354     // HMAC
355     0x5b, 0xd2, 0xa9, 0x9d,
356 };
357
358 static void print_data(const uint8_t *buf, int len)
359 {
360     int i;
361     for (i = 0; i < len; i++)
362         printf("%02x", buf[i]);
363     printf("\n");
364 }
365
366 static int test_decrypt(struct SRTPContext *srtp, const uint8_t *in, int len,
367                         uint8_t *out)
368 {
369     memcpy(out, in, len);
370     if (!ff_srtp_decrypt(srtp, out, &len)) {
371         print_data(out, len);
372         return len;
373     } else
374         return -1;
375 }
376
377 static void test_encrypt(const uint8_t *data, int in_len, const char *suite,
378                          const char *key)
379 {
380     struct SRTPContext enc = { 0 }, dec = { 0 };
381     int len;
382     char buf[1500];
383     ff_srtp_set_crypto(&enc, suite, key);
384     ff_srtp_set_crypto(&dec, suite, key);
385     len = ff_srtp_encrypt(&enc, data, in_len, buf, sizeof(buf));
386     if (!ff_srtp_decrypt(&dec, buf, &len)) {
387         if (len == in_len && !memcmp(buf, data, len))
388             printf("Decrypted content matches input\n");
389         else
390             printf("Decrypted content doesn't match input\n");
391     } else {
392         printf("Decryption failed\n");
393     }
394     ff_srtp_free(&enc);
395     ff_srtp_free(&dec);
396 }
397
398 int main(void)
399 {
400     static const char *aes128_80_suite = "AES_CM_128_HMAC_SHA1_80";
401     static const char *aes128_32_suite = "AES_CM_128_HMAC_SHA1_32";
402     static const char *test_key = "abcdefghijklmnopqrstuvwxyz1234567890ABCD";
403     uint8_t buf[1500];
404     struct SRTPContext srtp = { 0 };
405     int len;
406     ff_srtp_set_crypto(&srtp, aes128_80_suite, aes128_80_key);
407     len = test_decrypt(&srtp, rtp_aes128_80, sizeof(rtp_aes128_80), buf);
408     test_encrypt(buf, len, aes128_80_suite, test_key);
409     test_encrypt(buf, len, aes128_32_suite, test_key);
410     test_decrypt(&srtp, rtcp_aes128_80, sizeof(rtcp_aes128_80), buf);
411     test_encrypt(buf, len, aes128_80_suite, test_key);
412     test_encrypt(buf, len, aes128_32_suite, test_key);
413     ff_srtp_free(&srtp);
414
415     memset(&srtp, 0, sizeof(srtp)); // Clear the context
416     ff_srtp_set_crypto(&srtp, aes128_32_suite, aes128_32_key);
417     test_decrypt(&srtp, rtp_aes128_32, sizeof(rtp_aes128_32), buf);
418     test_decrypt(&srtp, rtcp_aes128_32, sizeof(rtcp_aes128_32), buf);
419     ff_srtp_free(&srtp);
420     return 0;
421 }
422 #endif /* TEST */