text: // Copyright 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 "components/autofill/content/browser/wallet/full_wallet.h"
  
  #include "base/logging.h"
  #include "base/strings/string_number_conversions.h"
  #include "base/strings/utf_string_conversions.h"
  #include "base/values.h"
  #include "components/autofill/core/browser/autofill_type.h"
  #include "components/autofill/core/browser/credit_card.h"
  
  namespace {
  
  const size_t kPanSize = 16;
  const size_t kBinSize = 6;
  const size_t kCvnSize = 3;
  const size_t kEncryptedRestSize = 12;
  
  }  // anonymous namespace
  
  namespace autofill {
  namespace wallet {
  
  FullWallet::FullWallet(int expiration_month,
                         int expiration_year,
                         const std::string& iin,
                         const std::string& encrypted_rest,
                         scoped_ptr<Address> billing_address,
                         scoped_ptr<Address> shipping_address,
                         const std::vector<RequiredAction>& required_actions)
      : expiration_month_(expiration_month),
        expiration_year_(expiration_year),
        iin_(iin),
        encrypted_rest_(encrypted_rest),
        billing_address_(billing_address.Pass()),
        shipping_address_(shipping_address.Pass()),
        required_actions_(required_actions) {
    DCHECK(required_actions_.size() > 0 || billing_address_.get());
  }
  
  FullWallet::~FullWallet() {}
  
  // static
  scoped_ptr<FullWallet>
      FullWallet::CreateFullWallet(const base::DictionaryValue& dictionary) {
    const base::ListValue* required_actions_list;
    std::vector<RequiredAction> required_actions;
    if (dictionary.GetList("required_action", &required_actions_list)) {
      for (size_t i = 0; i < required_actions_list->GetSize(); ++i) {
        std::string action_string;
        if (required_actions_list->GetString(i, &action_string)) {
          RequiredAction action = ParseRequiredActionFromString(action_string);
          if (!ActionAppliesToFullWallet(action)) {
            DLOG(ERROR) << "Response from Google wallet with bad required action:"
                           " \"" << action_string << "\"";
            return scoped_ptr<FullWallet>();
          }
          required_actions.push_back(action);
        }
      }
      if (required_actions.size() > 0) {
        return scoped_ptr<FullWallet>(new FullWallet(-1,
                                                     -1,
                                                     std::string(),
                                                     std::string(),
                                                     scoped_ptr<Address>(),
                                                     scoped_ptr<Address>(),
                                                     required_actions));
      }
    } else {
      DVLOG(1) << "Response from Google wallet missing required actions";
    }
  
    int expiration_month;
    if (!dictionary.GetInteger("expiration_month", &expiration_month)) {
      DLOG(ERROR) << "Response from Google wallet missing expiration month";
      return scoped_ptr<FullWallet>();
    }
  
    int expiration_year;
    if (!dictionary.GetInteger("expiration_year", &expiration_year)) {
      DLOG(ERROR) << "Response from Google wallet missing expiration year";
      return scoped_ptr<FullWallet>();
    }
  
    std::string iin;
    if (!dictionary.GetString("iin", &iin)) {
      DLOG(ERROR) << "Response from Google wallet missing iin";
      return scoped_ptr<FullWallet>();
    }
  
    std::string encrypted_rest;
    if (!dictionary.GetString("rest", &encrypted_rest)) {
      DLOG(ERROR) << "Response from Google wallet missing rest";
      return scoped_ptr<FullWallet>();
    }
  
    const base::DictionaryValue* billing_address_dict;
    if (!dictionary.GetDictionary("billing_address", &billing_address_dict)) {
      DLOG(ERROR) << "Response from Google wallet missing billing address";
      return scoped_ptr<FullWallet>();
    }
  
    scoped_ptr<Address> billing_address =
        Address::CreateAddress(*billing_address_dict);
    if (!billing_address.get()) {
      DLOG(ERROR) << "Response from Google wallet has malformed billing address";
      return scoped_ptr<FullWallet>();
    }
  
    const base::DictionaryValue* shipping_address_dict;
    scoped_ptr<Address> shipping_address;
    if (dictionary.GetDictionary("shipping_address", &shipping_address_dict)) {
      shipping_address =
          Address::CreateAddressWithID(*shipping_address_dict);
    } else {
      DVLOG(1) << "Response from Google wallet missing shipping address";
    }
  
    return scoped_ptr<FullWallet>(new FullWallet(expiration_month,
                                                 expiration_year,
                                                 iin,
                                                 encrypted_rest,
                                                 billing_address.Pass(),
                                                 shipping_address.Pass(),
                                                 required_actions));
  }
  
  // static
  scoped_ptr<FullWallet>
      FullWallet::CreateFullWalletFromClearText(
          int expiration_month,
          int expiration_year,
          const std::string& pan,
          const std::string& cvn,
          scoped_ptr<Address> billing_address,
          scoped_ptr<Address> shipping_address) {
    DCHECK(billing_address);
    DCHECK(!pan.empty());
    DCHECK(!cvn.empty());
  
    scoped_ptr<FullWallet> wallet(new FullWallet(
        expiration_month,
        expiration_year,
        std::string(),  // no iin -- clear text pan/cvn are set below.
        std::string(),  // no encrypted_rest -- clear text pan/cvn are set below.
        billing_address.Pass(),
        shipping_address.Pass(),
        std::vector<RequiredAction>()));  // no required actions in clear text.
    wallet->pan_ = pan;
    wallet->cvn_ = cvn;
    return wallet.Pass();
  }
  
  base::string16 FullWallet::GetInfo(const std::string& app_locale,
                                     const AutofillType& type) {
    switch (type.GetStorableType()) {
      case CREDIT_CARD_NUMBER:
        return base::ASCIIToUTF16(GetPan());
  
      case CREDIT_CARD_NAME:
        return billing_address()->recipient_name();
  
      case CREDIT_CARD_VERIFICATION_CODE:
        return base::ASCIIToUTF16(GetCvn());
  
      case CREDIT_CARD_EXP_MONTH:
        if (expiration_month() == 0)
          return base::string16();
        return base::IntToString16(expiration_month());
  
      case CREDIT_CARD_EXP_4_DIGIT_YEAR:
        if (expiration_year() == 0)
          return base::string16();
        return base::IntToString16(expiration_year());
  
      case CREDIT_CARD_EXP_2_DIGIT_YEAR:
        if (expiration_year() == 0)
          return base::string16();
        return base::IntToString16(expiration_year() % 100);
  
      case CREDIT_CARD_EXP_DATE_2_DIGIT_YEAR:
        if (expiration_month() == 0 || expiration_year() == 0)
          return base::string16();
        return base::IntToString16(expiration_month()) + base::ASCIIToUTF16("/") +
               base::IntToString16(expiration_year() % 100);
  
      case CREDIT_CARD_EXP_DATE_4_DIGIT_YEAR:
        if (expiration_month() == 0 || expiration_year() == 0)
              return base::string16();
        return base::IntToString16(expiration_month()) + base::ASCIIToUTF16("/") +
               base::IntToString16(expiration_year());
  
      case CREDIT_CARD_TYPE: {
        const char* const internal_type =
            CreditCard::GetCreditCardType(base::ASCIIToUTF16(GetPan()));
        if (internal_type == kGenericCard)
          return base::string16();
        return CreditCard::TypeForDisplay(internal_type);
      }
  
      default: {
        switch (type.group()) {
          case NAME_BILLING:
          case PHONE_BILLING:
          case ADDRESS_BILLING:
            return billing_address_->GetInfo(type, app_locale);
  
          case CREDIT_CARD:
            NOTREACHED();
  
          default:
            return shipping_address_->GetInfo(type, app_locale);
        }
      }
    }
  }
  
  bool FullWallet::HasRequiredAction(RequiredAction action) const {
    DCHECK(ActionAppliesToFullWallet(action));
    return std::find(required_actions_.begin(),
                     required_actions_.end(),
                     action) != required_actions_.end();
  }
  
  base::string16 FullWallet::TypeAndLastFourDigits() {
    CreditCard card;
    card.SetRawInfo(CREDIT_CARD_NUMBER, base::ASCIIToUTF16(GetPan()));
    return card.TypeAndLastFourDigits();
  }
  
  const std::string& FullWallet::GetPan() {
    if (pan_.empty())
      DecryptCardInfo();
    return pan_;
  }
  
  bool FullWallet::operator==(const FullWallet& other) const {
    if (expiration_month_ != other.expiration_month_)
      return false;
  
    if (expiration_year_ != other.expiration_year_)
      return false;
  
    if (iin_ != other.iin_)
      return false;
  
    if (encrypted_rest_ != other.encrypted_rest_)
      return false;
  
    if (billing_address_.get() && other.billing_address_.get()) {
      if (*billing_address_.get() != *other.billing_address_.get())
        return false;
    } else if (billing_address_.get() || other.billing_address_.get()) {
      return false;
    }
  
    if (shipping_address_.get() && other.shipping_address_.get()) {
      if (*shipping_address_.get() != *other.shipping_address_.get())
        return false;
    } else if (shipping_address_.get() || other.shipping_address_.get()) {
      return false;
    }
  
    if (required_actions_ != other.required_actions_)
      return false;
  
    return true;
  }
  
  bool FullWallet::operator!=(const FullWallet& other) const {
    return !(*this == other);
  }
  
  void FullWallet::DecryptCardInfo() {
    // |encrypted_rest_| must be of length |kEncryptedRestSize| in order for
    // decryption to succeed and the server will not pad it with zeros.
    while (encrypted_rest_.size() < kEncryptedRestSize) {
      encrypted_rest_ = '0' + encrypted_rest_;
    }
  
    DCHECK_EQ(kEncryptedRestSize, encrypted_rest_.size());
  
    std::vector<uint8> operating_data;
    // Convert |encrypted_rest_| to bytes so we can decrypt it with |otp|.
    if (!base::HexStringToBytes(encrypted_rest_, &operating_data)) {
      DLOG(ERROR) << "Failed to parse encrypted rest";
      return;
    }
  
    // Ensure |one_time_pad_| and |encrypted_rest_| are of the same length
    // otherwise something has gone wrong and we can't decrypt the data.
    DCHECK_EQ(one_time_pad_.size(), operating_data.size());
  
    std::vector<uint8> results;
    // XOR |otp| with the encrypted data to decrypt.
    for (size_t i = 0; i < one_time_pad_.size(); ++i)
      results.push_back(one_time_pad_[i] ^ operating_data[i]);
  
    // There is no uint8* to int64 so convert the decrypted data to hex and then
    // parse the hex to an int64 before getting the int64 as a string.
    std::string hex_decrypted = base::HexEncode(&(results[0]), results.size());
  
    int64 decrypted;
    if (!base::HexStringToInt64(hex_decrypted, &decrypted)) {
      DLOG(ERROR) << "Failed to parse decrypted data in hex to int64";
      return;
    }
    std::string card_info = base::Int64ToString(decrypted);
  
    size_t padded_length = kPanSize - kBinSize + kCvnSize;
    // |card_info| is PAN without the IIN concatenated with the CVN, i.e.
    // PANPANPANPCVN. If what was decrypted is not of that size the front needs
    // to be padded with 0's until it is.
    if (card_info.size() != padded_length)
      card_info.insert(card_info.begin(), padded_length - card_info.size(), '0');
  
    // Separate out the PAN from the CVN.
    size_t split = kPanSize - kBinSize;
    cvn_ = card_info.substr(split);
    pan_ = iin_ + card_info.substr(0, split);
  }
  
  const std::string& FullWallet::GetCvn() {
    if (cvn_.empty())
      DecryptCardInfo();
    return cvn_;
  }
  
  }  // namespace wallet
  }  // namespace autofill
  