Ahem. Fix crappy previous commit.

[vlc] / libs / srtp / srtp.c

diff --git a/libs/srtp/srtp.c b/libs/srtp/srtp.c
index 8fd96b828fa7db6734298b662cafda47fe909c32..a77f9ab9e1f626612c014c1720500d7a5c37fa97 100644 (file)
--- a/libs/srtp/srtp.c
+++ b/libs/srtp/srtp.c
@@ -387,13 +387,45 @@ rtp_crypt (gcry_cipher_hd_t hd, uint32_t ssrc, uint32_t roc, uint16_t seq,
 }
 
 
+/** Determines SRTP Roll-Over-Counter (in host-byte order) */
+static uint32_t
+srtp_compute_roc (const srtp_session_t *s, uint16_t seq)
+{
+    uint32_t roc = s->rtp_roc;
+
+    if (((seq - s->rtp_seq) & 0xffff) < 0x8000)
+    {
+        /* Sequence is ahead, good */
+        if (seq < s->rtp_seq)
+            roc++; /* Sequence number wrap */
+    }
+    else
+    {
+        /* Sequence is late, bad */
+        if (seq > s->rtp_seq)
+            roc--; /* Wrap back */
+    }
+    return roc;
+}
+
+
+/** Returns RTP sequence (in host-byte order) */
+static inline uint16_t rtp_seq (const uint8_t *buf)
+{
+    return (buf[2] << 8) | buf[3];
+}
+
+
 /** Message Authentication and Integrity for RTP */
 static const uint8_t *
-rtp_digest (gcry_md_hd_t md, const void *data, size_t len, uint32_t roc)
+rtp_digest (srtp_session_t *s, const uint8_t *data, size_t len)
 {
+    const gcry_md_hd_t md = s->rtp.mac;
+    uint32_t roc = htonl (srtp_compute_roc (s, rtp_seq (data)));
+
     gcry_md_reset (md);
     gcry_md_write (md, data, len);
-    gcry_md_write (md, &(uint32_t){ htonl (roc) }, 4);
+    gcry_md_write (md, &roc, 4);
     return gcry_md_read (md, 0);
 }
 
@@ -436,27 +468,22 @@ static int srtp_crypt (srtp_session_t *s, uint8_t *buf, size_t len)
         return EINVAL;
 
     /* Determines RTP 48-bits counter and SSRC */
-    uint32_t ssrc;
+    uint16_t seq = rtp_seq (buf);
+    uint32_t roc = srtp_compute_roc (s, seq), ssrc;
     memcpy (&ssrc, buf + 8, 4);
 
-    uint16_t seq = (buf[2] << 8) | buf[3];
-    if (((seq - s->rtp_seq) & 0xffff) < 32768)
-    {
-        if (seq < s->rtp_seq)
-            s->rtp_roc++; /* Sequence number wrap */
-    }
+    /* Updates ROC and sequence (it's safe now) */
+    if (roc > s->rtp_roc)
+        s->rtp_seq = seq, s->rtp_roc = roc;
     else
-    {
-        if (seq > s->rtp_seq)
-            s->rtp_roc--;
-    }
-
-    s->rtp_seq = seq;
+    if (seq > s->rtp_seq)
+        s->rtp_seq = seq;
 
+    /* Encrypt/Decrypt */
     if (s->flags & SRTP_UNENCRYPTED)
         return 0;
 
-    if (rtp_crypt (s->rtp.cipher, ssrc, s->rtp_roc, seq, s->rtp.salt,
+    if (rtp_crypt (s->rtp.cipher, ssrc, roc, seq, s->rtp.salt,
                    buf + offset, len - offset))
         return EINVAL;
 
@@ -486,15 +513,15 @@ srtp_send (srtp_session_t *s, uint8_t *buf, size_t *lenp, size_t bufsize)
     if (val)
         return val;
 
-    if (s->flags & SRTP_UNAUTHENTICATED)
-        return 0;
-
-    if (bufsize < (len + s->tag_len))
-        return ENOSPC;
+    if (!(s->flags & SRTP_UNAUTHENTICATED))
+    {
+        if (bufsize < (len + s->tag_len))
+            return ENOSPC;
 
-    const uint8_t *tag = rtp_digest (s->rtp.mac, buf, len, s->rtp_roc);
-    memcpy (buf + len, tag, s->tag_len);
-    *lenp = len + s->tag_len;
+        const uint8_t *tag = rtp_digest (s, buf, len);
+        memcpy (buf + len, tag, s->tag_len);
+        *lenp = len + s->tag_len;
+    }
 
     return 0;
 }
@@ -520,11 +547,11 @@ srtp_recv (srtp_session_t *s, uint8_t *buf, size_t *lenp)
 
     if (!(s->flags & SRTP_UNAUTHENTICATED))
     {
-        if (len < s->tag_len)
+        if (len < (12u + s->tag_len))
             return EINVAL;
         len -= s->tag_len;
 
-        const uint8_t *tag = rtp_digest (s->rtp.mac, buf, len, s->rtp_roc);
+        const uint8_t *tag = rtp_digest (s, buf, len);
         if (memcmp (buf + len, tag, s->tag_len))
             return EACCES;
 
@@ -573,10 +600,14 @@ static int srtcp_crypt (srtp_session_t *s, uint8_t *buf, size_t len)
     if ((len < 12) || ((buf[0] >> 6) != 2))
         return EINVAL;
 
-    uint32_t index = s->rtcp_index++;
-    if (index == 0x7fffffff)
-        s->rtcp_index = 0; /* 31-bit wrap */
+    /* Updates SRTCP index (safe here) */
+    uint32_t index;
+    memcpy (&index, buf + len, 4);
+    index = ntohl (index);
+    if (((index - s->rtcp_index) & 0x7fffffff) < 0x40000000)
+        s->rtcp_index = index; /* Update index */
 
+    /* Crypts SRTCP */
     if (s->flags & SRTCP_UNENCRYPTED)
         return 0;
 
@@ -610,7 +641,10 @@ srtcp_send (srtp_session_t *s, uint8_t *buf, size_t *lenp, size_t bufsize)
     if (bufsize < (len + 4 + s->tag_len))
         return ENOSPC;
 
-    uint32_t index = s->rtcp_index;
+    uint32_t index = ++s->rtcp_index;
+    if (index >> 31)
+        s->rtcp_index = index = 0; /* 31-bit wrap */
+
     if ((s->flags & SRTCP_UNENCRYPTED) == 0)
         index |= 0x80000000; /* Set Encrypted bit */
     memcpy (buf + len, &(uint32_t){ htonl (index) }, 4);
@@ -619,7 +653,7 @@ srtcp_send (srtp_session_t *s, uint8_t *buf, size_t *lenp, size_t bufsize)
     if (val)
         return val;
 
-    len += 4; /* Digest SRTCP index too */
+    len += 4; /* Digests SRTCP index too */
 
     const uint8_t *tag = rtcp_digest (s->rtp.mac, buf, len);
     memcpy (buf + len, tag, s->tag_len);
@@ -656,7 +690,6 @@ srtcp_recv (srtp_session_t *s, uint8_t *buf, size_t *lenp)
 
     len -= 4; /* Remove SRTCP index before decryption */
     *lenp = len;
-
     return srtp_crypt (s, buf, len);
 }