5230455705

Committed 10 Jun 2023 02:30PM UTC coverage: 91.715% (-0.03%) from 91.746%

Build # 5230455705

Build Type

push

github

Committed by

randombit

Commit Message

Merge GH #3584 Change clang-format AllowShortFunctionsOnASingleLine config from All to Inline

Run Details

77182 of 84154 relevant lines covered (91.72%)

11975295.43 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

92.0

/src/lib/kdf/kdf.cpp

/*
* KDF Retrieval
* (C) 1999-2007 Jack Lloyd
*
* Botan is released under the Simplified BSD License (see license.txt)
*/

#include <botan/kdf.h>

#include <botan/exceptn.h>
#include <botan/hash.h>
#include <botan/mac.h>
#include <botan/internal/fmt.h>
#include <botan/internal/scan_name.h>

#if defined(BOTAN_HAS_HKDF)
   #include <botan/internal/hkdf.h>
#endif

#if defined(BOTAN_HAS_KDF1)
   #include <botan/internal/kdf1.h>
#endif

#if defined(BOTAN_HAS_KDF2)
   #include <botan/internal/kdf2.h>
#endif

#if defined(BOTAN_HAS_KDF1_18033)
   #include <botan/internal/kdf1_iso18033.h>
#endif

#if defined(BOTAN_HAS_TLS_V12_PRF)
   #include <botan/internal/prf_tls.h>
#endif

#if defined(BOTAN_HAS_X942_PRF)
   #include <botan/internal/prf_x942.h>
#endif

#if defined(BOTAN_HAS_SP800_108)
   #include <botan/internal/sp800_108.h>
#endif

#if defined(BOTAN_HAS_SP800_56A)
   #include <botan/internal/sp800_56a.h>
#endif

#if defined(BOTAN_HAS_SP800_56C)
   #include <botan/internal/sp800_56c.h>
#endif

