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 <mutex>
  23 #include <unordered_map>
  24
  25 #include <grpc/support/log.h>
  26 #include <grpc/support/sync.h>
  27 #include <grpcpp/security/server_credentials.h>
  28
  29 #include "test/core/end2end/data/ssl_test_data.h"
  30
  31 namespace grpc {
  32 namespace testing {
  33 namespace {
  34
  35 class DefaultCredentialsProvider : public CredentialsProvider {
  36  public:
  37   ~DefaultCredentialsProvider() override {}
  38
  39   void AddSecureType(
  40       const grpc::string& type,
  41       std::unique_ptr<CredentialTypeProvider> type_provider) override {
  42     // This clobbers any existing entry for type, except the defaults, which
  43     // can't be clobbered.
  44     std::unique_lock<std::mutex> lock(mu_);
  45     auto it = std::find(added_secure_type_names_.begin(),
  46                         added_secure_type_names_.end(), type);
  47     if (it == added_secure_type_names_.end()) {
  48       added_secure_type_names_.push_back(type);
  49       added_secure_type_providers_.push_back(std::move(type_provider));
  50     } else {
  51       added_secure_type_providers_[it - added_secure_type_names_.begin()] =
  52           std::move(type_provider);
  53     }
  54   }
  55
  56   std::shared_ptr<ChannelCredentials> GetChannelCredentials(
  57       const grpc::string& type, ChannelArguments* args) override {
  58     if (type == grpc::testing::kInsecureCredentialsType) {
  59       return InsecureChannelCredentials();
  60     } else if (type == grpc::testing::kAltsCredentialsType) {
  61       grpc::experimental::AltsCredentialsOptions alts_opts;
  62       return grpc::experimental::AltsCredentials(alts_opts);
  63     } else if (type == grpc::testing::kTlsCredentialsType) {
  64       SslCredentialsOptions ssl_opts = {test_root_cert, "", ""};
  65       args->SetSslTargetNameOverride("foo.test.google.fr");
  66       return grpc::SslCredentials(ssl_opts);
  67     } else if (type == grpc::testing::kGoogleDefaultCredentialsType) {
  68       return grpc::GoogleDefaultCredentials();
  69     } else {
  70       std::unique_lock<std::mutex> lock(mu_);
  71       auto it(std::find(added_secure_type_names_.begin(),
  72                         added_secure_type_names_.end(), type));
  73       if (it == added_secure_type_names_.end()) {
  74         gpr_log(GPR_ERROR, "Unsupported credentials type %s.", type.c_str());
  75         return nullptr;
  76       }
  77       return added_secure_type_providers_[it - added_secure_type_names_.begin()]
  78           ->GetChannelCredentials(args);
  79     }
  80   }
  81
  82   std::shared_ptr<ServerCredentials> GetServerCredentials(
  83       const grpc::string& type) override {
  84     if (type == grpc::testing::kInsecureCredentialsType) {
  85       return InsecureServerCredentials();
  86     } else if (type == grpc::testing::kAltsCredentialsType) {
  87       grpc::experimental::AltsServerCredentialsOptions alts_opts;
  88       return grpc::experimental::AltsServerCredentials(alts_opts);
  89     } else if (type == grpc::testing::kTlsCredentialsType) {
  90       SslServerCredentialsOptions::PemKeyCertPair pkcp = {test_server1_key,
  91                                                           test_server1_cert};
  92       SslServerCredentialsOptions ssl_opts;
  93       ssl_opts.pem_root_certs = "";
  94       ssl_opts.pem_key_cert_pairs.push_back(pkcp);
  95       return SslServerCredentials(ssl_opts);
  96     } else {
  97       std::unique_lock<std::mutex> lock(mu_);
  98       auto it(std::find(added_secure_type_names_.begin(),
  99                         added_secure_type_names_.end(), type));
 100       if (it == added_secure_type_names_.end()) {
 101         gpr_log(GPR_ERROR, "Unsupported credentials type %s.", type.c_str());
 102         return nullptr;
 103       }
 104       return added_secure_type_providers_[it - added_secure_type_names_.begin()]
 105           ->GetServerCredentials();
 106     }
 107   }
 108   std::vector<grpc::string> GetSecureCredentialsTypeList() override {
 109     std::vector<grpc::string> types;
 110     types.push_back(grpc::testing::kTlsCredentialsType);
 111     std::unique_lock<std::mutex> lock(mu_);
 112     for (auto it = added_secure_type_names_.begin();
 113          it != added_secure_type_names_.end(); it++) {
 114       types.push_back(*it);
 115     }
 116     return types;
 117   }
 118
 119  private:
 120   std::mutex mu_;
 121   std::vector<grpc::string> added_secure_type_names_;
 122   std::vector<std::unique_ptr<CredentialTypeProvider>>
 123       added_secure_type_providers_;
 124 };
 125
 126 CredentialsProvider* g_provider = nullptr;
 127
 128 }  // namespace
 129
 130 CredentialsProvider* GetCredentialsProvider() {
 131   if (g_provider == nullptr) {
 132     g_provider = new DefaultCredentialsProvider;
 133   }
 134   return g_provider;
 135 }
 136
 137 void SetCredentialsProvider(CredentialsProvider* provider) {
 138   // For now, forbids overriding provider.
 139   GPR_ASSERT(g_provider == nullptr);
 140   g_provider = provider;
 141 }
 142
 143 }  // namespace testing
 144 }  // namespace grpc