Craig Tiller | 42bc87c | 2015-02-23 08:50:19 -0800 | [diff] [blame] | 1 | /* |
| 2 | * |
| 3 | * Copyright 2015, Google Inc. |
| 4 | * All rights reserved. |
| 5 | * |
| 6 | * Redistribution and use in source and binary forms, with or without |
| 7 | * modification, are permitted provided that the following conditions are |
| 8 | * met: |
| 9 | * |
| 10 | * * Redistributions of source code must retain the above copyright |
| 11 | * notice, this list of conditions and the following disclaimer. |
| 12 | * * Redistributions in binary form must reproduce the above |
| 13 | * copyright notice, this list of conditions and the following disclaimer |
| 14 | * in the documentation and/or other materials provided with the |
| 15 | * distribution. |
| 16 | * * Neither the name of Google Inc. nor the names of its |
| 17 | * contributors may be used to endorse or promote products derived from |
| 18 | * this software without specific prior written permission. |
| 19 | * |
| 20 | * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
| 21 | * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
| 22 | * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
| 23 | * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
| 24 | * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| 25 | * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
| 26 | * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| 27 | * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| 28 | * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| 29 | * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| 30 | * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| 31 | * |
| 32 | */ |
| 33 | |
Julien Boeuf | c2274e7 | 2015-08-10 12:45:17 -0700 | [diff] [blame] | 34 | #include <functional> |
| 35 | #include <map> |
| 36 | #include <memory> |
| 37 | |
Julien Boeuf | c2274e7 | 2015-08-10 12:45:17 -0700 | [diff] [blame] | 38 | #include "src/cpp/common/secure_auth_context.h" |
Julien Boeuf | 1d2240c | 2015-04-09 21:07:56 -0700 | [diff] [blame] | 39 | #include "src/cpp/server/secure_server_credentials.h" |
Craig Tiller | 42bc87c | 2015-02-23 08:50:19 -0800 | [diff] [blame] | 40 | |
Julien Boeuf | 5be92a3 | 2015-08-28 16:28:18 -0700 | [diff] [blame] | 41 | #include <grpc++/security/auth_metadata_processor.h> |
Julien Boeuf | c2274e7 | 2015-08-10 12:45:17 -0700 | [diff] [blame] | 42 | |
Craig Tiller | 42bc87c | 2015-02-23 08:50:19 -0800 | [diff] [blame] | 43 | namespace grpc { |
| 44 | |
Craig Tiller | 71a0f9d | 2015-09-28 17:22:01 -0700 | [diff] [blame] | 45 | void AuthMetadataProcessorAyncWrapper::Destroy(void* wrapper) { |
Julien Boeuf | 0c711ad | 2015-08-28 14:10:58 -0700 | [diff] [blame] | 46 | auto* w = reinterpret_cast<AuthMetadataProcessorAyncWrapper*>(wrapper); |
| 47 | delete w; |
| 48 | } |
| 49 | |
Julien Boeuf | c2274e7 | 2015-08-10 12:45:17 -0700 | [diff] [blame] | 50 | void AuthMetadataProcessorAyncWrapper::Process( |
Julien Boeuf | bf25bb0 | 2015-08-14 12:36:11 -0700 | [diff] [blame] | 51 | void* wrapper, grpc_auth_context* context, const grpc_metadata* md, |
| 52 | size_t num_md, grpc_process_auth_metadata_done_cb cb, void* user_data) { |
| 53 | auto* w = reinterpret_cast<AuthMetadataProcessorAyncWrapper*>(wrapper); |
Vijay Pai | e57abcf | 2015-09-29 22:55:34 +0000 | [diff] [blame] | 54 | if (!w->processor_) { |
Julien Boeuf | bf25bb0 | 2015-08-14 12:36:11 -0700 | [diff] [blame] | 55 | // Early exit. |
Julien Boeuf | 5b3516e | 2015-08-26 11:19:10 -0700 | [diff] [blame] | 56 | cb(user_data, nullptr, 0, nullptr, 0, GRPC_STATUS_OK, nullptr); |
Julien Boeuf | bf25bb0 | 2015-08-14 12:36:11 -0700 | [diff] [blame] | 57 | return; |
Julien Boeuf | 5941335 | 2015-08-13 22:03:56 -0700 | [diff] [blame] | 58 | } |
Julien Boeuf | bf25bb0 | 2015-08-14 12:36:11 -0700 | [diff] [blame] | 59 | if (w->processor_->IsBlocking()) { |
| 60 | w->thread_pool_->Add( |
| 61 | std::bind(&AuthMetadataProcessorAyncWrapper::InvokeProcessor, w, |
| 62 | context, md, num_md, cb, user_data)); |
| 63 | } else { |
| 64 | // invoke directly. |
| 65 | w->InvokeProcessor(context, md, num_md, cb, user_data); |
| 66 | } |
Julien Boeuf | c2274e7 | 2015-08-10 12:45:17 -0700 | [diff] [blame] | 67 | } |
| 68 | |
Julien Boeuf | bf25bb0 | 2015-08-14 12:36:11 -0700 | [diff] [blame] | 69 | void AuthMetadataProcessorAyncWrapper::InvokeProcessor( |
Craig Tiller | 71a0f9d | 2015-09-28 17:22:01 -0700 | [diff] [blame] | 70 | grpc_auth_context* ctx, const grpc_metadata* md, size_t num_md, |
Julien Boeuf | c2274e7 | 2015-08-10 12:45:17 -0700 | [diff] [blame] | 71 | grpc_process_auth_metadata_done_cb cb, void* user_data) { |
Julien Boeuf | 35b559f | 2015-08-26 23:17:35 -0700 | [diff] [blame] | 72 | AuthMetadataProcessor::InputMetadata metadata; |
Julien Boeuf | bf25bb0 | 2015-08-14 12:36:11 -0700 | [diff] [blame] | 73 | for (size_t i = 0; i < num_md; i++) { |
| 74 | metadata.insert(std::make_pair( |
Julien Boeuf | 35b559f | 2015-08-26 23:17:35 -0700 | [diff] [blame] | 75 | md[i].key, grpc::string_ref(md[i].value, md[i].value_length))); |
Julien Boeuf | bf25bb0 | 2015-08-14 12:36:11 -0700 | [diff] [blame] | 76 | } |
Julien Boeuf | 0c711ad | 2015-08-28 14:10:58 -0700 | [diff] [blame] | 77 | SecureAuthContext context(ctx, false); |
Julien Boeuf | 35b559f | 2015-08-26 23:17:35 -0700 | [diff] [blame] | 78 | AuthMetadataProcessor::OutputMetadata consumed_metadata; |
| 79 | AuthMetadataProcessor::OutputMetadata response_metadata; |
| 80 | |
| 81 | Status status = processor_->Process(metadata, &context, &consumed_metadata, |
| 82 | &response_metadata); |
| 83 | |
Julien Boeuf | 0c711ad | 2015-08-28 14:10:58 -0700 | [diff] [blame] | 84 | std::vector<grpc_metadata> consumed_md; |
Julien Boeuf | 35b559f | 2015-08-26 23:17:35 -0700 | [diff] [blame] | 85 | for (auto it = consumed_metadata.begin(); it != consumed_metadata.end(); |
| 86 | ++it) { |
Vijay Pai | e57abcf | 2015-09-29 22:55:34 +0000 | [diff] [blame] | 87 | grpc_metadata md_entry; |
| 88 | md_entry.key = it->first.c_str(); |
| 89 | md_entry.value = it->second.data(); |
| 90 | md_entry.value_length = it->second.size(); |
| 91 | md_entry.flags = 0; |
| 92 | consumed_md.push_back(md_entry); |
Julien Boeuf | c2274e7 | 2015-08-10 12:45:17 -0700 | [diff] [blame] | 93 | } |
Julien Boeuf | 0c711ad | 2015-08-28 14:10:58 -0700 | [diff] [blame] | 94 | std::vector<grpc_metadata> response_md; |
Julien Boeuf | 35b559f | 2015-08-26 23:17:35 -0700 | [diff] [blame] | 95 | for (auto it = response_metadata.begin(); it != response_metadata.end(); |
| 96 | ++it) { |
Vijay Pai | e57abcf | 2015-09-29 22:55:34 +0000 | [diff] [blame] | 97 | grpc_metadata md_entry; |
| 98 | md_entry.key = it->first.c_str(); |
| 99 | md_entry.value = it->second.data(); |
| 100 | md_entry.value_length = it->second.size(); |
| 101 | md_entry.flags = 0; |
| 102 | response_md.push_back(md_entry); |
Julien Boeuf | 35b559f | 2015-08-26 23:17:35 -0700 | [diff] [blame] | 103 | } |
yang-g | 61e461e | 2015-09-03 13:08:59 -0700 | [diff] [blame] | 104 | auto consumed_md_data = consumed_md.empty() ? nullptr : &consumed_md[0]; |
| 105 | auto response_md_data = response_md.empty() ? nullptr : &response_md[0]; |
| 106 | cb(user_data, consumed_md_data, consumed_md.size(), response_md_data, |
Julien Boeuf | 35b559f | 2015-08-26 23:17:35 -0700 | [diff] [blame] | 107 | response_md.size(), static_cast<grpc_status_code>(status.error_code()), |
| 108 | status.error_message().c_str()); |
Julien Boeuf | c2274e7 | 2015-08-10 12:45:17 -0700 | [diff] [blame] | 109 | } |
| 110 | |
Craig Tiller | d6c98df | 2015-08-18 09:33:44 -0700 | [diff] [blame] | 111 | int SecureServerCredentials::AddPortToServer(const grpc::string& addr, |
| 112 | grpc_server* server) { |
Julien Boeuf | 1d2240c | 2015-04-09 21:07:56 -0700 | [diff] [blame] | 113 | return grpc_server_add_secure_http2_port(server, addr.c_str(), creds_); |
| 114 | } |
Craig Tiller | 42bc87c | 2015-02-23 08:50:19 -0800 | [diff] [blame] | 115 | |
Julien Boeuf | c2274e7 | 2015-08-10 12:45:17 -0700 | [diff] [blame] | 116 | void SecureServerCredentials::SetAuthMetadataProcessor( |
| 117 | const std::shared_ptr<AuthMetadataProcessor>& processor) { |
Craig Tiller | 71a0f9d | 2015-09-28 17:22:01 -0700 | [diff] [blame] | 118 | auto* wrapper = new AuthMetadataProcessorAyncWrapper(processor); |
Julien Boeuf | c2274e7 | 2015-08-10 12:45:17 -0700 | [diff] [blame] | 119 | grpc_server_credentials_set_auth_metadata_processor( |
Julien Boeuf | 0c711ad | 2015-08-28 14:10:58 -0700 | [diff] [blame] | 120 | creds_, {AuthMetadataProcessorAyncWrapper::Process, |
| 121 | AuthMetadataProcessorAyncWrapper::Destroy, wrapper}); |
Julien Boeuf | c2274e7 | 2015-08-10 12:45:17 -0700 | [diff] [blame] | 122 | } |
| 123 | |
Craig Tiller | 42bc87c | 2015-02-23 08:50:19 -0800 | [diff] [blame] | 124 | std::shared_ptr<ServerCredentials> SslServerCredentials( |
Yang Gao | 6baa9b6 | 2015-03-17 10:49:39 -0700 | [diff] [blame] | 125 | const SslServerCredentialsOptions& options) { |
Craig Tiller | 42bc87c | 2015-02-23 08:50:19 -0800 | [diff] [blame] | 126 | std::vector<grpc_ssl_pem_key_cert_pair> pem_key_cert_pairs; |
Vijay Pai | 82dd80a | 2015-03-24 10:36:08 -0700 | [diff] [blame] | 127 | for (auto key_cert_pair = options.pem_key_cert_pairs.begin(); |
Julien Boeuf | 1d2240c | 2015-04-09 21:07:56 -0700 | [diff] [blame] | 128 | key_cert_pair != options.pem_key_cert_pairs.end(); key_cert_pair++) { |
Vijay Pai | 82dd80a | 2015-03-24 10:36:08 -0700 | [diff] [blame] | 129 | grpc_ssl_pem_key_cert_pair p = {key_cert_pair->private_key.c_str(), |
Julien Boeuf | 1d2240c | 2015-04-09 21:07:56 -0700 | [diff] [blame] | 130 | key_cert_pair->cert_chain.c_str()}; |
Vijay Pai | 82dd80a | 2015-03-24 10:36:08 -0700 | [diff] [blame] | 131 | pem_key_cert_pairs.push_back(p); |
Craig Tiller | 42bc87c | 2015-02-23 08:50:19 -0800 | [diff] [blame] | 132 | } |
Yang Gao | 6baa9b6 | 2015-03-17 10:49:39 -0700 | [diff] [blame] | 133 | grpc_server_credentials* c_creds = grpc_ssl_server_credentials_create( |
Craig Tiller | 42bc87c | 2015-02-23 08:50:19 -0800 | [diff] [blame] | 134 | options.pem_root_certs.empty() ? nullptr : options.pem_root_certs.c_str(), |
yang-g | 61e461e | 2015-09-03 13:08:59 -0700 | [diff] [blame] | 135 | pem_key_cert_pairs.empty() ? nullptr : &pem_key_cert_pairs[0], |
| 136 | pem_key_cert_pairs.size(), options.force_client_auth, nullptr); |
Yang Gao | 6baa9b6 | 2015-03-17 10:49:39 -0700 | [diff] [blame] | 137 | return std::shared_ptr<ServerCredentials>( |
| 138 | new SecureServerCredentials(c_creds)); |
Craig Tiller | 42bc87c | 2015-02-23 08:50:19 -0800 | [diff] [blame] | 139 | } |
| 140 | |
| 141 | } // namespace grpc |