net/quic/crypto/null_decrypter.cc

   1 // Copyright (c) 2012 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/null_decrypter.h"
   6
   7 #include <stdint.h>
   8
   9 #include "net/quic/quic_utils.h"
  10 #include "net/quic/quic_data_reader.h"
  11
  12 using base::StringPiece;
  13 using std::string;
  14
  15 namespace net {
  16
  17 NullDecrypter::NullDecrypter() {}
  18
  19 bool NullDecrypter::SetKey(StringPiece key) { return key.empty(); }
  20
  21 bool NullDecrypter::SetNoncePrefix(StringPiece nonce_prefix) {
  22   return nonce_prefix.empty();
  23 }
  24
  25 bool NullDecrypter::DecryptPacket(QuicPacketNumber /*packet_number*/,
  26                                   const StringPiece& associated_data,
  27                                   const StringPiece& ciphertext,
  28                                   char* output,
  29                                   size_t* output_length,
  30                                   size_t max_output_length) {
  31   QuicDataReader reader(ciphertext.data(), ciphertext.length());
  32   uint128 hash;
  33
  34   if (!ReadHash(&reader, &hash)) {
  35     return false;
  36   }
  37
  38   StringPiece plaintext = reader.ReadRemainingPayload();
  39   if (plaintext.length() > max_output_length) {
  40     LOG(DFATAL) << "Output buffer must be larger than the plaintext.";
  41     return false;
  42   }
  43   if (hash != ComputeHash(associated_data, plaintext)) {
  44     return false;
  45   }
  46   // Copy the plaintext to output.
  47   memcpy(output, plaintext.data(), plaintext.length());
  48   *output_length = plaintext.length();
  49   return true;
  50 }
  51
  52 StringPiece NullDecrypter::GetKey() const { return StringPiece(); }
  53
  54 StringPiece NullDecrypter::GetNoncePrefix() const { return StringPiece(); }
  55
  56 const char* NullDecrypter::cipher_name() const {
  57   return "NULL";
  58 }
  59
  60 uint32 NullDecrypter::cipher_id() const {
  61   return 0;
  62 }
  63
  64 bool NullDecrypter::ReadHash(QuicDataReader* reader, uint128* hash) {
  65   uint64 lo;
  66   uint32 hi;
  67   if (!reader->ReadUInt64(&lo) ||
  68       !reader->ReadUInt32(&hi)) {
  69     return false;
  70   }
  71   *hash = hi;
  72   *hash <<= 64;
  73   *hash += lo;
  74   return true;
  75 }
  76
  77 uint128 NullDecrypter::ComputeHash(const StringPiece& data1,
  78                                    const StringPiece& data2) const {
  79   uint128 correct_hash = QuicUtils::FNV1a_128_Hash_Two(
  80       data1.data(), data1.length(), data2.data(), data2.length());
  81   uint128 mask(UINT64_C(0x0), UINT64_C(0xffffffff));
  82   mask <<= 96;
  83   correct_hash &= ~mask;
  84   return correct_hash;
  85 }
  86
  87 }  // namespace net