Add support for GCM cipher suites from RFC 7714.

webrtc/pc/srtpfilter.h

 /*
  *  Copyright 2009 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 15 matching lines @@
 #include "webrtc/media/base/cryptoparams.h"
 #include "webrtc/p2p/base/sessiondescription.h"
 
 // Forward declaration to avoid pulling in libsrtp headers here
 struct srtp_event_data_t;
 struct srtp_ctx_t;
 struct srtp_policy_t;
 
 namespace cricket {
 
-// Key is 128 bits and salt is 112 bits == 30 bytes. B64 bloat => 40 bytes.
-extern const int SRTP_MASTER_KEY_BASE64_LEN;
-
-// Needed for DTLS-SRTP
-extern const int SRTP_MASTER_KEY_KEY_LEN;
-extern const int SRTP_MASTER_KEY_SALT_LEN;
-
 class SrtpSession;
 class SrtpStat;
 
 void EnableSrtpDebugging();
 void ShutdownSrtp();
 
 // Class to transform SRTP to/from RTP.
 // Initialize by calling SetSend with the local security params, then call
 // SetRecv once the remote security params are received. At that point
 // Protect/UnprotectRt(c)p can be called to encrypt/decrypt data.
@@ skipping 80 matching lines @@
                    ContentSource source);
   bool ExpectAnswer(ContentSource source);
   bool DoSetAnswer(const std::vector<CryptoParams>& answer_params,
                      ContentSource source,
                      bool final);
   void CreateSrtpSessions();
   bool NegotiateParams(const std::vector<CryptoParams>& answer_params,
                        CryptoParams* selected_params);
   bool ApplyParams(const CryptoParams& send_params,
                    const CryptoParams& recv_params);
-  static bool ParseKeyParams(const std::string& params, uint8_t* key, int len);
+  static bool ParseKeyParams(const std::string& params,
+                             uint8_t* key,
+                             size_t len);
 
  private:
   enum State {
     ST_INIT,           // SRTP filter unused.
     ST_SENTOFFER,      // Offer with SRTP parameters sent.
     ST_RECEIVEDOFFER,  // Offer with SRTP parameters received.
     ST_SENTPRANSWER_NO_CRYPTO,  // Sent provisional answer without crypto.
     // Received provisional answer without crypto.
     ST_RECEIVEDPRANSWER_NO_CRYPTO,
     ST_ACTIVE,         // Offer and answer set.
@@ skipping 24 matching lines @@
 };
 
 // Class that wraps a libSRTP session.
 class SrtpSession {
  public:
   SrtpSession();
   ~SrtpSession();
 
   // Configures the session for sending data using the specified
   // cipher-suite and key. Receiving must be done by a separate session.
-  bool SetSend(int cs, const uint8_t* key, int len);
+  bool SetSend(int cs, const uint8_t* key, size_t len);
   // Configures the session for receiving data using the specified
   // cipher-suite and key. Sending must be done by a separate session.
-  bool SetRecv(int cs, const uint8_t* key, int len);
+  bool SetRecv(int cs, const uint8_t* key, size_t len);
 
   // Encrypts/signs an individual RTP/RTCP packet, in-place.
   // If an HMAC is used, this will increase the packet size.
   bool ProtectRtp(void* data, int in_len, int max_len, int* out_len);
   // Overloaded version, outputs packet index.
   bool ProtectRtp(void* data,
                   int in_len,
                   int max_len,
                   int* out_len,
                   int64_t* index);
   bool ProtectRtcp(void* data, int in_len, int max_len, int* out_len);
   // Decrypts/verifies an invidiual RTP/RTCP packet.
   // If an HMAC is used, this will decrease the packet size.
   bool UnprotectRtp(void* data, int in_len, int* out_len);
   bool UnprotectRtcp(void* data, int in_len, int* out_len);
 
   // Helper method to get authentication params.
   bool GetRtpAuthParams(uint8_t** key, int* key_len, int* tag_len);
 
   // Update the silent threshold (in ms) for signaling errors.
   void set_signal_silent_time(int signal_silent_time_in_ms);
 
   // Calls srtp_shutdown if it's initialized.
   static void Terminate();
 
   sigslot::repeater3<uint32_t, SrtpFilter::Mode, SrtpFilter::Error>
       SignalSrtpError;
 
  private:
-  bool SetKey(int type, int cs, const uint8_t* key, int len);
+  bool SetKey(int type, int cs, const uint8_t* key, size_t len);
     // Returns send stream current packet index from srtp db.
   bool GetSendStreamPacketIndex(void* data, int in_len, int64_t* index);
 
   static bool Init();
   void HandleEvent(const srtp_event_data_t* ev);
   static void HandleEventThunk(srtp_event_data_t* ev);
 
   rtc::ThreadChecker thread_checker_;
   srtp_ctx_t* session_;
   int rtp_auth_tag_len_;
@@ skipping 73 matching lines @@
   std::map<FailureKey, FailureStat> failures_;
   // Threshold in ms to silent the signaling errors.
   int signal_silent_time_;
 
   RTC_DISALLOW_COPY_AND_ASSIGN(SrtpStat);
 };
 
 }  // namespace cricket
 
 #endif  // WEBRTC_PC_SRTPFILTER_H_