939 lines
27 KiB
C++
939 lines
27 KiB
C++
#include <QNetworkAccessManager>
|
|
#include <QNetworkRequest>
|
|
#include <QNetworkReply>
|
|
#include <QDesktopServices>
|
|
#include <QMetaEnum>
|
|
#include <QDebug>
|
|
|
|
#include <QJsonDocument>
|
|
#include <QJsonObject>
|
|
#include <QJsonArray>
|
|
|
|
#include <QUrlQuery>
|
|
|
|
#include <QPixmap>
|
|
#include <QPainter>
|
|
|
|
#include "context.h"
|
|
#include "katabasis/Globals.h"
|
|
#include "katabasis/StoreQSettings.h"
|
|
#include "katabasis/Requestor.h"
|
|
#include "BuildConfig.h"
|
|
|
|
using OAuth2 = Katabasis::OAuth2;
|
|
using Requestor = Katabasis::Requestor;
|
|
using Activity = Katabasis::Activity;
|
|
|
|
Context::Context(QObject *parent) :
|
|
QObject(parent)
|
|
{
|
|
mgr = new QNetworkAccessManager(this);
|
|
|
|
Katabasis::OAuth2::Options opts;
|
|
opts.scope = "XboxLive.signin offline_access";
|
|
opts.clientIdentifier = BuildConfig.CLIENT_ID;
|
|
opts.authorizationUrl = "https://login.live.com/oauth20_authorize.srf";
|
|
opts.accessTokenUrl = "https://login.live.com/oauth20_token.srf";
|
|
opts.listenerPorts = {28562, 28563, 28564, 28565, 28566};
|
|
|
|
oauth2 = new OAuth2(opts, m_account.msaToken, this, mgr);
|
|
|
|
connect(oauth2, &OAuth2::linkingFailed, this, &Context::onLinkingFailed);
|
|
connect(oauth2, &OAuth2::linkingSucceeded, this, &Context::onLinkingSucceeded);
|
|
connect(oauth2, &OAuth2::openBrowser, this, &Context::onOpenBrowser);
|
|
connect(oauth2, &OAuth2::closeBrowser, this, &Context::onCloseBrowser);
|
|
connect(oauth2, &OAuth2::activityChanged, this, &Context::onOAuthActivityChanged);
|
|
}
|
|
|
|
void Context::beginActivity(Activity activity) {
|
|
if(isBusy()) {
|
|
throw 0;
|
|
}
|
|
activity_ = activity;
|
|
emit activityChanged(activity_);
|
|
}
|
|
|
|
void Context::finishActivity() {
|
|
if(!isBusy()) {
|
|
throw 0;
|
|
}
|
|
activity_ = Katabasis::Activity::Idle;
|
|
m_account.validity_ = m_account.minecraftProfile.validity;
|
|
emit activityChanged(activity_);
|
|
}
|
|
|
|
QString Context::gameToken() {
|
|
return m_account.minecraftToken.token;
|
|
}
|
|
|
|
QString Context::userId() {
|
|
return m_account.minecraftProfile.id;
|
|
}
|
|
|
|
QString Context::userName() {
|
|
return m_account.minecraftProfile.name;
|
|
}
|
|
|
|
bool Context::silentSignIn() {
|
|
if(isBusy()) {
|
|
return false;
|
|
}
|
|
beginActivity(Activity::Refreshing);
|
|
if(!oauth2->refresh()) {
|
|
finishActivity();
|
|
return false;
|
|
}
|
|
|
|
requestsDone = 0;
|
|
xboxProfileSucceeded = false;
|
|
mcAuthSucceeded = false;
|
|
|
|
return true;
|
|
}
|
|
|
|
bool Context::signIn() {
|
|
if(isBusy()) {
|
|
return false;
|
|
}
|
|
|
|
requestsDone = 0;
|
|
xboxProfileSucceeded = false;
|
|
mcAuthSucceeded = false;
|
|
|
|
beginActivity(Activity::LoggingIn);
|
|
oauth2->unlink();
|
|
m_account = AccountData();
|
|
oauth2->link();
|
|
return true;
|
|
}
|
|
|
|
bool Context::signOut() {
|
|
if(isBusy()) {
|
|
return false;
|
|
}
|
|
beginActivity(Activity::LoggingOut);
|
|
oauth2->unlink();
|
|
m_account = AccountData();
|
|
finishActivity();
|
|
return true;
|
|
}
|
|
|
|
|
|
void Context::onOpenBrowser(const QUrl &url) {
|
|
QDesktopServices::openUrl(url);
|
|
}
|
|
|
|
void Context::onCloseBrowser() {
|
|
|
|
}
|
|
|
|
void Context::onLinkingFailed() {
|
|
finishActivity();
|
|
}
|
|
|
|
void Context::onLinkingSucceeded() {
|
|
auto *o2t = qobject_cast<OAuth2 *>(sender());
|
|
if (!o2t->linked()) {
|
|
finishActivity();
|
|
return;
|
|
}
|
|
QVariantMap extraTokens = o2t->extraTokens();
|
|
if (!extraTokens.isEmpty()) {
|
|
qDebug() << "Extra tokens in response:";
|
|
foreach (QString key, extraTokens.keys()) {
|
|
qDebug() << "\t" << key << ":" << extraTokens.value(key);
|
|
}
|
|
}
|
|
doUserAuth();
|
|
}
|
|
|
|
void Context::onOAuthActivityChanged(Katabasis::Activity activity) {
|
|
// respond to activity change here
|
|
}
|
|
|
|
void Context::doUserAuth() {
|
|
QString xbox_auth_template = R"XXX(
|
|
{
|
|
"Properties": {
|
|
"AuthMethod": "RPS",
|
|
"SiteName": "user.auth.xboxlive.com",
|
|
"RpsTicket": "d=%1"
|
|
},
|
|
"RelyingParty": "http://auth.xboxlive.com",
|
|
"TokenType": "JWT"
|
|
}
|
|
)XXX";
|
|
auto xbox_auth_data = xbox_auth_template.arg(m_account.msaToken.token);
|
|
|
|
QNetworkRequest request = QNetworkRequest(QUrl("https://user.auth.xboxlive.com/user/authenticate"));
|
|
request.setHeader(QNetworkRequest::ContentTypeHeader, "application/json");
|
|
request.setRawHeader("Accept", "application/json");
|
|
auto *requestor = new Katabasis::Requestor(mgr, oauth2, this);
|
|
requestor->setAddAccessTokenInQuery(false);
|
|
|
|
connect(requestor, &Requestor::finished, this, &Context::onUserAuthDone);
|
|
requestor->post(request, xbox_auth_data.toUtf8());
|
|
qDebug() << "First layer of XBox auth ... commencing.";
|
|
}
|
|
|
|
namespace {
|
|
bool getDateTime(QJsonValue value, QDateTime & out) {
|
|
if(!value.isString()) {
|
|
return false;
|
|
}
|
|
out = QDateTime::fromString(value.toString(), Qt::ISODateWithMs);
|
|
return out.isValid();
|
|
}
|
|
|
|
bool getString(QJsonValue value, QString & out) {
|
|
if(!value.isString()) {
|
|
return false;
|
|
}
|
|
out = value.toString();
|
|
return true;
|
|
}
|
|
|
|
bool getNumber(QJsonValue value, double & out) {
|
|
if(!value.isDouble()) {
|
|
return false;
|
|
}
|
|
out = value.toDouble();
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
{
|
|
"IssueInstant":"2020-12-07T19:52:08.4463796Z",
|
|
"NotAfter":"2020-12-21T19:52:08.4463796Z",
|
|
"Token":"token",
|
|
"DisplayClaims":{
|
|
"xui":[
|
|
{
|
|
"uhs":"userhash"
|
|
}
|
|
]
|
|
}
|
|
}
|
|
*/
|
|
// TODO: handle error responses ...
|
|
/*
|
|
{
|
|
"Identity":"0",
|
|
"XErr":2148916238,
|
|
"Message":"",
|
|
"Redirect":"https://start.ui.xboxlive.com/AddChildToFamily"
|
|
}
|
|
// 2148916233 = missing XBox account
|
|
// 2148916238 = child account not linked to a family
|
|
*/
|
|
|
|
bool parseXTokenResponse(QByteArray & data, Katabasis::Token &output) {
|
|
QJsonParseError jsonError;
|
|
QJsonDocument doc = QJsonDocument::fromJson(data, &jsonError);
|
|
if(jsonError.error) {
|
|
qWarning() << "Failed to parse response from user.auth.xboxlive.com as JSON: " << jsonError.errorString();
|
|
qDebug() << data;
|
|
return false;
|
|
}
|
|
|
|
auto obj = doc.object();
|
|
if(!getDateTime(obj.value("IssueInstant"), output.issueInstant)) {
|
|
qWarning() << "User IssueInstant is not a timestamp";
|
|
qDebug() << data;
|
|
return false;
|
|
}
|
|
if(!getDateTime(obj.value("NotAfter"), output.notAfter)) {
|
|
qWarning() << "User NotAfter is not a timestamp";
|
|
qDebug() << data;
|
|
return false;
|
|
}
|
|
if(!getString(obj.value("Token"), output.token)) {
|
|
qWarning() << "User Token is not a timestamp";
|
|
qDebug() << data;
|
|
return false;
|
|
}
|
|
auto arrayVal = obj.value("DisplayClaims").toObject().value("xui");
|
|
if(!arrayVal.isArray()) {
|
|
qWarning() << "Missing xui claims array";
|
|
qDebug() << data;
|
|
return false;
|
|
}
|
|
bool foundUHS = false;
|
|
for(auto item: arrayVal.toArray()) {
|
|
if(!item.isObject()) {
|
|
continue;
|
|
}
|
|
auto obj = item.toObject();
|
|
if(obj.contains("uhs")) {
|
|
foundUHS = true;
|
|
} else {
|
|
continue;
|
|
}
|
|
// consume all 'display claims' ... whatever that means
|
|
for(auto iter = obj.begin(); iter != obj.end(); iter++) {
|
|
QString claim;
|
|
if(!getString(obj.value(iter.key()), claim)) {
|
|
qWarning() << "display claim " << iter.key() << " is not a string...";
|
|
qDebug() << data;
|
|
return false;
|
|
}
|
|
output.extra[iter.key()] = claim;
|
|
}
|
|
|
|
break;
|
|
}
|
|
if(!foundUHS) {
|
|
qWarning() << "Missing uhs";
|
|
qDebug() << data;
|
|
return false;
|
|
}
|
|
output.validity = Katabasis::Validity::Certain;
|
|
qDebug() << data;
|
|
return true;
|
|
}
|
|
|
|
}
|
|
|
|
void Context::onUserAuthDone(
|
|
int requestId,
|
|
QNetworkReply::NetworkError error,
|
|
QByteArray replyData,
|
|
QList<QNetworkReply::RawHeaderPair> headers
|
|
) {
|
|
if (error != QNetworkReply::NoError) {
|
|
qWarning() << "Reply error:" << error;
|
|
finishActivity();
|
|
return;
|
|
}
|
|
|
|
Katabasis::Token temp;
|
|
if(!parseXTokenResponse(replyData, temp)) {
|
|
qWarning() << "Could not parse user authentication response...";
|
|
finishActivity();
|
|
return;
|
|
}
|
|
m_account.userToken = temp;
|
|
|
|
doSTSAuthMinecraft();
|
|
doSTSAuthGeneric();
|
|
}
|
|
/*
|
|
url = "https://xsts.auth.xboxlive.com/xsts/authorize"
|
|
headers = {"x-xbl-contract-version": "1"}
|
|
data = {
|
|
"RelyingParty": relying_party,
|
|
"TokenType": "JWT",
|
|
"Properties": {
|
|
"UserTokens": [self.user_token.token],
|
|
"SandboxId": "RETAIL",
|
|
},
|
|
}
|
|
*/
|
|
void Context::doSTSAuthMinecraft() {
|
|
QString xbox_auth_template = R"XXX(
|
|
{
|
|
"Properties": {
|
|
"SandboxId": "RETAIL",
|
|
"UserTokens": [
|
|
"%1"
|
|
]
|
|
},
|
|
"RelyingParty": "rp://api.minecraftservices.com/",
|
|
"TokenType": "JWT"
|
|
}
|
|
)XXX";
|
|
auto xbox_auth_data = xbox_auth_template.arg(m_account.userToken.token);
|
|
|
|
QNetworkRequest request = QNetworkRequest(QUrl("https://xsts.auth.xboxlive.com/xsts/authorize"));
|
|
request.setHeader(QNetworkRequest::ContentTypeHeader, "application/json");
|
|
request.setRawHeader("Accept", "application/json");
|
|
Requestor *requestor = new Requestor(mgr, oauth2, this);
|
|
requestor->setAddAccessTokenInQuery(false);
|
|
|
|
connect(requestor, &Requestor::finished, this, &Context::onSTSAuthMinecraftDone);
|
|
requestor->post(request, xbox_auth_data.toUtf8());
|
|
qDebug() << "Second layer of XBox auth ... commencing.";
|
|
}
|
|
|
|
void Context::onSTSAuthMinecraftDone(
|
|
int requestId,
|
|
QNetworkReply::NetworkError error,
|
|
QByteArray replyData,
|
|
QList<QNetworkReply::RawHeaderPair> headers
|
|
) {
|
|
if (error != QNetworkReply::NoError) {
|
|
qWarning() << "Reply error:" << error;
|
|
finishActivity();
|
|
return;
|
|
}
|
|
|
|
Katabasis::Token temp;
|
|
if(!parseXTokenResponse(replyData, temp)) {
|
|
qWarning() << "Could not parse authorization response for access to mojang services...";
|
|
finishActivity();
|
|
return;
|
|
}
|
|
|
|
if(temp.extra["uhs"] != m_account.userToken.extra["uhs"]) {
|
|
qWarning() << "Server has changed user hash in the reply... something is wrong. ABORTING";
|
|
qDebug() << replyData;
|
|
finishActivity();
|
|
return;
|
|
}
|
|
m_account.mojangservicesToken = temp;
|
|
|
|
doMinecraftAuth();
|
|
}
|
|
|
|
void Context::doSTSAuthGeneric() {
|
|
QString xbox_auth_template = R"XXX(
|
|
{
|
|
"Properties": {
|
|
"SandboxId": "RETAIL",
|
|
"UserTokens": [
|
|
"%1"
|
|
]
|
|
},
|
|
"RelyingParty": "http://xboxlive.com",
|
|
"TokenType": "JWT"
|
|
}
|
|
)XXX";
|
|
auto xbox_auth_data = xbox_auth_template.arg(m_account.userToken.token);
|
|
|
|
QNetworkRequest request = QNetworkRequest(QUrl("https://xsts.auth.xboxlive.com/xsts/authorize"));
|
|
request.setHeader(QNetworkRequest::ContentTypeHeader, "application/json");
|
|
request.setRawHeader("Accept", "application/json");
|
|
Requestor *requestor = new Requestor(mgr, oauth2, this);
|
|
requestor->setAddAccessTokenInQuery(false);
|
|
|
|
connect(requestor, &Requestor::finished, this, &Context::onSTSAuthGenericDone);
|
|
requestor->post(request, xbox_auth_data.toUtf8());
|
|
qDebug() << "Second layer of XBox auth ... commencing.";
|
|
}
|
|
|
|
void Context::onSTSAuthGenericDone(
|
|
int requestId,
|
|
QNetworkReply::NetworkError error,
|
|
QByteArray replyData,
|
|
QList<QNetworkReply::RawHeaderPair> headers
|
|
) {
|
|
if (error != QNetworkReply::NoError) {
|
|
qWarning() << "Reply error:" << error;
|
|
finishActivity();
|
|
return;
|
|
}
|
|
|
|
Katabasis::Token temp;
|
|
if(!parseXTokenResponse(replyData, temp)) {
|
|
qWarning() << "Could not parse authorization response for access to xbox API...";
|
|
finishActivity();
|
|
return;
|
|
}
|
|
|
|
if(temp.extra["uhs"] != m_account.userToken.extra["uhs"]) {
|
|
qWarning() << "Server has changed user hash in the reply... something is wrong. ABORTING";
|
|
qDebug() << replyData;
|
|
finishActivity();
|
|
return;
|
|
}
|
|
m_account.xboxApiToken = temp;
|
|
|
|
doXBoxProfile();
|
|
}
|
|
|
|
|
|
void Context::doMinecraftAuth() {
|
|
QString mc_auth_template = R"XXX(
|
|
{
|
|
"identityToken": "XBL3.0 x=%1;%2"
|
|
}
|
|
)XXX";
|
|
auto data = mc_auth_template.arg(m_account.mojangservicesToken.extra["uhs"].toString(), m_account.mojangservicesToken.token);
|
|
|
|
QNetworkRequest request = QNetworkRequest(QUrl("https://api.minecraftservices.com/authentication/login_with_xbox"));
|
|
request.setHeader(QNetworkRequest::ContentTypeHeader, "application/json");
|
|
request.setRawHeader("Accept", "application/json");
|
|
Requestor *requestor = new Requestor(mgr, oauth2, this);
|
|
requestor->setAddAccessTokenInQuery(false);
|
|
|
|
connect(requestor, &Requestor::finished, this, &Context::onMinecraftAuthDone);
|
|
requestor->post(request, data.toUtf8());
|
|
qDebug() << "Getting Minecraft access token...";
|
|
}
|
|
|
|
namespace {
|
|
bool parseMojangResponse(QByteArray & data, Katabasis::Token &output) {
|
|
QJsonParseError jsonError;
|
|
QJsonDocument doc = QJsonDocument::fromJson(data, &jsonError);
|
|
if(jsonError.error) {
|
|
qWarning() << "Failed to parse response from user.auth.xboxlive.com as JSON: " << jsonError.errorString();
|
|
qDebug() << data;
|
|
return false;
|
|
}
|
|
|
|
auto obj = doc.object();
|
|
double expires_in = 0;
|
|
if(!getNumber(obj.value("expires_in"), expires_in)) {
|
|
qWarning() << "expires_in is not a valid number";
|
|
qDebug() << data;
|
|
return false;
|
|
}
|
|
auto currentTime = QDateTime::currentDateTimeUtc();
|
|
output.issueInstant = currentTime;
|
|
output.notAfter = currentTime.addSecs(expires_in);
|
|
|
|
QString username;
|
|
if(!getString(obj.value("username"), username)) {
|
|
qWarning() << "username is not valid";
|
|
qDebug() << data;
|
|
return false;
|
|
}
|
|
|
|
// TODO: it's a JWT... validate it?
|
|
if(!getString(obj.value("access_token"), output.token)) {
|
|
qWarning() << "access_token is not valid";
|
|
qDebug() << data;
|
|
return false;
|
|
}
|
|
output.validity = Katabasis::Validity::Certain;
|
|
qDebug() << data;
|
|
return true;
|
|
}
|
|
}
|
|
|
|
void Context::onMinecraftAuthDone(
|
|
int requestId,
|
|
QNetworkReply::NetworkError error,
|
|
QByteArray replyData,
|
|
QList<QNetworkReply::RawHeaderPair> headers
|
|
) {
|
|
requestsDone++;
|
|
|
|
if (error != QNetworkReply::NoError) {
|
|
qWarning() << "Reply error:" << error;
|
|
qDebug() << replyData;
|
|
finishActivity();
|
|
return;
|
|
}
|
|
|
|
if(!parseMojangResponse(replyData, m_account.minecraftToken)) {
|
|
qWarning() << "Could not parse login_with_xbox response...";
|
|
qDebug() << replyData;
|
|
finishActivity();
|
|
return;
|
|
}
|
|
mcAuthSucceeded = true;
|
|
|
|
checkResult();
|
|
}
|
|
|
|
void Context::doXBoxProfile() {
|
|
auto url = QUrl("https://profile.xboxlive.com/users/me/profile/settings");
|
|
QUrlQuery q;
|
|
q.addQueryItem(
|
|
"settings",
|
|
"GameDisplayName,AppDisplayName,AppDisplayPicRaw,GameDisplayPicRaw,"
|
|
"PublicGamerpic,ShowUserAsAvatar,Gamerscore,Gamertag,ModernGamertag,ModernGamertagSuffix,"
|
|
"UniqueModernGamertag,AccountTier,TenureLevel,XboxOneRep,"
|
|
"PreferredColor,Location,Bio,Watermarks,"
|
|
"RealName,RealNameOverride,IsQuarantined"
|
|
);
|
|
url.setQuery(q);
|
|
|
|
QNetworkRequest request = QNetworkRequest(url);
|
|
request.setHeader(QNetworkRequest::ContentTypeHeader, "application/json");
|
|
request.setRawHeader("Accept", "application/json");
|
|
request.setRawHeader("x-xbl-contract-version", "3");
|
|
request.setRawHeader("Authorization", QString("XBL3.0 x=%1;%2").arg(m_account.userToken.extra["uhs"].toString(), m_account.xboxApiToken.token).toUtf8());
|
|
Requestor *requestor = new Requestor(mgr, oauth2, this);
|
|
requestor->setAddAccessTokenInQuery(false);
|
|
|
|
connect(requestor, &Requestor::finished, this, &Context::onXBoxProfileDone);
|
|
requestor->get(request);
|
|
qDebug() << "Getting Xbox profile...";
|
|
}
|
|
|
|
void Context::onXBoxProfileDone(
|
|
int requestId,
|
|
QNetworkReply::NetworkError error,
|
|
QByteArray replyData,
|
|
QList<QNetworkReply::RawHeaderPair> headers
|
|
) {
|
|
requestsDone ++;
|
|
|
|
if (error != QNetworkReply::NoError) {
|
|
qWarning() << "Reply error:" << error;
|
|
qDebug() << replyData;
|
|
finishActivity();
|
|
return;
|
|
}
|
|
|
|
qDebug() << "XBox profile: " << replyData;
|
|
|
|
xboxProfileSucceeded = true;
|
|
checkResult();
|
|
}
|
|
|
|
void Context::checkResult() {
|
|
if(requestsDone != 2) {
|
|
return;
|
|
}
|
|
if(mcAuthSucceeded && xboxProfileSucceeded) {
|
|
doMinecraftProfile();
|
|
}
|
|
else {
|
|
finishActivity();
|
|
}
|
|
}
|
|
|
|
namespace {
|
|
bool parseMinecraftProfile(QByteArray & data, MinecraftProfile &output) {
|
|
QJsonParseError jsonError;
|
|
QJsonDocument doc = QJsonDocument::fromJson(data, &jsonError);
|
|
if(jsonError.error) {
|
|
qWarning() << "Failed to parse response from user.auth.xboxlive.com as JSON: " << jsonError.errorString();
|
|
qDebug() << data;
|
|
return false;
|
|
}
|
|
|
|
auto obj = doc.object();
|
|
if(!getString(obj.value("id"), output.id)) {
|
|
qWarning() << "minecraft profile id is not a string";
|
|
qDebug() << data;
|
|
return false;
|
|
}
|
|
|
|
if(!getString(obj.value("name"), output.name)) {
|
|
qWarning() << "minecraft profile name is not a string";
|
|
qDebug() << data;
|
|
return false;
|
|
}
|
|
|
|
auto skinsArray = obj.value("skins").toArray();
|
|
for(auto skin: skinsArray) {
|
|
auto skinObj = skin.toObject();
|
|
Skin skinOut;
|
|
if(!getString(skinObj.value("id"), skinOut.id)) {
|
|
continue;
|
|
}
|
|
QString state;
|
|
if(!getString(skinObj.value("state"), state)) {
|
|
continue;
|
|
}
|
|
if(state != "ACTIVE") {
|
|
continue;
|
|
}
|
|
if(!getString(skinObj.value("url"), skinOut.url)) {
|
|
continue;
|
|
}
|
|
if(!getString(skinObj.value("variant"), skinOut.variant)) {
|
|
continue;
|
|
}
|
|
// we deal with only the active skin
|
|
output.skin = skinOut;
|
|
break;
|
|
}
|
|
auto capesArray = obj.value("capes").toArray();
|
|
int i = -1;
|
|
int currentCape = -1;
|
|
for(auto cape: capesArray) {
|
|
i++;
|
|
auto capeObj = cape.toObject();
|
|
Cape capeOut;
|
|
if(!getString(capeObj.value("id"), capeOut.id)) {
|
|
continue;
|
|
}
|
|
QString state;
|
|
if(!getString(capeObj.value("state"), state)) {
|
|
continue;
|
|
}
|
|
if(state == "ACTIVE") {
|
|
currentCape = i;
|
|
}
|
|
if(!getString(capeObj.value("url"), capeOut.url)) {
|
|
continue;
|
|
}
|
|
if(!getString(capeObj.value("alias"), capeOut.alias)) {
|
|
continue;
|
|
}
|
|
|
|
// we deal with only the active skin
|
|
output.capes.push_back(capeOut);
|
|
}
|
|
output.currentCape = currentCape;
|
|
output.validity = Katabasis::Validity::Certain;
|
|
return true;
|
|
}
|
|
}
|
|
|
|
void Context::doMinecraftProfile() {
|
|
auto url = QUrl("https://api.minecraftservices.com/minecraft/profile");
|
|
QNetworkRequest request = QNetworkRequest(url);
|
|
request.setHeader(QNetworkRequest::ContentTypeHeader, "application/json");
|
|
// request.setRawHeader("Accept", "application/json");
|
|
request.setRawHeader("Authorization", QString("Bearer %1").arg(m_account.minecraftToken.token).toUtf8());
|
|
|
|
Requestor *requestor = new Requestor(mgr, oauth2, this);
|
|
requestor->setAddAccessTokenInQuery(false);
|
|
|
|
connect(requestor, &Requestor::finished, this, &Context::onMinecraftProfileDone);
|
|
requestor->get(request);
|
|
}
|
|
|
|
void Context::onMinecraftProfileDone(int, QNetworkReply::NetworkError error, QByteArray data, QList<QNetworkReply::RawHeaderPair> headers) {
|
|
qDebug() << data;
|
|
if (error == QNetworkReply::ContentNotFoundError) {
|
|
m_account.minecraftProfile = MinecraftProfile();
|
|
finishActivity();
|
|
return;
|
|
}
|
|
if (error != QNetworkReply::NoError) {
|
|
finishActivity();
|
|
return;
|
|
}
|
|
if(!parseMinecraftProfile(data, m_account.minecraftProfile)) {
|
|
m_account.minecraftProfile = MinecraftProfile();
|
|
finishActivity();
|
|
return;
|
|
}
|
|
doGetSkin();
|
|
}
|
|
|
|
void Context::doGetSkin() {
|
|
auto url = QUrl(m_account.minecraftProfile.skin.url);
|
|
QNetworkRequest request = QNetworkRequest(url);
|
|
Requestor *requestor = new Requestor(mgr, oauth2, this);
|
|
requestor->setAddAccessTokenInQuery(false);
|
|
connect(requestor, &Requestor::finished, this, &Context::onSkinDone);
|
|
requestor->get(request);
|
|
}
|
|
|
|
void Context::onSkinDone(int, QNetworkReply::NetworkError error, QByteArray data, QList<QNetworkReply::RawHeaderPair>) {
|
|
if (error == QNetworkReply::NoError) {
|
|
m_account.minecraftProfile.skin.data = data;
|
|
}
|
|
finishActivity();
|
|
}
|
|
|
|
namespace {
|
|
void tokenToJSON(QJsonObject &parent, Katabasis::Token t, const char * tokenName) {
|
|
if(t.validity == Katabasis::Validity::None || !t.persistent) {
|
|
return;
|
|
}
|
|
QJsonObject out;
|
|
if(t.issueInstant.isValid()) {
|
|
out["iat"] = QJsonValue(t.issueInstant.toSecsSinceEpoch());
|
|
}
|
|
|
|
if(t.notAfter.isValid()) {
|
|
out["exp"] = QJsonValue(t.notAfter.toSecsSinceEpoch());
|
|
}
|
|
|
|
if(!t.token.isEmpty()) {
|
|
out["token"] = QJsonValue(t.token);
|
|
}
|
|
if(!t.refresh_token.isEmpty()) {
|
|
out["refresh_token"] = QJsonValue(t.refresh_token);
|
|
}
|
|
if(t.extra.size()) {
|
|
out["extra"] = QJsonObject::fromVariantMap(t.extra);
|
|
}
|
|
if(out.size()) {
|
|
parent[tokenName] = out;
|
|
}
|
|
}
|
|
|
|
Katabasis::Token tokenFromJSON(const QJsonObject &parent, const char * tokenName) {
|
|
Katabasis::Token out;
|
|
auto tokenObject = parent.value(tokenName).toObject();
|
|
if(tokenObject.isEmpty()) {
|
|
return out;
|
|
}
|
|
auto issueInstant = tokenObject.value("iat");
|
|
if(issueInstant.isDouble()) {
|
|
out.issueInstant = QDateTime::fromSecsSinceEpoch((int64_t) issueInstant.toDouble());
|
|
}
|
|
|
|
auto notAfter = tokenObject.value("exp");
|
|
if(notAfter.isDouble()) {
|
|
out.notAfter = QDateTime::fromSecsSinceEpoch((int64_t) notAfter.toDouble());
|
|
}
|
|
|
|
auto token = tokenObject.value("token");
|
|
if(token.isString()) {
|
|
out.token = token.toString();
|
|
out.validity = Katabasis::Validity::Assumed;
|
|
}
|
|
|
|
auto refresh_token = tokenObject.value("refresh_token");
|
|
if(refresh_token.isString()) {
|
|
out.refresh_token = refresh_token.toString();
|
|
}
|
|
|
|
auto extra = tokenObject.value("extra");
|
|
if(extra.isObject()) {
|
|
out.extra = extra.toObject().toVariantMap();
|
|
}
|
|
return out;
|
|
}
|
|
|
|
void profileToJSON(QJsonObject &parent, MinecraftProfile p, const char * tokenName) {
|
|
if(p.id.isEmpty()) {
|
|
return;
|
|
}
|
|
QJsonObject out;
|
|
out["id"] = QJsonValue(p.id);
|
|
out["name"] = QJsonValue(p.name);
|
|
if(p.currentCape != -1) {
|
|
out["cape"] = p.capes[p.currentCape].id;
|
|
}
|
|
|
|
{
|
|
QJsonObject skinObj;
|
|
skinObj["id"] = p.skin.id;
|
|
skinObj["url"] = p.skin.url;
|
|
skinObj["variant"] = p.skin.variant;
|
|
if(p.skin.data.size()) {
|
|
skinObj["data"] = QString::fromLatin1(p.skin.data.toBase64());
|
|
}
|
|
out["skin"] = skinObj;
|
|
}
|
|
|
|
QJsonArray capesArray;
|
|
for(auto & cape: p.capes) {
|
|
QJsonObject capeObj;
|
|
capeObj["id"] = cape.id;
|
|
capeObj["url"] = cape.url;
|
|
capeObj["alias"] = cape.alias;
|
|
if(cape.data.size()) {
|
|
capeObj["data"] = QString::fromLatin1(cape.data.toBase64());
|
|
}
|
|
capesArray.push_back(capeObj);
|
|
}
|
|
out["capes"] = capesArray;
|
|
parent[tokenName] = out;
|
|
}
|
|
|
|
MinecraftProfile profileFromJSON(const QJsonObject &parent, const char * tokenName) {
|
|
MinecraftProfile out;
|
|
auto tokenObject = parent.value(tokenName).toObject();
|
|
if(tokenObject.isEmpty()) {
|
|
return out;
|
|
}
|
|
{
|
|
auto idV = tokenObject.value("id");
|
|
auto nameV = tokenObject.value("name");
|
|
if(!idV.isString() || !nameV.isString()) {
|
|
qWarning() << "mandatory profile attributes are missing or of unexpected type";
|
|
return MinecraftProfile();
|
|
}
|
|
out.name = nameV.toString();
|
|
out.id = idV.toString();
|
|
}
|
|
|
|
{
|
|
auto skinV = tokenObject.value("skin");
|
|
if(!skinV.isObject()) {
|
|
qWarning() << "skin is missing";
|
|
return MinecraftProfile();
|
|
}
|
|
auto skinObj = skinV.toObject();
|
|
auto idV = skinObj.value("id");
|
|
auto urlV = skinObj.value("url");
|
|
auto variantV = skinObj.value("variant");
|
|
if(!idV.isString() || !urlV.isString() || !variantV.isString()) {
|
|
qWarning() << "mandatory skin attributes are missing or of unexpected type";
|
|
return MinecraftProfile();
|
|
}
|
|
out.skin.id = idV.toString();
|
|
out.skin.url = urlV.toString();
|
|
out.skin.variant = variantV.toString();
|
|
|
|
// data for skin is optional
|
|
auto dataV = skinObj.value("data");
|
|
if(dataV.isString()) {
|
|
// TODO: validate base64
|
|
out.skin.data = QByteArray::fromBase64(dataV.toString().toLatin1());
|
|
}
|
|
else if (!dataV.isUndefined()) {
|
|
qWarning() << "skin data is something unexpected";
|
|
return MinecraftProfile();
|
|
}
|
|
}
|
|
|
|
auto capesV = tokenObject.value("capes");
|
|
if(!capesV.isArray()) {
|
|
qWarning() << "capes is not an array!";
|
|
return MinecraftProfile();
|
|
}
|
|
auto capesArray = capesV.toArray();
|
|
for(auto capeV: capesArray) {
|
|
if(!capeV.isObject()) {
|
|
qWarning() << "cape is not an object!";
|
|
return MinecraftProfile();
|
|
}
|
|
auto capeObj = capeV.toObject();
|
|
auto idV = capeObj.value("id");
|
|
auto urlV = capeObj.value("url");
|
|
auto aliasV = capeObj.value("alias");
|
|
if(!idV.isString() || !urlV.isString() || !aliasV.isString()) {
|
|
qWarning() << "mandatory skin attributes are missing or of unexpected type";
|
|
return MinecraftProfile();
|
|
}
|
|
Cape cape;
|
|
cape.id = idV.toString();
|
|
cape.url = urlV.toString();
|
|
cape.alias = aliasV.toString();
|
|
|
|
// data for cape is optional.
|
|
auto dataV = capeObj.value("data");
|
|
if(dataV.isString()) {
|
|
// TODO: validate base64
|
|
cape.data = QByteArray::fromBase64(dataV.toString().toLatin1());
|
|
}
|
|
else if (!dataV.isUndefined()) {
|
|
qWarning() << "cape data is something unexpected";
|
|
return MinecraftProfile();
|
|
}
|
|
out.capes.push_back(cape);
|
|
}
|
|
out.validity = Katabasis::Validity::Assumed;
|
|
return out;
|
|
}
|
|
|
|
}
|
|
|
|
bool Context::resumeFromState(QByteArray data) {
|
|
QJsonParseError error;
|
|
auto doc = QJsonDocument::fromJson(data, &error);
|
|
if(error.error != QJsonParseError::NoError) {
|
|
qWarning() << "Failed to parse account data as JSON.";
|
|
return false;
|
|
}
|
|
auto docObject = doc.object();
|
|
m_account.msaToken = tokenFromJSON(docObject, "msa");
|
|
m_account.userToken = tokenFromJSON(docObject, "utoken");
|
|
m_account.xboxApiToken = tokenFromJSON(docObject, "xrp-main");
|
|
m_account.mojangservicesToken = tokenFromJSON(docObject, "xrp-mc");
|
|
m_account.minecraftToken = tokenFromJSON(docObject, "ygg");
|
|
|
|
m_account.minecraftProfile = profileFromJSON(docObject, "profile");
|
|
|
|
m_account.validity_ = m_account.minecraftProfile.validity;
|
|
|
|
return true;
|
|
}
|
|
|
|
QByteArray Context::saveState() {
|
|
QJsonDocument doc;
|
|
QJsonObject output;
|
|
tokenToJSON(output, m_account.msaToken, "msa");
|
|
tokenToJSON(output, m_account.userToken, "utoken");
|
|
tokenToJSON(output, m_account.xboxApiToken, "xrp-main");
|
|
tokenToJSON(output, m_account.mojangservicesToken, "xrp-mc");
|
|
tokenToJSON(output, m_account.minecraftToken, "ygg");
|
|
profileToJSON(output, m_account.minecraftProfile, "profile");
|
|
doc.setObject(output);
|
|
return doc.toJson(QJsonDocument::Indented);
|
|
}
|