net/quic/crypto/crypto_utils.cc

   1 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "net/quic/crypto/crypto_utils.h"
   6
   7 #include "crypto/hkdf.h"
   8 #include "net/base/net_util.h"
   9 #include "net/quic/crypto/crypto_handshake.h"
  10 #include "net/quic/crypto/crypto_protocol.h"
  11 #include "net/quic/crypto/quic_decrypter.h"
  12 #include "net/quic/crypto/quic_encrypter.h"
  13 #include "net/quic/crypto/quic_random.h"
  14 #include "net/quic/quic_time.h"
  15 #include "url/url_canon.h"
  16
  17 using base::StringPiece;
  18 using std::string;
  19
  20 namespace net {
  21
  22 // static
  23 void CryptoUtils::GenerateNonce(QuicWallTime now,
  24                                 QuicRandom* random_generator,
  25                                 StringPiece orbit,
  26                                 string* nonce) {
  27   // a 4-byte timestamp + 28 random bytes.
  28   nonce->reserve(kNonceSize);
  29   nonce->resize(kNonceSize);
  30   uint32 gmt_unix_time = now.ToUNIXSeconds();
  31   // The time in the nonce must be encoded in big-endian because the
  32   // strike-register depends on the nonces being ordered by time.
  33   (*nonce)[0] = static_cast<char>(gmt_unix_time >> 24);
  34   (*nonce)[1] = static_cast<char>(gmt_unix_time >> 16);
  35   (*nonce)[2] = static_cast<char>(gmt_unix_time >> 8);
  36   (*nonce)[3] = static_cast<char>(gmt_unix_time);
  37
  38   size_t bytes_written = sizeof(gmt_unix_time);
  39   if (orbit.size() == 8) {
  40     memcpy(&(*nonce)[bytes_written], orbit.data(), orbit.size());
  41     bytes_written += orbit.size();
  42   }
  43   random_generator->RandBytes(&(*nonce)[bytes_written],
  44                               kNonceSize - bytes_written);
  45 }
  46
  47 // static
  48 bool CryptoUtils::IsValidSNI(StringPiece sni) {
  49   // TODO(rtenneti): Support RFC2396 hostname.
  50   // NOTE: Microsoft does NOT enforce this spec, so if we throw away hostnames
  51   // based on the above spec, we may be losing some hostnames that windows
  52   // would consider valid. By far the most common hostname character NOT
  53   // accepted by the above spec is '_'.
  54   url::CanonHostInfo host_info;
  55   string canonicalized_host(CanonicalizeHost(sni.as_string(), &host_info));
  56   return !host_info.IsIPAddress() &&
  57       IsCanonicalizedHostCompliant(canonicalized_host, std::string()) &&
  58       sni.find_last_of('.') != string::npos;
  59 }
  60
  61 // static
  62 string CryptoUtils::NormalizeHostname(const char* hostname) {
  63   url::CanonHostInfo host_info;
  64   string host(CanonicalizeHost(hostname, &host_info));
  65
  66   // Walk backwards over the string, stopping at the first trailing dot.
  67   size_t host_end = host.length();
  68   while (host_end != 0 && host[host_end - 1] == '.') {
  69     host_end--;
  70   }
  71
  72   // Erase the trailing dots.
  73   if (host_end != host.length()) {
  74     host.erase(host_end, host.length() - host_end);
  75   }
  76   return host;
  77 }
  78
  79 // static
  80 bool CryptoUtils::DeriveKeys(StringPiece premaster_secret,
  81                              QuicTag aead,
  82                              StringPiece client_nonce,
  83                              StringPiece server_nonce,
  84                              const string& hkdf_input,
  85                              Perspective perspective,
  86                              CrypterPair* out) {
  87   out->encrypter.reset(QuicEncrypter::Create(aead));
  88   out->decrypter.reset(QuicDecrypter::Create(aead));
  89   size_t key_bytes = out->encrypter->GetKeySize();
  90   size_t nonce_prefix_bytes = out->encrypter->GetNoncePrefixSize();
  91
  92   StringPiece nonce = client_nonce;
  93   string nonce_storage;
  94   if (!server_nonce.empty()) {
  95     nonce_storage = client_nonce.as_string() + server_nonce.as_string();
  96     nonce = nonce_storage;
  97   }
  98
  99   crypto::HKDF hkdf(premaster_secret, nonce, hkdf_input, key_bytes,
 100                     nonce_prefix_bytes);
 101   if (perspective == SERVER) {
 102     if (!out->encrypter->SetKey(hkdf.server_write_key()) ||
 103         !out->encrypter->SetNoncePrefix(hkdf.server_write_iv()) ||
 104         !out->decrypter->SetKey(hkdf.client_write_key()) ||
 105         !out->decrypter->SetNoncePrefix(hkdf.client_write_iv())) {
 106       return false;
 107     }
 108   } else {
 109     if (!out->encrypter->SetKey(hkdf.client_write_key()) ||
 110         !out->encrypter->SetNoncePrefix(hkdf.client_write_iv()) ||
 111         !out->decrypter->SetKey(hkdf.server_write_key()) ||
 112         !out->decrypter->SetNoncePrefix(hkdf.server_write_iv())) {
 113       return false;
 114     }
 115   }
 116
 117   return true;
 118 }
 119
 120 }  // namespace net