namespace Botan {

namespace {

template <typename KDF_Type>
std::unique_ptr<KDF> kdf_create_mac_or_hash(std::string_view nm) {
   if(auto mac = MessageAuthenticationCode::create(fmt("HMAC({})", nm))) {
      return std::make_unique<KDF_Type>(std::move(mac));
   }

   if(auto mac = MessageAuthenticationCode::create(nm)) {
      return std::make_unique<KDF_Type>(std::move(mac));
   }

   return nullptr;
}

}  // namespace

std::unique_ptr<KDF> KDF::create(std::string_view algo_spec, std::string_view provider) {
   const SCAN_Name req(algo_spec);

#if defined(BOTAN_HAS_HKDF)
   if(req.algo_name() == "HKDF" && req.arg_count() == 1) {
      if(provider.empty() || provider == "base") {
         return kdf_create_mac_or_hash<HKDF>(req.arg(0));
      }
   }

   if(req.algo_name() == "HKDF-Extract" && req.arg_count() == 1) {
      if(provider.empty() || provider == "base") {
         return kdf_create_mac_or_hash<HKDF_Extract>(req.arg(0));
      }
   }

   if(req.algo_name() == "HKDF-Expand" && req.arg_count() == 1) {
      if(provider.empty() || provider == "base") {
         return kdf_create_mac_or_hash<HKDF_Expand>(req.arg(0));
      }
   }
#endif

#if defined(BOTAN_HAS_KDF2)
   if(req.algo_name() == "KDF2" && req.arg_count() == 1) {
      if(provider.empty() || provider == "base") {
         if(auto hash = HashFunction::create(req.arg(0))) {
            return std::make_unique<KDF2>(std::move(hash));
         }
      }
   }
#endif

#if defined(BOTAN_HAS_KDF1_18033)
   if(req.algo_name() == "KDF1-18033" && req.arg_count() == 1) {
      if(provider.empty() || provider == "base") {
         if(auto hash = HashFunction::create(req.arg(0))) {
            return std::make_unique<KDF1_18033>(std::move(hash));
         }
      }
   }
#endif

#if defined(BOTAN_HAS_KDF1)
   if(req.algo_name() == "KDF1" && req.arg_count() == 1) {
      if(provider.empty() || provider == "base") {
         if(auto hash = HashFunction::create(req.arg(0))) {
            return std::make_unique<KDF1>(std::move(hash));
         }
      }
   }
#endif

#if defined(BOTAN_HAS_TLS_V12_PRF)
   if(req.algo_name() == "TLS-12-PRF" && req.arg_count() == 1) {
      if(provider.empty() || provider == "base") {
         return kdf_create_mac_or_hash<TLS_12_PRF>(req.arg(0));
      }
   }
#endif

#if defined(BOTAN_HAS_X942_PRF)
   if(req.algo_name() == "X9.42-PRF" && req.arg_count() == 1) {
      if(provider.empty() || provider == "base") {
         return std::make_unique<X942_PRF>(req.arg(0));
      }
   }
#endif

#if defined(BOTAN_HAS_SP800_108)
   if(req.algo_name() == "SP800-108-Counter" && req.arg_count() == 1) {
      if(provider.empty() || provider == "base") {
         return kdf_create_mac_or_hash<SP800_108_Counter>(req.arg(0));
      }
   }

   if(req.algo_name() == "SP800-108-Feedback" && req.arg_count() == 1) {
      if(provider.empty() || provider == "base") {
         return kdf_create_mac_or_hash<SP800_108_Feedback>(req.arg(0));
      }
   }

   if(req.algo_name() == "SP800-108-Pipeline" && req.arg_count() == 1) {
      if(provider.empty() || provider == "base") {
         return kdf_create_mac_or_hash<SP800_108_Pipeline>(req.arg(0));
      }
   }
#endif

#if defined(BOTAN_HAS_SP800_56A)
   if(req.algo_name() == "SP800-56A" && req.arg_count() == 1) {
      if(auto hash = HashFunction::create(req.arg(0))) {
         return std::make_unique<SP800_56A_Hash>(std::move(hash));
      }
      if(auto mac = MessageAuthenticationCode::create(req.arg(0))) {
         return std::make_unique<SP800_56A_HMAC>(std::move(mac));
      }
   }
#endif

#if defined(BOTAN_HAS_SP800_56C)
   if(req.algo_name() == "SP800-56C" && req.arg_count() == 1) {
      std::unique_ptr<KDF> exp(kdf_create_mac_or_hash<SP800_108_Feedback>(req.arg(0)));
      if(exp) {
         if(auto mac = MessageAuthenticationCode::create(req.arg(0))) {
            return std::make_unique<SP800_56C>(std::move(mac), std::move(exp));
         }

         if(auto mac = MessageAuthenticationCode::create(fmt("HMAC({})", req.arg(0)))) {
            return std::make_unique<SP800_56C>(std::move(mac), std::move(exp));
         }
      }
   }
#endif

   BOTAN_UNUSED(req);
   BOTAN_UNUSED(provider);

   return nullptr;
}

//static
std::unique_ptr<KDF> KDF::create_or_throw(std::string_view algo, std::string_view provider) {
   if(auto kdf = KDF::create(algo, provider)) {
      return kdf;
   }
   throw Lookup_Error("KDF", algo, provider);
}

std::vector<std::string> KDF::providers(std::string_view algo_spec) {
   return probe_providers_of<KDF>(algo_spec);
}

}  // namespace Botan

