[Sync] Move //sync to //components/sync.

components/sync/base/nigori.cc

 // Copyright (c) 2012 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 "sync/util/nigori.h"
+#include "components/sync/base/nigori.h"
 
 #include <stdint.h>
 
 #include <sstream>
 #include <vector>
 
 #include "base/base64.h"
 #include "base/logging.h"
 #include "base/strings/string_util.h"
 #include "base/sys_byteorder.h"
@@ skipping 27 matching lines @@
   // followed by the big-endian representation of the value of |type|, with 32
   // bits, to the stream.
   NigoriStream& operator<<(const Nigori::Type type) {
     uint32_t size = base::HostToNet32(sizeof(uint32_t));
     stream_.write(reinterpret_cast<char*>(&size), sizeof(uint32_t));
     uint32_t value = base::HostToNet32(type);
     stream_.write(reinterpret_cast<char*>(&value), sizeof(uint32_t));
     return *this;
   }
 
-  std::string str() {
-    return stream_.str();
-  }
+  std::string str() { return stream_.str(); }
 
  private:
   std::ostringstream stream_;
 };
 
 // static
 const char Nigori::kSaltSalt[] = "saltsalt";
 
-Nigori::Nigori() {
-}
+Nigori::Nigori() {}
 
-Nigori::~Nigori() {
-}
+Nigori::~Nigori() {}
 
 bool Nigori::InitByDerivation(const std::string& hostname,
                               const std::string& username,
                               const std::string& password) {
   NigoriStream salt_password;
   salt_password << username << hostname;
 
   // Suser = PBKDF2(Username || Servername, "saltsalt", Nsalt, 8)
   std::unique_ptr<SymmetricKey> user_salt(SymmetricKey::DeriveKeyFromPassword(
       SymmetricKey::HMAC_SHA1, salt_password.str(), kSaltSalt, kSaltIterations,
@@ skipping 34 matching lines @@
   encryption_key_ = SymmetricKey::Import(SymmetricKey::AES, encryption_key);
   DCHECK(encryption_key_);
 
   mac_key_ = SymmetricKey::Import(SymmetricKey::HMAC_SHA1, mac_key);
   DCHECK(mac_key_);
 
   return user_key_ && encryption_key_ && mac_key_;
 }
 
 // Permute[Kenc,Kmac](type || name)
-bool Nigori::Permute(Type type, const std::string& name,
+bool Nigori::Permute(Type type,
+                     const std::string& name,
                      std::string* permuted) const {
   DCHECK_LT(0U, name.size());
 
   NigoriStream plaintext;
   plaintext << type << name;
 
   Encryptor encryptor;
   if (!encryptor.Init(encryption_key_.get(), Encryptor::CBC,
                       std::string(kIvSize, 0)))
     return false;
@@ skipping 65 matching lines @@
     return false;
 
   if (input.size() < kIvSize * 2 + kHashSize)
     return false;
 
   // The input is:
   // * iv (16 bytes)
   // * ciphertext (multiple of 16 bytes)
   // * hash (32 bytes)
   std::string iv(input.substr(0, kIvSize));
-  std::string ciphertext(input.substr(kIvSize,
-                                      input.size() - (kIvSize + kHashSize)));
+  std::string ciphertext(
+      input.substr(kIvSize, input.size() - (kIvSize + kHashSize)));
   std::string hash(input.substr(input.size() - kHashSize, kHashSize));
 
   std::string raw_mac_key;
   if (!mac_key_->GetRawKey(&raw_mac_key))
     return false;
 
   HMAC hmac(HMAC::SHA256);
   if (!hmac.Init(raw_mac_key))
     return false;
 
   std::vector<unsigned char> expected(kHashSize);
   if (!hmac.Sign(ciphertext, &expected[0], expected.size()))
     return false;
 
-  if (hash.compare(0, hash.size(),
-                   reinterpret_cast<char *>(&expected[0]),
+  if (hash.compare(0, hash.size(), reinterpret_cast<char*>(&expected[0]),
                    expected.size()))
     return false;
 
   Encryptor encryptor;
   if (!encryptor.Init(encryption_key_.get(), Encryptor::CBC, iv))
     return false;
 
   if (!encryptor.Decrypt(ciphertext, value))
     return false;
 
   return true;
 }
 
 bool Nigori::ExportKeys(std::string* user_key,
                         std::string* encryption_key,
                         std::string* mac_key) const {
   DCHECK(user_key);
   DCHECK(encryption_key);
   DCHECK(mac_key);
 
   return user_key_->GetRawKey(user_key) &&
-      encryption_key_->GetRawKey(encryption_key) &&
-      mac_key_->GetRawKey(mac_key);
+         encryption_key_->GetRawKey(encryption_key) &&
+         mac_key_->GetRawKey(mac_key);
 }
 
 }  // namespace syncer