blob: 1f691238ffa5f3a99f119ac0f02763150a73de07 [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";
Patrick Williamsbd79bce2024-08-16 15:22:20 -0400109 std::ofstream out(certificateFile,
110 std::ofstream::out | std::ofstream::binary |
111 std::ofstream::trunc);
Marri Devender Rao5968cae2019-01-21 10:27:12 -0600112 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 */
Ed Tanous4ff0f1f2024-09-04 17:27:37 -0700151inline 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 */
Ed Tanous4ff0f1f2024-09-04 17:27:37 -0700216inline void getCertificateList(
Patrick Williamsbd79bce2024-08-16 15:22:20 -0400217 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
218 const std::string& basePath, const nlohmann::json::json_pointer& listPtr,
219 const nlohmann::json::json_pointer& countPtr)
Jiaqing Zhaod3f92ce2022-06-03 11:46:12 +0800220{
George Liu7a1dbc42022-12-07 16:03:22 +0800221 constexpr std::array<std::string_view, 1> interfaces = {
222 certs::certPropIntf};
223 dbus::utility::getSubTreePaths(
224 basePath, 0, interfaces,
Jiaqing Zhaod3f92ce2022-06-03 11:46:12 +0800225 [asyncResp, listPtr, countPtr](
George Liu7a1dbc42022-12-07 16:03:22 +0800226 const boost::system::error_code& ec,
Jiaqing Zhaod3f92ce2022-06-03 11:46:12 +0800227 const dbus::utility::MapperGetSubTreePathsResponse& certPaths) {
Patrick Williamsbd79bce2024-08-16 15:22:20 -0400228 if (ec)
Jiaqing Zhaod3f92ce2022-06-03 11:46:12 +0800229 {
Patrick Williamsbd79bce2024-08-16 15:22:20 -0400230 BMCWEB_LOG_ERROR("Certificate collection query failed: {}", ec);
231 messages::internalError(asyncResp->res);
232 return;
Jiaqing Zhaod3f92ce2022-06-03 11:46:12 +0800233 }
234
Patrick Williamsbd79bce2024-08-16 15:22:20 -0400235 nlohmann::json& links = asyncResp->res.jsonValue[listPtr];
236 links = nlohmann::json::array();
237 for (const auto& certPath : certPaths)
Jiaqing Zhaod3f92ce2022-06-03 11:46:12 +0800238 {
Patrick Williamsbd79bce2024-08-16 15:22:20 -0400239 sdbusplus::message::object_path objPath(certPath);
240 std::string certId = objPath.filename();
241 if (certId.empty())
242 {
243 BMCWEB_LOG_ERROR("Invalid certificate objPath {}",
244 certPath);
245 continue;
246 }
247
248 boost::urls::url certURL;
249 if (objPath.parent_path() == certs::httpsObjectPath)
250 {
251 certURL = boost::urls::format(
252 "/redfish/v1/Managers/{}/NetworkProtocol/HTTPS/Certificates/{}",
253 BMCWEB_REDFISH_MANAGER_URI_NAME, certId);
254 }
255 else if (objPath.parent_path() == certs::ldapObjectPath)
256 {
257 certURL = boost::urls::format(
258 "/redfish/v1/AccountService/LDAP/Certificates/{}",
259 certId);
260 }
261 else if (objPath.parent_path() == certs::authorityObjectPath)
262 {
263 certURL = boost::urls::format(
264 "/redfish/v1/Managers/{}/Truststore/Certificates/{}",
265 BMCWEB_REDFISH_MANAGER_URI_NAME, certId);
266 }
267 else
268 {
269 continue;
270 }
271
272 nlohmann::json::object_t link;
273 link["@odata.id"] = certURL;
274 links.emplace_back(std::move(link));
Jiaqing Zhaod3f92ce2022-06-03 11:46:12 +0800275 }
276
Patrick Williamsbd79bce2024-08-16 15:22:20 -0400277 asyncResp->res.jsonValue[countPtr] = links.size();
278 });
Jiaqing Zhaod3f92ce2022-06-03 11:46:12 +0800279}
280
281/**
Marri Devender Rao5968cae2019-01-21 10:27:12 -0600282 * @brief Retrieve the certificates properties and append to the response
283 * message
284 *
285 * @param[in] asyncResp Shared pointer to the response message
286 * @param[in] objectPath Path of the D-Bus service object
287 * @param[in] certId Id of the certificate
288 * @param[in] certURL URL of the certificate object
289 * @param[in] name name of the certificate
290 * @return None
291 */
Ed Tanous4ff0f1f2024-09-04 17:27:37 -0700292inline void getCertificateProperties(
zhanghch058d1b46d2021-04-01 11:18:24 +0800293 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
Jiaqing Zhaoe19e97e2022-06-06 19:43:39 +0800294 const std::string& objectPath, const std::string& service,
Jiaqing Zhao1e312592022-06-14 12:58:09 +0800295 const std::string& certId, const boost::urls::url& certURL,
Jiaqing Zhaoe19e97e2022-06-06 19:43:39 +0800296 const std::string& name)
Marri Devender Rao5968cae2019-01-21 10:27:12 -0600297{
Ed Tanous62598e32023-07-17 17:06:25 -0700298 BMCWEB_LOG_DEBUG("getCertificateProperties Path={} certId={} certURl={}",
299 objectPath, certId, certURL);
Krzysztof Grobelny9b12d1f2022-08-11 09:52:56 +0200300 sdbusplus::asio::getAllProperties(
301 *crow::connections::systemBus, service, objectPath, certs::certPropIntf,
Ed Tanousb9d36b42022-02-26 21:42:46 -0800302 [asyncResp, certURL, certId,
Ed Tanous5e7e2dc2023-02-16 10:37:01 -0800303 name](const boost::system::error_code& ec,
Ed Tanousb9d36b42022-02-26 21:42:46 -0800304 const dbus::utility::DBusPropertiesMap& properties) {
Patrick Williamsbd79bce2024-08-16 15:22:20 -0400305 if (ec)
306 {
307 BMCWEB_LOG_ERROR("DBUS response error: {}", ec);
308 messages::resourceNotFound(asyncResp->res, "Certificate",
309 certId);
310 return;
311 }
Krzysztof Grobelny9b12d1f2022-08-11 09:52:56 +0200312
Patrick Williamsbd79bce2024-08-16 15:22:20 -0400313 const std::string* certificateString = nullptr;
314 const std::vector<std::string>* keyUsage = nullptr;
315 const std::string* issuer = nullptr;
316 const std::string* subject = nullptr;
317 const uint64_t* validNotAfter = nullptr;
318 const uint64_t* validNotBefore = nullptr;
Krzysztof Grobelny9b12d1f2022-08-11 09:52:56 +0200319
Patrick Williamsbd79bce2024-08-16 15:22:20 -0400320 const bool success = sdbusplus::unpackPropertiesNoThrow(
321 dbus_utils::UnpackErrorPrinter(), properties,
322 "CertificateString", certificateString, "KeyUsage", keyUsage,
323 "Issuer", issuer, "Subject", subject, "ValidNotAfter",
324 validNotAfter, "ValidNotBefore", validNotBefore);
Krzysztof Grobelny9b12d1f2022-08-11 09:52:56 +0200325
Patrick Williamsbd79bce2024-08-16 15:22:20 -0400326 if (!success)
327 {
328 messages::internalError(asyncResp->res);
329 return;
330 }
Krzysztof Grobelny9b12d1f2022-08-11 09:52:56 +0200331
Patrick Williamsbd79bce2024-08-16 15:22:20 -0400332 asyncResp->res.jsonValue["@odata.id"] = certURL;
333 asyncResp->res.jsonValue["@odata.type"] =
334 "#Certificate.v1_0_0.Certificate";
335 asyncResp->res.jsonValue["Id"] = certId;
336 asyncResp->res.jsonValue["Name"] = name;
337 asyncResp->res.jsonValue["Description"] = name;
338 asyncResp->res.jsonValue["CertificateString"] = "";
339 asyncResp->res.jsonValue["KeyUsage"] = nlohmann::json::array();
Krzysztof Grobelny9b12d1f2022-08-11 09:52:56 +0200340
Patrick Williamsbd79bce2024-08-16 15:22:20 -0400341 if (certificateString != nullptr)
342 {
343 asyncResp->res.jsonValue["CertificateString"] =
344 *certificateString;
345 }
Krzysztof Grobelny9b12d1f2022-08-11 09:52:56 +0200346
Patrick Williamsbd79bce2024-08-16 15:22:20 -0400347 if (keyUsage != nullptr)
348 {
349 asyncResp->res.jsonValue["KeyUsage"] = *keyUsage;
350 }
Krzysztof Grobelny9b12d1f2022-08-11 09:52:56 +0200351
Patrick Williamsbd79bce2024-08-16 15:22:20 -0400352 if (issuer != nullptr)
353 {
354 updateCertIssuerOrSubject(asyncResp->res.jsonValue["Issuer"],
355 *issuer);
356 }
Krzysztof Grobelny9b12d1f2022-08-11 09:52:56 +0200357
Patrick Williamsbd79bce2024-08-16 15:22:20 -0400358 if (subject != nullptr)
359 {
360 updateCertIssuerOrSubject(asyncResp->res.jsonValue["Subject"],
361 *subject);
362 }
Krzysztof Grobelny9b12d1f2022-08-11 09:52:56 +0200363
Patrick Williamsbd79bce2024-08-16 15:22:20 -0400364 if (validNotAfter != nullptr)
365 {
366 asyncResp->res.jsonValue["ValidNotAfter"] =
367 redfish::time_utils::getDateTimeUint(*validNotAfter);
368 }
Krzysztof Grobelny9b12d1f2022-08-11 09:52:56 +0200369
Patrick Williamsbd79bce2024-08-16 15:22:20 -0400370 if (validNotBefore != nullptr)
371 {
372 asyncResp->res.jsonValue["ValidNotBefore"] =
373 redfish::time_utils::getDateTimeUint(*validNotBefore);
374 }
Krzysztof Grobelny9b12d1f2022-08-11 09:52:56 +0200375
Patrick Williamsbd79bce2024-08-16 15:22:20 -0400376 asyncResp->res.addHeader(
377 boost::beast::http::field::location,
378 std::string_view(certURL.data(), certURL.size()));
379 });
Marri Devender Rao5968cae2019-01-21 10:27:12 -0600380}
381
Ed Tanous4ff0f1f2024-09-04 17:27:37 -0700382inline void
Jiaqing Zhao7a3a8f72022-09-29 15:15:58 +0800383 deleteCertificate(const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
384 const std::string& service,
385 const sdbusplus::message::object_path& objectPath)
386{
387 crow::connections::systemBus->async_method_call(
388 [asyncResp,
Ed Tanous5e7e2dc2023-02-16 10:37:01 -0800389 id{objectPath.filename()}](const boost::system::error_code& ec) {
Patrick Williamsbd79bce2024-08-16 15:22:20 -0400390 if (ec)
391 {
392 messages::resourceNotFound(asyncResp->res, "Certificate", id);
393 return;
394 }
395 BMCWEB_LOG_INFO("Certificate deleted");
396 asyncResp->res.result(boost::beast::http::status::no_content);
397 },
Jiaqing Zhao7a3a8f72022-09-29 15:15:58 +0800398 service, objectPath, certs::objDeleteIntf, "Delete");
399}
400
Jiaqing Zhao828252d2022-09-30 13:59:19 +0800401inline void handleCertificateServiceGet(
402 App& app, const crow::Request& req,
403 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp)
Marri Devender Rao5968cae2019-01-21 10:27:12 -0600404{
Jiaqing Zhao828252d2022-09-30 13:59:19 +0800405 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
406 {
407 return;
408 }
409
Ninad Palsule3e72c202023-03-27 17:19:55 -0500410 if (req.session == nullptr)
411 {
412 messages::internalError(asyncResp->res);
413 return;
414 }
415
Jiaqing Zhao828252d2022-09-30 13:59:19 +0800416 asyncResp->res.jsonValue["@odata.type"] =
417 "#CertificateService.v1_0_0.CertificateService";
418 asyncResp->res.jsonValue["@odata.id"] = "/redfish/v1/CertificateService";
419 asyncResp->res.jsonValue["Id"] = "CertificateService";
420 asyncResp->res.jsonValue["Name"] = "Certificate Service";
421 asyncResp->res.jsonValue["Description"] =
422 "Actions available to manage certificates";
423 // /redfish/v1/CertificateService/CertificateLocations is something
424 // only ConfigureManager can access then only display when the user
425 // has permissions ConfigureManager
426 Privileges effectiveUserPrivileges =
Ninad Palsule3e72c202023-03-27 17:19:55 -0500427 redfish::getUserPrivileges(*req.session);
Jiaqing Zhao828252d2022-09-30 13:59:19 +0800428 if (isOperationAllowedWithPrivileges({{"ConfigureManager"}},
429 effectiveUserPrivileges))
430 {
431 asyncResp->res.jsonValue["CertificateLocations"]["@odata.id"] =
432 "/redfish/v1/CertificateService/CertificateLocations";
433 }
434 nlohmann::json& actions = asyncResp->res.jsonValue["Actions"];
435 nlohmann::json& replace = actions["#CertificateService.ReplaceCertificate"];
436 replace["target"] =
437 "/redfish/v1/CertificateService/Actions/CertificateService.ReplaceCertificate";
438 nlohmann::json::array_t allowed;
Patrick Williamsad539542023-05-12 10:10:08 -0500439 allowed.emplace_back("PEM");
Jiaqing Zhao828252d2022-09-30 13:59:19 +0800440 replace["CertificateType@Redfish.AllowableValues"] = std::move(allowed);
441 actions["#CertificateService.GenerateCSR"]["target"] =
442 "/redfish/v1/CertificateService/Actions/CertificateService.GenerateCSR";
443}
444
445inline void handleCertificateLocationsGet(
446 App& app, const crow::Request& req,
447 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp)
448{
449 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
450 {
451 return;
452 }
453 asyncResp->res.jsonValue["@odata.id"] =
454 "/redfish/v1/CertificateService/CertificateLocations";
455 asyncResp->res.jsonValue["@odata.type"] =
456 "#CertificateLocations.v1_0_0.CertificateLocations";
457 asyncResp->res.jsonValue["Name"] = "Certificate Locations";
458 asyncResp->res.jsonValue["Id"] = "CertificateLocations";
459 asyncResp->res.jsonValue["Description"] =
460 "Defines a resource that an administrator can use in order to "
461 "locate all certificates installed on a given service";
462
463 getCertificateList(asyncResp, certs::baseObjectPath,
464 "/Links/Certificates"_json_pointer,
465 "/Links/Certificates@odata.count"_json_pointer);
466}
467
Chandra Harkude26d3b0f2024-09-23 22:02:35 +0530468inline void handleError(const std::string_view dbusErrorName,
469 const std::string& id, const std::string& certificate,
470 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp)
471{
472 if (dbusErrorName == "org.freedesktop.DBus.Error.UnknownObject")
473 {
474 messages::resourceNotFound(asyncResp->res, "Certificate", id);
475 }
476 else if (dbusErrorName ==
477 "xyz.openbmc_project.Certs.Error.InvalidCertificate")
478 {
479 messages::propertyValueIncorrect(asyncResp->res, "Certificate",
480 certificate);
481 }
482 else
483 {
484 messages::internalError(asyncResp->res);
485 }
486}
487
Jiaqing Zhao828252d2022-09-30 13:59:19 +0800488inline void handleReplaceCertificateAction(
489 App& app, const crow::Request& req,
490 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp)
491{
492 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
493 {
494 return;
495 }
496 std::string certificate;
Ed Tanous7a31e332024-03-06 12:17:43 -0800497 std::string certURI;
Jiaqing Zhao828252d2022-09-30 13:59:19 +0800498 std::optional<std::string> certificateType = "PEM";
499
500 if (!json_util::readJsonAction(req, asyncResp->res, "CertificateString",
Ed Tanous7a31e332024-03-06 12:17:43 -0800501 certificate, "CertificateUri/@odata.id",
502 certURI, "CertificateType", certificateType))
Jiaqing Zhao828252d2022-09-30 13:59:19 +0800503 {
Ed Tanous62598e32023-07-17 17:06:25 -0700504 BMCWEB_LOG_ERROR("Required parameters are missing");
Jiaqing Zhao828252d2022-09-30 13:59:19 +0800505 return;
506 }
507
508 if (!certificateType)
509 {
510 // should never happen, but it never hurts to be paranoid.
511 return;
512 }
513 if (certificateType != "PEM")
514 {
515 messages::actionParameterNotSupported(asyncResp->res, "CertificateType",
516 "ReplaceCertificate");
517 return;
518 }
519
Ed Tanous62598e32023-07-17 17:06:25 -0700520 BMCWEB_LOG_INFO("Certificate URI to replace: {}", certURI);
Jiaqing Zhao828252d2022-09-30 13:59:19 +0800521
Ed Tanous6fd29552023-10-04 09:40:14 -0700522 boost::system::result<boost::urls::url> parsedUrl =
Jiaqing Zhao828252d2022-09-30 13:59:19 +0800523 boost::urls::parse_relative_ref(certURI);
524 if (!parsedUrl)
525 {
526 messages::actionParameterValueFormatError(
527 asyncResp->res, certURI, "CertificateUri", "ReplaceCertificate");
528 return;
529 }
530
531 std::string id;
532 sdbusplus::message::object_path objectPath;
533 std::string name;
534 std::string service;
535 if (crow::utility::readUrlSegments(*parsedUrl, "redfish", "v1", "Managers",
536 "bmc", "NetworkProtocol", "HTTPS",
537 "Certificates", std::ref(id)))
538 {
Patrick Williams89492a12023-05-10 07:51:34 -0500539 objectPath = sdbusplus::message::object_path(certs::httpsObjectPath) /
540 id;
Jiaqing Zhao828252d2022-09-30 13:59:19 +0800541 name = "HTTPS certificate";
542 service = certs::httpsServiceName;
543 }
544 else if (crow::utility::readUrlSegments(*parsedUrl, "redfish", "v1",
545 "AccountService", "LDAP",
546 "Certificates", std::ref(id)))
547 {
Patrick Williams89492a12023-05-10 07:51:34 -0500548 objectPath = sdbusplus::message::object_path(certs::ldapObjectPath) /
549 id;
Jiaqing Zhao828252d2022-09-30 13:59:19 +0800550 name = "LDAP certificate";
551 service = certs::ldapServiceName;
552 }
553 else if (crow::utility::readUrlSegments(*parsedUrl, "redfish", "v1",
554 "Managers", "bmc", "Truststore",
555 "Certificates", std::ref(id)))
556 {
557 objectPath =
558 sdbusplus::message::object_path(certs::authorityObjectPath) / id;
559 name = "TrustStore certificate";
560 service = certs::authorityServiceName;
561 }
562 else
563 {
564 messages::actionParameterNotSupported(asyncResp->res, "CertificateUri",
565 "ReplaceCertificate");
566 return;
567 }
568
569 std::shared_ptr<CertificateFile> certFile =
570 std::make_shared<CertificateFile>(certificate);
571 crow::connections::systemBus->async_method_call(
Chandra Harkude26d3b0f2024-09-23 22:02:35 +0530572 [asyncResp, certFile, objectPath, service, url{*parsedUrl}, id, name,
573 certificate](const boost::system::error_code& ec,
574 sdbusplus::message::message& m) {
Patrick Williamsbd79bce2024-08-16 15:22:20 -0400575 if (ec)
Jiaqing Zhao828252d2022-09-30 13:59:19 +0800576 {
Patrick Williamsbd79bce2024-08-16 15:22:20 -0400577 BMCWEB_LOG_ERROR("DBUS response error: {}", ec);
Chandra Harkude26d3b0f2024-09-23 22:02:35 +0530578 const sd_bus_error* dbusError = m.get_error();
579 if ((dbusError != nullptr) && (dbusError->name != nullptr))
Patrick Williamsbd79bce2024-08-16 15:22:20 -0400580 {
Chandra Harkude26d3b0f2024-09-23 22:02:35 +0530581 handleError(dbusError->name, id, certificate, asyncResp);
Patrick Williamsbd79bce2024-08-16 15:22:20 -0400582 }
Chandra Harkude26d3b0f2024-09-23 22:02:35 +0530583 else
584 {
585 messages::internalError(asyncResp->res);
586 }
Jiaqing Zhao828252d2022-09-30 13:59:19 +0800587 return;
588 }
Patrick Williamsbd79bce2024-08-16 15:22:20 -0400589 getCertificateProperties(asyncResp, objectPath, service, id, url,
590 name);
591 BMCWEB_LOG_DEBUG("HTTPS certificate install file={}",
592 certFile->getCertFilePath());
593 },
Jiaqing Zhao828252d2022-09-30 13:59:19 +0800594 service, objectPath, certs::certReplaceIntf, "Replace",
595 certFile->getCertFilePath());
596}
597
Ed Tanouscf9e4172022-12-21 09:30:16 -0800598// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
Jiaqing Zhao828252d2022-09-30 13:59:19 +0800599static std::unique_ptr<sdbusplus::bus::match_t> csrMatcher;
600/**
601 * @brief Read data from CSR D-bus object and set to response
602 *
603 * @param[in] asyncResp Shared pointer to the response message
Ed Tanous8ece0e42024-01-02 13:16:50 -0800604 * @param[in] certURI Link to certificate collection URI
Jiaqing Zhao828252d2022-09-30 13:59:19 +0800605 * @param[in] service D-Bus service name
606 * @param[in] certObjPath certificate D-Bus object path
607 * @param[in] csrObjPath CSR D-Bus object path
608 * @return None
609 */
Ed Tanous4ff0f1f2024-09-04 17:27:37 -0700610inline void getCSR(const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
Jiaqing Zhao828252d2022-09-30 13:59:19 +0800611 const std::string& certURI, const std::string& service,
612 const std::string& certObjPath,
613 const std::string& csrObjPath)
614{
Ed Tanous62598e32023-07-17 17:06:25 -0700615 BMCWEB_LOG_DEBUG("getCSR CertObjectPath{} CSRObjectPath={} service={}",
616 certObjPath, csrObjPath, service);
Jiaqing Zhao828252d2022-09-30 13:59:19 +0800617 crow::connections::systemBus->async_method_call(
Patrick Williamsbd79bce2024-08-16 15:22:20 -0400618 [asyncResp,
619 certURI](const boost::system::error_code& ec, const std::string& csr) {
620 if (ec)
621 {
622 BMCWEB_LOG_ERROR("DBUS response error: {}", ec);
623 messages::internalError(asyncResp->res);
624 return;
625 }
626 if (csr.empty())
627 {
628 BMCWEB_LOG_ERROR("CSR read is empty");
629 messages::internalError(asyncResp->res);
630 return;
631 }
632 asyncResp->res.jsonValue["CSRString"] = csr;
633 asyncResp->res.jsonValue["CertificateCollection"]["@odata.id"] =
634 certURI;
635 },
Jiaqing Zhao828252d2022-09-30 13:59:19 +0800636 service, csrObjPath, "xyz.openbmc_project.Certs.CSR", "CSR");
637}
638
639inline void
640 handleGenerateCSRAction(App& app, const crow::Request& req,
641 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp)
642{
643 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
644 {
645 return;
646 }
647 static const int rsaKeyBitLength = 2048;
648
649 // Required parameters
650 std::string city;
651 std::string commonName;
652 std::string country;
653 std::string organization;
654 std::string organizationalUnit;
655 std::string state;
Ed Tanous7a31e332024-03-06 12:17:43 -0800656 std::string certURI;
Jiaqing Zhao828252d2022-09-30 13:59:19 +0800657
658 // Optional parameters
659 std::optional<std::vector<std::string>> optAlternativeNames =
660 std::vector<std::string>();
661 std::optional<std::string> optContactPerson = "";
662 std::optional<std::string> optChallengePassword = "";
663 std::optional<std::string> optEmail = "";
664 std::optional<std::string> optGivenName = "";
665 std::optional<std::string> optInitials = "";
666 std::optional<int64_t> optKeyBitLength = rsaKeyBitLength;
667 std::optional<std::string> optKeyCurveId = "secp384r1";
668 std::optional<std::string> optKeyPairAlgorithm = "EC";
669 std::optional<std::vector<std::string>> optKeyUsage =
670 std::vector<std::string>();
671 std::optional<std::string> optSurname = "";
672 std::optional<std::string> optUnstructuredName = "";
673 if (!json_util::readJsonAction(
674 req, asyncResp->res, "City", city, "CommonName", commonName,
675 "ContactPerson", optContactPerson, "Country", country,
676 "Organization", organization, "OrganizationalUnit",
Ed Tanous7a31e332024-03-06 12:17:43 -0800677 organizationalUnit, "State", state,
678 "CertificateCollection/@odata.id", certURI, "AlternativeNames",
679 optAlternativeNames, "ChallengePassword", optChallengePassword,
680 "Email", optEmail, "GivenName", optGivenName, "Initials",
681 optInitials, "KeyBitLength", optKeyBitLength, "KeyCurveId",
682 optKeyCurveId, "KeyPairAlgorithm", optKeyPairAlgorithm, "KeyUsage",
683 optKeyUsage, "Surname", optSurname, "UnstructuredName",
684 optUnstructuredName))
Jiaqing Zhao828252d2022-09-30 13:59:19 +0800685 {
686 return;
687 }
688
689 // bmcweb has no way to store or decode a private key challenge
690 // password, which will likely cause bmcweb to crash on startup
691 // if this is not set on a post so not allowing the user to set
692 // value
693 if (!optChallengePassword->empty())
694 {
695 messages::actionParameterNotSupported(asyncResp->res, "GenerateCSR",
696 "ChallengePassword");
697 return;
698 }
699
Jiaqing Zhao828252d2022-09-30 13:59:19 +0800700 std::string objectPath;
701 std::string service;
Ed Tanous253f11b2024-05-16 09:38:31 -0700702 if (certURI.starts_with(std::format(
703 "/redfish/v1/Managers/{}/NetworkProtocol/HTTPS/Certificates",
704 BMCWEB_REDFISH_MANAGER_URI_NAME)))
Jiaqing Zhao828252d2022-09-30 13:59:19 +0800705 {
706 objectPath = certs::httpsObjectPath;
707 service = certs::httpsServiceName;
708 }
709 else if (certURI.starts_with(
710 "/redfish/v1/AccountService/LDAP/Certificates"))
711 {
712 objectPath = certs::ldapObjectPath;
713 service = certs::ldapServiceName;
714 }
715 else
716 {
717 messages::actionParameterNotSupported(
718 asyncResp->res, "CertificateCollection", "GenerateCSR");
719 return;
720 }
721
722 // supporting only EC and RSA algorithm
723 if (*optKeyPairAlgorithm != "EC" && *optKeyPairAlgorithm != "RSA")
724 {
725 messages::actionParameterNotSupported(
726 asyncResp->res, "KeyPairAlgorithm", "GenerateCSR");
727 return;
728 }
729
730 // supporting only 2048 key bit length for RSA algorithm due to
731 // time consumed in generating private key
732 if (*optKeyPairAlgorithm == "RSA" && *optKeyBitLength != rsaKeyBitLength)
733 {
Ed Tanouse2616cc2022-06-27 12:45:55 -0700734 messages::propertyValueNotInList(asyncResp->res, *optKeyBitLength,
735 "KeyBitLength");
Jiaqing Zhao828252d2022-09-30 13:59:19 +0800736 return;
737 }
738
739 // validate KeyUsage supporting only 1 type based on URL
Ed Tanous253f11b2024-05-16 09:38:31 -0700740 if (certURI.starts_with(std::format(
741 "/redfish/v1/Managers/{}/NetworkProtocol/HTTPS/Certificates",
742 BMCWEB_REDFISH_MANAGER_URI_NAME)))
Jiaqing Zhao828252d2022-09-30 13:59:19 +0800743 {
744 if (optKeyUsage->empty())
745 {
Patrick Williamsb2ba3072023-05-12 10:27:39 -0500746 optKeyUsage->emplace_back("ServerAuthentication");
Jiaqing Zhao828252d2022-09-30 13:59:19 +0800747 }
748 else if (optKeyUsage->size() == 1)
749 {
750 if ((*optKeyUsage)[0] != "ServerAuthentication")
751 {
752 messages::propertyValueNotInList(asyncResp->res,
753 (*optKeyUsage)[0], "KeyUsage");
754 return;
755 }
756 }
757 else
758 {
759 messages::actionParameterNotSupported(asyncResp->res, "KeyUsage",
760 "GenerateCSR");
761 return;
762 }
763 }
764 else if (certURI.starts_with(
765 "/redfish/v1/AccountService/LDAP/Certificates"))
766 {
767 if (optKeyUsage->empty())
768 {
Patrick Williamsb2ba3072023-05-12 10:27:39 -0500769 optKeyUsage->emplace_back("ClientAuthentication");
Jiaqing Zhao828252d2022-09-30 13:59:19 +0800770 }
771 else if (optKeyUsage->size() == 1)
772 {
773 if ((*optKeyUsage)[0] != "ClientAuthentication")
774 {
775 messages::propertyValueNotInList(asyncResp->res,
776 (*optKeyUsage)[0], "KeyUsage");
777 return;
778 }
779 }
780 else
781 {
782 messages::actionParameterNotSupported(asyncResp->res, "KeyUsage",
783 "GenerateCSR");
784 return;
785 }
786 }
787
788 // Only allow one CSR matcher at a time so setting retry
789 // time-out and timer expiry to 10 seconds for now.
790 static const int timeOut = 10;
791 if (csrMatcher)
792 {
793 messages::serviceTemporarilyUnavailable(asyncResp->res,
794 std::to_string(timeOut));
795 return;
796 }
797
Ed Tanous8e8245d2024-04-11 22:21:38 -0700798 if (req.ioService == nullptr)
799 {
800 messages::internalError(asyncResp->res);
801 return;
802 }
803
Jiaqing Zhao828252d2022-09-30 13:59:19 +0800804 // Make this static so it survives outside this method
805 static boost::asio::steady_timer timeout(*req.ioService);
806 timeout.expires_after(std::chrono::seconds(timeOut));
807 timeout.async_wait([asyncResp](const boost::system::error_code& ec) {
808 csrMatcher = nullptr;
809 if (ec)
810 {
811 // operation_aborted is expected if timer is canceled
812 // before completion.
813 if (ec != boost::asio::error::operation_aborted)
814 {
Ed Tanous62598e32023-07-17 17:06:25 -0700815 BMCWEB_LOG_ERROR("Async_wait failed {}", ec);
Jiaqing Zhao828252d2022-09-30 13:59:19 +0800816 }
817 return;
818 }
Ed Tanous62598e32023-07-17 17:06:25 -0700819 BMCWEB_LOG_ERROR("Timed out waiting for Generating CSR");
Jiaqing Zhao828252d2022-09-30 13:59:19 +0800820 messages::internalError(asyncResp->res);
821 });
822
823 // create a matcher to wait on CSR object
Ed Tanous62598e32023-07-17 17:06:25 -0700824 BMCWEB_LOG_DEBUG("create matcher with path {}", objectPath);
Jiaqing Zhao828252d2022-09-30 13:59:19 +0800825 std::string match("type='signal',"
826 "interface='org.freedesktop.DBus.ObjectManager',"
827 "path='" +
828 objectPath +
829 "',"
830 "member='InterfacesAdded'");
831 csrMatcher = std::make_unique<sdbusplus::bus::match_t>(
832 *crow::connections::systemBus, match,
833 [asyncResp, service, objectPath, certURI](sdbusplus::message_t& m) {
Patrick Williamsbd79bce2024-08-16 15:22:20 -0400834 timeout.cancel();
835 if (m.is_method_error())
Jiaqing Zhao828252d2022-09-30 13:59:19 +0800836 {
Patrick Williamsbd79bce2024-08-16 15:22:20 -0400837 BMCWEB_LOG_ERROR("Dbus method error!!!");
838 messages::internalError(asyncResp->res);
839 return;
Jiaqing Zhao828252d2022-09-30 13:59:19 +0800840 }
Patrick Williamsbd79bce2024-08-16 15:22:20 -0400841
842 dbus::utility::DBusInterfacesMap interfacesProperties;
843
844 sdbusplus::message::object_path csrObjectPath;
845 m.read(csrObjectPath, interfacesProperties);
846 BMCWEB_LOG_DEBUG("CSR object added{}", csrObjectPath.str);
847 for (const auto& interface : interfacesProperties)
848 {
849 if (interface.first == "xyz.openbmc_project.Certs.CSR")
850 {
851 getCSR(asyncResp, certURI, service, objectPath,
852 csrObjectPath.str);
853 break;
854 }
855 }
856 });
Jiaqing Zhao828252d2022-09-30 13:59:19 +0800857 crow::connections::systemBus->async_method_call(
Ed Tanous5e7e2dc2023-02-16 10:37:01 -0800858 [asyncResp](const boost::system::error_code& ec, const std::string&) {
Patrick Williamsbd79bce2024-08-16 15:22:20 -0400859 if (ec)
860 {
861 BMCWEB_LOG_ERROR("DBUS response error: {}", ec.message());
862 messages::internalError(asyncResp->res);
863 return;
864 }
865 },
Jiaqing Zhao828252d2022-09-30 13:59:19 +0800866 service, objectPath, "xyz.openbmc_project.Certs.CSR.Create",
867 "GenerateCSR", *optAlternativeNames, *optChallengePassword, city,
868 commonName, *optContactPerson, country, *optEmail, *optGivenName,
869 *optInitials, *optKeyBitLength, *optKeyCurveId, *optKeyPairAlgorithm,
870 *optKeyUsage, organization, organizationalUnit, state, *optSurname,
871 *optUnstructuredName);
872}
873
874inline void requestRoutesCertificateService(App& app)
875{
876 BMCWEB_ROUTE(app, "/redfish/v1/CertificateService/")
877 .privileges(redfish::privileges::getCertificateService)
878 .methods(boost::beast::http::verb::get)(
879 std::bind_front(handleCertificateServiceGet, std::ref(app)));
880
881 BMCWEB_ROUTE(app, "/redfish/v1/CertificateService/CertificateLocations/")
882 .privileges(redfish::privileges::getCertificateLocations)
883 .methods(boost::beast::http::verb::get)(
884 std::bind_front(handleCertificateLocationsGet, std::ref(app)));
885
George Liu0fda0f12021-11-16 10:06:17 +0800886 BMCWEB_ROUTE(
887 app,
888 "/redfish/v1/CertificateService/Actions/CertificateService.ReplaceCertificate/")
Ed Tanoused398212021-06-09 17:05:54 -0700889 .privileges(redfish::privileges::postCertificateService)
Ed Tanous002d39b2022-05-31 08:59:27 -0700890 .methods(boost::beast::http::verb::post)(
Jiaqing Zhao828252d2022-09-30 13:59:19 +0800891 std::bind_front(handleReplaceCertificateAction, std::ref(app)));
Marri Devender Rao5968cae2019-01-21 10:27:12 -0600892
Jiaqing Zhao828252d2022-09-30 13:59:19 +0800893 BMCWEB_ROUTE(
894 app,
895 "/redfish/v1/CertificateService/Actions/CertificateService.GenerateCSR/")
896 .privileges(redfish::privileges::postCertificateService)
897 .methods(boost::beast::http::verb::post)(
898 std::bind_front(handleGenerateCSRAction, std::ref(app)));
899} // requestRoutesCertificateService
900
901inline void handleHTTPSCertificateCollectionGet(
902 App& app, const crow::Request& req,
Ed Tanous253f11b2024-05-16 09:38:31 -0700903 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
904 const std::string& managerId)
Jiaqing Zhao828252d2022-09-30 13:59:19 +0800905{
906 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
907 {
908 return;
909 }
910
Ed Tanous253f11b2024-05-16 09:38:31 -0700911 if (managerId != BMCWEB_REDFISH_MANAGER_URI_NAME)
912 {
913 messages::resourceNotFound(asyncResp->res, "Manager", managerId);
914 return;
915 }
916
917 asyncResp->res.jsonValue["@odata.id"] = boost::urls::format(
918 "/redfish/v1/Managers/{}/NetworkProtocol/HTTPS/Certificates",
919 BMCWEB_REDFISH_MANAGER_URI_NAME);
Jiaqing Zhao828252d2022-09-30 13:59:19 +0800920 asyncResp->res.jsonValue["@odata.type"] =
921 "#CertificateCollection.CertificateCollection";
922 asyncResp->res.jsonValue["Name"] = "HTTPS Certificates Collection";
923 asyncResp->res.jsonValue["Description"] =
924 "A Collection of HTTPS certificate instances";
925
926 getCertificateList(asyncResp, certs::httpsObjectPath,
927 "/Members"_json_pointer,
928 "/Members@odata.count"_json_pointer);
929}
930
931inline void handleHTTPSCertificateCollectionPost(
932 App& app, const crow::Request& req,
Ed Tanous253f11b2024-05-16 09:38:31 -0700933 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
934 const std::string& managerId)
Jiaqing Zhao828252d2022-09-30 13:59:19 +0800935{
936 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
937 {
938 return;
939 }
Ed Tanous253f11b2024-05-16 09:38:31 -0700940
941 if (managerId != BMCWEB_REDFISH_MANAGER_URI_NAME)
942 {
943 messages::resourceNotFound(asyncResp->res, "Manager", managerId);
944 return;
945 }
946
Ed Tanous62598e32023-07-17 17:06:25 -0700947 BMCWEB_LOG_DEBUG("HTTPSCertificateCollection::doPost");
Jiaqing Zhao828252d2022-09-30 13:59:19 +0800948
949 asyncResp->res.jsonValue["Name"] = "HTTPS Certificate";
950 asyncResp->res.jsonValue["Description"] = "HTTPS Certificate";
951
Ed Tanousb2896142024-01-31 15:25:47 -0800952 std::string certHttpBody = getCertificateFromReqBody(asyncResp, req);
Jiaqing Zhao828252d2022-09-30 13:59:19 +0800953
Ed Tanousb2896142024-01-31 15:25:47 -0800954 if (certHttpBody.empty())
Jiaqing Zhao828252d2022-09-30 13:59:19 +0800955 {
Ed Tanous62598e32023-07-17 17:06:25 -0700956 BMCWEB_LOG_ERROR("Cannot get certificate from request body.");
Jiaqing Zhao828252d2022-09-30 13:59:19 +0800957 messages::unrecognizedRequestBody(asyncResp->res);
958 return;
959 }
960
961 std::shared_ptr<CertificateFile> certFile =
Ed Tanousb2896142024-01-31 15:25:47 -0800962 std::make_shared<CertificateFile>(certHttpBody);
Jiaqing Zhao828252d2022-09-30 13:59:19 +0800963
964 crow::connections::systemBus->async_method_call(
Ed Tanous5e7e2dc2023-02-16 10:37:01 -0800965 [asyncResp, certFile](const boost::system::error_code& ec,
Jiaqing Zhao828252d2022-09-30 13:59:19 +0800966 const std::string& objectPath) {
Patrick Williamsbd79bce2024-08-16 15:22:20 -0400967 if (ec)
968 {
969 BMCWEB_LOG_ERROR("DBUS response error: {}", ec);
970 messages::internalError(asyncResp->res);
971 return;
972 }
Ed Tanous002d39b2022-05-31 08:59:27 -0700973
Patrick Williamsbd79bce2024-08-16 15:22:20 -0400974 sdbusplus::message::object_path path(objectPath);
975 std::string certId = path.filename();
976 const boost::urls::url certURL = boost::urls::format(
977 "/redfish/v1/Managers/{}/NetworkProtocol/HTTPS/Certificates/{}",
978 BMCWEB_REDFISH_MANAGER_URI_NAME, certId);
979 getCertificateProperties(asyncResp, objectPath,
980 certs::httpsServiceName, certId, certURL,
981 "HTTPS Certificate");
982 BMCWEB_LOG_DEBUG("HTTPS certificate install file={}",
983 certFile->getCertFilePath());
984 },
Jiaqing Zhao828252d2022-09-30 13:59:19 +0800985 certs::httpsServiceName, certs::httpsObjectPath, certs::certInstallIntf,
986 "Install", certFile->getCertFilePath());
987}
Ed Tanous002d39b2022-05-31 08:59:27 -0700988
Jiaqing Zhao828252d2022-09-30 13:59:19 +0800989inline void handleHTTPSCertificateGet(
990 App& app, const crow::Request& req,
Ed Tanous253f11b2024-05-16 09:38:31 -0700991 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
992 const std::string& managerId, const std::string& certId)
Jiaqing Zhao828252d2022-09-30 13:59:19 +0800993{
994 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
995 {
996 return;
997 }
Ed Tanous002d39b2022-05-31 08:59:27 -0700998
Ed Tanous253f11b2024-05-16 09:38:31 -0700999 if (managerId != BMCWEB_REDFISH_MANAGER_URI_NAME)
1000 {
1001 messages::resourceNotFound(asyncResp->res, "Manager", managerId);
1002 return;
1003 }
1004
1005 BMCWEB_LOG_DEBUG("HTTPS Certificate ID={}", certId);
Ed Tanousef4c65b2023-04-24 15:28:50 -07001006 const boost::urls::url certURL = boost::urls::format(
Ed Tanous253f11b2024-05-16 09:38:31 -07001007 "/redfish/v1/Managers/{}/NetworkProtocol/HTTPS/Certificates/{}",
1008 BMCWEB_REDFISH_MANAGER_URI_NAME, certId);
Jiaqing Zhao828252d2022-09-30 13:59:19 +08001009 std::string objPath =
Ed Tanous253f11b2024-05-16 09:38:31 -07001010 sdbusplus::message::object_path(certs::httpsObjectPath) / certId;
1011 getCertificateProperties(asyncResp, objPath, certs::httpsServiceName,
1012 certId, certURL, "HTTPS Certificate");
Jiaqing Zhao828252d2022-09-30 13:59:19 +08001013}
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001014
1015inline void requestRoutesHTTPSCertificate(App& app)
Marri Devender Rao5968cae2019-01-21 10:27:12 -06001016{
Ed Tanous253f11b2024-05-16 09:38:31 -07001017 BMCWEB_ROUTE(
1018 app, "/redfish/v1/Managers/<str>/NetworkProtocol/HTTPS/Certificates/")
Jiaqing Zhao828252d2022-09-30 13:59:19 +08001019 .privileges(redfish::privileges::getCertificateCollection)
1020 .methods(boost::beast::http::verb::get)(std::bind_front(
1021 handleHTTPSCertificateCollectionGet, std::ref(app)));
1022
Ed Tanous253f11b2024-05-16 09:38:31 -07001023 BMCWEB_ROUTE(
1024 app, "/redfish/v1/Managers/<str>/NetworkProtocol/HTTPS/Certificates/")
Jiaqing Zhao828252d2022-09-30 13:59:19 +08001025 .privileges(redfish::privileges::postCertificateCollection)
1026 .methods(boost::beast::http::verb::post)(std::bind_front(
1027 handleHTTPSCertificateCollectionPost, std::ref(app)));
1028
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001029 BMCWEB_ROUTE(
1030 app,
Ed Tanous253f11b2024-05-16 09:38:31 -07001031 "/redfish/v1/Managers/<str>/NetworkProtocol/HTTPS/Certificates/<str>/")
Ed Tanoused398212021-06-09 17:05:54 -07001032 .privileges(redfish::privileges::getCertificate)
Jiaqing Zhao1e312592022-06-14 12:58:09 +08001033 .methods(boost::beast::http::verb::get)(
Jiaqing Zhao828252d2022-09-30 13:59:19 +08001034 std::bind_front(handleHTTPSCertificateGet, std::ref(app)));
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001035}
Marri Devender Rao5968cae2019-01-21 10:27:12 -06001036
Jiaqing Zhao828252d2022-09-30 13:59:19 +08001037inline void handleLDAPCertificateCollectionGet(
1038 App& app, const crow::Request& req,
1039 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp)
Marri Devender Rao5968cae2019-01-21 10:27:12 -06001040{
Jiaqing Zhao828252d2022-09-30 13:59:19 +08001041 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
1042 {
1043 return;
1044 }
Ed Tanous002d39b2022-05-31 08:59:27 -07001045
Jiaqing Zhao828252d2022-09-30 13:59:19 +08001046 asyncResp->res.jsonValue["@odata.id"] =
1047 "/redfish/v1/AccountService/LDAP/Certificates";
1048 asyncResp->res.jsonValue["@odata.type"] =
1049 "#CertificateCollection.CertificateCollection";
1050 asyncResp->res.jsonValue["Name"] = "LDAP Certificates Collection";
1051 asyncResp->res.jsonValue["Description"] =
1052 "A Collection of LDAP certificate instances";
Ed Tanous002d39b2022-05-31 08:59:27 -07001053
Jiaqing Zhao828252d2022-09-30 13:59:19 +08001054 getCertificateList(asyncResp, certs::ldapObjectPath,
1055 "/Members"_json_pointer,
1056 "/Members@odata.count"_json_pointer);
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001057}
Marri Devender Rao37cce912019-02-20 01:05:22 -06001058
Jiaqing Zhao828252d2022-09-30 13:59:19 +08001059inline void handleLDAPCertificateCollectionPost(
1060 App& app, const crow::Request& req,
1061 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp)
Marri Devender Rao37cce912019-02-20 01:05:22 -06001062{
Jiaqing Zhao828252d2022-09-30 13:59:19 +08001063 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
1064 {
1065 return;
1066 }
Ed Tanousb2896142024-01-31 15:25:47 -08001067 std::string certHttpBody = getCertificateFromReqBody(asyncResp, req);
Jiaqing Zhao828252d2022-09-30 13:59:19 +08001068
Ed Tanousb2896142024-01-31 15:25:47 -08001069 if (certHttpBody.empty())
Jiaqing Zhao828252d2022-09-30 13:59:19 +08001070 {
Ed Tanous62598e32023-07-17 17:06:25 -07001071 BMCWEB_LOG_ERROR("Cannot get certificate from request body.");
Jiaqing Zhao828252d2022-09-30 13:59:19 +08001072 messages::unrecognizedRequestBody(asyncResp->res);
1073 return;
1074 }
1075
1076 std::shared_ptr<CertificateFile> certFile =
Ed Tanousb2896142024-01-31 15:25:47 -08001077 std::make_shared<CertificateFile>(certHttpBody);
Jiaqing Zhao828252d2022-09-30 13:59:19 +08001078
1079 crow::connections::systemBus->async_method_call(
Ed Tanous5e7e2dc2023-02-16 10:37:01 -08001080 [asyncResp, certFile](const boost::system::error_code& ec,
Jiaqing Zhao828252d2022-09-30 13:59:19 +08001081 const std::string& objectPath) {
Patrick Williamsbd79bce2024-08-16 15:22:20 -04001082 if (ec)
1083 {
1084 BMCWEB_LOG_ERROR("DBUS response error: {}", ec);
1085 messages::internalError(asyncResp->res);
1086 return;
1087 }
Ed Tanous002d39b2022-05-31 08:59:27 -07001088
Patrick Williamsbd79bce2024-08-16 15:22:20 -04001089 sdbusplus::message::object_path path(objectPath);
1090 std::string certId = path.filename();
1091 const boost::urls::url certURL = boost::urls::format(
1092 "/redfish/v1/AccountService/LDAP/Certificates/{}", certId);
1093 getCertificateProperties(asyncResp, objectPath,
1094 certs::ldapServiceName, certId, certURL,
1095 "LDAP Certificate");
1096 BMCWEB_LOG_DEBUG("LDAP certificate install file={}",
1097 certFile->getCertFilePath());
1098 },
Jiaqing Zhao828252d2022-09-30 13:59:19 +08001099 certs::ldapServiceName, certs::ldapObjectPath, certs::certInstallIntf,
1100 "Install", certFile->getCertFilePath());
1101}
Ed Tanous002d39b2022-05-31 08:59:27 -07001102
Jiaqing Zhao828252d2022-09-30 13:59:19 +08001103inline void handleLDAPCertificateGet(
1104 App& app, const crow::Request& req,
1105 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp, const std::string& id)
1106{
1107 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
1108 {
1109 return;
1110 }
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001111
Ed Tanous62598e32023-07-17 17:06:25 -07001112 BMCWEB_LOG_DEBUG("LDAP Certificate ID={}", id);
Ed Tanousef4c65b2023-04-24 15:28:50 -07001113 const boost::urls::url certURL = boost::urls::format(
1114 "/redfish/v1/AccountService/LDAP/Certificates/{}", id);
Jiaqing Zhao828252d2022-09-30 13:59:19 +08001115 std::string objPath =
1116 sdbusplus::message::object_path(certs::ldapObjectPath) / id;
1117 getCertificateProperties(asyncResp, objPath, certs::ldapServiceName, id,
1118 certURL, "LDAP Certificate");
1119}
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001120
Jiaqing Zhao99612242022-09-29 15:31:09 +08001121inline void handleLDAPCertificateDelete(
1122 App& app, const crow::Request& req,
1123 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp, const std::string& id)
1124{
1125 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
1126 {
1127 return;
1128 }
1129
Ed Tanous62598e32023-07-17 17:06:25 -07001130 BMCWEB_LOG_DEBUG("Delete LDAP Certificate ID={}", id);
Jiaqing Zhao99612242022-09-29 15:31:09 +08001131 std::string objPath =
1132 sdbusplus::message::object_path(certs::ldapObjectPath) / id;
1133
1134 deleteCertificate(asyncResp, certs::ldapServiceName, objPath);
1135}
1136
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001137inline void requestRoutesLDAPCertificate(App& app)
Marri Devender Rao37cce912019-02-20 01:05:22 -06001138{
Jiaqing Zhao828252d2022-09-30 13:59:19 +08001139 BMCWEB_ROUTE(app, "/redfish/v1/AccountService/LDAP/Certificates/")
1140 .privileges(redfish::privileges::getCertificateCollection)
1141 .methods(boost::beast::http::verb::get)(
1142 std::bind_front(handleLDAPCertificateCollectionGet, std::ref(app)));
1143
1144 BMCWEB_ROUTE(app, "/redfish/v1/AccountService/LDAP/Certificates/")
1145 .privileges(redfish::privileges::postCertificateCollection)
1146 .methods(boost::beast::http::verb::post)(std::bind_front(
1147 handleLDAPCertificateCollectionPost, std::ref(app)));
1148
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001149 BMCWEB_ROUTE(app, "/redfish/v1/AccountService/LDAP/Certificates/<str>/")
Ed Tanoused398212021-06-09 17:05:54 -07001150 .privileges(redfish::privileges::getCertificate)
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001151 .methods(boost::beast::http::verb::get)(
Jiaqing Zhao828252d2022-09-30 13:59:19 +08001152 std::bind_front(handleLDAPCertificateGet, std::ref(app)));
Jiaqing Zhao99612242022-09-29 15:31:09 +08001153
1154 BMCWEB_ROUTE(app, "/redfish/v1/AccountService/LDAP/Certificates/<str>/")
1155 .privileges(redfish::privileges::deleteCertificate)
1156 .methods(boost::beast::http::verb::delete_)(
1157 std::bind_front(handleLDAPCertificateDelete, std::ref(app)));
Jiaqing Zhao828252d2022-09-30 13:59:19 +08001158} // requestRoutesLDAPCertificate
1159
1160inline void handleTrustStoreCertificateCollectionGet(
1161 App& app, const crow::Request& req,
Ed Tanous253f11b2024-05-16 09:38:31 -07001162 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
1163 const std::string& managerId)
Jiaqing Zhao828252d2022-09-30 13:59:19 +08001164{
1165 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
1166 {
1167 return;
1168 }
1169
Ed Tanous253f11b2024-05-16 09:38:31 -07001170 if (managerId != BMCWEB_REDFISH_MANAGER_URI_NAME)
1171 {
1172 messages::resourceNotFound(asyncResp->res, "Manager", managerId);
1173 return;
1174 }
1175
Jiaqing Zhao828252d2022-09-30 13:59:19 +08001176 asyncResp->res.jsonValue["@odata.id"] =
Ed Tanous253f11b2024-05-16 09:38:31 -07001177 boost::urls::format("/redfish/v1/Managers/{}/Truststore/Certificates/",
1178 BMCWEB_REDFISH_MANAGER_URI_NAME);
Jiaqing Zhao828252d2022-09-30 13:59:19 +08001179 asyncResp->res.jsonValue["@odata.type"] =
1180 "#CertificateCollection.CertificateCollection";
1181 asyncResp->res.jsonValue["Name"] = "TrustStore Certificates Collection";
1182 asyncResp->res.jsonValue["Description"] =
1183 "A Collection of TrustStore certificate instances";
1184
1185 getCertificateList(asyncResp, certs::authorityObjectPath,
1186 "/Members"_json_pointer,
1187 "/Members@odata.count"_json_pointer);
1188}
1189
1190inline void handleTrustStoreCertificateCollectionPost(
1191 App& app, const crow::Request& req,
Ed Tanous253f11b2024-05-16 09:38:31 -07001192 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
1193 const std::string& managerId)
Jiaqing Zhao828252d2022-09-30 13:59:19 +08001194{
1195 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
1196 {
1197 return;
1198 }
Ed Tanous253f11b2024-05-16 09:38:31 -07001199
1200 if (managerId != BMCWEB_REDFISH_MANAGER_URI_NAME)
1201 {
1202 messages::resourceNotFound(asyncResp->res, "Manager", managerId);
1203 return;
1204 }
1205
Ed Tanousb2896142024-01-31 15:25:47 -08001206 std::string certHttpBody = getCertificateFromReqBody(asyncResp, req);
Jiaqing Zhao828252d2022-09-30 13:59:19 +08001207
Ed Tanousb2896142024-01-31 15:25:47 -08001208 if (certHttpBody.empty())
Jiaqing Zhao828252d2022-09-30 13:59:19 +08001209 {
Ed Tanous62598e32023-07-17 17:06:25 -07001210 BMCWEB_LOG_ERROR("Cannot get certificate from request body.");
Jiaqing Zhao828252d2022-09-30 13:59:19 +08001211 messages::unrecognizedRequestBody(asyncResp->res);
1212 return;
1213 }
1214
1215 std::shared_ptr<CertificateFile> certFile =
Ed Tanousb2896142024-01-31 15:25:47 -08001216 std::make_shared<CertificateFile>(certHttpBody);
Jiaqing Zhao828252d2022-09-30 13:59:19 +08001217 crow::connections::systemBus->async_method_call(
Ed Tanous5e7e2dc2023-02-16 10:37:01 -08001218 [asyncResp, certFile](const boost::system::error_code& ec,
Jiaqing Zhao828252d2022-09-30 13:59:19 +08001219 const std::string& objectPath) {
Patrick Williamsbd79bce2024-08-16 15:22:20 -04001220 if (ec)
1221 {
1222 BMCWEB_LOG_ERROR("DBUS response error: {}", ec);
1223 messages::internalError(asyncResp->res);
1224 return;
1225 }
Jiaqing Zhao717b9802022-06-06 20:24:04 +08001226
Patrick Williamsbd79bce2024-08-16 15:22:20 -04001227 sdbusplus::message::object_path path(objectPath);
1228 std::string certId = path.filename();
1229 const boost::urls::url certURL = boost::urls::format(
1230 "/redfish/v1/Managers/{}/Truststore/Certificates/{}",
1231 BMCWEB_REDFISH_MANAGER_URI_NAME, certId);
1232 getCertificateProperties(asyncResp, objectPath,
1233 certs::authorityServiceName, certId,
1234 certURL, "TrustStore Certificate");
1235 BMCWEB_LOG_DEBUG("TrustStore certificate install file={}",
1236 certFile->getCertFilePath());
1237 },
Jiaqing Zhao828252d2022-09-30 13:59:19 +08001238 certs::authorityServiceName, certs::authorityObjectPath,
1239 certs::certInstallIntf, "Install", certFile->getCertFilePath());
1240}
1241
1242inline void handleTrustStoreCertificateGet(
1243 App& app, const crow::Request& req,
Ed Tanous253f11b2024-05-16 09:38:31 -07001244 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
1245 const std::string& managerId, const std::string& certId)
Jiaqing Zhao828252d2022-09-30 13:59:19 +08001246{
1247 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
1248 {
1249 return;
1250 }
1251
Ed Tanous253f11b2024-05-16 09:38:31 -07001252 if (managerId != BMCWEB_REDFISH_MANAGER_URI_NAME)
1253 {
1254 messages::resourceNotFound(asyncResp->res, "Manager", managerId);
1255 return;
1256 }
1257
1258 BMCWEB_LOG_DEBUG("Truststore Certificate ID={}", certId);
Ed Tanousef4c65b2023-04-24 15:28:50 -07001259 const boost::urls::url certURL = boost::urls::format(
Ed Tanous253f11b2024-05-16 09:38:31 -07001260 "/redfish/v1/Managers/{}/Truststore/Certificates/{}",
1261 BMCWEB_REDFISH_MANAGER_URI_NAME, certId);
Jiaqing Zhao828252d2022-09-30 13:59:19 +08001262 std::string objPath =
Ed Tanous253f11b2024-05-16 09:38:31 -07001263 sdbusplus::message::object_path(certs::authorityObjectPath) / certId;
Jiaqing Zhao828252d2022-09-30 13:59:19 +08001264 getCertificateProperties(asyncResp, objPath, certs::authorityServiceName,
Ed Tanous253f11b2024-05-16 09:38:31 -07001265 certId, certURL, "TrustStore Certificate");
Jiaqing Zhao828252d2022-09-30 13:59:19 +08001266}
1267
1268inline void handleTrustStoreCertificateDelete(
1269 App& app, const crow::Request& req,
Ed Tanous253f11b2024-05-16 09:38:31 -07001270 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
1271 const std::string& managerId, const std::string& certId)
Jiaqing Zhao828252d2022-09-30 13:59:19 +08001272{
1273 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
1274 {
1275 return;
1276 }
1277
Ed Tanous253f11b2024-05-16 09:38:31 -07001278 if (managerId != BMCWEB_REDFISH_MANAGER_URI_NAME)
1279 {
1280 messages::resourceNotFound(asyncResp->res, "Manager", managerId);
1281 return;
1282 }
1283
1284 BMCWEB_LOG_DEBUG("Delete TrustStore Certificate ID={}", certId);
Jiaqing Zhao828252d2022-09-30 13:59:19 +08001285 std::string objPath =
Ed Tanous253f11b2024-05-16 09:38:31 -07001286 sdbusplus::message::object_path(certs::authorityObjectPath) / certId;
Jiaqing Zhao828252d2022-09-30 13:59:19 +08001287
Jiaqing Zhao7a3a8f72022-09-29 15:15:58 +08001288 deleteCertificate(asyncResp, certs::authorityServiceName, objPath);
Jiaqing Zhao828252d2022-09-30 13:59:19 +08001289}
1290
1291inline void requestRoutesTrustStoreCertificate(App& app)
Marri Devender Raocfcd5f62019-05-17 08:34:37 -05001292{
Ed Tanous253f11b2024-05-16 09:38:31 -07001293 BMCWEB_ROUTE(app, "/redfish/v1/Managers/<str>/Truststore/Certificates/")
Ed Tanoused398212021-06-09 17:05:54 -07001294 .privileges(redfish::privileges::getCertificate)
Jiaqing Zhao828252d2022-09-30 13:59:19 +08001295 .methods(boost::beast::http::verb::get)(std::bind_front(
1296 handleTrustStoreCertificateCollectionGet, std::ref(app)));
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001297
Ed Tanous253f11b2024-05-16 09:38:31 -07001298 BMCWEB_ROUTE(app, "/redfish/v1/Managers/<str>/Truststore/Certificates/")
Ed Tanoused398212021-06-09 17:05:54 -07001299 .privileges(redfish::privileges::postCertificateCollection)
Jiaqing Zhao828252d2022-09-30 13:59:19 +08001300 .methods(boost::beast::http::verb::post)(std::bind_front(
1301 handleTrustStoreCertificateCollectionPost, std::ref(app)));
Ed Tanous002d39b2022-05-31 08:59:27 -07001302
Ed Tanous253f11b2024-05-16 09:38:31 -07001303 BMCWEB_ROUTE(app,
1304 "/redfish/v1/Managers/<str>/Truststore/Certificates/<str>/")
Ed Tanoused398212021-06-09 17:05:54 -07001305 .privileges(redfish::privileges::getCertificate)
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001306 .methods(boost::beast::http::verb::get)(
Jiaqing Zhao828252d2022-09-30 13:59:19 +08001307 std::bind_front(handleTrustStoreCertificateGet, std::ref(app)));
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001308
Ed Tanous253f11b2024-05-16 09:38:31 -07001309 BMCWEB_ROUTE(app,
1310 "/redfish/v1/Managers/<str>/Truststore/Certificates/<str>/")
Ed Tanoused398212021-06-09 17:05:54 -07001311 .privileges(redfish::privileges::deleteCertificate)
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001312 .methods(boost::beast::http::verb::delete_)(
Jiaqing Zhao828252d2022-09-30 13:59:19 +08001313 std::bind_front(handleTrustStoreCertificateDelete, std::ref(app)));
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001314} // requestRoutesTrustStoreCertificate
Marri Devender Rao5968cae2019-01-21 10:27:12 -06001315} // namespace redfish