blob: af35450ab75c8fe7f578e8613795327789e98d5f [file] [log] [blame]
Marri Devender Rao5968cae2019-01-21 10:27:12 -06001#pragma once
2
Ed Tanous3ccb3ad2023-01-13 17:40:03 -08003#include "app.hpp"
4#include "async_resp.hpp"
George Liu7a1dbc42022-12-07 16:03:22 +08005#include "dbus_utility.hpp"
Ed Tanous1aa0c2b2022-02-08 12:24:30 +01006#include "http/parsing.hpp"
Ed Tanous3ccb3ad2023-01-13 17:40:03 -08007#include "http_response.hpp"
8#include "query.hpp"
9#include "registries/privilege_registry.hpp"
Krzysztof Grobelny9b12d1f2022-08-11 09:52:56 +020010#include "utils/dbus_utils.hpp"
Ed Tanous3ccb3ad2023-01-13 17:40:03 -080011#include "utils/json_utils.hpp"
12#include "utils/time_utils.hpp"
Krzysztof Grobelny9b12d1f2022-08-11 09:52:56 +020013
Jiaqing Zhao90d2d1e2022-04-13 17:01:57 +080014#include <boost/system/linux_error.hpp>
Ed Tanousef4c65b2023-04-24 15:28:50 -070015#include <boost/url/format.hpp>
Krzysztof Grobelny9b12d1f2022-08-11 09:52:56 +020016#include <sdbusplus/asio/property.hpp>
Ed Tanous3ccb3ad2023-01-13 17:40:03 -080017#include <sdbusplus/bus/match.hpp>
Krzysztof Grobelny9b12d1f2022-08-11 09:52:56 +020018#include <sdbusplus/unpack_properties.hpp>
Gunnar Mills1214b7e2020-06-04 10:11:30 -050019
George Liu7a1dbc42022-12-07 16:03:22 +080020#include <array>
Ed Tanous3ccb3ad2023-01-13 17:40:03 -080021#include <memory>
George Liu7a1dbc42022-12-07 16:03:22 +080022#include <string_view>
23
Marri Devender Rao5968cae2019-01-21 10:27:12 -060024namespace redfish
25{
26namespace certs
27{
Patrick Williams89492a12023-05-10 07:51:34 -050028constexpr const char* certInstallIntf = "xyz.openbmc_project.Certs.Install";
29constexpr const char* certReplaceIntf = "xyz.openbmc_project.Certs.Replace";
30constexpr const char* objDeleteIntf = "xyz.openbmc_project.Object.Delete";
31constexpr const char* certPropIntf = "xyz.openbmc_project.Certs.Certificate";
32constexpr const char* dbusPropIntf = "org.freedesktop.DBus.Properties";
33constexpr const char* dbusObjManagerIntf = "org.freedesktop.DBus.ObjectManager";
34constexpr const char* httpsServiceName =
Marri Devender Rao37cce912019-02-20 01:05:22 -060035 "xyz.openbmc_project.Certs.Manager.Server.Https";
Patrick Williams89492a12023-05-10 07:51:34 -050036constexpr const char* ldapServiceName =
Marri Devender Rao37cce912019-02-20 01:05:22 -060037 "xyz.openbmc_project.Certs.Manager.Client.Ldap";
Patrick Williams89492a12023-05-10 07:51:34 -050038constexpr const char* authorityServiceName =
Michal Orzelb2254cc2023-07-27 14:08:32 +020039 "xyz.openbmc_project.Certs.Manager.Authority.Truststore";
Patrick Williams89492a12023-05-10 07:51:34 -050040constexpr const char* baseObjectPath = "/xyz/openbmc_project/certs";
41constexpr const char* httpsObjectPath =
Jiaqing Zhaoc6a8dfb2022-06-03 10:44:23 +080042 "/xyz/openbmc_project/certs/server/https";
Patrick Williams89492a12023-05-10 07:51:34 -050043constexpr const char* ldapObjectPath = "/xyz/openbmc_project/certs/client/ldap";
44constexpr const char* authorityObjectPath =
Michal Orzelb2254cc2023-07-27 14:08:32 +020045 "/xyz/openbmc_project/certs/authority/truststore";
Marri Devender Rao5968cae2019-01-21 10:27:12 -060046} // namespace certs
47
48/**
49 * The Certificate schema defines a Certificate Service which represents the
50 * actions available to manage certificates and links to where certificates
51 * are installed.
52 */
Marri Devender Rao5968cae2019-01-21 10:27:12 -060053
zhanghch058d1b46d2021-04-01 11:18:24 +080054inline std::string getCertificateFromReqBody(
55 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
56 const crow::Request& req)
Kowalski, Kamil58eb2382019-08-12 11:54:31 +020057{
Ed Tanous1aa0c2b2022-02-08 12:24:30 +010058 nlohmann::json reqJson;
59 JsonParseResult ret = parseRequestAsJson(req, reqJson);
60 if (ret != JsonParseResult::Success)
Kowalski, Kamil58eb2382019-08-12 11:54:31 +020061 {
62 // We did not receive JSON request, proceed as it is RAW data
Ed Tanous33c6b582023-02-14 15:05:48 -080063 return req.body();
Kowalski, Kamil58eb2382019-08-12 11:54:31 +020064 }
65
66 std::string certificate;
67 std::optional<std::string> certificateType = "PEM";
68
Willy Tu15ed6782021-12-14 11:03:16 -080069 if (!json_util::readJsonPatch(req, asyncResp->res, "CertificateString",
70 certificate, "CertificateType",
71 certificateType))
Kowalski, Kamil58eb2382019-08-12 11:54:31 +020072 {
Ed Tanous62598e32023-07-17 17:06:25 -070073 BMCWEB_LOG_ERROR("Required parameters are missing");
Kowalski, Kamil58eb2382019-08-12 11:54:31 +020074 messages::internalError(asyncResp->res);
Ed Tanousabb93cd2021-09-02 14:34:57 -070075 return {};
Kowalski, Kamil58eb2382019-08-12 11:54:31 +020076 }
77
78 if (*certificateType != "PEM")
79 {
80 messages::propertyValueNotInList(asyncResp->res, *certificateType,
81 "CertificateType");
Ed Tanousabb93cd2021-09-02 14:34:57 -070082 return {};
Kowalski, Kamil58eb2382019-08-12 11:54:31 +020083 }
84
85 return certificate;
86}
87
Marri Devender Rao5968cae2019-01-21 10:27:12 -060088/**
89 * Class to create a temporary certificate file for uploading to system
90 */
91class CertificateFile
92{
93 public:
94 CertificateFile() = delete;
Gunnar Mills1214b7e2020-06-04 10:11:30 -050095 CertificateFile(const CertificateFile&) = delete;
96 CertificateFile& operator=(const CertificateFile&) = delete;
97 CertificateFile(CertificateFile&&) = delete;
98 CertificateFile& operator=(CertificateFile&&) = delete;
Ed Tanous4e23a442022-06-06 09:57:26 -070099 explicit CertificateFile(const std::string& certString)
Marri Devender Rao5968cae2019-01-21 10:27:12 -0600100 {
Ed Tanous72d52d22020-10-12 07:46:27 -0700101 std::array<char, 18> dirTemplate = {'/', 't', 'm', 'p', '/', 'C',
Ed Tanous52074382020-09-28 19:16:18 -0700102 'e', 'r', 't', 's', '.', 'X',
103 'X', 'X', 'X', 'X', 'X', '\0'};
104 char* tempDirectory = mkdtemp(dirTemplate.data());
Ed Tanouse662eae2022-01-25 10:39:19 -0800105 if (tempDirectory != nullptr)
Marri Devender Rao5968cae2019-01-21 10:27:12 -0600106 {
107 certDirectory = tempDirectory;
108 certificateFile = certDirectory / "cert.pem";
109 std::ofstream out(certificateFile, std::ofstream::out |
110 std::ofstream::binary |
111 std::ofstream::trunc);
112 out << certString;
113 out.close();
Ed Tanous62598e32023-07-17 17:06:25 -0700114 BMCWEB_LOG_DEBUG("Creating certificate file{}",
115 certificateFile.string());
Marri Devender Rao5968cae2019-01-21 10:27:12 -0600116 }
117 }
118 ~CertificateFile()
119 {
120 if (std::filesystem::exists(certDirectory))
121 {
Ed Tanous62598e32023-07-17 17:06:25 -0700122 BMCWEB_LOG_DEBUG("Removing certificate file{}",
123 certificateFile.string());
Ed Tanous23a21a12020-07-25 04:45:05 +0000124 std::error_code ec;
125 std::filesystem::remove_all(certDirectory, ec);
126 if (ec)
Marri Devender Rao5968cae2019-01-21 10:27:12 -0600127 {
Ed Tanous62598e32023-07-17 17:06:25 -0700128 BMCWEB_LOG_ERROR("Failed to remove temp directory{}",
129 certDirectory.string());
Marri Devender Rao5968cae2019-01-21 10:27:12 -0600130 }
131 }
132 }
133 std::string getCertFilePath()
134 {
135 return certificateFile;
136 }
137
138 private:
139 std::filesystem::path certificateFile;
140 std::filesystem::path certDirectory;
141};
142
143/**
Gunnar Mills4e0453b2020-07-08 14:00:30 -0500144 * @brief Parse and update Certificate Issue/Subject property
Marri Devender Rao5968cae2019-01-21 10:27:12 -0600145 *
146 * @param[in] asyncResp Shared pointer to the response message
147 * @param[in] str Issuer/Subject value in key=value pairs
148 * @param[in] type Issuer/Subject
149 * @return None
150 */
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500151static void updateCertIssuerOrSubject(nlohmann::json& out,
Ed Tanous26ccae32023-02-16 10:28:44 -0800152 std::string_view value)
Marri Devender Rao5968cae2019-01-21 10:27:12 -0600153{
154 // example: O=openbmc-project.xyz,CN=localhost
155 std::string_view::iterator i = value.begin();
156 while (i != value.end())
157 {
158 std::string_view::iterator tokenBegin = i;
159 while (i != value.end() && *i != '=')
160 {
Patrick Williams6da47ba2023-05-11 11:53:56 -0500161 std::advance(i, 1);
Marri Devender Rao5968cae2019-01-21 10:27:12 -0600162 }
163 if (i == value.end())
164 {
165 break;
166 }
Ed Tanous26ccae32023-02-16 10:28:44 -0800167 std::string_view key(tokenBegin, static_cast<size_t>(i - tokenBegin));
Patrick Williams6da47ba2023-05-11 11:53:56 -0500168 std::advance(i, 1);
Marri Devender Rao5968cae2019-01-21 10:27:12 -0600169 tokenBegin = i;
170 while (i != value.end() && *i != ',')
171 {
Patrick Williams6da47ba2023-05-11 11:53:56 -0500172 std::advance(i, 1);
Marri Devender Rao5968cae2019-01-21 10:27:12 -0600173 }
Ed Tanous26ccae32023-02-16 10:28:44 -0800174 std::string_view val(tokenBegin, static_cast<size_t>(i - tokenBegin));
Marri Devender Rao5968cae2019-01-21 10:27:12 -0600175 if (key == "L")
176 {
177 out["City"] = val;
178 }
179 else if (key == "CN")
180 {
181 out["CommonName"] = val;
182 }
183 else if (key == "C")
184 {
185 out["Country"] = val;
186 }
187 else if (key == "O")
188 {
189 out["Organization"] = val;
190 }
191 else if (key == "OU")
192 {
193 out["OrganizationalUnit"] = val;
194 }
195 else if (key == "ST")
196 {
197 out["State"] = val;
198 }
199 // skip comma character
200 if (i != value.end())
201 {
Patrick Williams6da47ba2023-05-11 11:53:56 -0500202 std::advance(i, 1);
Marri Devender Rao5968cae2019-01-21 10:27:12 -0600203 }
204 }
205}
206
207/**
Jiaqing Zhaod3f92ce2022-06-03 11:46:12 +0800208 * @brief Retrieve the installed certificate list
209 *
210 * @param[in] asyncResp Shared pointer to the response message
211 * @param[in] basePath DBus object path to search
212 * @param[in] listPtr Json pointer to the list in asyncResp
213 * @param[in] countPtr Json pointer to the count in asyncResp
214 * @return None
215 */
216static void
217 getCertificateList(const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
218 const std::string& basePath,
219 const nlohmann::json::json_pointer& listPtr,
220 const nlohmann::json::json_pointer& countPtr)
221{
George Liu7a1dbc42022-12-07 16:03:22 +0800222 constexpr std::array<std::string_view, 1> interfaces = {
223 certs::certPropIntf};
224 dbus::utility::getSubTreePaths(
225 basePath, 0, interfaces,
Jiaqing Zhaod3f92ce2022-06-03 11:46:12 +0800226 [asyncResp, listPtr, countPtr](
George Liu7a1dbc42022-12-07 16:03:22 +0800227 const boost::system::error_code& ec,
Jiaqing Zhaod3f92ce2022-06-03 11:46:12 +0800228 const dbus::utility::MapperGetSubTreePathsResponse& certPaths) {
229 if (ec)
230 {
Ed Tanous62598e32023-07-17 17:06:25 -0700231 BMCWEB_LOG_ERROR("Certificate collection query failed: {}", ec);
Jiaqing Zhaod3f92ce2022-06-03 11:46:12 +0800232 messages::internalError(asyncResp->res);
233 return;
234 }
235
236 nlohmann::json& links = asyncResp->res.jsonValue[listPtr];
237 links = nlohmann::json::array();
238 for (const auto& certPath : certPaths)
239 {
240 sdbusplus::message::object_path objPath(certPath);
241 std::string certId = objPath.filename();
242 if (certId.empty())
243 {
Ed Tanous62598e32023-07-17 17:06:25 -0700244 BMCWEB_LOG_ERROR("Invalid certificate objPath {}", certPath);
Jiaqing Zhaod3f92ce2022-06-03 11:46:12 +0800245 continue;
246 }
247
248 boost::urls::url certURL;
249 if (objPath.parent_path() == certs::httpsObjectPath)
250 {
Ed Tanousef4c65b2023-04-24 15:28:50 -0700251 certURL = boost::urls::format(
Ed Tanous253f11b2024-05-16 09:38:31 -0700252 "/redfish/v1/Managers/{}/NetworkProtocol/HTTPS/Certificates/{}",
253 BMCWEB_REDFISH_MANAGER_URI_NAME, certId);
Jiaqing Zhaod3f92ce2022-06-03 11:46:12 +0800254 }
255 else if (objPath.parent_path() == certs::ldapObjectPath)
256 {
Ed Tanousef4c65b2023-04-24 15:28:50 -0700257 certURL = boost::urls::format(
258 "/redfish/v1/AccountService/LDAP/Certificates/{}", certId);
Jiaqing Zhaod3f92ce2022-06-03 11:46:12 +0800259 }
260 else if (objPath.parent_path() == certs::authorityObjectPath)
261 {
Ed Tanousef4c65b2023-04-24 15:28:50 -0700262 certURL = boost::urls::format(
Ed Tanous253f11b2024-05-16 09:38:31 -0700263 "/redfish/v1/Managers/{}/Truststore/Certificates/{}",
264 BMCWEB_REDFISH_MANAGER_URI_NAME, certId);
Jiaqing Zhaod3f92ce2022-06-03 11:46:12 +0800265 }
266 else
267 {
268 continue;
269 }
270
271 nlohmann::json::object_t link;
272 link["@odata.id"] = certURL;
273 links.emplace_back(std::move(link));
274 }
275
276 asyncResp->res.jsonValue[countPtr] = links.size();
Patrick Williams5a39f772023-10-20 11:20:21 -0500277 });
Jiaqing Zhaod3f92ce2022-06-03 11:46:12 +0800278}
279
280/**
Marri Devender Rao5968cae2019-01-21 10:27:12 -0600281 * @brief Retrieve the certificates properties and append to the response
282 * message
283 *
284 * @param[in] asyncResp Shared pointer to the response message
285 * @param[in] objectPath Path of the D-Bus service object
286 * @param[in] certId Id of the certificate
287 * @param[in] certURL URL of the certificate object
288 * @param[in] name name of the certificate
289 * @return None
290 */
291static void getCertificateProperties(
zhanghch058d1b46d2021-04-01 11:18:24 +0800292 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
Jiaqing Zhaoe19e97e2022-06-06 19:43:39 +0800293 const std::string& objectPath, const std::string& service,
Jiaqing Zhao1e312592022-06-14 12:58:09 +0800294 const std::string& certId, const boost::urls::url& certURL,
Jiaqing Zhaoe19e97e2022-06-06 19:43:39 +0800295 const std::string& name)
Marri Devender Rao5968cae2019-01-21 10:27:12 -0600296{
Ed Tanous62598e32023-07-17 17:06:25 -0700297 BMCWEB_LOG_DEBUG("getCertificateProperties Path={} certId={} certURl={}",
298 objectPath, certId, certURL);
Krzysztof Grobelny9b12d1f2022-08-11 09:52:56 +0200299 sdbusplus::asio::getAllProperties(
300 *crow::connections::systemBus, service, objectPath, certs::certPropIntf,
Ed Tanousb9d36b42022-02-26 21:42:46 -0800301 [asyncResp, certURL, certId,
Ed Tanous5e7e2dc2023-02-16 10:37:01 -0800302 name](const boost::system::error_code& ec,
Ed Tanousb9d36b42022-02-26 21:42:46 -0800303 const dbus::utility::DBusPropertiesMap& properties) {
Ed Tanous002d39b2022-05-31 08:59:27 -0700304 if (ec)
305 {
Ed Tanous62598e32023-07-17 17:06:25 -0700306 BMCWEB_LOG_ERROR("DBUS response error: {}", ec);
Jiaqing Zhaod8a5d5d2022-08-05 16:21:51 +0800307 messages::resourceNotFound(asyncResp->res, "Certificate", certId);
Ed Tanous002d39b2022-05-31 08:59:27 -0700308 return;
309 }
Krzysztof Grobelny9b12d1f2022-08-11 09:52:56 +0200310
311 const std::string* certificateString = nullptr;
312 const std::vector<std::string>* keyUsage = nullptr;
313 const std::string* issuer = nullptr;
314 const std::string* subject = nullptr;
315 const uint64_t* validNotAfter = nullptr;
316 const uint64_t* validNotBefore = nullptr;
317
318 const bool success = sdbusplus::unpackPropertiesNoThrow(
319 dbus_utils::UnpackErrorPrinter(), properties, "CertificateString",
320 certificateString, "KeyUsage", keyUsage, "Issuer", issuer,
321 "Subject", subject, "ValidNotAfter", validNotAfter,
322 "ValidNotBefore", validNotBefore);
323
324 if (!success)
325 {
326 messages::internalError(asyncResp->res);
327 return;
328 }
329
Ed Tanous002d39b2022-05-31 08:59:27 -0700330 asyncResp->res.jsonValue["@odata.id"] = certURL;
331 asyncResp->res.jsonValue["@odata.type"] =
332 "#Certificate.v1_0_0.Certificate";
Jiaqing Zhaoe19e97e2022-06-06 19:43:39 +0800333 asyncResp->res.jsonValue["Id"] = certId;
Ed Tanous002d39b2022-05-31 08:59:27 -0700334 asyncResp->res.jsonValue["Name"] = name;
335 asyncResp->res.jsonValue["Description"] = name;
Krzysztof Grobelny9b12d1f2022-08-11 09:52:56 +0200336 asyncResp->res.jsonValue["CertificateString"] = "";
337 asyncResp->res.jsonValue["KeyUsage"] = nlohmann::json::array();
338
339 if (certificateString != nullptr)
Ed Tanous002d39b2022-05-31 08:59:27 -0700340 {
Krzysztof Grobelny9b12d1f2022-08-11 09:52:56 +0200341 asyncResp->res.jsonValue["CertificateString"] = *certificateString;
Ed Tanous002d39b2022-05-31 08:59:27 -0700342 }
Krzysztof Grobelny9b12d1f2022-08-11 09:52:56 +0200343
344 if (keyUsage != nullptr)
345 {
346 asyncResp->res.jsonValue["KeyUsage"] = *keyUsage;
347 }
348
349 if (issuer != nullptr)
350 {
351 updateCertIssuerOrSubject(asyncResp->res.jsonValue["Issuer"],
352 *issuer);
353 }
354
355 if (subject != nullptr)
356 {
357 updateCertIssuerOrSubject(asyncResp->res.jsonValue["Subject"],
358 *subject);
359 }
360
361 if (validNotAfter != nullptr)
362 {
363 asyncResp->res.jsonValue["ValidNotAfter"] =
364 redfish::time_utils::getDateTimeUint(*validNotAfter);
365 }
366
367 if (validNotBefore != nullptr)
368 {
369 asyncResp->res.jsonValue["ValidNotBefore"] =
370 redfish::time_utils::getDateTimeUint(*validNotBefore);
371 }
372
Jiaqing Zhao1e312592022-06-14 12:58:09 +0800373 asyncResp->res.addHeader(
Ed Tanousd9f6c622022-03-17 09:12:17 -0700374 boost::beast::http::field::location,
375 std::string_view(certURL.data(), certURL.size()));
Patrick Williams5a39f772023-10-20 11:20:21 -0500376 });
Marri Devender Rao5968cae2019-01-21 10:27:12 -0600377}
378
Jiaqing Zhao7a3a8f72022-09-29 15:15:58 +0800379static void
380 deleteCertificate(const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
381 const std::string& service,
382 const sdbusplus::message::object_path& objectPath)
383{
384 crow::connections::systemBus->async_method_call(
385 [asyncResp,
Ed Tanous5e7e2dc2023-02-16 10:37:01 -0800386 id{objectPath.filename()}](const boost::system::error_code& ec) {
Jiaqing Zhao7a3a8f72022-09-29 15:15:58 +0800387 if (ec)
388 {
389 messages::resourceNotFound(asyncResp->res, "Certificate", id);
390 return;
391 }
Ed Tanous62598e32023-07-17 17:06:25 -0700392 BMCWEB_LOG_INFO("Certificate deleted");
Jiaqing Zhao7a3a8f72022-09-29 15:15:58 +0800393 asyncResp->res.result(boost::beast::http::status::no_content);
Patrick Williams5a39f772023-10-20 11:20:21 -0500394 },
Jiaqing Zhao7a3a8f72022-09-29 15:15:58 +0800395 service, objectPath, certs::objDeleteIntf, "Delete");
396}
397
Jiaqing Zhao828252d2022-09-30 13:59:19 +0800398inline void handleCertificateServiceGet(
399 App& app, const crow::Request& req,
400 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp)
Marri Devender Rao5968cae2019-01-21 10:27:12 -0600401{
Jiaqing Zhao828252d2022-09-30 13:59:19 +0800402 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
403 {
404 return;
405 }
406
Ninad Palsule3e72c202023-03-27 17:19:55 -0500407 if (req.session == nullptr)
408 {
409 messages::internalError(asyncResp->res);
410 return;
411 }
412
Jiaqing Zhao828252d2022-09-30 13:59:19 +0800413 asyncResp->res.jsonValue["@odata.type"] =
414 "#CertificateService.v1_0_0.CertificateService";
415 asyncResp->res.jsonValue["@odata.id"] = "/redfish/v1/CertificateService";
416 asyncResp->res.jsonValue["Id"] = "CertificateService";
417 asyncResp->res.jsonValue["Name"] = "Certificate Service";
418 asyncResp->res.jsonValue["Description"] =
419 "Actions available to manage certificates";
420 // /redfish/v1/CertificateService/CertificateLocations is something
421 // only ConfigureManager can access then only display when the user
422 // has permissions ConfigureManager
423 Privileges effectiveUserPrivileges =
Ninad Palsule3e72c202023-03-27 17:19:55 -0500424 redfish::getUserPrivileges(*req.session);
Jiaqing Zhao828252d2022-09-30 13:59:19 +0800425 if (isOperationAllowedWithPrivileges({{"ConfigureManager"}},
426 effectiveUserPrivileges))
427 {
428 asyncResp->res.jsonValue["CertificateLocations"]["@odata.id"] =
429 "/redfish/v1/CertificateService/CertificateLocations";
430 }
431 nlohmann::json& actions = asyncResp->res.jsonValue["Actions"];
432 nlohmann::json& replace = actions["#CertificateService.ReplaceCertificate"];
433 replace["target"] =
434 "/redfish/v1/CertificateService/Actions/CertificateService.ReplaceCertificate";
435 nlohmann::json::array_t allowed;
Patrick Williamsad539542023-05-12 10:10:08 -0500436 allowed.emplace_back("PEM");
Jiaqing Zhao828252d2022-09-30 13:59:19 +0800437 replace["CertificateType@Redfish.AllowableValues"] = std::move(allowed);
438 actions["#CertificateService.GenerateCSR"]["target"] =
439 "/redfish/v1/CertificateService/Actions/CertificateService.GenerateCSR";
440}
441
442inline void handleCertificateLocationsGet(
443 App& app, const crow::Request& req,
444 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp)
445{
446 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
447 {
448 return;
449 }
450 asyncResp->res.jsonValue["@odata.id"] =
451 "/redfish/v1/CertificateService/CertificateLocations";
452 asyncResp->res.jsonValue["@odata.type"] =
453 "#CertificateLocations.v1_0_0.CertificateLocations";
454 asyncResp->res.jsonValue["Name"] = "Certificate Locations";
455 asyncResp->res.jsonValue["Id"] = "CertificateLocations";
456 asyncResp->res.jsonValue["Description"] =
457 "Defines a resource that an administrator can use in order to "
458 "locate all certificates installed on a given service";
459
460 getCertificateList(asyncResp, certs::baseObjectPath,
461 "/Links/Certificates"_json_pointer,
462 "/Links/Certificates@odata.count"_json_pointer);
463}
464
465inline void handleReplaceCertificateAction(
466 App& app, const crow::Request& req,
467 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp)
468{
469 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
470 {
471 return;
472 }
473 std::string certificate;
Ed Tanous7a31e332024-03-06 12:17:43 -0800474 std::string certURI;
Jiaqing Zhao828252d2022-09-30 13:59:19 +0800475 std::optional<std::string> certificateType = "PEM";
476
477 if (!json_util::readJsonAction(req, asyncResp->res, "CertificateString",
Ed Tanous7a31e332024-03-06 12:17:43 -0800478 certificate, "CertificateUri/@odata.id",
479 certURI, "CertificateType", certificateType))
Jiaqing Zhao828252d2022-09-30 13:59:19 +0800480 {
Ed Tanous62598e32023-07-17 17:06:25 -0700481 BMCWEB_LOG_ERROR("Required parameters are missing");
Jiaqing Zhao828252d2022-09-30 13:59:19 +0800482 return;
483 }
484
485 if (!certificateType)
486 {
487 // should never happen, but it never hurts to be paranoid.
488 return;
489 }
490 if (certificateType != "PEM")
491 {
492 messages::actionParameterNotSupported(asyncResp->res, "CertificateType",
493 "ReplaceCertificate");
494 return;
495 }
496
Ed Tanous62598e32023-07-17 17:06:25 -0700497 BMCWEB_LOG_INFO("Certificate URI to replace: {}", certURI);
Jiaqing Zhao828252d2022-09-30 13:59:19 +0800498
Ed Tanous6fd29552023-10-04 09:40:14 -0700499 boost::system::result<boost::urls::url> parsedUrl =
Jiaqing Zhao828252d2022-09-30 13:59:19 +0800500 boost::urls::parse_relative_ref(certURI);
501 if (!parsedUrl)
502 {
503 messages::actionParameterValueFormatError(
504 asyncResp->res, certURI, "CertificateUri", "ReplaceCertificate");
505 return;
506 }
507
508 std::string id;
509 sdbusplus::message::object_path objectPath;
510 std::string name;
511 std::string service;
512 if (crow::utility::readUrlSegments(*parsedUrl, "redfish", "v1", "Managers",
513 "bmc", "NetworkProtocol", "HTTPS",
514 "Certificates", std::ref(id)))
515 {
Patrick Williams89492a12023-05-10 07:51:34 -0500516 objectPath = sdbusplus::message::object_path(certs::httpsObjectPath) /
517 id;
Jiaqing Zhao828252d2022-09-30 13:59:19 +0800518 name = "HTTPS certificate";
519 service = certs::httpsServiceName;
520 }
521 else if (crow::utility::readUrlSegments(*parsedUrl, "redfish", "v1",
522 "AccountService", "LDAP",
523 "Certificates", std::ref(id)))
524 {
Patrick Williams89492a12023-05-10 07:51:34 -0500525 objectPath = sdbusplus::message::object_path(certs::ldapObjectPath) /
526 id;
Jiaqing Zhao828252d2022-09-30 13:59:19 +0800527 name = "LDAP certificate";
528 service = certs::ldapServiceName;
529 }
530 else if (crow::utility::readUrlSegments(*parsedUrl, "redfish", "v1",
531 "Managers", "bmc", "Truststore",
532 "Certificates", std::ref(id)))
533 {
534 objectPath =
535 sdbusplus::message::object_path(certs::authorityObjectPath) / id;
536 name = "TrustStore certificate";
537 service = certs::authorityServiceName;
538 }
539 else
540 {
541 messages::actionParameterNotSupported(asyncResp->res, "CertificateUri",
542 "ReplaceCertificate");
543 return;
544 }
545
546 std::shared_ptr<CertificateFile> certFile =
547 std::make_shared<CertificateFile>(certificate);
548 crow::connections::systemBus->async_method_call(
549 [asyncResp, certFile, objectPath, service, url{*parsedUrl}, id,
Ed Tanous5e7e2dc2023-02-16 10:37:01 -0800550 name](const boost::system::error_code& ec) {
Jiaqing Zhao828252d2022-09-30 13:59:19 +0800551 if (ec)
552 {
Ed Tanous62598e32023-07-17 17:06:25 -0700553 BMCWEB_LOG_ERROR("DBUS response error: {}", ec);
Jiaqing Zhao828252d2022-09-30 13:59:19 +0800554 if (ec.value() ==
555 boost::system::linux_error::bad_request_descriptor)
556 {
557 messages::resourceNotFound(asyncResp->res, "Certificate", id);
558 return;
559 }
560 messages::internalError(asyncResp->res);
561 return;
562 }
563 getCertificateProperties(asyncResp, objectPath, service, id, url, name);
Ed Tanous62598e32023-07-17 17:06:25 -0700564 BMCWEB_LOG_DEBUG("HTTPS certificate install file={}",
565 certFile->getCertFilePath());
Patrick Williams5a39f772023-10-20 11:20:21 -0500566 },
Jiaqing Zhao828252d2022-09-30 13:59:19 +0800567 service, objectPath, certs::certReplaceIntf, "Replace",
568 certFile->getCertFilePath());
569}
570
Ed Tanouscf9e4172022-12-21 09:30:16 -0800571// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
Jiaqing Zhao828252d2022-09-30 13:59:19 +0800572static std::unique_ptr<sdbusplus::bus::match_t> csrMatcher;
573/**
574 * @brief Read data from CSR D-bus object and set to response
575 *
576 * @param[in] asyncResp Shared pointer to the response message
Ed Tanous8ece0e42024-01-02 13:16:50 -0800577 * @param[in] certURI Link to certificate collection URI
Jiaqing Zhao828252d2022-09-30 13:59:19 +0800578 * @param[in] service D-Bus service name
579 * @param[in] certObjPath certificate D-Bus object path
580 * @param[in] csrObjPath CSR D-Bus object path
581 * @return None
582 */
583static void getCSR(const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
584 const std::string& certURI, const std::string& service,
585 const std::string& certObjPath,
586 const std::string& csrObjPath)
587{
Ed Tanous62598e32023-07-17 17:06:25 -0700588 BMCWEB_LOG_DEBUG("getCSR CertObjectPath{} CSRObjectPath={} service={}",
589 certObjPath, csrObjPath, service);
Jiaqing Zhao828252d2022-09-30 13:59:19 +0800590 crow::connections::systemBus->async_method_call(
Ed Tanous5e7e2dc2023-02-16 10:37:01 -0800591 [asyncResp, certURI](const boost::system::error_code& ec,
Jiaqing Zhao828252d2022-09-30 13:59:19 +0800592 const std::string& csr) {
593 if (ec)
594 {
Ed Tanous62598e32023-07-17 17:06:25 -0700595 BMCWEB_LOG_ERROR("DBUS response error: {}", ec);
Jiaqing Zhao828252d2022-09-30 13:59:19 +0800596 messages::internalError(asyncResp->res);
597 return;
598 }
599 if (csr.empty())
600 {
Ed Tanous62598e32023-07-17 17:06:25 -0700601 BMCWEB_LOG_ERROR("CSR read is empty");
Jiaqing Zhao828252d2022-09-30 13:59:19 +0800602 messages::internalError(asyncResp->res);
603 return;
604 }
605 asyncResp->res.jsonValue["CSRString"] = csr;
606 asyncResp->res.jsonValue["CertificateCollection"]["@odata.id"] =
607 certURI;
Patrick Williams5a39f772023-10-20 11:20:21 -0500608 },
Jiaqing Zhao828252d2022-09-30 13:59:19 +0800609 service, csrObjPath, "xyz.openbmc_project.Certs.CSR", "CSR");
610}
611
612inline void
613 handleGenerateCSRAction(App& app, const crow::Request& req,
614 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp)
615{
616 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
617 {
618 return;
619 }
620 static const int rsaKeyBitLength = 2048;
621
622 // Required parameters
623 std::string city;
624 std::string commonName;
625 std::string country;
626 std::string organization;
627 std::string organizationalUnit;
628 std::string state;
Ed Tanous7a31e332024-03-06 12:17:43 -0800629 std::string certURI;
Jiaqing Zhao828252d2022-09-30 13:59:19 +0800630
631 // Optional parameters
632 std::optional<std::vector<std::string>> optAlternativeNames =
633 std::vector<std::string>();
634 std::optional<std::string> optContactPerson = "";
635 std::optional<std::string> optChallengePassword = "";
636 std::optional<std::string> optEmail = "";
637 std::optional<std::string> optGivenName = "";
638 std::optional<std::string> optInitials = "";
639 std::optional<int64_t> optKeyBitLength = rsaKeyBitLength;
640 std::optional<std::string> optKeyCurveId = "secp384r1";
641 std::optional<std::string> optKeyPairAlgorithm = "EC";
642 std::optional<std::vector<std::string>> optKeyUsage =
643 std::vector<std::string>();
644 std::optional<std::string> optSurname = "";
645 std::optional<std::string> optUnstructuredName = "";
646 if (!json_util::readJsonAction(
647 req, asyncResp->res, "City", city, "CommonName", commonName,
648 "ContactPerson", optContactPerson, "Country", country,
649 "Organization", organization, "OrganizationalUnit",
Ed Tanous7a31e332024-03-06 12:17:43 -0800650 organizationalUnit, "State", state,
651 "CertificateCollection/@odata.id", certURI, "AlternativeNames",
652 optAlternativeNames, "ChallengePassword", optChallengePassword,
653 "Email", optEmail, "GivenName", optGivenName, "Initials",
654 optInitials, "KeyBitLength", optKeyBitLength, "KeyCurveId",
655 optKeyCurveId, "KeyPairAlgorithm", optKeyPairAlgorithm, "KeyUsage",
656 optKeyUsage, "Surname", optSurname, "UnstructuredName",
657 optUnstructuredName))
Jiaqing Zhao828252d2022-09-30 13:59:19 +0800658 {
659 return;
660 }
661
662 // bmcweb has no way to store or decode a private key challenge
663 // password, which will likely cause bmcweb to crash on startup
664 // if this is not set on a post so not allowing the user to set
665 // value
666 if (!optChallengePassword->empty())
667 {
668 messages::actionParameterNotSupported(asyncResp->res, "GenerateCSR",
669 "ChallengePassword");
670 return;
671 }
672
Jiaqing Zhao828252d2022-09-30 13:59:19 +0800673 std::string objectPath;
674 std::string service;
Ed Tanous253f11b2024-05-16 09:38:31 -0700675 if (certURI.starts_with(std::format(
676 "/redfish/v1/Managers/{}/NetworkProtocol/HTTPS/Certificates",
677 BMCWEB_REDFISH_MANAGER_URI_NAME)))
Jiaqing Zhao828252d2022-09-30 13:59:19 +0800678 {
679 objectPath = certs::httpsObjectPath;
680 service = certs::httpsServiceName;
681 }
682 else if (certURI.starts_with(
683 "/redfish/v1/AccountService/LDAP/Certificates"))
684 {
685 objectPath = certs::ldapObjectPath;
686 service = certs::ldapServiceName;
687 }
688 else
689 {
690 messages::actionParameterNotSupported(
691 asyncResp->res, "CertificateCollection", "GenerateCSR");
692 return;
693 }
694
695 // supporting only EC and RSA algorithm
696 if (*optKeyPairAlgorithm != "EC" && *optKeyPairAlgorithm != "RSA")
697 {
698 messages::actionParameterNotSupported(
699 asyncResp->res, "KeyPairAlgorithm", "GenerateCSR");
700 return;
701 }
702
703 // supporting only 2048 key bit length for RSA algorithm due to
704 // time consumed in generating private key
705 if (*optKeyPairAlgorithm == "RSA" && *optKeyBitLength != rsaKeyBitLength)
706 {
Ed Tanouse2616cc2022-06-27 12:45:55 -0700707 messages::propertyValueNotInList(asyncResp->res, *optKeyBitLength,
708 "KeyBitLength");
Jiaqing Zhao828252d2022-09-30 13:59:19 +0800709 return;
710 }
711
712 // validate KeyUsage supporting only 1 type based on URL
Ed Tanous253f11b2024-05-16 09:38:31 -0700713 if (certURI.starts_with(std::format(
714 "/redfish/v1/Managers/{}/NetworkProtocol/HTTPS/Certificates",
715 BMCWEB_REDFISH_MANAGER_URI_NAME)))
Jiaqing Zhao828252d2022-09-30 13:59:19 +0800716 {
717 if (optKeyUsage->empty())
718 {
Patrick Williamsb2ba3072023-05-12 10:27:39 -0500719 optKeyUsage->emplace_back("ServerAuthentication");
Jiaqing Zhao828252d2022-09-30 13:59:19 +0800720 }
721 else if (optKeyUsage->size() == 1)
722 {
723 if ((*optKeyUsage)[0] != "ServerAuthentication")
724 {
725 messages::propertyValueNotInList(asyncResp->res,
726 (*optKeyUsage)[0], "KeyUsage");
727 return;
728 }
729 }
730 else
731 {
732 messages::actionParameterNotSupported(asyncResp->res, "KeyUsage",
733 "GenerateCSR");
734 return;
735 }
736 }
737 else if (certURI.starts_with(
738 "/redfish/v1/AccountService/LDAP/Certificates"))
739 {
740 if (optKeyUsage->empty())
741 {
Patrick Williamsb2ba3072023-05-12 10:27:39 -0500742 optKeyUsage->emplace_back("ClientAuthentication");
Jiaqing Zhao828252d2022-09-30 13:59:19 +0800743 }
744 else if (optKeyUsage->size() == 1)
745 {
746 if ((*optKeyUsage)[0] != "ClientAuthentication")
747 {
748 messages::propertyValueNotInList(asyncResp->res,
749 (*optKeyUsage)[0], "KeyUsage");
750 return;
751 }
752 }
753 else
754 {
755 messages::actionParameterNotSupported(asyncResp->res, "KeyUsage",
756 "GenerateCSR");
757 return;
758 }
759 }
760
761 // Only allow one CSR matcher at a time so setting retry
762 // time-out and timer expiry to 10 seconds for now.
763 static const int timeOut = 10;
764 if (csrMatcher)
765 {
766 messages::serviceTemporarilyUnavailable(asyncResp->res,
767 std::to_string(timeOut));
768 return;
769 }
770
Ed Tanous8e8245d2024-04-11 22:21:38 -0700771 if (req.ioService == nullptr)
772 {
773 messages::internalError(asyncResp->res);
774 return;
775 }
776
Jiaqing Zhao828252d2022-09-30 13:59:19 +0800777 // Make this static so it survives outside this method
778 static boost::asio::steady_timer timeout(*req.ioService);
779 timeout.expires_after(std::chrono::seconds(timeOut));
780 timeout.async_wait([asyncResp](const boost::system::error_code& ec) {
781 csrMatcher = nullptr;
782 if (ec)
783 {
784 // operation_aborted is expected if timer is canceled
785 // before completion.
786 if (ec != boost::asio::error::operation_aborted)
787 {
Ed Tanous62598e32023-07-17 17:06:25 -0700788 BMCWEB_LOG_ERROR("Async_wait failed {}", ec);
Jiaqing Zhao828252d2022-09-30 13:59:19 +0800789 }
790 return;
791 }
Ed Tanous62598e32023-07-17 17:06:25 -0700792 BMCWEB_LOG_ERROR("Timed out waiting for Generating CSR");
Jiaqing Zhao828252d2022-09-30 13:59:19 +0800793 messages::internalError(asyncResp->res);
794 });
795
796 // create a matcher to wait on CSR object
Ed Tanous62598e32023-07-17 17:06:25 -0700797 BMCWEB_LOG_DEBUG("create matcher with path {}", objectPath);
Jiaqing Zhao828252d2022-09-30 13:59:19 +0800798 std::string match("type='signal',"
799 "interface='org.freedesktop.DBus.ObjectManager',"
800 "path='" +
801 objectPath +
802 "',"
803 "member='InterfacesAdded'");
804 csrMatcher = std::make_unique<sdbusplus::bus::match_t>(
805 *crow::connections::systemBus, match,
806 [asyncResp, service, objectPath, certURI](sdbusplus::message_t& m) {
807 timeout.cancel();
808 if (m.is_method_error())
809 {
Ed Tanous62598e32023-07-17 17:06:25 -0700810 BMCWEB_LOG_ERROR("Dbus method error!!!");
Jiaqing Zhao828252d2022-09-30 13:59:19 +0800811 messages::internalError(asyncResp->res);
812 return;
813 }
814
Michael Shen80f79a42023-08-24 13:41:53 +0000815 dbus::utility::DBusInterfacesMap interfacesProperties;
Jiaqing Zhao828252d2022-09-30 13:59:19 +0800816
817 sdbusplus::message::object_path csrObjectPath;
818 m.read(csrObjectPath, interfacesProperties);
Ed Tanous62598e32023-07-17 17:06:25 -0700819 BMCWEB_LOG_DEBUG("CSR object added{}", csrObjectPath.str);
Jiaqing Zhao828252d2022-09-30 13:59:19 +0800820 for (const auto& interface : interfacesProperties)
821 {
822 if (interface.first == "xyz.openbmc_project.Certs.CSR")
823 {
824 getCSR(asyncResp, certURI, service, objectPath,
825 csrObjectPath.str);
826 break;
827 }
828 }
Patrick Williams5a39f772023-10-20 11:20:21 -0500829 });
Jiaqing Zhao828252d2022-09-30 13:59:19 +0800830 crow::connections::systemBus->async_method_call(
Ed Tanous5e7e2dc2023-02-16 10:37:01 -0800831 [asyncResp](const boost::system::error_code& ec, const std::string&) {
Jiaqing Zhao828252d2022-09-30 13:59:19 +0800832 if (ec)
833 {
Ed Tanous62598e32023-07-17 17:06:25 -0700834 BMCWEB_LOG_ERROR("DBUS response error: {}", ec.message());
Jiaqing Zhao828252d2022-09-30 13:59:19 +0800835 messages::internalError(asyncResp->res);
836 return;
837 }
Patrick Williams5a39f772023-10-20 11:20:21 -0500838 },
Jiaqing Zhao828252d2022-09-30 13:59:19 +0800839 service, objectPath, "xyz.openbmc_project.Certs.CSR.Create",
840 "GenerateCSR", *optAlternativeNames, *optChallengePassword, city,
841 commonName, *optContactPerson, country, *optEmail, *optGivenName,
842 *optInitials, *optKeyBitLength, *optKeyCurveId, *optKeyPairAlgorithm,
843 *optKeyUsage, organization, organizationalUnit, state, *optSurname,
844 *optUnstructuredName);
845}
846
847inline void requestRoutesCertificateService(App& app)
848{
849 BMCWEB_ROUTE(app, "/redfish/v1/CertificateService/")
850 .privileges(redfish::privileges::getCertificateService)
851 .methods(boost::beast::http::verb::get)(
852 std::bind_front(handleCertificateServiceGet, std::ref(app)));
853
854 BMCWEB_ROUTE(app, "/redfish/v1/CertificateService/CertificateLocations/")
855 .privileges(redfish::privileges::getCertificateLocations)
856 .methods(boost::beast::http::verb::get)(
857 std::bind_front(handleCertificateLocationsGet, std::ref(app)));
858
George Liu0fda0f12021-11-16 10:06:17 +0800859 BMCWEB_ROUTE(
860 app,
861 "/redfish/v1/CertificateService/Actions/CertificateService.ReplaceCertificate/")
Ed Tanoused398212021-06-09 17:05:54 -0700862 .privileges(redfish::privileges::postCertificateService)
Ed Tanous002d39b2022-05-31 08:59:27 -0700863 .methods(boost::beast::http::verb::post)(
Jiaqing Zhao828252d2022-09-30 13:59:19 +0800864 std::bind_front(handleReplaceCertificateAction, std::ref(app)));
Marri Devender Rao5968cae2019-01-21 10:27:12 -0600865
Jiaqing Zhao828252d2022-09-30 13:59:19 +0800866 BMCWEB_ROUTE(
867 app,
868 "/redfish/v1/CertificateService/Actions/CertificateService.GenerateCSR/")
869 .privileges(redfish::privileges::postCertificateService)
870 .methods(boost::beast::http::verb::post)(
871 std::bind_front(handleGenerateCSRAction, std::ref(app)));
872} // requestRoutesCertificateService
873
874inline void handleHTTPSCertificateCollectionGet(
875 App& app, const crow::Request& req,
Ed Tanous253f11b2024-05-16 09:38:31 -0700876 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
877 const std::string& managerId)
Jiaqing Zhao828252d2022-09-30 13:59:19 +0800878{
879 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
880 {
881 return;
882 }
883
Ed Tanous253f11b2024-05-16 09:38:31 -0700884 if (managerId != BMCWEB_REDFISH_MANAGER_URI_NAME)
885 {
886 messages::resourceNotFound(asyncResp->res, "Manager", managerId);
887 return;
888 }
889
890 asyncResp->res.jsonValue["@odata.id"] = boost::urls::format(
891 "/redfish/v1/Managers/{}/NetworkProtocol/HTTPS/Certificates",
892 BMCWEB_REDFISH_MANAGER_URI_NAME);
Jiaqing Zhao828252d2022-09-30 13:59:19 +0800893 asyncResp->res.jsonValue["@odata.type"] =
894 "#CertificateCollection.CertificateCollection";
895 asyncResp->res.jsonValue["Name"] = "HTTPS Certificates Collection";
896 asyncResp->res.jsonValue["Description"] =
897 "A Collection of HTTPS certificate instances";
898
899 getCertificateList(asyncResp, certs::httpsObjectPath,
900 "/Members"_json_pointer,
901 "/Members@odata.count"_json_pointer);
902}
903
904inline void handleHTTPSCertificateCollectionPost(
905 App& app, const crow::Request& req,
Ed Tanous253f11b2024-05-16 09:38:31 -0700906 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
907 const std::string& managerId)
Jiaqing Zhao828252d2022-09-30 13:59:19 +0800908{
909 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
910 {
911 return;
912 }
Ed Tanous253f11b2024-05-16 09:38:31 -0700913
914 if (managerId != BMCWEB_REDFISH_MANAGER_URI_NAME)
915 {
916 messages::resourceNotFound(asyncResp->res, "Manager", managerId);
917 return;
918 }
919
Ed Tanous62598e32023-07-17 17:06:25 -0700920 BMCWEB_LOG_DEBUG("HTTPSCertificateCollection::doPost");
Jiaqing Zhao828252d2022-09-30 13:59:19 +0800921
922 asyncResp->res.jsonValue["Name"] = "HTTPS Certificate";
923 asyncResp->res.jsonValue["Description"] = "HTTPS Certificate";
924
Ed Tanousb2896142024-01-31 15:25:47 -0800925 std::string certHttpBody = getCertificateFromReqBody(asyncResp, req);
Jiaqing Zhao828252d2022-09-30 13:59:19 +0800926
Ed Tanousb2896142024-01-31 15:25:47 -0800927 if (certHttpBody.empty())
Jiaqing Zhao828252d2022-09-30 13:59:19 +0800928 {
Ed Tanous62598e32023-07-17 17:06:25 -0700929 BMCWEB_LOG_ERROR("Cannot get certificate from request body.");
Jiaqing Zhao828252d2022-09-30 13:59:19 +0800930 messages::unrecognizedRequestBody(asyncResp->res);
931 return;
932 }
933
934 std::shared_ptr<CertificateFile> certFile =
Ed Tanousb2896142024-01-31 15:25:47 -0800935 std::make_shared<CertificateFile>(certHttpBody);
Jiaqing Zhao828252d2022-09-30 13:59:19 +0800936
937 crow::connections::systemBus->async_method_call(
Ed Tanous5e7e2dc2023-02-16 10:37:01 -0800938 [asyncResp, certFile](const boost::system::error_code& ec,
Jiaqing Zhao828252d2022-09-30 13:59:19 +0800939 const std::string& objectPath) {
940 if (ec)
Ed Tanous002d39b2022-05-31 08:59:27 -0700941 {
Ed Tanous62598e32023-07-17 17:06:25 -0700942 BMCWEB_LOG_ERROR("DBUS response error: {}", ec);
Ed Tanous002d39b2022-05-31 08:59:27 -0700943 messages::internalError(asyncResp->res);
944 return;
945 }
946
Jiaqing Zhao828252d2022-09-30 13:59:19 +0800947 sdbusplus::message::object_path path(objectPath);
948 std::string certId = path.filename();
Ed Tanousef4c65b2023-04-24 15:28:50 -0700949 const boost::urls::url certURL = boost::urls::format(
Ed Tanous253f11b2024-05-16 09:38:31 -0700950 "/redfish/v1/Managers/{}/NetworkProtocol/HTTPS/Certificates/{}",
951 BMCWEB_REDFISH_MANAGER_URI_NAME, certId);
Jiaqing Zhao828252d2022-09-30 13:59:19 +0800952 getCertificateProperties(asyncResp, objectPath, certs::httpsServiceName,
953 certId, certURL, "HTTPS Certificate");
Ed Tanous62598e32023-07-17 17:06:25 -0700954 BMCWEB_LOG_DEBUG("HTTPS certificate install file={}",
955 certFile->getCertFilePath());
Patrick Williams5a39f772023-10-20 11:20:21 -0500956 },
Jiaqing Zhao828252d2022-09-30 13:59:19 +0800957 certs::httpsServiceName, certs::httpsObjectPath, certs::certInstallIntf,
958 "Install", certFile->getCertFilePath());
959}
Ed Tanous002d39b2022-05-31 08:59:27 -0700960
Jiaqing Zhao828252d2022-09-30 13:59:19 +0800961inline void handleHTTPSCertificateGet(
962 App& app, const crow::Request& req,
Ed Tanous253f11b2024-05-16 09:38:31 -0700963 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
964 const std::string& managerId, const std::string& certId)
Jiaqing Zhao828252d2022-09-30 13:59:19 +0800965{
966 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
967 {
968 return;
969 }
Ed Tanous002d39b2022-05-31 08:59:27 -0700970
Ed Tanous253f11b2024-05-16 09:38:31 -0700971 if (managerId != BMCWEB_REDFISH_MANAGER_URI_NAME)
972 {
973 messages::resourceNotFound(asyncResp->res, "Manager", managerId);
974 return;
975 }
976
977 BMCWEB_LOG_DEBUG("HTTPS Certificate ID={}", certId);
Ed Tanousef4c65b2023-04-24 15:28:50 -0700978 const boost::urls::url certURL = boost::urls::format(
Ed Tanous253f11b2024-05-16 09:38:31 -0700979 "/redfish/v1/Managers/{}/NetworkProtocol/HTTPS/Certificates/{}",
980 BMCWEB_REDFISH_MANAGER_URI_NAME, certId);
Jiaqing Zhao828252d2022-09-30 13:59:19 +0800981 std::string objPath =
Ed Tanous253f11b2024-05-16 09:38:31 -0700982 sdbusplus::message::object_path(certs::httpsObjectPath) / certId;
983 getCertificateProperties(asyncResp, objPath, certs::httpsServiceName,
984 certId, certURL, "HTTPS Certificate");
Jiaqing Zhao828252d2022-09-30 13:59:19 +0800985}
John Edward Broadbent7e860f12021-04-08 15:57:16 -0700986
987inline void requestRoutesHTTPSCertificate(App& app)
Marri Devender Rao5968cae2019-01-21 10:27:12 -0600988{
Ed Tanous253f11b2024-05-16 09:38:31 -0700989 BMCWEB_ROUTE(
990 app, "/redfish/v1/Managers/<str>/NetworkProtocol/HTTPS/Certificates/")
Jiaqing Zhao828252d2022-09-30 13:59:19 +0800991 .privileges(redfish::privileges::getCertificateCollection)
992 .methods(boost::beast::http::verb::get)(std::bind_front(
993 handleHTTPSCertificateCollectionGet, std::ref(app)));
994
Ed Tanous253f11b2024-05-16 09:38:31 -0700995 BMCWEB_ROUTE(
996 app, "/redfish/v1/Managers/<str>/NetworkProtocol/HTTPS/Certificates/")
Jiaqing Zhao828252d2022-09-30 13:59:19 +0800997 .privileges(redfish::privileges::postCertificateCollection)
998 .methods(boost::beast::http::verb::post)(std::bind_front(
999 handleHTTPSCertificateCollectionPost, std::ref(app)));
1000
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001001 BMCWEB_ROUTE(
1002 app,
Ed Tanous253f11b2024-05-16 09:38:31 -07001003 "/redfish/v1/Managers/<str>/NetworkProtocol/HTTPS/Certificates/<str>/")
Ed Tanoused398212021-06-09 17:05:54 -07001004 .privileges(redfish::privileges::getCertificate)
Jiaqing Zhao1e312592022-06-14 12:58:09 +08001005 .methods(boost::beast::http::verb::get)(
Jiaqing Zhao828252d2022-09-30 13:59:19 +08001006 std::bind_front(handleHTTPSCertificateGet, std::ref(app)));
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001007}
Marri Devender Rao5968cae2019-01-21 10:27:12 -06001008
Jiaqing Zhao828252d2022-09-30 13:59:19 +08001009inline void handleLDAPCertificateCollectionGet(
1010 App& app, const crow::Request& req,
1011 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp)
Marri Devender Rao5968cae2019-01-21 10:27:12 -06001012{
Jiaqing Zhao828252d2022-09-30 13:59:19 +08001013 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
1014 {
1015 return;
1016 }
Ed Tanous002d39b2022-05-31 08:59:27 -07001017
Jiaqing Zhao828252d2022-09-30 13:59:19 +08001018 asyncResp->res.jsonValue["@odata.id"] =
1019 "/redfish/v1/AccountService/LDAP/Certificates";
1020 asyncResp->res.jsonValue["@odata.type"] =
1021 "#CertificateCollection.CertificateCollection";
1022 asyncResp->res.jsonValue["Name"] = "LDAP Certificates Collection";
1023 asyncResp->res.jsonValue["Description"] =
1024 "A Collection of LDAP certificate instances";
Ed Tanous002d39b2022-05-31 08:59:27 -07001025
Jiaqing Zhao828252d2022-09-30 13:59:19 +08001026 getCertificateList(asyncResp, certs::ldapObjectPath,
1027 "/Members"_json_pointer,
1028 "/Members@odata.count"_json_pointer);
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001029}
Marri Devender Rao37cce912019-02-20 01:05:22 -06001030
Jiaqing Zhao828252d2022-09-30 13:59:19 +08001031inline void handleLDAPCertificateCollectionPost(
1032 App& app, const crow::Request& req,
1033 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp)
Marri Devender Rao37cce912019-02-20 01:05:22 -06001034{
Jiaqing Zhao828252d2022-09-30 13:59:19 +08001035 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
1036 {
1037 return;
1038 }
Ed Tanousb2896142024-01-31 15:25:47 -08001039 std::string certHttpBody = getCertificateFromReqBody(asyncResp, req);
Jiaqing Zhao828252d2022-09-30 13:59:19 +08001040
Ed Tanousb2896142024-01-31 15:25:47 -08001041 if (certHttpBody.empty())
Jiaqing Zhao828252d2022-09-30 13:59:19 +08001042 {
Ed Tanous62598e32023-07-17 17:06:25 -07001043 BMCWEB_LOG_ERROR("Cannot get certificate from request body.");
Jiaqing Zhao828252d2022-09-30 13:59:19 +08001044 messages::unrecognizedRequestBody(asyncResp->res);
1045 return;
1046 }
1047
1048 std::shared_ptr<CertificateFile> certFile =
Ed Tanousb2896142024-01-31 15:25:47 -08001049 std::make_shared<CertificateFile>(certHttpBody);
Jiaqing Zhao828252d2022-09-30 13:59:19 +08001050
1051 crow::connections::systemBus->async_method_call(
Ed Tanous5e7e2dc2023-02-16 10:37:01 -08001052 [asyncResp, certFile](const boost::system::error_code& ec,
Jiaqing Zhao828252d2022-09-30 13:59:19 +08001053 const std::string& objectPath) {
1054 if (ec)
Ed Tanous002d39b2022-05-31 08:59:27 -07001055 {
Ed Tanous62598e32023-07-17 17:06:25 -07001056 BMCWEB_LOG_ERROR("DBUS response error: {}", ec);
Jiaqing Zhao828252d2022-09-30 13:59:19 +08001057 messages::internalError(asyncResp->res);
Ed Tanous002d39b2022-05-31 08:59:27 -07001058 return;
1059 }
1060
Jiaqing Zhao828252d2022-09-30 13:59:19 +08001061 sdbusplus::message::object_path path(objectPath);
1062 std::string certId = path.filename();
Ed Tanousef4c65b2023-04-24 15:28:50 -07001063 const boost::urls::url certURL = boost::urls::format(
1064 "/redfish/v1/AccountService/LDAP/Certificates/{}", certId);
Jiaqing Zhao828252d2022-09-30 13:59:19 +08001065 getCertificateProperties(asyncResp, objectPath, certs::ldapServiceName,
1066 certId, certURL, "LDAP Certificate");
Ed Tanous62598e32023-07-17 17:06:25 -07001067 BMCWEB_LOG_DEBUG("LDAP certificate install file={}",
1068 certFile->getCertFilePath());
Patrick Williams5a39f772023-10-20 11:20:21 -05001069 },
Jiaqing Zhao828252d2022-09-30 13:59:19 +08001070 certs::ldapServiceName, certs::ldapObjectPath, certs::certInstallIntf,
1071 "Install", certFile->getCertFilePath());
1072}
Ed Tanous002d39b2022-05-31 08:59:27 -07001073
Jiaqing Zhao828252d2022-09-30 13:59:19 +08001074inline void handleLDAPCertificateGet(
1075 App& app, const crow::Request& req,
1076 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp, const std::string& id)
1077{
1078 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
1079 {
1080 return;
1081 }
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001082
Ed Tanous62598e32023-07-17 17:06:25 -07001083 BMCWEB_LOG_DEBUG("LDAP Certificate ID={}", id);
Ed Tanousef4c65b2023-04-24 15:28:50 -07001084 const boost::urls::url certURL = boost::urls::format(
1085 "/redfish/v1/AccountService/LDAP/Certificates/{}", id);
Jiaqing Zhao828252d2022-09-30 13:59:19 +08001086 std::string objPath =
1087 sdbusplus::message::object_path(certs::ldapObjectPath) / id;
1088 getCertificateProperties(asyncResp, objPath, certs::ldapServiceName, id,
1089 certURL, "LDAP Certificate");
1090}
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001091
Jiaqing Zhao99612242022-09-29 15:31:09 +08001092inline void handleLDAPCertificateDelete(
1093 App& app, const crow::Request& req,
1094 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp, const std::string& id)
1095{
1096 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
1097 {
1098 return;
1099 }
1100
Ed Tanous62598e32023-07-17 17:06:25 -07001101 BMCWEB_LOG_DEBUG("Delete LDAP Certificate ID={}", id);
Jiaqing Zhao99612242022-09-29 15:31:09 +08001102 std::string objPath =
1103 sdbusplus::message::object_path(certs::ldapObjectPath) / id;
1104
1105 deleteCertificate(asyncResp, certs::ldapServiceName, objPath);
1106}
1107
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001108inline void requestRoutesLDAPCertificate(App& app)
Marri Devender Rao37cce912019-02-20 01:05:22 -06001109{
Jiaqing Zhao828252d2022-09-30 13:59:19 +08001110 BMCWEB_ROUTE(app, "/redfish/v1/AccountService/LDAP/Certificates/")
1111 .privileges(redfish::privileges::getCertificateCollection)
1112 .methods(boost::beast::http::verb::get)(
1113 std::bind_front(handleLDAPCertificateCollectionGet, std::ref(app)));
1114
1115 BMCWEB_ROUTE(app, "/redfish/v1/AccountService/LDAP/Certificates/")
1116 .privileges(redfish::privileges::postCertificateCollection)
1117 .methods(boost::beast::http::verb::post)(std::bind_front(
1118 handleLDAPCertificateCollectionPost, std::ref(app)));
1119
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001120 BMCWEB_ROUTE(app, "/redfish/v1/AccountService/LDAP/Certificates/<str>/")
Ed Tanoused398212021-06-09 17:05:54 -07001121 .privileges(redfish::privileges::getCertificate)
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001122 .methods(boost::beast::http::verb::get)(
Jiaqing Zhao828252d2022-09-30 13:59:19 +08001123 std::bind_front(handleLDAPCertificateGet, std::ref(app)));
Jiaqing Zhao99612242022-09-29 15:31:09 +08001124
1125 BMCWEB_ROUTE(app, "/redfish/v1/AccountService/LDAP/Certificates/<str>/")
1126 .privileges(redfish::privileges::deleteCertificate)
1127 .methods(boost::beast::http::verb::delete_)(
1128 std::bind_front(handleLDAPCertificateDelete, std::ref(app)));
Jiaqing Zhao828252d2022-09-30 13:59:19 +08001129} // requestRoutesLDAPCertificate
1130
1131inline void handleTrustStoreCertificateCollectionGet(
1132 App& app, const crow::Request& req,
Ed Tanous253f11b2024-05-16 09:38:31 -07001133 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
1134 const std::string& managerId)
Jiaqing Zhao828252d2022-09-30 13:59:19 +08001135{
1136 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
1137 {
1138 return;
1139 }
1140
Ed Tanous253f11b2024-05-16 09:38:31 -07001141 if (managerId != BMCWEB_REDFISH_MANAGER_URI_NAME)
1142 {
1143 messages::resourceNotFound(asyncResp->res, "Manager", managerId);
1144 return;
1145 }
1146
Jiaqing Zhao828252d2022-09-30 13:59:19 +08001147 asyncResp->res.jsonValue["@odata.id"] =
Ed Tanous253f11b2024-05-16 09:38:31 -07001148 boost::urls::format("/redfish/v1/Managers/{}/Truststore/Certificates/",
1149 BMCWEB_REDFISH_MANAGER_URI_NAME);
Jiaqing Zhao828252d2022-09-30 13:59:19 +08001150 asyncResp->res.jsonValue["@odata.type"] =
1151 "#CertificateCollection.CertificateCollection";
1152 asyncResp->res.jsonValue["Name"] = "TrustStore Certificates Collection";
1153 asyncResp->res.jsonValue["Description"] =
1154 "A Collection of TrustStore certificate instances";
1155
1156 getCertificateList(asyncResp, certs::authorityObjectPath,
1157 "/Members"_json_pointer,
1158 "/Members@odata.count"_json_pointer);
1159}
1160
1161inline void handleTrustStoreCertificateCollectionPost(
1162 App& app, const crow::Request& req,
Ed Tanous253f11b2024-05-16 09:38:31 -07001163 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
1164 const std::string& managerId)
Jiaqing Zhao828252d2022-09-30 13:59:19 +08001165{
1166 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
1167 {
1168 return;
1169 }
Ed Tanous253f11b2024-05-16 09:38:31 -07001170
1171 if (managerId != BMCWEB_REDFISH_MANAGER_URI_NAME)
1172 {
1173 messages::resourceNotFound(asyncResp->res, "Manager", managerId);
1174 return;
1175 }
1176
Ed Tanousb2896142024-01-31 15:25:47 -08001177 std::string certHttpBody = getCertificateFromReqBody(asyncResp, req);
Jiaqing Zhao828252d2022-09-30 13:59:19 +08001178
Ed Tanousb2896142024-01-31 15:25:47 -08001179 if (certHttpBody.empty())
Jiaqing Zhao828252d2022-09-30 13:59:19 +08001180 {
Ed Tanous62598e32023-07-17 17:06:25 -07001181 BMCWEB_LOG_ERROR("Cannot get certificate from request body.");
Jiaqing Zhao828252d2022-09-30 13:59:19 +08001182 messages::unrecognizedRequestBody(asyncResp->res);
1183 return;
1184 }
1185
1186 std::shared_ptr<CertificateFile> certFile =
Ed Tanousb2896142024-01-31 15:25:47 -08001187 std::make_shared<CertificateFile>(certHttpBody);
Jiaqing Zhao828252d2022-09-30 13:59:19 +08001188 crow::connections::systemBus->async_method_call(
Ed Tanous5e7e2dc2023-02-16 10:37:01 -08001189 [asyncResp, certFile](const boost::system::error_code& ec,
Jiaqing Zhao828252d2022-09-30 13:59:19 +08001190 const std::string& objectPath) {
1191 if (ec)
Ed Tanous002d39b2022-05-31 08:59:27 -07001192 {
Ed Tanous62598e32023-07-17 17:06:25 -07001193 BMCWEB_LOG_ERROR("DBUS response error: {}", ec);
Jiaqing Zhao828252d2022-09-30 13:59:19 +08001194 messages::internalError(asyncResp->res);
Ed Tanous002d39b2022-05-31 08:59:27 -07001195 return;
1196 }
Jiaqing Zhao717b9802022-06-06 20:24:04 +08001197
Jiaqing Zhao828252d2022-09-30 13:59:19 +08001198 sdbusplus::message::object_path path(objectPath);
1199 std::string certId = path.filename();
Ed Tanousef4c65b2023-04-24 15:28:50 -07001200 const boost::urls::url certURL = boost::urls::format(
Ed Tanous253f11b2024-05-16 09:38:31 -07001201 "/redfish/v1/Managers/{}/Truststore/Certificates/{}",
1202 BMCWEB_REDFISH_MANAGER_URI_NAME, certId);
Jiaqing Zhao828252d2022-09-30 13:59:19 +08001203 getCertificateProperties(asyncResp, objectPath,
1204 certs::authorityServiceName, certId, certURL,
1205 "TrustStore Certificate");
Ed Tanous62598e32023-07-17 17:06:25 -07001206 BMCWEB_LOG_DEBUG("TrustStore certificate install file={}",
1207 certFile->getCertFilePath());
Patrick Williams5a39f772023-10-20 11:20:21 -05001208 },
Jiaqing Zhao828252d2022-09-30 13:59:19 +08001209 certs::authorityServiceName, certs::authorityObjectPath,
1210 certs::certInstallIntf, "Install", certFile->getCertFilePath());
1211}
1212
1213inline void handleTrustStoreCertificateGet(
1214 App& app, const crow::Request& req,
Ed Tanous253f11b2024-05-16 09:38:31 -07001215 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
1216 const std::string& managerId, const std::string& certId)
Jiaqing Zhao828252d2022-09-30 13:59:19 +08001217{
1218 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
1219 {
1220 return;
1221 }
1222
Ed Tanous253f11b2024-05-16 09:38:31 -07001223 if (managerId != BMCWEB_REDFISH_MANAGER_URI_NAME)
1224 {
1225 messages::resourceNotFound(asyncResp->res, "Manager", managerId);
1226 return;
1227 }
1228
1229 BMCWEB_LOG_DEBUG("Truststore Certificate ID={}", certId);
Ed Tanousef4c65b2023-04-24 15:28:50 -07001230 const boost::urls::url certURL = boost::urls::format(
Ed Tanous253f11b2024-05-16 09:38:31 -07001231 "/redfish/v1/Managers/{}/Truststore/Certificates/{}",
1232 BMCWEB_REDFISH_MANAGER_URI_NAME, certId);
Jiaqing Zhao828252d2022-09-30 13:59:19 +08001233 std::string objPath =
Ed Tanous253f11b2024-05-16 09:38:31 -07001234 sdbusplus::message::object_path(certs::authorityObjectPath) / certId;
Jiaqing Zhao828252d2022-09-30 13:59:19 +08001235 getCertificateProperties(asyncResp, objPath, certs::authorityServiceName,
Ed Tanous253f11b2024-05-16 09:38:31 -07001236 certId, certURL, "TrustStore Certificate");
Jiaqing Zhao828252d2022-09-30 13:59:19 +08001237}
1238
1239inline void handleTrustStoreCertificateDelete(
1240 App& app, const crow::Request& req,
Ed Tanous253f11b2024-05-16 09:38:31 -07001241 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
1242 const std::string& managerId, const std::string& certId)
Jiaqing Zhao828252d2022-09-30 13:59:19 +08001243{
1244 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
1245 {
1246 return;
1247 }
1248
Ed Tanous253f11b2024-05-16 09:38:31 -07001249 if (managerId != BMCWEB_REDFISH_MANAGER_URI_NAME)
1250 {
1251 messages::resourceNotFound(asyncResp->res, "Manager", managerId);
1252 return;
1253 }
1254
1255 BMCWEB_LOG_DEBUG("Delete TrustStore Certificate ID={}", certId);
Jiaqing Zhao828252d2022-09-30 13:59:19 +08001256 std::string objPath =
Ed Tanous253f11b2024-05-16 09:38:31 -07001257 sdbusplus::message::object_path(certs::authorityObjectPath) / certId;
Jiaqing Zhao828252d2022-09-30 13:59:19 +08001258
Jiaqing Zhao7a3a8f72022-09-29 15:15:58 +08001259 deleteCertificate(asyncResp, certs::authorityServiceName, objPath);
Jiaqing Zhao828252d2022-09-30 13:59:19 +08001260}
1261
1262inline void requestRoutesTrustStoreCertificate(App& app)
Marri Devender Raocfcd5f62019-05-17 08:34:37 -05001263{
Ed Tanous253f11b2024-05-16 09:38:31 -07001264 BMCWEB_ROUTE(app, "/redfish/v1/Managers/<str>/Truststore/Certificates/")
Ed Tanoused398212021-06-09 17:05:54 -07001265 .privileges(redfish::privileges::getCertificate)
Jiaqing Zhao828252d2022-09-30 13:59:19 +08001266 .methods(boost::beast::http::verb::get)(std::bind_front(
1267 handleTrustStoreCertificateCollectionGet, std::ref(app)));
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001268
Ed Tanous253f11b2024-05-16 09:38:31 -07001269 BMCWEB_ROUTE(app, "/redfish/v1/Managers/<str>/Truststore/Certificates/")
Ed Tanoused398212021-06-09 17:05:54 -07001270 .privileges(redfish::privileges::postCertificateCollection)
Jiaqing Zhao828252d2022-09-30 13:59:19 +08001271 .methods(boost::beast::http::verb::post)(std::bind_front(
1272 handleTrustStoreCertificateCollectionPost, std::ref(app)));
Ed Tanous002d39b2022-05-31 08:59:27 -07001273
Ed Tanous253f11b2024-05-16 09:38:31 -07001274 BMCWEB_ROUTE(app,
1275 "/redfish/v1/Managers/<str>/Truststore/Certificates/<str>/")
Ed Tanoused398212021-06-09 17:05:54 -07001276 .privileges(redfish::privileges::getCertificate)
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001277 .methods(boost::beast::http::verb::get)(
Jiaqing Zhao828252d2022-09-30 13:59:19 +08001278 std::bind_front(handleTrustStoreCertificateGet, std::ref(app)));
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001279
Ed Tanous253f11b2024-05-16 09:38:31 -07001280 BMCWEB_ROUTE(app,
1281 "/redfish/v1/Managers/<str>/Truststore/Certificates/<str>/")
Ed Tanoused398212021-06-09 17:05:54 -07001282 .privileges(redfish::privileges::deleteCertificate)
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001283 .methods(boost::beast::http::verb::delete_)(
Jiaqing Zhao828252d2022-09-30 13:59:19 +08001284 std::bind_front(handleTrustStoreCertificateDelete, std::ref(app)));
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001285} // requestRoutesTrustStoreCertificate
Marri Devender Rao5968cae2019-01-21 10:27:12 -06001286} // namespace redfish