xref: /system/connectivity/shill/test-rpc-proxy/proxy_rpc_security_types.cc

//
// Copyright (C) 2015 The Android Open Source Project
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//      http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//

#include <base/logging.h>
#include <base/strings/stringprintf.h>
#include <service_constants.h>

#include "proxy_rpc_security_types.h"
#include "proxy_util.h"

// Autotest Server test encodes the object type in this key.
static const char kXmlRpcStructTypeKey[] = "xmlrpc_struct_type_key";
const char SecurityConfig::kDefaultSecurity[] = "none";
const int WPAConfig::kMaxPskSize = 64;
const char EAPConfig::kDefaultEapUsers[] = "* TLS";
const char EAPConfig::kDefaultEAPIdentity[] = "brillo";
int EAPConfig::last_tmp_id = 8800;
const int DynamicWEPConfig::kDefaultKeyPeriod = 20;
const char Tunneled1xConfig::kTTLSPrefix[] = "TTLS-";
const char Tunneled1xConfig::kLayer1TypePEAP[] = "PEAP";
const char Tunneled1xConfig::kLayer1TypeTTLS[] = "TTLS";
const char Tunneled1xConfig::kLayer2TypeGTC[] = "GTC";
const char Tunneled1xConfig::kLayer2TypeMSCHAPV2[] = "MSCHAPV2";
const char Tunneled1xConfig::kLayer2TypeMD5[] = "MD5";
const char Tunneled1xConfig::kLayer2TypeTTLSMSCHAPV2[] = "TTLS-MSCHAPV2";
const char Tunneled1xConfig::kLayer2TypeTTLSMSCHAP[] = "TTLS-MSCHAP";
const char Tunneled1xConfig::kLayer2TypeTTLSPAP[] = "TTLS-PAP";

std::unique_ptr<SecurityConfig> SecurityConfig::CreateSecurityConfigObject(
    XmlRpc::XmlRpcValue* xml_rpc_value_in) {
  const std::string& security_type = (*xml_rpc_value_in)[kXmlRpcStructTypeKey];
  if (security_type == "SecurityConfig") {
    return std::unique_ptr<SecurityConfig>(new SecurityConfig(xml_rpc_value_in));
  }
  if (security_type == "WEPConfig") {
    return std::unique_ptr<SecurityConfig>(new WEPConfig(xml_rpc_value_in));
  }
  if (security_type == "WPAConfig") {
    return std::unique_ptr<SecurityConfig>(new WPAConfig(xml_rpc_value_in));
  }
  LOG(FATAL) << "Unexpected object received. Received: " << security_type;
  return nullptr;
}

SecurityConfig::SecurityConfig(
    XmlRpc::XmlRpcValue* xml_rpc_value_in) {
  GetStringValueFromXmlRpcValueStructMember(
      xml_rpc_value_in, "security", kDefaultSecurity, &security_);
}

void SecurityConfig::GetServiceProperties(brillo::VariantDictionary* properties) {
  // The base class represents a connection with no security. So, no security
  // properties to be sent to Shill.
}

WEPConfig::WEPConfig(XmlRpc::XmlRpcValue* xml_rpc_value_in)
  : SecurityConfig::SecurityConfig(xml_rpc_value_in) {
  GetStringVectorFromXmlRpcValueStructMember(
      xml_rpc_value_in, "wep_keys", std::vector<std::string>(), &wep_keys_);
  GetIntValueFromXmlRpcValueStructMember(
        xml_rpc_value_in, "wep_default_key", 0, &wep_default_key_index_);
  GetIntValueFromXmlRpcValueStructMember(
        xml_rpc_value_in, "auth_algorithm", (int)kAuthAlgorithmTypeDefault,
        &auth_algorithm_);
  if (wep_default_key_index_ > static_cast<int>(wep_keys_.size())) {
    LOG(FATAL) << "Error in received wep_default_key: "
               << wep_default_key_index_;
  }
}

void WEPConfig::GetServiceProperties(brillo::VariantDictionary* properties) {
  std::string passphrase = base::StringPrintf(
      "%d:%s", wep_default_key_index_,
      wep_keys_[wep_default_key_index_].c_str());
  (*properties)[shill::kPassphraseProperty] = passphrase;
}

WPAConfig::WPAConfig(XmlRpc::XmlRpcValue* xml_rpc_value_in)
  : SecurityConfig::SecurityConfig(xml_rpc_value_in) {
  GetStringValueFromXmlRpcValueStructMember(
      xml_rpc_value_in, "psk", std::string(), &psk_);
  GetIntValueFromXmlRpcValueStructMember(
        xml_rpc_value_in, "wpa_mode", kWpaModeDefault, &wpa_mode_);
  GetStringVectorFromXmlRpcValueStructMember(
      xml_rpc_value_in, "wpa_ciphers", std::vector<std::string>(),
      &wpa_ciphers_);
  GetStringVectorFromXmlRpcValueStructMember(
      xml_rpc_value_in, "wpa2_ciphers", std::vector<std::string>(),
      &wpa2_ciphers_);
  GetIntValueFromXmlRpcValueStructMember(
      xml_rpc_value_in, "wpa_ptk_rekey_period", 0,
      &wpa_ptk_rekey_period_seconds_);
  GetIntValueFromXmlRpcValueStructMember(
      xml_rpc_value_in, "wpa_gtk_rekey_period", 0,
      &wpa_gtk_rekey_period_seconds_);
  GetIntValueFromXmlRpcValueStructMember(
      xml_rpc_value_in, "wpa_gmk_rekey_period", 0,
      &wpa_gmk_rekey_period_seconds_);
  GetBoolValueFromXmlRpcValueStructMember(
      xml_rpc_value_in, "use_strict_rekey", 0, &use_strict_rekey_);

  if (psk_.size() > kMaxPskSize) {
    LOG(FATAL) << "WPA passphrases can be no longer than 63 characters"
                  "(or 64 hex digits). PSK: " << psk_;
  }
  if ((psk_.size() == kMaxPskSize) &&
      (psk_.find_first_not_of("0123456789abcdef") != std::string::npos)) {
    LOG(FATAL) << "Invalid PSK: " << psk_;
  }
}

void WPAConfig::GetServiceProperties(brillo::VariantDictionary* properties) {
  (*properties)[shill::kPassphraseProperty] = psk_;
}