QUIC: don't ignore SetKey and SetNoncePrefix return values.

net/quic/crypto/crypto_server_config.cc

 // Copyright (c) 2013 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 "net/quic/crypto/crypto_server_config.h"
 
 #include <stdlib.h>
 #include <algorithm>
 
 #include "base/stl_util.h"
@@ skipping 431 matching lines @@
     const QuicData& client_hello_serialized = client_hello_copy.GetSerialized();
     string hkdf_input;
     hkdf_input.append(QuicCryptoConfig::kCETVLabel,
                       strlen(QuicCryptoConfig::kCETVLabel) + 1);
     hkdf_input.append(reinterpret_cast<char*>(&guid), sizeof(guid));
     hkdf_input.append(client_hello_serialized.data(),
                       client_hello_serialized.length());
     hkdf_input.append(requested_config->serialized);
 
     CrypterPair crypters;
-    CryptoUtils::DeriveKeys(params->initial_premaster_secret, params->aead,
-                            info.client_nonce, info.server_nonce, hkdf_input,
-                            CryptoUtils::SERVER, &crypters);
+    if (!CryptoUtils::DeriveKeys(params->initial_premaster_secret, params->aead,
+                                 info.client_nonce, info.server_nonce,
+                                 hkdf_input, CryptoUtils::SERVER, &crypters)) {
+      *error_details = "Symmetric key setup failed";
+      return QUIC_CRYPTO_SYMMETRIC_KEY_SETUP_FAILED;
+    }
 
     scoped_ptr<QuicData> cetv_plaintext(crypters.decrypter->DecryptPacket(
         0 /* sequence number */, StringPiece() /* associated data */,
         cetv_ciphertext));
     if (!cetv_plaintext.get()) {
       *error_details = "CETV decryption failure";
       return QUIC_INVALID_CRYPTO_MESSAGE_PARAMETER;
     }
 
     scoped_ptr<CryptoHandshakeMessage> cetv(CryptoFramer::ParseMessage(
@@ skipping 14 matching lines @@
       params->channel_id = key.as_string();
     }
   }
 
   string hkdf_input;
   size_t label_len = strlen(QuicCryptoConfig::kInitialLabel) + 1;
   hkdf_input.reserve(label_len + hkdf_suffix.size());
   hkdf_input.append(QuicCryptoConfig::kInitialLabel, label_len);
   hkdf_input.append(hkdf_suffix);
 
-  CryptoUtils::DeriveKeys(params->initial_premaster_secret, params->aead,
-                          info.client_nonce, info.server_nonce, hkdf_input,
-                          CryptoUtils::SERVER, &params->initial_crypters);
+  if (!CryptoUtils::DeriveKeys(params->initial_premaster_secret, params->aead,
+                               info.client_nonce, info.server_nonce, hkdf_input,
+                               CryptoUtils::SERVER,
+                               &params->initial_crypters)) {
+    *error_details = "Symmetric key setup failed";
+    return QUIC_CRYPTO_SYMMETRIC_KEY_SETUP_FAILED;
+  }
 
   string forward_secure_public_value;
   if (ephemeral_key_source_.get()) {
     params->forward_secure_premaster_secret =
         ephemeral_key_source_->CalculateForwardSecureKey(
             key_exchange, rand, clock->ApproximateNow(), public_value,
             &forward_secure_public_value);
   } else {
     scoped_ptr<KeyExchange> forward_secure_key_exchange(
         key_exchange->NewKeyPair(rand));
     forward_secure_public_value =
         forward_secure_key_exchange->public_value().as_string();
     if (!forward_secure_key_exchange->CalculateSharedKey(
             public_value, &params->forward_secure_premaster_secret)) {
       *error_details = "Invalid public value";
       return QUIC_INVALID_CRYPTO_MESSAGE_PARAMETER;
     }
   }
 
   string forward_secure_hkdf_input;
   label_len = strlen(QuicCryptoConfig::kForwardSecureLabel) + 1;
   forward_secure_hkdf_input.reserve(label_len + hkdf_suffix.size());
   forward_secure_hkdf_input.append(QuicCryptoConfig::kForwardSecureLabel,
                                    label_len);
   forward_secure_hkdf_input.append(hkdf_suffix);
 
-  CryptoUtils::DeriveKeys(params->forward_secure_premaster_secret, params->aead,
-                          info.client_nonce, info.server_nonce,
-                          forward_secure_hkdf_input, CryptoUtils::SERVER,
-                          &params->forward_secure_crypters);
+  if (!CryptoUtils::DeriveKeys(
+           params->forward_secure_premaster_secret, params->aead,
+           info.client_nonce, info.server_nonce, forward_secure_hkdf_input,
+           CryptoUtils::SERVER, &params->forward_secure_crypters)) {
+    *error_details = "Symmetric key setup failed";
+    return QUIC_CRYPTO_SYMMETRIC_KEY_SETUP_FAILED;
+  }
 
   out->set_tag(kSHLO);
   out->SetStringPiece(kSourceAddressTokenTag,
                       NewSourceAddressToken(client_ip, rand, info.now));
   out->SetStringPiece(kPUBS, forward_secure_public_value);
   return QUIC_NO_ERROR;
 }
 
 // ConfigPrimaryTimeLessThan is a comparator that implements "less than" for
 // Config's based on their primary_time.
@@ skipping 548 matching lines @@
 }
 
 QuicCryptoServerConfig::Config::Config()
     : channel_id_enabled(false),
       is_primary(false),
       primary_time(QuicWallTime::Zero()) {}
 
 QuicCryptoServerConfig::Config::~Config() { STLDeleteElements(&key_exchanges); }
 
 }  // namespace net