4 * Copyright 2016 gRPC authors.
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
10 * http://www.apache.org/licenses/LICENSE-2.0
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.
20 #include "test/cpp/util/test_credentials_provider.h"
23 #include <unordered_map>
25 #include <grpc/support/log.h>
26 #include <grpc/support/sync.h>
27 #include <grpcpp/security/server_credentials.h>
29 #include "test/core/end2end/data/ssl_test_data.h"
35 class DefaultCredentialsProvider : public CredentialsProvider {
37 ~DefaultCredentialsProvider() override {}
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));
51 added_secure_type_providers_[it - added_secure_type_names_.begin()] =
52 std::move(type_provider);
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();
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());
77 return added_secure_type_providers_[it - added_secure_type_names_.begin()]
78 ->GetChannelCredentials(args);
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,
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);
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());
104 return added_secure_type_providers_[it - added_secure_type_names_.begin()]
105 ->GetServerCredentials();
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);
121 std::vector<grpc::string> added_secure_type_names_;
122 std::vector<std::unique_ptr<CredentialTypeProvider>>
123 added_secure_type_providers_;
126 CredentialsProvider* g_provider = nullptr;
130 CredentialsProvider* GetCredentialsProvider() {
131 if (g_provider == nullptr) {
132 g_provider = new DefaultCredentialsProvider;
137 void SetCredentialsProvider(CredentialsProvider* provider) {
138 // For now, forbids overriding provider.
139 GPR_ASSERT(g_provider == nullptr);
140 g_provider = provider;
143 } // namespace testing