google_apis/google_api_keys.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 "google_apis/google_api_keys.h"
   6
   7 // If you add more includes to this list, you also need to add them to
   8 // google_api_keys_unittest.cc.
   9 #include "base/command_line.h"
  10 #include "base/environment.h"
  11 #include "base/lazy_instance.h"
  12 #include "base/logging.h"
  13 #include "base/memory/scoped_ptr.h"
  14 #include "base/strings/stringize_macros.h"
  15
  16 #if defined(GOOGLE_CHROME_BUILD) || defined(USE_OFFICIAL_GOOGLE_API_KEYS)
  17 #include "google_apis/internal/google_chrome_api_keys.h"
  18 #endif
  19
  20 // Used to indicate an unset key/id/secret.  This works better with
  21 // various unit tests than leaving the token empty.
  22 #define DUMMY_API_TOKEN "dummytoken"
  23
  24 #if !defined(GOOGLE_API_KEY)
  25 #define GOOGLE_API_KEY DUMMY_API_TOKEN
  26 #endif
  27
  28 #if !defined(GOOGLE_CLIENT_ID_MAIN)
  29 #define GOOGLE_CLIENT_ID_MAIN DUMMY_API_TOKEN
  30 #endif
  31
  32 #if !defined(GOOGLE_CLIENT_SECRET_MAIN)
  33 #define GOOGLE_CLIENT_SECRET_MAIN DUMMY_API_TOKEN
  34 #endif
  35
  36 #if !defined(GOOGLE_CLIENT_ID_CLOUD_PRINT)
  37 #define GOOGLE_CLIENT_ID_CLOUD_PRINT DUMMY_API_TOKEN
  38 #endif
  39
  40 #if !defined(GOOGLE_CLIENT_SECRET_CLOUD_PRINT)
  41 #define GOOGLE_CLIENT_SECRET_CLOUD_PRINT DUMMY_API_TOKEN
  42 #endif
  43
  44 #if !defined(GOOGLE_CLIENT_ID_REMOTING)
  45 #define GOOGLE_CLIENT_ID_REMOTING DUMMY_API_TOKEN
  46 #endif
  47
  48 #if !defined(GOOGLE_CLIENT_SECRET_REMOTING)
  49 #define GOOGLE_CLIENT_SECRET_REMOTING DUMMY_API_TOKEN
  50 #endif
  51
  52 #if !defined(GOOGLE_CLIENT_ID_REMOTING_HOST)
  53 #define GOOGLE_CLIENT_ID_REMOTING_HOST DUMMY_API_TOKEN
  54 #endif
  55
  56 #if !defined(GOOGLE_CLIENT_SECRET_REMOTING_HOST)
  57 #define GOOGLE_CLIENT_SECRET_REMOTING_HOST DUMMY_API_TOKEN
  58 #endif
  59
  60 // These are used as shortcuts for developers and users providing
  61 // OAuth credentials via preprocessor defines or environment
  62 // variables.  If set, they will be used to replace any of the client
  63 // IDs and secrets above that have not been set (and only those; they
  64 // will not override already-set values).
  65 #if !defined(GOOGLE_DEFAULT_CLIENT_ID)
  66 #define GOOGLE_DEFAULT_CLIENT_ID ""
  67 #endif
  68 #if !defined(GOOGLE_DEFAULT_CLIENT_SECRET)
  69 #define GOOGLE_DEFAULT_CLIENT_SECRET ""
  70 #endif
  71
  72 namespace switches {
  73
  74 // Specifies custom OAuth2 client id for testing purposes.
  75 const char kOAuth2ClientID[] = "oauth2-client-id";
  76
  77 // Specifies custom OAuth2 client secret for testing purposes.
  78 const char kOAuth2ClientSecret[] = "oauth2-client-secret";
  79
  80 }  // namespace switches
  81
  82 namespace google_apis {
  83
  84 // This is used as a lazy instance to determine keys once and cache them.
  85 class APIKeyCache {
  86  public:
  87   APIKeyCache() {
  88     scoped_ptr<base::Environment> environment(base::Environment::Create());
  89     CommandLine* command_line = CommandLine::ForCurrentProcess();
  90
  91     api_key_ = CalculateKeyValue(GOOGLE_API_KEY,
  92                                  STRINGIZE_NO_EXPANSION(GOOGLE_API_KEY),
  93                                  NULL,
  94                                  std::string(),
  95                                  environment.get(),
  96                                  command_line);
  97
  98     std::string default_client_id =
  99         CalculateKeyValue(GOOGLE_DEFAULT_CLIENT_ID,
 100                           STRINGIZE_NO_EXPANSION(GOOGLE_DEFAULT_CLIENT_ID),
 101                           NULL,
 102                           std::string(),
 103                           environment.get(),
 104                           command_line);
 105     std::string default_client_secret =
 106         CalculateKeyValue(GOOGLE_DEFAULT_CLIENT_SECRET,
 107                           STRINGIZE_NO_EXPANSION(GOOGLE_DEFAULT_CLIENT_SECRET),
 108                           NULL,
 109                           std::string(),
 110                           environment.get(),
 111                           command_line);
 112
 113     // We currently only allow overriding the baked-in values for the
 114     // default OAuth2 client ID and secret using a command-line
 115     // argument, since that is useful to enable testing against
 116     // staging servers, and since that was what was possible and
 117     // likely practiced by the QA team before this implementation was
 118     // written.
 119     client_ids_[CLIENT_MAIN] = CalculateKeyValue(
 120         GOOGLE_CLIENT_ID_MAIN,
 121         STRINGIZE_NO_EXPANSION(GOOGLE_CLIENT_ID_MAIN),
 122         switches::kOAuth2ClientID,
 123         default_client_id,
 124         environment.get(),
 125         command_line);
 126     client_secrets_[CLIENT_MAIN] = CalculateKeyValue(
 127         GOOGLE_CLIENT_SECRET_MAIN,
 128         STRINGIZE_NO_EXPANSION(GOOGLE_CLIENT_SECRET_MAIN),
 129         switches::kOAuth2ClientSecret,
 130         default_client_secret,
 131         environment.get(),
 132         command_line);
 133
 134     client_ids_[CLIENT_CLOUD_PRINT] = CalculateKeyValue(
 135         GOOGLE_CLIENT_ID_CLOUD_PRINT,
 136         STRINGIZE_NO_EXPANSION(GOOGLE_CLIENT_ID_CLOUD_PRINT),
 137         NULL,
 138         default_client_id,
 139         environment.get(),
 140         command_line);
 141     client_secrets_[CLIENT_CLOUD_PRINT] = CalculateKeyValue(
 142         GOOGLE_CLIENT_SECRET_CLOUD_PRINT,
 143         STRINGIZE_NO_EXPANSION(GOOGLE_CLIENT_SECRET_CLOUD_PRINT),
 144         NULL,
 145         default_client_secret,
 146         environment.get(),
 147         command_line);
 148
 149     client_ids_[CLIENT_REMOTING] = CalculateKeyValue(
 150         GOOGLE_CLIENT_ID_REMOTING,
 151         STRINGIZE_NO_EXPANSION(GOOGLE_CLIENT_ID_REMOTING),
 152         NULL,
 153         default_client_id,
 154         environment.get(),
 155         command_line);
 156     client_secrets_[CLIENT_REMOTING] = CalculateKeyValue(
 157         GOOGLE_CLIENT_SECRET_REMOTING,
 158         STRINGIZE_NO_EXPANSION(GOOGLE_CLIENT_SECRET_REMOTING),
 159         NULL,
 160         default_client_secret,
 161         environment.get(),
 162         command_line);
 163
 164     client_ids_[CLIENT_REMOTING_HOST] = CalculateKeyValue(
 165         GOOGLE_CLIENT_ID_REMOTING_HOST,
 166         STRINGIZE_NO_EXPANSION(GOOGLE_CLIENT_ID_REMOTING_HOST),
 167         NULL,
 168         default_client_id,
 169         environment.get(),
 170         command_line);
 171     client_secrets_[CLIENT_REMOTING_HOST] = CalculateKeyValue(
 172         GOOGLE_CLIENT_SECRET_REMOTING_HOST,
 173         STRINGIZE_NO_EXPANSION(GOOGLE_CLIENT_SECRET_REMOTING_HOST),
 174         NULL,
 175         default_client_secret,
 176         environment.get(),
 177         command_line);
 178   }
 179
 180   std::string api_key() const { return api_key_; }
 181
 182   std::string GetClientID(OAuth2Client client) const {
 183     DCHECK_LT(client, CLIENT_NUM_ITEMS);
 184     return client_ids_[client];
 185   }
 186
 187   std::string GetClientSecret(OAuth2Client client) const {
 188     DCHECK_LT(client, CLIENT_NUM_ITEMS);
 189     return client_secrets_[client];
 190   }
 191
 192  private:
 193   // Gets a value for a key.  In priority order, this will be the value
 194   // provided via a command-line switch, the value provided via an
 195   // environment variable, or finally a value baked into the build.
 196   // |command_line_switch| may be NULL.
 197   static std::string CalculateKeyValue(const char* baked_in_value,
 198                                        const char* environment_variable_name,
 199                                        const char* command_line_switch,
 200                                        const std::string& default_if_unset,
 201                                        base::Environment* environment,
 202                                        CommandLine* command_line) {
 203     std::string key_value = baked_in_value;
 204     std::string temp;
 205     if (environment->GetVar(environment_variable_name, &temp)) {
 206       key_value = temp;
 207       VLOG(1) << "Overriding API key " << environment_variable_name
 208               << " with value " << key_value << " from environment variable.";
 209     }
 210
 211     if (command_line_switch && command_line->HasSwitch(command_line_switch)) {
 212       key_value = command_line->GetSwitchValueASCII(command_line_switch);
 213       VLOG(1) << "Overriding API key " << environment_variable_name
 214               << " with value " << key_value << " from command-line switch.";
 215     }
 216
 217     if (key_value == DUMMY_API_TOKEN) {
 218 #if defined(GOOGLE_CHROME_BUILD)
 219       // No key should be unset in an official build except the
 220       // GOOGLE_DEFAULT_* keys.  The default keys don't trigger this
 221       // check as their "unset" value is not DUMMY_API_TOKEN.
 222       CHECK(false);
 223 #endif
 224       if (default_if_unset.size() > 0) {
 225         VLOG(1) << "Using default value \"" << default_if_unset
 226                 << "\" for API key " << environment_variable_name;
 227         key_value = default_if_unset;
 228       }
 229     }
 230
 231     // This should remain a debug-only log.
 232     DVLOG(1) << "API key " << environment_variable_name << "=" << key_value;
 233
 234     return key_value;
 235   }
 236
 237   std::string api_key_;
 238   std::string client_ids_[CLIENT_NUM_ITEMS];
 239   std::string client_secrets_[CLIENT_NUM_ITEMS];
 240 };
 241
 242 static base::LazyInstance<APIKeyCache> g_api_key_cache =
 243     LAZY_INSTANCE_INITIALIZER;
 244
 245 bool HasKeysConfigured() {
 246   if (GetAPIKey() == DUMMY_API_TOKEN)
 247     return false;
 248
 249   for (size_t client_id = 0; client_id < CLIENT_NUM_ITEMS; ++client_id) {
 250     OAuth2Client client = static_cast<OAuth2Client>(client_id);
 251     if (GetOAuth2ClientID(client) == DUMMY_API_TOKEN ||
 252         GetOAuth2ClientSecret(client) == DUMMY_API_TOKEN) {
 253       return false;
 254     }
 255   }
 256
 257   return true;
 258 }
 259
 260 std::string GetAPIKey() {
 261   return g_api_key_cache.Get().api_key();
 262 }
 263
 264 std::string GetOAuth2ClientID(OAuth2Client client) {
 265   return g_api_key_cache.Get().GetClientID(client);
 266 }
 267
 268 std::string GetOAuth2ClientSecret(OAuth2Client client) {
 269   return g_api_key_cache.Get().GetClientSecret(client);
 270 }
 271
 272 bool IsGoogleChromeAPIKeyUsed() {
 273 #if defined(GOOGLE_CHROME_BUILD) || defined(USE_OFFICIAL_GOOGLE_API_KEYS)
 274   return true;
 275 #else
 276   return false;
 277 #endif
 278 }
 279
 280 }  // namespace google_apis