Play your Steam library's Windows games on a jailbroken PS5.
C++
#include "steam/backend/cm_messages.h"
#include "steam/backend/proto_wire.h"
namespace playden::steam::cm {
namespace {
constexpr proto::DecodeLimits kLimits{kMaxFrameBytes, kMaxFrameBytes, kMaxRepeatedEntries + 16, 8};
std::uint32_t ReadLE32(const std::uint8_t* data) {
return static_cast<std::uint32_t>(data[0]) | static_cast<std::uint32_t>(data[1]) << 8 |
static_cast<std::uint32_t>(data[2]) << 16 | static_cast<std::uint32_t>(data[3]) << 24;
}
void AppendLE32(std::vector<std::uint8_t>& out, std::uint32_t value) {
for (int shift = 0; shift < 32; shift += 8)
out.push_back(static_cast<std::uint8_t>(value >> shift));
}
// Varint fields declared int32 carry negative values sign-extended to 64 bits.
std::int32_t AsInt32(std::uint64_t value) {
return static_cast<std::int32_t>(static_cast<std::uint32_t>(value));
}
bool IsVarint(const proto::Field& field) { return field.wire_type == proto::WireType::kVarint; }
bool IsBytes(const proto::Field& field) {
return field.wire_type == proto::WireType::kLengthDelimited;
}
bool IsFixed32(const proto::Field& field) { return field.wire_type == proto::WireType::kFixed32; }
bool IsFixed64(const proto::Field& field) { return field.wire_type == proto::WireType::kFixed64; }
std::vector<std::uint8_t> Bytes(const proto::Field& field) {
return std::vector<std::uint8_t>(field.data, field.data + field.size);
}
bool DecodeHeader(const std::uint8_t* data, std::size_t size, Header* header) {
proto::Reader reader(data, size, kLimits);
proto::Field field;
while (reader.Next(&field)) {
switch (field.number) {
case 1:
if (!IsFixed64(field)) return false;
header->steam_id = field.value;
break;
case 2:
if (!IsVarint(field)) return false;
header->session_id = AsInt32(field.value);
break;
case 10:
if (!IsFixed64(field)) return false;
header->jobid_source = field.value;
break;
case 11:
if (!IsFixed64(field)) return false;
header->jobid_target = field.value;
break;
case 13:
if (!IsVarint(field)) return false;
header->eresult = AsInt32(field.value);
break;
default:
break;
}
}
return reader.ok();
}
} // namespace
std::vector<std::uint8_t> EncodeFrame(std::uint32_t emsg, const Header& header,
const std::vector<std::uint8_t>& body) {
proto::Writer encoded(kMaxFrameBytes);
encoded.AddFixed64(1, header.steam_id);
encoded.AddVarint(2, static_cast<std::uint64_t>(static_cast<std::int64_t>(header.session_id)));
if (header.jobid_source) encoded.AddFixed64(10, *header.jobid_source);
if (header.jobid_target) encoded.AddFixed64(11, *header.jobid_target);
if (!header.target_job_name.empty()) encoded.AddString(12, header.target_job_name);
if (header.eresult)
encoded.AddVarint(13, static_cast<std::uint64_t>(static_cast<std::int64_t>(*header.eresult)));
if (!encoded.ok() || 8 + encoded.bytes().size() + body.size() > kMaxFrameBytes) return {};
std::vector<std::uint8_t> frame;
frame.reserve(8 + encoded.bytes().size() + body.size());
AppendLE32(frame, emsg | kProtoMask);
AppendLE32(frame, static_cast<std::uint32_t>(encoded.bytes().size()));
frame.insert(frame.end(), encoded.bytes().begin(), encoded.bytes().end());
frame.insert(frame.end(), body.begin(), body.end());
return frame;
}
bool DecodeFrame(const std::uint8_t* data, std::size_t size, Frame* frame) {
if (data == nullptr || size < 8 || size > kMaxFrameBytes) return false;
const std::uint32_t raw = ReadLE32(data);
if ((raw & kProtoMask) == 0) return false;
const std::uint32_t header_size = ReadLE32(data + 4);
if (header_size > size - 8) return false;
Frame decoded;
decoded.emsg = raw & ~kProtoMask;
if (!DecodeHeader(data + 8, header_size, &decoded.header)) return false;
decoded.body.assign(data + 8 + header_size, data + size);
*frame = std::move(decoded);
return true;
}
std::vector<std::uint8_t> EncodeHello() {
proto::Writer body;
body.AddVarint(1, kProtocolVersion);
return body.bytes();
}
std::vector<std::uint8_t> EncodeLogon(const std::string& account_name,
const std::string& refresh_token, std::uint32_t cell_id,
const DeviceIdentity& device) {
proto::Writer address;
address.AddFixed32(1, device.login_id);
proto::Writer body;
body.AddVarint(1, kProtocolVersion);
body.AddVarint(3, cell_id);
body.AddVarint(5, kClientPackageVersion);
body.AddString(6, "english");
body.AddVarint(7, 0); // EOSType WinUnknown, as the reference client
body.AddVarint(8, 1); // should_remember_password: without it Steam signs the device out when the session ends
body.AddMessage(11, address);
body.AddBytes(30, device.machine_id);
body.AddString(50, account_name);
body.AddString(96, device.machine_name);
body.AddVarint(102, 1);
body.AddString(108, refresh_token); // CM logon takes the refresh token in access_token
if (!body.ok()) return {};
return body.bytes();
}
std::vector<std::uint8_t> EncodeHeartBeat() { return {}; }
bool DecodeLogonResponse(const std::vector<std::uint8_t>& body, LogonResponse* response) {
proto::Reader reader(body, kLimits);
proto::Field field;
LogonResponse decoded;
std::optional<std::int32_t> heartbeat;
std::optional<std::int32_t> legacy_heartbeat;
while (reader.Next(&field)) {
if (field.number == 1 && IsVarint(field)) decoded.eresult = AsInt32(field.value);
else if (field.number == 2 && IsVarint(field)) legacy_heartbeat = AsInt32(field.value);
else if (field.number == 3 && IsVarint(field)) heartbeat = AsInt32(field.value);
else if (field.number == 7 && IsVarint(field)) decoded.cell_id = static_cast<std::uint32_t>(field.value);
else if (field.number <= 7 && field.number != 4 && field.number != 5 && field.number != 6)
return false; // a known field with the wrong wire type
}
if (!reader.ok()) return false;
const std::int32_t seconds = heartbeat ? *heartbeat : legacy_heartbeat.value_or(0);
decoded.heartbeat_seconds = seconds > 0 ? seconds : 9;
*response = decoded;
return true;
}
bool DecodeLoggedOff(const std::vector<std::uint8_t>& body, std::int32_t* eresult) {
proto::Reader reader(body, kLimits);
proto::Field field;
std::int32_t value = kEResultFail;
while (reader.Next(&field)) {
if (field.number != 1) continue;
if (!IsVarint(field)) return false;
value = AsInt32(field.value);
}
if (!reader.ok()) return false;
*eresult = value;
return true;
}
bool DecodeMulti(const std::vector<std::uint8_t>& body, Multi* multi) {
proto::Reader reader(body, kLimits);
proto::Field field;
Multi decoded;
while (reader.Next(&field)) {
if (field.number == 1) {
if (!IsVarint(field) || field.value > kMaxFrameBytes) return false;
decoded.size_unzipped = static_cast<std::uint32_t>(field.value);
} else if (field.number == 2) {
if (!IsBytes(field)) return false;
decoded.message_body = Bytes(field);
}
}
if (!reader.ok()) return false;
*multi = std::move(decoded);
return true;
}
bool SplitMultiPayload(const std::vector<std::uint8_t>& payload,
std::vector<std::vector<std::uint8_t>>* frames) {
std::vector<std::vector<std::uint8_t>> result;
std::size_t offset = 0;
while (offset < payload.size()) {
if (payload.size() - offset < 4 || result.size() >= kMaxRepeatedEntries) return false;
const std::uint32_t size = ReadLE32(payload.data() + offset);
offset += 4;
if (size > payload.size() - offset) return false;
result.emplace_back(payload.begin() + static_cast<std::ptrdiff_t>(offset),
payload.begin() + static_cast<std::ptrdiff_t>(offset + size));
offset += size;
}
*frames = std::move(result);
return true;
}
bool DecodeLicenseList(const std::vector<std::uint8_t>& body, LicenseList* list) {
proto::Reader reader(body, kLimits);
proto::Field field;
LicenseList decoded;
while (reader.Next(&field)) {
if (field.number == 1) {
if (!IsVarint(field)) return false;
decoded.eresult = AsInt32(field.value);
continue;
}
if (field.number != 2) continue;
if (decoded.licenses.size() >= kMaxRepeatedEntries) return false;
proto::Reader child;
if (!reader.Submessage(field, &child)) return false;
License license;
proto::Field entry;
while (child.Next(&entry)) {
switch (entry.number) {
case 1: if (!IsVarint(entry)) return false; license.package_id = static_cast<std::uint32_t>(entry.value); break;
case 2: if (!IsFixed32(entry)) return false; license.time_created = static_cast<std::uint32_t>(entry.value); break;
case 4: if (!IsVarint(entry)) return false; license.minute_limit = AsInt32(entry.value); break;
case 5: if (!IsVarint(entry)) return false; license.minutes_used = AsInt32(entry.value); break;
case 7: if (!IsVarint(entry)) return false; license.flags = static_cast<std::uint32_t>(entry.value); break;
case 9: if (!IsVarint(entry)) return false; license.license_type = static_cast<std::uint32_t>(entry.value); break;
case 12: if (!IsVarint(entry)) return false; license.owner_id = static_cast<std::uint32_t>(entry.value); break;
case 17: if (!IsVarint(entry)) return false; license.access_token = entry.value; break;
default: break;
}
}
if (!child.ok()) return false;
decoded.licenses.push_back(license);
}
if (!reader.ok()) return false;
*list = std::move(decoded);
return true;
}
std::vector<std::uint8_t> EncodePicsPackagesRequest(const std::vector<PackageRequest>& packages) {
proto::Writer body(kMaxFrameBytes);
for (const auto& package : packages) {
proto::Writer entry;
entry.AddVarint(1, package.package_id);
entry.AddVarint(2, package.access_token);
body.AddMessage(1, entry);
}
if (!body.ok()) return {};
return body.bytes();
}
bool DecodePicsResponse(const std::vector<std::uint8_t>& body, PicsResponse* response) {
proto::Reader reader(body, kLimits);
proto::Field field;
PicsResponse decoded;
while (reader.Next(&field)) {
if (field.number == 6) {
if (!IsVarint(field)) return false;
decoded.response_pending = field.value != 0;
continue;
}
if (field.number == 2) {
if (!IsVarint(field)) return false;
if (decoded.unknown_apps.size() >= kMaxRepeatedEntries) return false;
decoded.unknown_apps.push_back(static_cast<std::uint32_t>(field.value));
continue;
}
if (field.number == 7) {
if (!IsVarint(field)) return false;
decoded.http_min_size = static_cast<std::uint32_t>(field.value);
continue;
}
if (field.number == 8) {
if (!IsBytes(field)) return false;
decoded.http_host.assign(reinterpret_cast<const char*>(field.data), field.size);
continue;
}
if (field.number == 1) {
if (decoded.apps.size() >= kMaxRepeatedEntries) return false;
proto::Reader child;
if (!reader.Submessage(field, &child)) return false;
PicsApp app;
proto::Field entry;
while (child.Next(&entry)) {
if (entry.number == 1) {
if (!IsVarint(entry)) return false;
app.app_id = static_cast<std::uint32_t>(entry.value);
} else if (entry.number == 3) {
if (!IsVarint(entry)) return false;
app.missing_token = entry.value != 0;
} else if (entry.number == 4) {
if (!IsBytes(entry)) return false;
app.sha = Bytes(entry);
} else if (entry.number == 5) {
if (!IsBytes(entry)) return false;
app.buffer = Bytes(entry);
} else if (entry.number == 6) {
if (!IsVarint(entry)) return false;
app.only_public = entry.value != 0;
} else if (entry.number == 7) {
if (!IsVarint(entry)) return false;
app.size = static_cast<std::uint32_t>(entry.value);
}
}
if (!child.ok()) return false;
decoded.apps.push_back(std::move(app));
continue;
}
if (field.number != 3) continue;
if (decoded.packages.size() >= kMaxRepeatedEntries) return false;
proto::Reader child;
if (!reader.Submessage(field, &child)) return false;
PicsPackage package;
proto::Field entry;
while (child.Next(&entry)) {
if (entry.number == 1) {
if (!IsVarint(entry)) return false;
package.package_id = static_cast<std::uint32_t>(entry.value);
} else if (entry.number == 3) {
if (!IsVarint(entry)) return false;
package.missing_token = entry.value != 0;
} else if (entry.number == 5) {
if (!IsBytes(entry)) return false;
package.buffer = Bytes(entry);
}
}
if (!child.ok()) return false;
decoded.packages.push_back(std::move(package));
}
if (!reader.ok()) return false;
*response = std::move(decoded);
return true;
}
std::vector<std::uint8_t> EncodePicsAppsRequest(const std::vector<AppRequest>& apps) {
proto::Writer body(kMaxFrameBytes);
for (const auto& app : apps) {
proto::Writer entry;
entry.AddVarint(1, app.app_id);
entry.AddVarint(2, app.access_token);
body.AddMessage(2, entry);
}
if (!body.ok()) return {};
return body.bytes();
}
std::vector<std::uint8_t> EncodePicsAccessTokenRequest(const std::vector<std::uint32_t>& app_ids) {
proto::Writer body(kMaxFrameBytes);
for (const auto id : app_ids) body.AddVarint(2, id);
if (!body.ok()) return {};
return body.bytes();
}
bool DecodePicsAccessTokenResponse(const std::vector<std::uint8_t>& body,
std::vector<AppRequest>* tokens,
std::vector<std::uint32_t>* denied) {
proto::Reader reader(body, kLimits);
proto::Field field;
std::vector<AppRequest> decoded;
std::vector<std::uint32_t> refused;
while (reader.Next(&field)) {
if (field.number == 4 && IsVarint(field)) {
if (refused.size() >= kMaxRepeatedEntries) return false;
refused.push_back(static_cast<std::uint32_t>(field.value));
continue;
}
if (field.number != 3) continue;
if (decoded.size() >= kMaxRepeatedEntries) return false;
proto::Reader child;
if (!reader.Submessage(field, &child)) return false;
AppRequest token;
proto::Field entry;
while (child.Next(&entry)) {
if (entry.number == 1 && IsVarint(entry)) token.app_id = static_cast<std::uint32_t>(entry.value);
else if (entry.number == 2 && IsVarint(entry)) token.access_token = entry.value;
else if (entry.number == 1 || entry.number == 2) return false;
}
if (!child.ok()) return false;
decoded.push_back(token);
}
if (!reader.ok()) return false;
*tokens = std::move(decoded);
if (denied) *denied = std::move(refused);
return true;
}
std::vector<std::uint8_t> EncodeDepotKeyRequest(std::uint32_t depot_id, std::uint32_t app_id) {
proto::Writer body;
body.AddVarint(1, depot_id);
body.AddVarint(2, app_id);
return body.bytes();
}
bool DecodeDepotKeyResponse(const std::vector<std::uint8_t>& body, DepotKeyResponse* response) {
proto::Reader reader(body, kLimits);
proto::Field field;
DepotKeyResponse decoded;
while (reader.Next(&field)) {
if (field.number == 1) {
if (!IsVarint(field)) return false;
decoded.eresult = AsInt32(field.value);
} else if (field.number == 2) {
if (!IsVarint(field)) return false;
decoded.depot_id = static_cast<std::uint32_t>(field.value);
} else if (field.number == 3) {
if (!IsBytes(field) || field.size > 64) return false;
decoded.key = Bytes(field);
}
}
if (!reader.ok()) return false;
*response = std::move(decoded);
return true;
}
std::vector<std::uint8_t> EncodeManifestRequestCodeRequest(std::uint32_t app_id, std::uint32_t depot_id,
std::uint64_t manifest_id, std::string_view branch) {
proto::Writer body;
body.AddVarint(1, app_id);
body.AddVarint(2, depot_id);
body.AddVarint(3, manifest_id);
body.AddString(4, branch.empty() ? std::string("public") : std::string(branch));
return body.bytes();
}
bool DecodeManifestRequestCodeResponse(const std::vector<std::uint8_t>& body, std::uint64_t* code) {
proto::Reader reader(body, kLimits);
proto::Field field;
std::uint64_t value = 0;
while (reader.Next(&field)) {
if (field.number != 1) continue;
if (!IsVarint(field)) return false;
value = field.value;
}
if (!reader.ok()) return false;
*code = value;
return true;
}
std::vector<std::uint8_t> EncodeFreeLicenseRequest(const std::vector<std::uint32_t>& app_ids) {
proto::Writer body;
for (const auto id : app_ids) body.AddVarint(2, id);
return body.bytes();
}
namespace {
// One repeated uint32 field entry: a varint, or a packed run of them.
bool AppendUint32s(const proto::Field& field, std::vector<std::uint32_t>* out) {
if (IsVarint(field)) {
if (out->size() >= kMaxRepeatedEntries) return false;
out->push_back(static_cast<std::uint32_t>(field.value));
return true;
}
if (!IsBytes(field)) return false;
std::size_t offset = 0;
while (offset < field.size) {
std::uint64_t value = 0;
int shift = 0;
for (;;) {
if (offset >= field.size || shift > 63) return false;
const std::uint8_t byte = field.data[offset++];
value |= static_cast<std::uint64_t>(byte & 0x7f) << shift;
if ((byte & 0x80) == 0) break;
shift += 7;
}
if (out->size() >= kMaxRepeatedEntries) return false;
out->push_back(static_cast<std::uint32_t>(value));
}
return true;
}
} // namespace
bool DecodeFreeLicenseResponse(const std::vector<std::uint8_t>& body, FreeLicenseResponse* response) {
proto::Reader reader(body, kLimits);
proto::Field field;
FreeLicenseResponse decoded;
while (reader.Next(&field)) {
if (field.number == 1) {
if (!IsVarint(field)) return false;
decoded.eresult = AsInt32(field.value);
} else if (field.number == 2) {
if (!AppendUint32s(field, &decoded.granted_packages)) return false;
} else if (field.number == 3) {
if (!AppendUint32s(field, &decoded.granted_apps)) return false;
}
}
if (!reader.ok()) return false;
*response = std::move(decoded);
return true;
}
} // namespace playden::steam::cm