Tom Joseph | 8bb10b7 | 2016-12-06 17:47:56 +0530 | [diff] [blame] | 1 | #include "rakp12.hpp" |
| 2 | |
Vernon Mauery | 9e801a2 | 2018-10-12 13:20:49 -0700 | [diff] [blame] | 3 | #include "comm_module.hpp" |
| 4 | #include "endian.hpp" |
| 5 | #include "guid.hpp" |
| 6 | #include "main.hpp" |
| 7 | |
Tom Joseph | 8bb10b7 | 2016-12-06 17:47:56 +0530 | [diff] [blame] | 8 | #include <openssl/rand.h> |
| 9 | |
| 10 | #include <algorithm> |
Tom Joseph | 56527b9 | 2018-03-21 19:31:58 +0530 | [diff] [blame] | 11 | #include <cstring> |
Tom Joseph | 8bb10b7 | 2016-12-06 17:47:56 +0530 | [diff] [blame] | 12 | #include <iomanip> |
Vernon Mauery | fc37e59 | 2018-12-19 14:55:15 -0800 | [diff] [blame] | 13 | #include <phosphor-logging/log.hpp> |
Tom Joseph | 8bb10b7 | 2016-12-06 17:47:56 +0530 | [diff] [blame] | 14 | |
Vernon Mauery | fc37e59 | 2018-12-19 14:55:15 -0800 | [diff] [blame] | 15 | using namespace phosphor::logging; |
| 16 | |
Tom Joseph | 8bb10b7 | 2016-12-06 17:47:56 +0530 | [diff] [blame] | 17 | namespace command |
| 18 | { |
| 19 | |
AppaRao Puli | ecb32fb | 2020-07-01 22:55:38 +0530 | [diff] [blame] | 20 | bool isChannelAccessModeEnabled(const uint8_t accessMode) |
| 21 | { |
| 22 | return accessMode != |
| 23 | static_cast<uint8_t>(ipmi::EChannelAccessMode::disabled); |
| 24 | } |
| 25 | |
Tom Joseph | 18a45e9 | 2017-04-11 11:30:44 +0530 | [diff] [blame] | 26 | std::vector<uint8_t> RAKP12(const std::vector<uint8_t>& inPayload, |
Tom Joseph | 8bb10b7 | 2016-12-06 17:47:56 +0530 | [diff] [blame] | 27 | const message::Handler& handler) |
| 28 | { |
Tom Joseph | 18a45e9 | 2017-04-11 11:30:44 +0530 | [diff] [blame] | 29 | auto request = reinterpret_cast<const RAKP1request*>(inPayload.data()); |
Zhikui Ren | 2b1edef | 2020-07-24 14:32:13 -0700 | [diff] [blame] | 30 | // verify inPayload minimum size |
| 31 | if (inPayload.size() < (sizeof(*request) - userNameMaxLen)) |
| 32 | { |
| 33 | std::vector<uint8_t> errorPayload{IPMI_CC_REQ_DATA_LEN_INVALID}; |
| 34 | return errorPayload; |
| 35 | } |
| 36 | |
| 37 | std::vector<uint8_t> outPayload(sizeof(RAKP2response)); |
Tom Joseph | 8bb10b7 | 2016-12-06 17:47:56 +0530 | [diff] [blame] | 38 | auto response = reinterpret_cast<RAKP2response*>(outPayload.data()); |
| 39 | |
| 40 | // Session ID zero is reserved for Session Setup |
Vernon Mauery | 9e801a2 | 2018-10-12 13:20:49 -0700 | [diff] [blame] | 41 | if (endian::from_ipmi(request->managedSystemSessionID) == |
Suryakanth Sekar | f8a34fc | 2019-06-12 20:59:18 +0530 | [diff] [blame] | 42 | session::sessionZero) |
Tom Joseph | 8bb10b7 | 2016-12-06 17:47:56 +0530 | [diff] [blame] | 43 | { |
Vernon Mauery | fc37e59 | 2018-12-19 14:55:15 -0800 | [diff] [blame] | 44 | log<level::INFO>("RAKP12: BMC invalid Session ID"); |
Tom Joseph | 8bb10b7 | 2016-12-06 17:47:56 +0530 | [diff] [blame] | 45 | response->rmcpStatusCode = |
| 46 | static_cast<uint8_t>(RAKP_ReturnCode::INVALID_SESSION_ID); |
| 47 | return outPayload; |
| 48 | } |
| 49 | |
| 50 | std::shared_ptr<session::Session> session; |
| 51 | try |
| 52 | { |
Vernon Mauery | ae1fda4 | 2018-10-15 12:55:34 -0700 | [diff] [blame] | 53 | session = |
| 54 | std::get<session::Manager&>(singletonPool) |
| 55 | .getSession(endian::from_ipmi(request->managedSystemSessionID)); |
Tom Joseph | 8bb10b7 | 2016-12-06 17:47:56 +0530 | [diff] [blame] | 56 | } |
| 57 | catch (std::exception& e) |
| 58 | { |
Vernon Mauery | fc37e59 | 2018-12-19 14:55:15 -0800 | [diff] [blame] | 59 | log<level::ERR>("RAKP12 : session not found", |
| 60 | entry("EXCEPTION=%s", e.what())); |
Tom Joseph | 8bb10b7 | 2016-12-06 17:47:56 +0530 | [diff] [blame] | 61 | response->rmcpStatusCode = |
| 62 | static_cast<uint8_t>(RAKP_ReturnCode::INVALID_SESSION_ID); |
| 63 | return outPayload; |
| 64 | } |
| 65 | |
Vernon Mauery | 9e801a2 | 2018-10-12 13:20:49 -0700 | [diff] [blame] | 66 | auto rakp1Size = |
| 67 | sizeof(RAKP1request) - (userNameMaxLen - request->user_name_len); |
Tom Joseph | 56527b9 | 2018-03-21 19:31:58 +0530 | [diff] [blame] | 68 | |
| 69 | // Validate user name length in the message |
| 70 | if (request->user_name_len > userNameMaxLen || |
Vernon Mauery | 9e801a2 | 2018-10-12 13:20:49 -0700 | [diff] [blame] | 71 | inPayload.size() != rakp1Size) |
Tom Joseph | 56527b9 | 2018-03-21 19:31:58 +0530 | [diff] [blame] | 72 | { |
| 73 | response->rmcpStatusCode = |
| 74 | static_cast<uint8_t>(RAKP_ReturnCode::INVALID_NAME_LENGTH); |
| 75 | return outPayload; |
| 76 | } |
| 77 | |
| 78 | session->userName.assign(request->user_name, request->user_name_len); |
| 79 | |
Tom Joseph | 8bb10b7 | 2016-12-06 17:47:56 +0530 | [diff] [blame] | 80 | // Update transaction time |
| 81 | session->updateLastTransactionTime(); |
| 82 | |
| 83 | auto rcSessionID = endian::to_ipmi(session->getRCSessionID()); |
| 84 | auto bmcSessionID = endian::to_ipmi(session->getBMCSessionID()); |
| 85 | auto authAlgo = session->getAuthAlgo(); |
| 86 | |
| 87 | /* |
| 88 | * Generate Key Authentication Code - RAKP 2 |
| 89 | * |
| 90 | * 1) Remote Console Session ID - 4 bytes |
| 91 | * 2) Managed System Session ID - 4 bytes |
| 92 | * 3) Remote Console Random Number - 16 bytes |
| 93 | * 4) Managed System Random Number - 16 bytes |
| 94 | * 5) Managed System GUID - 16 bytes |
| 95 | * 6) Requested Privilege Level - 1 byte |
| 96 | * 7) User Name Length Byte - 1 byte (0 for 'null' username) |
| 97 | * 8) User Name - variable (absent for 'null' username) |
| 98 | */ |
| 99 | |
| 100 | std::vector<uint8_t> input; |
| 101 | input.resize(sizeof(rcSessionID) + sizeof(bmcSessionID) + |
| 102 | cipher::rakp_auth::REMOTE_CONSOLE_RANDOM_NUMBER_LEN + |
Vernon Mauery | 9e801a2 | 2018-10-12 13:20:49 -0700 | [diff] [blame] | 103 | cipher::rakp_auth::BMC_RANDOM_NUMBER_LEN + BMC_GUID_LEN + |
| 104 | sizeof(request->req_max_privilege_level) + |
| 105 | sizeof(request->user_name_len) + session->userName.size()); |
Tom Joseph | 8bb10b7 | 2016-12-06 17:47:56 +0530 | [diff] [blame] | 106 | |
| 107 | auto iter = input.begin(); |
| 108 | |
| 109 | // Remote Console Session ID |
Vernon Mauery | 9e801a2 | 2018-10-12 13:20:49 -0700 | [diff] [blame] | 110 | std::copy_n(reinterpret_cast<uint8_t*>(&rcSessionID), sizeof(rcSessionID), |
| 111 | iter); |
Tom Joseph | 8bb10b7 | 2016-12-06 17:47:56 +0530 | [diff] [blame] | 112 | std::advance(iter, sizeof(rcSessionID)); |
| 113 | |
| 114 | // Managed System Session ID |
| 115 | std::copy_n(reinterpret_cast<uint8_t*>(&bmcSessionID), sizeof(bmcSessionID), |
| 116 | iter); |
| 117 | std::advance(iter, sizeof(bmcSessionID)); |
| 118 | |
| 119 | // Copy the Remote Console Random Number from the RAKP1 request to the |
| 120 | // Authentication Algorithm |
Vernon Mauery | 9e801a2 | 2018-10-12 13:20:49 -0700 | [diff] [blame] | 121 | std::copy_n( |
| 122 | reinterpret_cast<const uint8_t*>(request->remote_console_random_number), |
| 123 | cipher::rakp_auth::REMOTE_CONSOLE_RANDOM_NUMBER_LEN, |
| 124 | authAlgo->rcRandomNum.begin()); |
Tom Joseph | 8bb10b7 | 2016-12-06 17:47:56 +0530 | [diff] [blame] | 125 | |
Vernon Mauery | 9e801a2 | 2018-10-12 13:20:49 -0700 | [diff] [blame] | 126 | std::copy(authAlgo->rcRandomNum.begin(), authAlgo->rcRandomNum.end(), iter); |
Tom Joseph | 8bb10b7 | 2016-12-06 17:47:56 +0530 | [diff] [blame] | 127 | std::advance(iter, cipher::rakp_auth::REMOTE_CONSOLE_RANDOM_NUMBER_LEN); |
| 128 | |
| 129 | // Generate the Managed System Random Number |
| 130 | if (!RAND_bytes(input.data() + sizeof(rcSessionID) + sizeof(bmcSessionID) + |
Vernon Mauery | 9e801a2 | 2018-10-12 13:20:49 -0700 | [diff] [blame] | 131 | cipher::rakp_auth::REMOTE_CONSOLE_RANDOM_NUMBER_LEN, |
Tom Joseph | 8bb10b7 | 2016-12-06 17:47:56 +0530 | [diff] [blame] | 132 | cipher::rakp_auth::BMC_RANDOM_NUMBER_LEN)) |
| 133 | { |
| 134 | response->rmcpStatusCode = |
| 135 | static_cast<uint8_t>(RAKP_ReturnCode::INSUFFICIENT_RESOURCE); |
| 136 | return outPayload; |
| 137 | } |
Richard Marian Thomaiyar | d5a4f45 | 2019-01-16 12:15:44 +0530 | [diff] [blame] | 138 | // As stated in Set Session Privilege Level command in IPMI Spec, when |
jayaprakash Mutyala | 2555e2e | 2019-12-24 22:51:46 +0000 | [diff] [blame] | 139 | // creating a session through Activate command / RAKP 1 message, it must |
| 140 | // be established with USER privilege as well as all other sessions are |
| 141 | // initially set to USER privilege, regardless of the requested maximum |
| 142 | // privilege. |
| 143 | if (!(static_cast<session::Privilege>(request->req_max_privilege_level & |
| 144 | session::reqMaxPrivMask) > |
| 145 | session::Privilege::CALLBACK)) |
Richard Marian Thomaiyar | d5a4f45 | 2019-01-16 12:15:44 +0530 | [diff] [blame] | 146 | { |
jayaprakash Mutyala | 2555e2e | 2019-12-24 22:51:46 +0000 | [diff] [blame] | 147 | response->rmcpStatusCode = |
| 148 | static_cast<uint8_t>(RAKP_ReturnCode::UNAUTH_ROLE_PRIV); |
| 149 | return outPayload; |
Richard Marian Thomaiyar | d5a4f45 | 2019-01-16 12:15:44 +0530 | [diff] [blame] | 150 | } |
jayaprakash Mutyala | 2555e2e | 2019-12-24 22:51:46 +0000 | [diff] [blame] | 151 | session->currentPrivilege(static_cast<uint8_t>(session::Privilege::USER)); |
| 152 | |
Tom Joseph | 4021b1f | 2019-02-12 10:10:12 +0530 | [diff] [blame] | 153 | session->reqMaxPrivLevel = |
| 154 | static_cast<session::Privilege>(request->req_max_privilege_level); |
Richard Marian Thomaiyar | d91fd9d | 2018-12-06 12:03:50 +0530 | [diff] [blame] | 155 | if (request->user_name_len == 0) |
Richard Marian Thomaiyar | 127748a | 2018-09-06 07:08:51 +0530 | [diff] [blame] | 156 | { |
Richard Marian Thomaiyar | d91fd9d | 2018-12-06 12:03:50 +0530 | [diff] [blame] | 157 | // Bail out, if user name is not specified. |
| 158 | // Yes, NULL user name is not supported for security reasons. |
Richard Marian Thomaiyar | 99b8784 | 2018-12-06 21:35:43 +0530 | [diff] [blame] | 159 | response->rmcpStatusCode = |
| 160 | static_cast<uint8_t>(RAKP_ReturnCode::UNAUTH_NAME); |
| 161 | return outPayload; |
Richard Marian Thomaiyar | d2563c5 | 2018-11-29 11:49:10 +0530 | [diff] [blame] | 162 | } |
Richard Marian Thomaiyar | 99b8784 | 2018-12-06 21:35:43 +0530 | [diff] [blame] | 163 | |
| 164 | // Perform user name based lookup |
| 165 | std::string userName(request->user_name, request->user_name_len); |
| 166 | std::string passwd; |
| 167 | uint8_t userId = ipmi::ipmiUserGetUserId(userName); |
| 168 | if (userId == ipmi::invalidUserId) |
| 169 | { |
| 170 | response->rmcpStatusCode = |
| 171 | static_cast<uint8_t>(RAKP_ReturnCode::UNAUTH_NAME); |
| 172 | return outPayload; |
| 173 | } |
| 174 | // check user is enabled before proceeding. |
| 175 | bool userEnabled = false; |
| 176 | ipmi::ipmiUserCheckEnabled(userId, userEnabled); |
| 177 | if (!userEnabled) |
| 178 | { |
| 179 | response->rmcpStatusCode = |
| 180 | static_cast<uint8_t>(RAKP_ReturnCode::INACTIVE_ROLE); |
| 181 | return outPayload; |
| 182 | } |
Richard Marian Thomaiyar | 4c4694e | 2019-06-20 16:36:49 +0530 | [diff] [blame] | 183 | // Get the user password for RAKP message authenticate |
| 184 | passwd = ipmi::ipmiUserGetPassword(userName); |
| 185 | if (passwd.empty()) |
| 186 | { |
| 187 | response->rmcpStatusCode = |
| 188 | static_cast<uint8_t>(RAKP_ReturnCode::UNAUTH_NAME); |
| 189 | return outPayload; |
| 190 | } |
Ayushi Smriti | b31e969 | 2019-05-15 12:06:51 +0000 | [diff] [blame] | 191 | // Check whether user is already locked for failed attempts |
| 192 | if (!ipmi::ipmiUserPamAuthenticate(userName, passwd)) |
| 193 | { |
| 194 | log<level::ERR>("Authentication failed - user already locked out", |
| 195 | entry("USER-ID=%d", static_cast<uint8_t>(userId))); |
| 196 | |
| 197 | response->rmcpStatusCode = |
| 198 | static_cast<uint8_t>(RAKP_ReturnCode::UNAUTH_NAME); |
| 199 | return outPayload; |
| 200 | } |
Saravanan Palanisamy | d9c86bb | 2019-08-07 17:57:37 +0000 | [diff] [blame] | 201 | |
| 202 | uint8_t chNum = static_cast<uint8_t>(getInterfaceIndex()); |
Richard Marian Thomaiyar | 99b8784 | 2018-12-06 21:35:43 +0530 | [diff] [blame] | 203 | // Get channel based access information |
Richard Marian Thomaiyar | 992e53c | 2019-03-03 13:30:46 +0530 | [diff] [blame] | 204 | if ((ipmi::ipmiUserGetPrivilegeAccess( |
| 205 | userId, chNum, session->sessionUserPrivAccess) != IPMI_CC_OK) || |
| 206 | (ipmi::getChannelAccessData(chNum, session->sessionChannelAccess) != |
| 207 | IPMI_CC_OK)) |
Richard Marian Thomaiyar | 99b8784 | 2018-12-06 21:35:43 +0530 | [diff] [blame] | 208 | { |
| 209 | response->rmcpStatusCode = |
| 210 | static_cast<uint8_t>(RAKP_ReturnCode::INACTIVE_ROLE); |
| 211 | return outPayload; |
| 212 | } |
AppaRao Puli | ecb32fb | 2020-07-01 22:55:38 +0530 | [diff] [blame] | 213 | if (!isChannelAccessModeEnabled(session->sessionChannelAccess.accessMode)) |
| 214 | { |
| 215 | phosphor::logging::log<phosphor::logging::level::ERR>( |
| 216 | "Channel access mode disabled."); |
| 217 | response->rmcpStatusCode = |
| 218 | static_cast<uint8_t>(RAKP_ReturnCode::INACTIVE_ROLE); |
| 219 | return outPayload; |
| 220 | } |
Richard Marian Thomaiyar | 992e53c | 2019-03-03 13:30:46 +0530 | [diff] [blame] | 221 | if (session->sessionUserPrivAccess.privilege > |
| 222 | static_cast<uint8_t>(session::Privilege::OEM)) |
Richard Marian Thomaiyar | 7e5d38d | 2019-03-02 22:11:41 +0530 | [diff] [blame] | 223 | { |
| 224 | response->rmcpStatusCode = |
| 225 | static_cast<uint8_t>(RAKP_ReturnCode::INACTIVE_ROLE); |
| 226 | return outPayload; |
| 227 | } |
Suryakanth Sekar | f8a34fc | 2019-06-12 20:59:18 +0530 | [diff] [blame] | 228 | session->channelNum(chNum); |
| 229 | session->userID(userId); |
jayaprakash Mutyala | 2555e2e | 2019-12-24 22:51:46 +0000 | [diff] [blame] | 230 | // minimum privilege of Channel / User / session::privilege::USER |
Richard Marian Thomaiyar | d5a4f45 | 2019-01-16 12:15:44 +0530 | [diff] [blame] | 231 | // has to be used as session current privilege level |
Richard Marian Thomaiyar | 99b8784 | 2018-12-06 21:35:43 +0530 | [diff] [blame] | 232 | uint8_t minPriv = 0; |
Richard Marian Thomaiyar | 992e53c | 2019-03-03 13:30:46 +0530 | [diff] [blame] | 233 | if (session->sessionChannelAccess.privLimit < |
| 234 | session->sessionUserPrivAccess.privilege) |
Richard Marian Thomaiyar | 99b8784 | 2018-12-06 21:35:43 +0530 | [diff] [blame] | 235 | { |
Richard Marian Thomaiyar | 992e53c | 2019-03-03 13:30:46 +0530 | [diff] [blame] | 236 | minPriv = session->sessionChannelAccess.privLimit; |
Richard Marian Thomaiyar | 99b8784 | 2018-12-06 21:35:43 +0530 | [diff] [blame] | 237 | } |
| 238 | else |
| 239 | { |
Richard Marian Thomaiyar | 992e53c | 2019-03-03 13:30:46 +0530 | [diff] [blame] | 240 | minPriv = session->sessionUserPrivAccess.privilege; |
Richard Marian Thomaiyar | 99b8784 | 2018-12-06 21:35:43 +0530 | [diff] [blame] | 241 | } |
Suryakanth Sekar | f8a34fc | 2019-06-12 20:59:18 +0530 | [diff] [blame] | 242 | if (session->currentPrivilege() > minPriv) |
Richard Marian Thomaiyar | 99b8784 | 2018-12-06 21:35:43 +0530 | [diff] [blame] | 243 | { |
Suryakanth Sekar | f8a34fc | 2019-06-12 20:59:18 +0530 | [diff] [blame] | 244 | session->currentPrivilege(static_cast<uint8_t>(minPriv)); |
Richard Marian Thomaiyar | 99b8784 | 2018-12-06 21:35:43 +0530 | [diff] [blame] | 245 | } |
Richard Marian Thomaiyar | d91fd9d | 2018-12-06 12:03:50 +0530 | [diff] [blame] | 246 | // For username / privilege lookup, fail with UNAUTH_NAME, if requested |
Richard Marian Thomaiyar | d8e92fe | 2019-01-16 11:56:23 +0530 | [diff] [blame] | 247 | // max privilege does not match user privilege |
Richard Marian Thomaiyar | d91fd9d | 2018-12-06 12:03:50 +0530 | [diff] [blame] | 248 | if (((request->req_max_privilege_level & userNameOnlyLookupMask) == |
| 249 | userNamePrivLookup) && |
Richard Marian Thomaiyar | d8e92fe | 2019-01-16 11:56:23 +0530 | [diff] [blame] | 250 | ((request->req_max_privilege_level & session::reqMaxPrivMask) != |
Richard Marian Thomaiyar | 992e53c | 2019-03-03 13:30:46 +0530 | [diff] [blame] | 251 | session->sessionUserPrivAccess.privilege)) |
Richard Marian Thomaiyar | d91fd9d | 2018-12-06 12:03:50 +0530 | [diff] [blame] | 252 | { |
Vernon Mauery | fc37e59 | 2018-12-19 14:55:15 -0800 | [diff] [blame] | 253 | log<level::INFO>( |
| 254 | "Username/Privilege lookup failed for requested privilege"); |
Richard Marian Thomaiyar | d91fd9d | 2018-12-06 12:03:50 +0530 | [diff] [blame] | 255 | response->rmcpStatusCode = |
| 256 | static_cast<uint8_t>(RAKP_ReturnCode::UNAUTH_NAME); |
| 257 | return outPayload; |
| 258 | } |
Richard Marian Thomaiyar | 99b8784 | 2018-12-06 21:35:43 +0530 | [diff] [blame] | 259 | |
| 260 | std::fill(authAlgo->userKey.data(), |
| 261 | authAlgo->userKey.data() + authAlgo->userKey.size(), 0); |
| 262 | std::copy_n(passwd.c_str(), passwd.size(), authAlgo->userKey.data()); |
| 263 | |
Tom Joseph | 8bb10b7 | 2016-12-06 17:47:56 +0530 | [diff] [blame] | 264 | // Copy the Managed System Random Number to the Authentication Algorithm |
| 265 | std::copy_n(iter, cipher::rakp_auth::BMC_RANDOM_NUMBER_LEN, |
| 266 | authAlgo->bmcRandomNum.begin()); |
| 267 | std::advance(iter, cipher::rakp_auth::BMC_RANDOM_NUMBER_LEN); |
| 268 | |
| 269 | // Managed System GUID |
Tom Joseph | 83029cb | 2017-09-01 16:37:31 +0530 | [diff] [blame] | 270 | std::copy_n(cache::guid.data(), cache::guid.size(), iter); |
Tom Joseph | 8bb10b7 | 2016-12-06 17:47:56 +0530 | [diff] [blame] | 271 | std::advance(iter, BMC_GUID_LEN); |
| 272 | |
| 273 | // Requested Privilege Level |
Tom Joseph | 8bb10b7 | 2016-12-06 17:47:56 +0530 | [diff] [blame] | 274 | std::copy_n(&(request->req_max_privilege_level), |
| 275 | sizeof(request->req_max_privilege_level), iter); |
| 276 | std::advance(iter, sizeof(request->req_max_privilege_level)); |
| 277 | |
Tom Joseph | 8bb10b7 | 2016-12-06 17:47:56 +0530 | [diff] [blame] | 278 | // User Name Length Byte |
| 279 | std::copy_n(&(request->user_name_len), sizeof(request->user_name_len), |
| 280 | iter); |
Tom Joseph | 56527b9 | 2018-03-21 19:31:58 +0530 | [diff] [blame] | 281 | std::advance(iter, sizeof(request->user_name_len)); |
| 282 | |
| 283 | std::copy_n(session->userName.data(), session->userName.size(), iter); |
Tom Joseph | 8bb10b7 | 2016-12-06 17:47:56 +0530 | [diff] [blame] | 284 | |
| 285 | // Generate Key Exchange Authentication Code - RAKP2 |
| 286 | auto output = authAlgo->generateHMAC(input); |
| 287 | |
| 288 | response->messageTag = request->messageTag; |
| 289 | response->rmcpStatusCode = static_cast<uint8_t>(RAKP_ReturnCode::NO_ERROR); |
| 290 | response->reserved = 0; |
Vernon Mauery | 9e801a2 | 2018-10-12 13:20:49 -0700 | [diff] [blame] | 291 | response->remoteConsoleSessionID = rcSessionID; |
Tom Joseph | 8bb10b7 | 2016-12-06 17:47:56 +0530 | [diff] [blame] | 292 | |
| 293 | // Copy Managed System Random Number to the Response |
| 294 | std::copy(authAlgo->bmcRandomNum.begin(), authAlgo->bmcRandomNum.end(), |
| 295 | response->managed_system_random_number); |
| 296 | |
| 297 | // Copy System GUID to the Response |
Vernon Mauery | 9e801a2 | 2018-10-12 13:20:49 -0700 | [diff] [blame] | 298 | std::copy_n(cache::guid.data(), cache::guid.size(), |
Tom Joseph | 83029cb | 2017-09-01 16:37:31 +0530 | [diff] [blame] | 299 | response->managed_system_guid); |
Tom Joseph | 8bb10b7 | 2016-12-06 17:47:56 +0530 | [diff] [blame] | 300 | |
| 301 | // Insert the HMAC output into the payload |
| 302 | outPayload.insert(outPayload.end(), output.begin(), output.end()); |
Tom Joseph | 8bb10b7 | 2016-12-06 17:47:56 +0530 | [diff] [blame] | 303 | return outPayload; |
| 304 | } |
| 305 | |
| 306 | } // namespace command |