Remove key exchange code from JingleSession.

remoting/protocol/jingle_session.cc

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "remoting/protocol/jingle_session.h"
 
 #include "base/bind.h"
 #include "base/message_loop.h"
 #include "base/rand_util.h"
 #include "base/stl_util.h"
@@ skipping 16 matching lines @@
 
 namespace protocol {
 
 const char JingleSession::kChromotingContentName[] = "chromoting";
 
 namespace {
 
 const char kControlChannelName[] = "control";
 const char kEventChannelName[] = "event";
 
-const int kMasterKeyLength = 16;
-const int kChannelKeyLength = 16;
-
-std::string GenerateRandomMasterKey() {
-  std::string result;
-  result.resize(kMasterKeyLength);
-  base::RandBytes(&result[0], result.size());
-  return result;
-}
-
-std::string EncryptMasterKey(const std::string& host_public_key,
-                             const std::string& master_key) {
-  // TODO(sergeyu): Implement RSA public key encryption in src/crypto
-  // and actually encrypt the key here.
-  return master_key;
-}
-
-bool DecryptMasterKey(const crypto::RSAPrivateKey* private_key,
-                      const std::string& encrypted_master_key,
-                      std::string* master_key) {
-  // TODO(sergeyu): Implement RSA public key encryption in src/crypto
-  // and actually encrypt the key here.
-  *master_key = encrypted_master_key;
-  return true;
-}
-
-// Generates channel key from master key and channel name. Must be
-// used to generate channel key so that we don't use the same key for
-// different channels. The key is calculated as
-//   HMAC_SHA256(master_key, channel_name)
-bool GetChannelKey(const std::string& channel_name,
-                   const std::string& master_key,
-                   std::string* channel_key) {
-  crypto::HMAC hmac(crypto::HMAC::SHA256);
-  if (!hmac.Init(channel_name)) {
-    channel_key->clear();
-    return false;
-  }
-  channel_key->resize(kChannelKeyLength);
-  if (!hmac.Sign(master_key,
-                 reinterpret_cast<unsigned char*>(&(*channel_key)[0]),
-                 channel_key->size())) {
-    channel_key->clear();
-    return false;
-  }
-  return true;
-}
-
 }  // namespace
 
 // static
 JingleSession* JingleSession::CreateClientSession(
     JingleSessionManager* manager, const std::string& host_public_key) {
   return new JingleSession(manager, "", NULL, host_public_key);
 }
 
 // static
 JingleSession* JingleSession::CreateServerSession(
     JingleSessionManager* manager,
     const std::string& certificate,
     crypto::RSAPrivateKey* key) {
   return new JingleSession(manager, certificate, key, "");
 }
 
 JingleSession::JingleSession(
     JingleSessionManager* jingle_session_manager,
     const std::string& local_cert,
     crypto::RSAPrivateKey* local_private_key,
     const std::string& peer_public_key)
     : jingle_session_manager_(jingle_session_manager),
       local_cert_(local_cert),
-      master_key_(GenerateRandomMasterKey()),
       state_(INITIALIZING),
       closed_(false),
       closing_(false),
       cricket_session_(NULL),
       ALLOW_THIS_IN_INITIALIZER_LIST(task_factory_(this)) {
   // TODO(hclam): Need a better way to clone a key.
   if (local_private_key) {
     std::vector<uint8> key_bytes;
     CHECK(local_private_key->ExportPrivateKey(&key_bytes));
     local_private_key_.reset(
@@ skipping 13 matching lines @@
   DCHECK(CalledOnValidThread());
 
   cricket_session_ = cricket_session;
   jid_ = cricket_session_->remote_name();
   cricket_session_->SignalState.connect(
       this, &JingleSession::OnSessionState);
   cricket_session_->SignalError.connect(
       this, &JingleSession::OnSessionError);
 }
 
-std::string JingleSession::GetEncryptedMasterKey() const {
-  DCHECK(CalledOnValidThread());
-  return EncryptMasterKey(peer_public_key_, master_key_);
-}
-
 void JingleSession::CloseInternal(int result, bool failed) {
   DCHECK(CalledOnValidThread());
 
   if (!closed_ && !closing_) {
     closing_ = true;
 
     // Inform the StateChangeCallback, so calling code knows not to touch any
     // channels.
     if (failed)
       SetState(FAILED);
@@ skipping 196 matching lines @@
 
 void JingleSession::OnInitiate() {
   DCHECK(CalledOnValidThread());
   jid_ = cricket_session_->remote_name();
 
   if (!cricket_session_->initiator()) {
     const protocol::ContentDescription* content_description =
         static_cast<const protocol::ContentDescription*>(
             GetContentInfo()->description);
     CHECK(content_description);
-
-    if (!DecryptMasterKey(local_private_key_.get(),
-                          content_description->master_key(), &master_key_)) {
-      LOG(ERROR) << "Failed to decrypt master-key";
-      CloseInternal(net::ERR_CONNECTION_FAILED, true);
-      return;
-    }
   }
 
   if (cricket_session_->initiator()) {
     // Set state to CONNECTING if this is an outgoing message. We need
     // to post this task because channel creation works only after we
     // return from this method. This is because
     // JingleChannelConnector::Connect() needs to call
     // set_incoming_only() on P2PTransportChannel, but
     // P2PTransportChannel is created only after we return from this
     // method.
@@ skipping 159 matching lines @@
 
     state_ = new_state;
     if (!closed_ && state_change_callback_.get())
       state_change_callback_->Run(new_state);
   }
 }
 
 }  // namespace protocol
 
 }  // namespace remoting