| /* |
| * 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. |
| */ |
| |
| #include "webrtc/pc/srtpfilter.h" |
| |
| #include <string.h> |
| |
| #include <algorithm> |
| |
| #include "webrtc/media/base/rtputils.h" |
| #include "webrtc/pc/srtpsession.h" |
| #include "webrtc/rtc_base/base64.h" |
| #include "webrtc/rtc_base/byteorder.h" |
| #include "webrtc/rtc_base/checks.h" |
| #include "webrtc/rtc_base/logging.h" |
| #include "webrtc/rtc_base/stringencode.h" |
| #include "webrtc/rtc_base/timeutils.h" |
| |
| namespace cricket { |
| |
| // NOTE: This is called from ChannelManager D'tor. |
| void ShutdownSrtp() { |
| // If srtp_dealloc is not executed then this will clear all existing sessions. |
| // This should be called when application is shutting down. |
| SrtpSession::Terminate(); |
| } |
| |
| SrtpFilter::SrtpFilter() { |
| } |
| |
| SrtpFilter::~SrtpFilter() { |
| } |
| |
| bool SrtpFilter::IsActive() const { |
| return state_ >= ST_ACTIVE; |
| } |
| |
| bool SrtpFilter::SetOffer(const std::vector<CryptoParams>& offer_params, |
| ContentSource source) { |
| if (!ExpectOffer(source)) { |
| LOG(LS_ERROR) << "Wrong state to update SRTP offer"; |
| return false; |
| } |
| return StoreParams(offer_params, source); |
| } |
| |
| bool SrtpFilter::SetAnswer(const std::vector<CryptoParams>& answer_params, |
| ContentSource source) { |
| return DoSetAnswer(answer_params, source, true); |
| } |
| |
| bool SrtpFilter::SetProvisionalAnswer( |
| const std::vector<CryptoParams>& answer_params, |
| ContentSource source) { |
| return DoSetAnswer(answer_params, source, false); |
| } |
| |
| bool SrtpFilter::ExpectOffer(ContentSource source) { |
| return ((state_ == ST_INIT) || |
| (state_ == ST_ACTIVE) || |
| (state_ == ST_SENTOFFER && source == CS_LOCAL) || |
| (state_ == ST_SENTUPDATEDOFFER && source == CS_LOCAL) || |
| (state_ == ST_RECEIVEDOFFER && source == CS_REMOTE) || |
| (state_ == ST_RECEIVEDUPDATEDOFFER && source == CS_REMOTE)); |
| } |
| |
| bool SrtpFilter::StoreParams(const std::vector<CryptoParams>& params, |
| ContentSource source) { |
| offer_params_ = params; |
| if (state_ == ST_INIT) { |
| state_ = (source == CS_LOCAL) ? ST_SENTOFFER : ST_RECEIVEDOFFER; |
| } else if (state_ == ST_ACTIVE) { |
| state_ = |
| (source == CS_LOCAL) ? ST_SENTUPDATEDOFFER : ST_RECEIVEDUPDATEDOFFER; |
| } |
| return true; |
| } |
| |
| bool SrtpFilter::ExpectAnswer(ContentSource source) { |
| return ((state_ == ST_SENTOFFER && source == CS_REMOTE) || |
| (state_ == ST_RECEIVEDOFFER && source == CS_LOCAL) || |
| (state_ == ST_SENTUPDATEDOFFER && source == CS_REMOTE) || |
| (state_ == ST_RECEIVEDUPDATEDOFFER && source == CS_LOCAL) || |
| (state_ == ST_SENTPRANSWER_NO_CRYPTO && source == CS_LOCAL) || |
| (state_ == ST_SENTPRANSWER && source == CS_LOCAL) || |
| (state_ == ST_RECEIVEDPRANSWER_NO_CRYPTO && source == CS_REMOTE) || |
| (state_ == ST_RECEIVEDPRANSWER && source == CS_REMOTE)); |
| } |
| |
| bool SrtpFilter::DoSetAnswer(const std::vector<CryptoParams>& answer_params, |
| ContentSource source, |
| bool final) { |
| if (!ExpectAnswer(source)) { |
| LOG(LS_ERROR) << "Invalid state for SRTP answer"; |
| return false; |
| } |
| |
| // If the answer doesn't requests crypto complete the negotiation of an |
| // unencrypted session. |
| // Otherwise, finalize the parameters and apply them. |
| if (answer_params.empty()) { |
| if (final) { |
| return ResetParams(); |
| } else { |
| // Need to wait for the final answer to decide if |
| // we should go to Active state. |
| state_ = (source == CS_LOCAL) ? ST_SENTPRANSWER_NO_CRYPTO : |
| ST_RECEIVEDPRANSWER_NO_CRYPTO; |
| return true; |
| } |
| } |
| CryptoParams selected_params; |
| if (!NegotiateParams(answer_params, &selected_params)) |
| return false; |
| |
| const CryptoParams& new_send_params = |
| (source == CS_REMOTE) ? selected_params : answer_params[0]; |
| const CryptoParams& new_recv_params = |
| (source == CS_REMOTE) ? answer_params[0] : selected_params; |
| if (!ApplySendParams(new_send_params) || !ApplyRecvParams(new_recv_params)) { |
| return false; |
| } |
| applied_send_params_ = new_send_params; |
| applied_recv_params_ = new_recv_params; |
| |
| if (final) { |
| offer_params_.clear(); |
| state_ = ST_ACTIVE; |
| } else { |
| state_ = |
| (source == CS_LOCAL) ? ST_SENTPRANSWER : ST_RECEIVEDPRANSWER; |
| } |
| return true; |
| } |
| |
| bool SrtpFilter::NegotiateParams(const std::vector<CryptoParams>& answer_params, |
| CryptoParams* selected_params) { |
| // We're processing an accept. We should have exactly one set of params, |
| // unless the offer didn't mention crypto, in which case we shouldn't be here. |
| bool ret = (answer_params.size() == 1U && !offer_params_.empty()); |
| if (ret) { |
| // We should find a match between the answer params and the offered params. |
| std::vector<CryptoParams>::const_iterator it; |
| for (it = offer_params_.begin(); it != offer_params_.end(); ++it) { |
| if (answer_params[0].Matches(*it)) { |
| break; |
| } |
| } |
| |
| if (it != offer_params_.end()) { |
| *selected_params = *it; |
| } else { |
| ret = false; |
| } |
| } |
| |
| if (!ret) { |
| LOG(LS_WARNING) << "Invalid parameters in SRTP answer"; |
| } |
| return ret; |
| } |
| |
| bool SrtpFilter::ResetParams() { |
| offer_params_.clear(); |
| applied_send_params_ = CryptoParams(); |
| applied_recv_params_ = CryptoParams(); |
| send_cipher_suite_ = rtc::Optional<int>(); |
| recv_cipher_suite_ = rtc::Optional<int>(); |
| send_key_.Clear(); |
| recv_key_.Clear(); |
| state_ = ST_INIT; |
| return true; |
| } |
| |
| bool SrtpFilter::ApplySendParams(const CryptoParams& send_params) { |
| if (applied_send_params_.cipher_suite == send_params.cipher_suite && |
| applied_send_params_.key_params == send_params.key_params) { |
| LOG(LS_INFO) << "Applying the same SRTP send parameters again. No-op."; |
| |
| // We do not want to reset the ROC if the keys are the same. So just return. |
| return true; |
| } |
| |
| send_cipher_suite_ = rtc::Optional<int>( |
| rtc::SrtpCryptoSuiteFromName(send_params.cipher_suite)); |
| if (send_cipher_suite_ == rtc::SRTP_INVALID_CRYPTO_SUITE) { |
| LOG(LS_WARNING) << "Unknown crypto suite(s) received:" |
| << " send cipher_suite " << send_params.cipher_suite; |
| return false; |
| } |
| |
| int send_key_len, send_salt_len; |
| if (!rtc::GetSrtpKeyAndSaltLengths(*send_cipher_suite_, &send_key_len, |
| &send_salt_len)) { |
| LOG(LS_WARNING) << "Could not get lengths for crypto suite(s):" |
| << " send cipher_suite " << send_params.cipher_suite; |
| return false; |
| } |
| |
| send_key_ = rtc::Buffer(send_key_len + send_salt_len); |
| return ParseKeyParams(send_params.key_params, send_key_.data(), |
| send_key_.size()); |
| } |
| |
| bool SrtpFilter::ApplyRecvParams(const CryptoParams& recv_params) { |
| if (applied_recv_params_.cipher_suite == recv_params.cipher_suite && |
| applied_recv_params_.key_params == recv_params.key_params) { |
| LOG(LS_INFO) << "Applying the same SRTP recv parameters again. No-op."; |
| |
| // We do not want to reset the ROC if the keys are the same. So just return. |
| return true; |
| } |
| |
| recv_cipher_suite_ = rtc::Optional<int>( |
| rtc::SrtpCryptoSuiteFromName(recv_params.cipher_suite)); |
| if (recv_cipher_suite_ == rtc::SRTP_INVALID_CRYPTO_SUITE) { |
| LOG(LS_WARNING) << "Unknown crypto suite(s) received:" |
| << " recv cipher_suite " << recv_params.cipher_suite; |
| return false; |
| } |
| |
| int recv_key_len, recv_salt_len; |
| if (!rtc::GetSrtpKeyAndSaltLengths(*recv_cipher_suite_, &recv_key_len, |
| &recv_salt_len)) { |
| LOG(LS_WARNING) << "Could not get lengths for crypto suite(s):" |
| << " recv cipher_suite " << recv_params.cipher_suite; |
| return false; |
| } |
| |
| recv_key_ = rtc::Buffer(recv_key_len + recv_salt_len); |
| return ParseKeyParams(recv_params.key_params, recv_key_.data(), |
| recv_key_.size()); |
| } |
| |
| bool SrtpFilter::ParseKeyParams(const std::string& key_params, |
| uint8_t* key, |
| size_t len) { |
| // example key_params: "inline:YUJDZGVmZ2hpSktMbW9QUXJzVHVWd3l6MTIzNDU2" |
| |
| // Fail if key-method is wrong. |
| if (key_params.find("inline:") != 0) { |
| return false; |
| } |
| |
| // Fail if base64 decode fails, or the key is the wrong size. |
| std::string key_b64(key_params.substr(7)), key_str; |
| if (!rtc::Base64::Decode(key_b64, rtc::Base64::DO_STRICT, &key_str, |
| nullptr) || |
| key_str.size() != len) { |
| return false; |
| } |
| |
| memcpy(key, key_str.c_str(), len); |
| return true; |
| } |
| |
| } // namespace cricket |