test/cpp/util/test_credentials_provider.cc

   1
   2 /*
   3  *
   4  * Copyright 2016 gRPC authors.
   5  *
   6  * Licensed under the Apache License, Version 2.0 (the "License");
   7  * you may not use this file except in compliance with the License.
   8  * You may obtain a copy of the License at
   9  *
  10  *     http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  * Unless required by applicable law or agreed to in writing, software
  13  * distributed under the License is distributed on an "AS IS" BASIS,
  14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  * See the License for the specific language governing permissions and
  16  * limitations under the License.
  17  *
  18  */
  19
  20 #include "test/cpp/util/test_credentials_provider.h"
  21
  22 #include <cstdio>
  23 #include <fstream>
  24 #include <iostream>
  25 #include <mutex>
  26 #include <unordered_map>
  27
  28 #include "absl/flags/flag.h"
  29
  30 #include <grpc/support/log.h>
  31 #include <grpc/support/sync.h>
  32 #include <grpcpp/security/server_credentials.h>
  33
  34 #include "test/core/end2end/data/ssl_test_data.h"
  35
  36 ABSL_FLAG(std::string, tls_cert_file, "",
  37           "The TLS cert file used when --use_tls=true");
  38 ABSL_FLAG(std::string, tls_key_file, "",
  39           "The TLS key file used when --use_tls=true");
  40
  41 namespace grpc {
  42 namespace testing {
  43 namespace {
  44
  45 std::string ReadFile(const std::string& src_path) {
  46   std::ifstream src;
  47   src.open(src_path, std::ifstream::in | std::ifstream::binary);
  48
  49   std::string contents;
  50   src.seekg(0, std::ios::end);
  51   contents.reserve(src.tellg());
  52   src.seekg(0, std::ios::beg);
  53   contents.assign((std::istreambuf_iterator<char>(src)),
  54                   (std::istreambuf_iterator<char>()));
  55   return contents;
  56 }
  57
  58 class DefaultCredentialsProvider : public CredentialsProvider {
  59  public:
  60   DefaultCredentialsProvider() {
  61     if (!absl::GetFlag(FLAGS_tls_key_file).empty()) {
  62       custom_server_key_ = ReadFile(absl::GetFlag(FLAGS_tls_key_file));
  63     }
  64     if (!absl::GetFlag(FLAGS_tls_cert_file).empty()) {
  65       custom_server_cert_ = ReadFile(absl::GetFlag(FLAGS_tls_cert_file));
  66     }
  67   }
  68   ~DefaultCredentialsProvider() override {}
  69
  70   void AddSecureType(
  71       const std::string& type,
  72       std::unique_ptr<CredentialTypeProvider> type_provider) override {
  73     // This clobbers any existing entry for type, except the defaults, which
  74     // can't be clobbered.
  75     std::unique_lock<std::mutex> lock(mu_);
  76     auto it = std::find(added_secure_type_names_.begin(),
  77                         added_secure_type_names_.end(), type);
  78     if (it == added_secure_type_names_.end()) {
  79       added_secure_type_names_.push_back(type);
  80       added_secure_type_providers_.push_back(std::move(type_provider));
  81     } else {
  82       added_secure_type_providers_[it - added_secure_type_names_.begin()] =
  83           std::move(type_provider);
  84     }
  85   }
  86
  87   std::shared_ptr<ChannelCredentials> GetChannelCredentials(
  88       const std::string& type, ChannelArguments* args) override {
  89     if (type == grpc::testing::kInsecureCredentialsType) {
  90       return InsecureChannelCredentials();
  91     } else if (type == grpc::testing::kAltsCredentialsType) {
  92       grpc::experimental::AltsCredentialsOptions alts_opts;
  93       return grpc::experimental::AltsCredentials(alts_opts);
  94     } else if (type == grpc::testing::kTlsCredentialsType) {
  95       SslCredentialsOptions ssl_opts = {test_root_cert, "", ""};
  96       args->SetSslTargetNameOverride("foo.test.google.fr");
  97       return grpc::SslCredentials(ssl_opts);
  98     } else if (type == grpc::testing::kGoogleDefaultCredentialsType) {
  99       return grpc::GoogleDefaultCredentials();
 100     } else {
 101       std::unique_lock<std::mutex> lock(mu_);
 102       auto it(std::find(added_secure_type_names_.begin(),
 103                         added_secure_type_names_.end(), type));
 104       if (it == added_secure_type_names_.end()) {
 105         gpr_log(GPR_ERROR, "Unsupported credentials type %s.", type.c_str());
 106         return nullptr;
 107       }
 108       return added_secure_type_providers_[it - added_secure_type_names_.begin()]
 109           ->GetChannelCredentials(args);
 110     }
 111   }
 112
 113   std::shared_ptr<ServerCredentials> GetServerCredentials(
 114       const std::string& type) override {
 115     if (type == grpc::testing::kInsecureCredentialsType) {
 116       return InsecureServerCredentials();
 117     } else if (type == grpc::testing::kAltsCredentialsType) {
 118       grpc::experimental::AltsServerCredentialsOptions alts_opts;
 119       return grpc::experimental::AltsServerCredentials(alts_opts);
 120     } else if (type == grpc::testing::kTlsCredentialsType) {
 121       SslServerCredentialsOptions ssl_opts;
 122       ssl_opts.pem_root_certs = "";
 123       if (!custom_server_key_.empty() && !custom_server_cert_.empty()) {
 124         SslServerCredentialsOptions::PemKeyCertPair pkcp = {
 125             custom_server_key_, custom_server_cert_};
 126         ssl_opts.pem_key_cert_pairs.push_back(pkcp);
 127       } else {
 128         SslServerCredentialsOptions::PemKeyCertPair pkcp = {test_server1_key,
 129                                                             test_server1_cert};
 130         ssl_opts.pem_key_cert_pairs.push_back(pkcp);
 131       }
 132       return SslServerCredentials(ssl_opts);
 133     } else {
 134       std::unique_lock<std::mutex> lock(mu_);
 135       auto it(std::find(added_secure_type_names_.begin(),
 136                         added_secure_type_names_.end(), type));
 137       if (it == added_secure_type_names_.end()) {
 138         gpr_log(GPR_ERROR, "Unsupported credentials type %s.", type.c_str());
 139         return nullptr;
 140       }
 141       return added_secure_type_providers_[it - added_secure_type_names_.begin()]
 142           ->GetServerCredentials();
 143     }
 144   }
 145   std::vector<std::string> GetSecureCredentialsTypeList() override {
 146     std::vector<std::string> types;
 147     types.push_back(grpc::testing::kTlsCredentialsType);
 148     std::unique_lock<std::mutex> lock(mu_);
 149     for (auto it = added_secure_type_names_.begin();
 150          it != added_secure_type_names_.end(); it++) {
 151       types.push_back(*it);
 152     }
 153     return types;
 154   }
 155
 156  private:
 157   std::mutex mu_;
 158   std::vector<std::string> added_secure_type_names_;
 159   std::vector<std::unique_ptr<CredentialTypeProvider>>
 160       added_secure_type_providers_;
 161   std::string custom_server_key_;
 162   std::string custom_server_cert_;
 163 };
 164
 165 CredentialsProvider* g_provider = nullptr;
 166
 167 }  // namespace
 168
 169 CredentialsProvider* GetCredentialsProvider() {
 170   if (g_provider == nullptr) {
 171     g_provider = new DefaultCredentialsProvider;
 172   }
 173   return g_provider;
 174 }
 175
 176 void SetCredentialsProvider(CredentialsProvider* provider) {
 177   // For now, forbids overriding provider.
 178   GPR_ASSERT(g_provider == nullptr);
 179   g_provider = provider;
 180 }
 181
 182 }  // namespace testing
 183 }  // namespace grpc