1 // Copyright 2023 Google LLC
2 //
3 // Licensed under the Apache License, Version 2.0 (the "License");
4 // you may not use this file except in compliance with the License.
5 // You may obtain a copy of the License at
6 //
7 // http://www.apache.org/licenses/LICENSE-2.0
8 //
9 // Unless required by applicable law or agreed to in writing, software
10 // distributed under the License is distributed on an "AS IS" BASIS,
11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 // See the License for the specific language governing permissions and
13 // limitations under the License.
14 //
15 ////////////////////////////////////////////////////////////////////////////////
16
17 #include "tink/config/v0.h"
18
19 #include "absl/log/check.h"
20 #include "tink/aead/aead_wrapper.h"
21 #include "tink/aead/aes_ctr_hmac_aead_key_manager.h"
22 #include "tink/aead/aes_eax_key_manager.h"
23 #include "tink/aead/aes_gcm_key_manager.h"
24 #include "tink/aead/aes_gcm_siv_key_manager.h"
25 #include "tink/aead/xchacha20_poly1305_key_manager.h"
26 #include "tink/configuration.h"
27 #include "tink/daead/aes_siv_key_manager.h"
28 #include "tink/daead/deterministic_aead_wrapper.h"
29 #include "tink/hybrid/ecies_aead_hkdf_private_key_manager.h"
30 #include "tink/hybrid/ecies_aead_hkdf_public_key_manager.h"
31 #include "tink/hybrid/hybrid_decrypt_wrapper.h"
32 #include "tink/hybrid/hybrid_encrypt_wrapper.h"
33 #include "tink/hybrid/internal/hpke_private_key_manager.h"
34 #include "tink/hybrid/internal/hpke_public_key_manager.h"
35 #include "tink/internal/configuration_impl.h"
36 #include "tink/mac/aes_cmac_key_manager.h"
37 #include "tink/mac/hmac_key_manager.h"
38 #include "tink/mac/internal/chunked_mac_wrapper.h"
39 #include "tink/mac/mac_wrapper.h"
40 #include "tink/prf/aes_cmac_prf_key_manager.h"
41 #include "tink/prf/hkdf_prf_key_manager.h"
42 #include "tink/prf/hmac_prf_key_manager.h"
43 #include "tink/prf/prf_set_wrapper.h"
44 #include "tink/signature/ecdsa_verify_key_manager.h"
45 #include "tink/signature/ed25519_sign_key_manager.h"
46 #include "tink/signature/ed25519_verify_key_manager.h"
47 #include "tink/signature/public_key_sign_wrapper.h"
48 #include "tink/signature/public_key_verify_wrapper.h"
49 #include "tink/signature/rsa_ssa_pkcs1_sign_key_manager.h"
50 #include "tink/signature/rsa_ssa_pkcs1_verify_key_manager.h"
51 #include "tink/signature/rsa_ssa_pss_sign_key_manager.h"
52 #include "tink/signature/rsa_ssa_pss_verify_key_manager.h"
53 #include "tink/streamingaead/aes_ctr_hmac_streaming_key_manager.h"
54 #include "tink/streamingaead/aes_gcm_hkdf_streaming_key_manager.h"
55 #include "tink/streamingaead/streaming_aead_wrapper.h"
56 #include "tink/signature/ecdsa_sign_key_manager.h"
57
58 namespace crypto {
59 namespace tink {
60 namespace {
61
AddMac(Configuration & config)62 util::Status AddMac(Configuration& config) {
63 util::Status status = internal::ConfigurationImpl::AddPrimitiveWrapper(
64 absl::make_unique<MacWrapper>(), config);
65 if (!status.ok()) {
66 return status;
67 }
68 status = internal::ConfigurationImpl::AddPrimitiveWrapper(
69 absl::make_unique<internal::ChunkedMacWrapper>(), config);
70 if (!status.ok()) {
71 return status;
72 }
73
74 status = internal::ConfigurationImpl::AddKeyTypeManager(
75 absl::make_unique<HmacKeyManager>(), config);
76 if (!status.ok()) {
77 return status;
78 }
79 return internal::ConfigurationImpl::AddKeyTypeManager(
80 absl::make_unique<AesCmacKeyManager>(), config);
81 }
82
AddAead(Configuration & config)83 util::Status AddAead(Configuration& config) {
84 util::Status status = internal::ConfigurationImpl::AddPrimitiveWrapper(
85 absl::make_unique<AeadWrapper>(), config);
86 if (!status.ok()) {
87 return status;
88 }
89
90 status = internal::ConfigurationImpl::AddKeyTypeManager(
91 absl::make_unique<AesCtrHmacAeadKeyManager>(), config);
92 if (!status.ok()) {
93 return status;
94 }
95 status = internal::ConfigurationImpl::AddKeyTypeManager(
96 absl::make_unique<AesGcmKeyManager>(), config);
97 if (!status.ok()) {
98 return status;
99 }
100 status = internal::ConfigurationImpl::AddKeyTypeManager(
101 absl::make_unique<AesGcmSivKeyManager>(), config);
102 if (!status.ok()) {
103 return status;
104 }
105 status = internal::ConfigurationImpl::AddKeyTypeManager(
106 absl::make_unique<AesEaxKeyManager>(), config);
107 if (!status.ok()) {
108 return status;
109 }
110 return internal::ConfigurationImpl::AddKeyTypeManager(
111 absl::make_unique<XChaCha20Poly1305KeyManager>(), config);
112 }
113
AddDeterministicAead(Configuration & config)114 util::Status AddDeterministicAead(Configuration& config) {
115 util::Status status = internal::ConfigurationImpl::AddPrimitiveWrapper(
116 absl::make_unique<DeterministicAeadWrapper>(), config);
117 if (!status.ok()) {
118 return status;
119 }
120
121 return internal::ConfigurationImpl::AddKeyTypeManager(
122 absl::make_unique<AesSivKeyManager>(), config);
123 }
124
AddStreamingAead(Configuration & config)125 util::Status AddStreamingAead(Configuration& config) {
126 util::Status status = internal::ConfigurationImpl::AddPrimitiveWrapper(
127 absl::make_unique<StreamingAeadWrapper>(), config);
128 if (!status.ok()) {
129 return status;
130 }
131
132 status = internal::ConfigurationImpl::AddKeyTypeManager(
133 absl::make_unique<AesGcmHkdfStreamingKeyManager>(), config);
134 if (!status.ok()) {
135 return status;
136 }
137 return internal::ConfigurationImpl::AddKeyTypeManager(
138 absl::make_unique<AesCtrHmacStreamingKeyManager>(), config);
139 }
140
AddHybrid(Configuration & config)141 util::Status AddHybrid(Configuration& config) {
142 util::Status status = internal::ConfigurationImpl::AddPrimitiveWrapper(
143 absl::make_unique<HybridEncryptWrapper>(), config);
144 if (!status.ok()) {
145 return status;
146 }
147 status = internal::ConfigurationImpl::AddPrimitiveWrapper(
148 absl::make_unique<HybridDecryptWrapper>(), config);
149 if (!status.ok()) {
150 return status;
151 }
152
153 status = internal::ConfigurationImpl::AddAsymmetricKeyManagers(
154 absl::make_unique<EciesAeadHkdfPrivateKeyManager>(),
155 absl::make_unique<EciesAeadHkdfPublicKeyManager>(), config);
156 if (!status.ok()) {
157 return status;
158 }
159 return internal::ConfigurationImpl::AddAsymmetricKeyManagers(
160 absl::make_unique<internal::HpkePrivateKeyManager>(),
161 absl::make_unique<internal::HpkePublicKeyManager>(), config);
162 }
163
AddPrf(Configuration & config)164 util::Status AddPrf(Configuration& config) {
165 util::Status status = internal::ConfigurationImpl::AddPrimitiveWrapper(
166 absl::make_unique<PrfSetWrapper>(), config);
167 if (!status.ok()) {
168 return status;
169 }
170
171 status = internal::ConfigurationImpl::AddKeyTypeManager(
172 absl::make_unique<HmacPrfKeyManager>(), config);
173 if (!status.ok()) {
174 return status;
175 }
176 status = internal::ConfigurationImpl::AddKeyTypeManager(
177 absl::make_unique<HkdfPrfKeyManager>(), config);
178 if (!status.ok()) {
179 return status;
180 }
181 return internal::ConfigurationImpl::AddKeyTypeManager(
182 absl::make_unique<AesCmacPrfKeyManager>(), config);
183 }
184
AddSignature(Configuration & config)185 util::Status AddSignature(Configuration& config) {
186 util::Status status = internal::ConfigurationImpl::AddPrimitiveWrapper(
187 absl::make_unique<PublicKeySignWrapper>(), config);
188 if (!status.ok()) {
189 return status;
190 }
191 status = internal::ConfigurationImpl::AddPrimitiveWrapper(
192 absl::make_unique<PublicKeyVerifyWrapper>(), config);
193 if (!status.ok()) {
194 return status;
195 }
196
197 status = internal::ConfigurationImpl::AddAsymmetricKeyManagers(
198 absl::make_unique<EcdsaSignKeyManager>(),
199 absl::make_unique<EcdsaVerifyKeyManager>(), config);
200 if (!status.ok()) {
201 return status;
202 }
203 status = internal::ConfigurationImpl::AddAsymmetricKeyManagers(
204 absl::make_unique<RsaSsaPssSignKeyManager>(),
205 absl::make_unique<RsaSsaPssVerifyKeyManager>(), config);
206 if (!status.ok()) {
207 return status;
208 }
209 status = internal::ConfigurationImpl::AddAsymmetricKeyManagers(
210 absl::make_unique<RsaSsaPkcs1SignKeyManager>(),
211 absl::make_unique<RsaSsaPkcs1VerifyKeyManager>(), config);
212 if (!status.ok()) {
213 return status;
214 }
215 return internal::ConfigurationImpl::AddAsymmetricKeyManagers(
216 absl::make_unique<Ed25519SignKeyManager>(),
217 absl::make_unique<Ed25519VerifyKeyManager>(), config);
218 }
219
220 } // namespace
221
ConfigV0()222 const Configuration& ConfigV0() {
223 static const Configuration* instance = [] {
224 static Configuration* config = new Configuration();
225 CHECK_OK(AddMac(*config));
226 CHECK_OK(AddAead(*config));
227 CHECK_OK(AddDeterministicAead(*config));
228 CHECK_OK(AddStreamingAead(*config));
229 CHECK_OK(AddHybrid(*config));
230 CHECK_OK(AddPrf(*config));
231 CHECK_OK(AddSignature(*config));
232 return config;
233 }();
234 return *instance;
235 }
236
237 } // namespace tink
238 } // namespace crypto
239