1	/*
2	* KDF Retrieval
3	* (C) 1999-2007 Jack Lloyd
4	*
5	* Botan is released under the Simplified BSD License (see license.txt)
6	*/
7
8	#include <botan/kdf.h>
9
10	#include <botan/exceptn.h>
11	#include <botan/hash.h>
12	#include <botan/mac.h>
13	#include <botan/internal/fmt.h>
14	#include <botan/internal/scan_name.h>
15
16	#if defined(BOTAN_HAS_HKDF)
17	#include <botan/internal/hkdf.h>
18	#endif
19
20	#if defined(BOTAN_HAS_KDF1)
21	#include <botan/internal/kdf1.h>
22	#endif
23
24	#if defined(BOTAN_HAS_KDF2)
25	#include <botan/internal/kdf2.h>
26	#endif
27
28	#if defined(BOTAN_HAS_KDF1_18033)
29	#include <botan/internal/kdf1_iso18033.h>
30	#endif
31
32	#if defined(BOTAN_HAS_TLS_V12_PRF)
33	#include <botan/internal/prf_tls.h>
34	#endif
35
36	#if defined(BOTAN_HAS_X942_PRF)
37	#include <botan/internal/prf_x942.h>
38	#endif
39
40	#if defined(BOTAN_HAS_SP800_108)
41	#include <botan/internal/sp800_108.h>
42	#endif
43
44	#if defined(BOTAN_HAS_SP800_56A)
45	#include <botan/internal/sp800_56a.h>
46	#endif
47
48	#if defined(BOTAN_HAS_SP800_56C)
49	#include <botan/internal/sp800_56c.h>
50	#endif
51
52	namespace Botan {
53
54	namespace {
55
56	template <typename KDF_Type>
57	std::unique_ptr<KDF> kdf_create_mac_or_hash(std::string_view nm) {	6,513✔
58	if(auto mac = MessageAuthenticationCode::create(fmt("HMAC({})", nm))) {	18,738✔
59	return std::make_unique<KDF_Type>(std::move(mac));	5,712✔
60	}
61
62	if(auto mac = MessageAuthenticationCode::create(nm)) {	1,602✔
63	return std::make_unique<KDF_Type>(std::move(mac));	801✔
64	}
65
66	return nullptr;	6,513✔
67	}
68
69	} // namespace
70
71	std::unique_ptr<KDF> KDF::create(std::string_view algo_spec, std::string_view provider) {	7,666✔
72	const SCAN_Name req(algo_spec);	7,666✔
73
74	#if defined(BOTAN_HAS_HKDF)
75	if(req.algo_name() == "HKDF" && req.arg_count() == 1) {	22,998✔
76	if(provider.empty() \|\| provider == "base") {	13✔
77	return kdf_create_mac_or_hash<HKDF>(req.arg(0));	26✔
78	}
79	}
80
81	if(req.algo_name() == "HKDF-Extract" && req.arg_count() == 1) {	22,959✔
82	if(provider.empty() \|\| provider == "base") {	12✔
83	return kdf_create_mac_or_hash<HKDF_Extract>(req.arg(0));	24✔
84	}
85	}
86
87	if(req.algo_name() == "HKDF-Expand" && req.arg_count() == 1) {	22,923✔
88	if(provider.empty() \|\| provider == "base") {	12✔
89	return kdf_create_mac_or_hash<HKDF_Expand>(req.arg(0));	24✔
90	}
91	}
92	#endif
93
94	#if defined(BOTAN_HAS_KDF2)
95	if(req.algo_name() == "KDF2" && req.arg_count() == 1) {	22,887✔
96	if(provider.empty() \|\| provider == "base") {	549✔
97	if(auto hash = HashFunction::create(req.arg(0))) {	1,098✔
98	return std::make_unique<KDF2>(std::move(hash));	549✔
99	}	549✔
100	}
101	}
102	#endif
103
104	#if defined(BOTAN_HAS_KDF1_18033)
105	if(req.algo_name() == "KDF1-18033" && req.arg_count() == 1) {	21,240✔
106	if(provider.empty() \|\| provider == "base") {	72✔
107	if(auto hash = HashFunction::create(req.arg(0))) {	144✔
108	return std::make_unique<KDF1_18033>(std::move(hash));	72✔
109	}	72✔
110	}
111	}
112	#endif
113
114	#if defined(BOTAN_HAS_KDF1)
115	if(req.algo_name() == "KDF1" && req.arg_count() == 1) {	21,024✔
116	if(provider.empty() \|\| provider == "base") {	18✔
117	if(auto hash = HashFunction::create(req.arg(0))) {	36✔
118	return std::make_unique<KDF1>(std::move(hash));	18✔
119	}	18✔
120	}
121	}
122	#endif
123
124	#if defined(BOTAN_HAS_TLS_V12_PRF)
125	if(req.algo_name() == "TLS-12-PRF" && req.arg_count() == 1) {	20,970✔
126	if(provider.empty() \|\| provider == "base") {	5,716✔
127	return kdf_create_mac_or_hash<TLS_12_PRF>(req.arg(0));	11,432✔
128	}
129	}
130	#endif
131
132	#if defined(BOTAN_HAS_X942_PRF)
133	if(req.algo_name() == "X9.42-PRF" && req.arg_count() == 1) {	3,822✔
134	if(provider.empty() \|\| provider == "base") {	2✔
135	return std::make_unique<X942_PRF>(req.arg(0));	4✔
136	}
137	}
138	#endif
139
140	#if defined(BOTAN_HAS_SP800_108)
141	if(req.algo_name() == "SP800-108-Counter" && req.arg_count() == 1) {	3,816✔
142	if(provider.empty() \|\| provider == "base") {	240✔
143	return kdf_create_mac_or_hash<SP800_108_Counter>(req.arg(0));	480✔
144	}
145	}
146
147	if(req.algo_name() == "SP800-108-Feedback" && req.arg_count() == 1) {	3,096✔
148	if(provider.empty() \|\| provider == "base") {	240✔
149	return kdf_create_mac_or_hash<SP800_108_Feedback>(req.arg(0));	480✔
150	}
151	}
152
153	if(req.algo_name() == "SP800-108-Pipeline" && req.arg_count() == 1) {	2,376✔
154	if(provider.empty() \|\| provider == "base") {	240✔
155	return kdf_create_mac_or_hash<SP800_108_Pipeline>(req.arg(0));	480✔
156	}
157	}
158	#endif
159
160	#if defined(BOTAN_HAS_SP800_56A)
161	if(req.algo_name() == "SP800-56A" && req.arg_count() == 1) {	1,656✔
162	if(auto hash = HashFunction::create(req.arg(0))) {	960✔
163	return std::make_unique<SP800_56A_Hash>(std::move(hash));	235✔
164	}	235✔
165	if(auto mac = MessageAuthenticationCode::create(req.arg(0))) {	490✔
166	return std::make_unique<SP800_56A_HMAC>(std::move(mac));	245✔
167	}	245✔
168	}
169	#endif
170
171	#if defined(BOTAN_HAS_SP800_56C)
172	if(req.algo_name() == "SP800-56C" && req.arg_count() == 1) {	216✔
173	std::unique_ptr<KDF> exp(kdf_create_mac_or_hash<SP800_108_Feedback>(req.arg(0)));	40✔
174	if(exp) {	40✔
175	if(auto mac = MessageAuthenticationCode::create(req.arg(0))) {	80✔
176	return std::make_unique<SP800_56C>(std::move(mac), std::move(exp));	40✔
177	}	40✔
178
179	if(auto mac = MessageAuthenticationCode::create(fmt("HMAC({})", req.arg(0)))) {	×
180	return std::make_unique<SP800_56C>(std::move(mac), std::move(exp));	×
181	}	×
182	}
183	}	40✔
184	#endif
185
186	BOTAN_UNUSED(req);	32✔
187	BOTAN_UNUSED(provider);	32✔
188
189	return nullptr;	32✔
190	}	7,666✔
191
192	//static
193	std::unique_ptr<KDF> KDF::create_or_throw(std::string_view algo, std::string_view provider) {	6,187✔
194	if(auto kdf = KDF::create(algo, provider)) {	6,187✔
195	return kdf;	6,187✔
196	}	6,187✔
197	throw Lookup_Error("KDF", algo, provider);	×
198	}
199
200	std::vector<std::string> KDF::providers(std::string_view algo_spec) {	×
201	return probe_providers_of<KDF>(algo_spec);	×
202	}
203
204	} // namespace Botan

randombit / botan / 5230455705

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous