StarMirror/qTox
1
0
Fork 0
mirror of https://github.com/qTox/qTox.git synced 2024-03-22 14:00:36 +08:00
Code Issues Projects Releases Wiki Activity

chore: remove dead updater code

Browse Source 
The server for this updater doesn't exist anymore and it wasn't used in years.
This commit is contained in:
sudden6 2019-10-23 00:14:56 +02:00
parent 25943be3c2
commit 7475ba4689
No known key found for this signature in database
GPG Key ID: 279509B499E032B9
16 changed files with 0 additions and 1292 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

103
updater/main.cpp
View File

@ -1,103 +0,0 @@
/*
Copyright © 2014-2019 by The qTox Project Contributors
This file is part of qTox, a Qt-based graphical interface for Tox.
qTox is libre software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
qTox is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with qTox. If not, see <http://www.gnu.org/licenses/>.
*/
#include "settings.h"
#include "widget.h"
#include <QApplication>
#include <QDateTime>
#include <QDebug>
#include <QDir>
#include <QFile>
#include <QMutex>
#include <memory>
#include <windows.h>
static std::unique_ptr<QTextStream> logFileStream{nullptr};
static std::unique_ptr<QFile> logFileFile{nullptr};
static QMutex mutex;
void logMessageHandler(QtMsgType type, const QMessageLogContext& ctxt, const QString& msg)
{
// Silence qWarning spam due to bug in QTextBrowser (trying to open a file for base64 images)
if (ctxt.function == QString("virtual bool QFSFileEngine::open(QIODevice::OpenMode)")
&& msg == QString("QFSFileEngine::open: No file name specified"))
return;
QString LogMsg = QString("[%1] %2:%3 : ")
.arg(QTime::currentTime().toString("HH:mm:ss.zzz"))
.arg(ctxt.file)
.arg(ctxt.line);
switch (type) {
case QtDebugMsg:
LogMsg += "Debug";
break;
case QtWarningMsg:
LogMsg += "Warning";
break;
case QtCriticalMsg:
LogMsg += "Critical";
break;
case QtFatalMsg:
LogMsg += "Fatal";
break;
default:
break;
}
LogMsg += ": " + msg + "\n";
QTextStream out(stderr, QIODevice::WriteOnly);
out << LogMsg;
if (!logFileStream)
return;
QMutexLocker locker(&mutex);
*logFileStream << LogMsg;
logFileStream->flush();
}
int main(int argc, char* argv[])
{
qInstallMessageHandler(logMessageHandler);
QApplication a(argc, argv);
Settings s;
logFileStream.reset(new QTextStream);
logFileFile.reset(new QFile(s.getSettingsDirPath() + "qtox.log"));
if (logFileFile->open(QIODevice::Append)) {
logFileStream->setDevice(logFileFile.get());
*logFileStream << QDateTime::currentDateTime().toString(
"\nyyyy-MM-dd HH:mm:ss' Updater file logger starting\n'");
} else {
qWarning() << "Couldn't open log file!\n";
logFileStream.release();
}
long unsigned int bufsize = 100;
char buf[100];
GetUserNameA(buf, &bufsize);
qDebug() << "Updater running as user" << buf;
Widget w(s);
w.show();
return a.exec();
}

5
updater/res.qrc
View File

@ -1,5 +0,0 @@
<RCC>
<qresource prefix="/">
<file>res/qtox-256x256.png</file>
</qresource>
</RCC>

BIN
updater/res/qtox-256x256.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 5.5 KiB

244
updater/serialize.cpp
View File

@ -1,244 +0,0 @@
/*
Copyright © 2014-2019 by The qTox Project Contributors
This file is part of qTox, a Qt-based graphical interface for Tox.
qTox is libre software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
qTox is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with qTox. If not, see <http://www.gnu.org/licenses/>.
*/
#include "serialize.h"
QByteArray doubleToData(double num)
{
union
{
char tab[8];
double n;
} castUnion;
// char n[8];
//*((double*) n) = num;
castUnion.n = num;
return QByteArray(castUnion.tab, 8);
}
QByteArray floatToData(float num)
{
union
{
char tab[4];
float n;
} castUnion;
castUnion.n = num;
return QByteArray(castUnion.tab, 4);
}
float dataToFloat(QByteArray data)
{
union
{
char tab[4];
float n;
} castUnion;
castUnion.tab[0] = data.data()[0];
castUnion.tab[1] = data.data()[1];
castUnion.tab[2] = data.data()[2];
castUnion.tab[3] = data.data()[3];
return castUnion.n;
}
// Converts a string into PNet string data
QByteArray stringToData(QString str)
{
QByteArray data(4, 0);
// Write the size in a Uint of variable lenght (8-32 bits)
int i = 0;
uint num1 = (uint)str.toUtf8().size();
while (num1 >= 0x80) {
data[i] = (unsigned char)(num1 | 0x80);
i++;
num1 = num1 >> 7;
}
data[i] = num1;
data.resize(i + 1);
data += str.toUtf8();
return data;
}
QString dataToString(QByteArray data)
{
// Variable UInt32
unsigned char num3;
int num = 0;
int num2 = 0;
int i = 0;
do {
num3 = data[i];
i++;
num |= (num3 & 0x7f) << num2;
num2 += 7;
} while ((num3 & 0x80) != 0);
unsigned int strlen = (uint)num;
if (!strlen)
return QString();
data = data.right(data.size() - i); // Remove the strlen
data.truncate(strlen);
return QString(data);
}
float dataToRangedSingle(float min, float max, int numberOfBits, QByteArray data)
{
uint endvalue = 0;
uint value = 0;
if (numberOfBits <= 8) {
endvalue = (uchar)data[0];
goto done;
}
value = (uchar)data[0];
numberOfBits -= 8;
if (numberOfBits <= 8) {
endvalue = (value | ((uint)((uchar)data[1]) << 8));
goto done;
}
value |= (uint)(((uchar)data[1]) << 8);
numberOfBits -= 8;
if (numberOfBits <= 8) {
uint num2 = (uint)(((uchar)data[2]) << 0x10);
endvalue = (value | num2);
goto done;
}
value |= (uint)(((uchar)data[2]) << 0x10);
numberOfBits -= 8;
endvalue = (value | ((uint)(((uchar)data[3]) << 0x18)));
goto done;
done:
float num = max - min;
int num2 = (((int)1) << numberOfBits) - 1;
float num3 = endvalue;
float num4 = num3 / ((float)num2);
return (min + (num4 * num));
}
QByteArray rangedSingleToData(float value, float min, float max, int numberOfBits)
{
QByteArray data;
float num = max - min;
float num2 = (value - min) / num;
int num3 = (((int)1) << numberOfBits) - 1;
uint source = num3 * num2;
if (numberOfBits <= 8) {
data += (unsigned char)source;
return data;
}
data += (unsigned char)source;
numberOfBits -= 8;
if (numberOfBits <= 8) {
data += (unsigned char)(source >> 8);
return data;
}
data += (unsigned char)(source >> 8);
numberOfBits -= 8;
if (numberOfBits <= 8) {
data += (unsigned char)(source >> 16);
return data;
}
data += (unsigned char)(source >> 16);
data += (unsigned char)(source >> 24);
return data;
}
uint8_t dataToUint8(QByteArray data)
{
return (uint8_t)data[0];
}
uint16_t dataToUint16(QByteArray data)
{
return ((uint16_t)(uint8_t)data[0]) + (((uint16_t)(uint8_t)data[1]) << 8);
}
uint32_t dataToUint32(QByteArray data)
{
return ((uint32_t)(uint8_t)data[0]) + (((uint32_t)(uint8_t)data[1]) << 8)
+ (((uint32_t)(uint8_t)data[2]) << 16) + (((uint32_t)(uint8_t)data[3]) << 24);
}
uint64_t dataToUint64(QByteArray data)
{
return ((uint64_t)(uint8_t)data[0]) + (((uint64_t)(uint8_t)data[1]) << 8)
+ (((uint64_t)(uint8_t)data[2]) << 16) + (((uint64_t)(uint8_t)data[3]) << 24)
+ (((uint64_t)(uint8_t)data[4]) << 32) + (((uint64_t)(uint8_t)data[5]) << 40)
+ (((uint64_t)(uint8_t)data[6]) << 48) + (((uint64_t)(uint8_t)data[7]) << 56);
}
unsigned getVUint32Size(QByteArray data)
{
unsigned lensize = 0;
{
unsigned char num3;
do {
num3 = data[lensize];
lensize++;
} while ((num3 & 0x80) != 0);
}
return lensize;
}
QByteArray uint8ToData(uint8_t num)
{
QByteArray data(1, 0);
data[0] = (uint8_t)num;
return data;
}
QByteArray uint16ToData(uint16_t num)
{
QByteArray data(2, 0);
data[0] = (uint8_t)(num & 0xFF);
data[1] = (uint8_t)((num >> 8) & 0xFF);
return data;
}
QByteArray uint32ToData(uint32_t num)
{
QByteArray data(4, 0);
data[0] = (uint8_t)(num & 0xFF);
data[1] = (uint8_t)((num >> 8) & 0xFF);
data[2] = (uint8_t)((num >> 16) & 0xFF);
data[3] = (uint8_t)((num >> 24) & 0xFF);
return data;
}
QByteArray uint64ToData(uint64_t num)
{
QByteArray data(8, 0);
data[0] = (uint8_t)(num & 0xFF);
data[1] = (uint8_t)((num >> 8) & 0xFF);
data[2] = (uint8_t)((num >> 16) & 0xFF);
data[3] = (uint8_t)((num >> 24) & 0xFF);
data[4] = (uint8_t)((num >> 32) & 0xFF);
data[5] = (uint8_t)((num >> 40) & 0xFF);
data[6] = (uint8_t)((num >> 48) & 0xFF);
data[7] = (uint8_t)((num >> 56) & 0xFF);
return data;
}

48
updater/serialize.h
View File

@ -1,48 +0,0 @@
/*
Copyright © 2014-2019 by The qTox Project Contributors
This file is part of qTox, a Qt-based graphical interface for Tox.
qTox is libre software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
qTox is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with qTox. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef SERIALIZE_H
#define SERIALIZE_H
#include <QByteArray>
#include <QString>
#include <cstdint>
/// Most of those functions are unsafe unless otherwise specified
/// Do not use them on untrusted data (e.g. check a signature first)
QByteArray doubleToData(double num);
QByteArray floatToData(float num);
float dataToFloat(QByteArray data);
QByteArray stringToData(QString str);
QString dataToString(QByteArray data);
float dataToRangedSingle(float min, float max, int numberOfBits, QByteArray data);
QByteArray rangedSingleToData(float value, float min, float max, int numberOfBits);
uint8_t dataToUint8(QByteArray data);
uint16_t dataToUint16(QByteArray data);
uint32_t dataToUint32(QByteArray data);
uint64_t dataToUint64(QByteArray data);
unsigned getVUint32Size(QByteArray data);
QByteArray uint8ToData(uint8_t num);
QByteArray uint16ToData(uint16_t num);
QByteArray uint32ToData(uint32_t num);
QByteArray uint64ToData(uint64_t num);
#endif // SERIALIZE_H

155
updater/settings.cpp
View File

@ -1,155 +0,0 @@
/*
Copyright © 2019 by The qTox Project Contributors
This file is part of qTox, a Qt-based graphical interface for Tox.
qTox is libre software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
qTox is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with qTox. If not, see <http://www.gnu.org/licenses/>.
*/
#include "settings.h"
#include <QDebug>
#include <QDir>
#include <QFile>
#include <QSettings>
#include <QStandardPaths>
#ifdef Q_OS_WIN
#ifdef _WIN32_WINNT
#undef _WIN32_WINNT
#endif
#define _WIN32_WINNT 0x0600 // Vista for SHGetKnownFolderPath
#include <exdisp.h>
#include <shldisp.h>
#include <shlobj.h>
#include <windows.h>
#endif
Settings::Settings()
{
portable = false;
QFile portableSettings(SETTINGS_FILE);
if (portableSettings.exists()) {
QSettings ps(SETTINGS_FILE, QSettings::IniFormat);
ps.beginGroup("General");
portable = ps.value("makeToxPortable", false).toBool();
}
qDebug() << "Portable: " << portable;
#ifdef Q_OS_WIN
// Get a primary unelevated token of the actual user
hPrimaryToken = nullptr;
HANDLE hShellProcess = nullptr, hShellProcessToken = nullptr;
const DWORD dwTokenRights = TOKEN_QUERY | TOKEN_IMPERSONATE | TOKEN_ASSIGN_PRIMARY
| TOKEN_DUPLICATE | TOKEN_ADJUST_DEFAULT | TOKEN_ADJUST_SESSIONID;
DWORD dwPID = 0;
HWND hwnd = nullptr;
DWORD dwLastErr = 0;
// Enable SeIncreaseQuotaPrivilege
HANDLE hProcessToken = nullptr;
if (!OpenProcessToken(GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES, &hProcessToken))
goto unelevateFail;
TOKEN_PRIVILEGES tkp;
tkp.PrivilegeCount = 1;
LookupPrivilegeValueW(nullptr, SE_INCREASE_QUOTA_NAME, &tkp.Privileges[0].Luid);
tkp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
AdjustTokenPrivileges(hProcessToken, FALSE, &tkp, 0, nullptr, nullptr);
dwLastErr = GetLastError();
CloseHandle(hProcessToken);
if (ERROR_SUCCESS != dwLastErr)
goto unelevateFail;
// Get a primary copy of the desktop shell's token,
// we're assuming the shell is running as the actual user
hwnd = GetShellWindow();
if (!hwnd)
goto unelevateFail;
GetWindowThreadProcessId(hwnd, &dwPID);
if (!dwPID)
goto unelevateFail;
hShellProcess = OpenProcess(PROCESS_QUERY_INFORMATION, FALSE, dwPID);
if (!hShellProcess)
goto unelevateFail;
if (!OpenProcessToken(hShellProcess, TOKEN_DUPLICATE, &hShellProcessToken))
goto unelevateFail;
// Duplicate the shell's process token to get a primary token.
// Based on experimentation, this is the minimal set of rights required for
// CreateProcessWithTokenW (contrary to current documentation).
if (!DuplicateTokenEx(hShellProcessToken, dwTokenRights, nullptr, SecurityImpersonation,
TokenPrimary, &hPrimaryToken))
goto unelevateFail;
qDebug() << "Unelevated primary access token acquired";
goto unelevateCleanup;
unelevateFail:
qWarning() << "Unelevate failed, couldn't get access token";
unelevateCleanup:
CloseHandle(hShellProcessToken);
CloseHandle(hShellProcess);
#endif
}
Settings::~Settings()
{
#ifdef Q_OS_WIN
CloseHandle(hPrimaryToken);
#endif
}
QString Settings::getSettingsDirPath() const
{
if (portable)
return QString(".") + QDir::separator();
// workaround for https://bugreports.qt-project.org/browse/QTBUG-38845
#ifdef Q_OS_WIN
wchar_t* path;
bool isOld = false; // If true, we can't unelevate and just return the path for our current home
auto shell32H = LoadLibrary(TEXT("shell32.dll"));
if (!(isOld = (shell32H == nullptr))) {
auto SHGetKnownFolderPathH =
(decltype(&SHGetKnownFolderPath))GetProcAddress(shell32H, "SHGetKnownFolderPath");
if (!(isOld = (SHGetKnownFolderPathH == nullptr)))
SHGetKnownFolderPathH(FOLDERID_RoamingAppData, 0, hPrimaryToken, &path);
}
if (isOld) {
return QDir::cleanPath(QStandardPaths::writableLocation(QStandardPaths::HomeLocation)
+ QDir::separator() + "AppData" + QDir::separator() + "Roaming"
+ QDir::separator() + "tox" + QDir::separator());
} else {
QString pathStr = QString::fromStdWString(path);
pathStr.replace("\\", "/");
return pathStr + "/tox";
}
#elif defined(Q_OS_OSX)
return QDir::cleanPath(QStandardPaths::writableLocation(QStandardPaths::HomeLocation)
+ QDir::separator() + "Library" + QDir::separator()
+ "Application Support" + QDir::separator() + "Tox")
+ QDir::separator();
#else
return QDir::cleanPath(QStandardPaths::writableLocation(QStandardPaths::ConfigLocation)
+ QDir::separator() + "tox")
+ QDir::separator();
#endif
}
#ifdef Q_OS_WIN
HANDLE Settings::getPrimaryToken() const
{
return hPrimaryToken;
}
#endif

48
updater/settings.h
View File

@ -1,48 +0,0 @@
/*
Copyright © 2019 by The qTox Project Contributors
This file is part of qTox, a Qt-based graphical interface for Tox.
qTox is libre software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
qTox is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with qTox. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef SETTINGS_H
#define SETTINGS_H
#include <QString>
#ifdef Q_OS_WIN
#include <windows.h>
#endif
class Settings
{
public:
Settings();
~Settings();
QString getSettingsDirPath() const; ///< The returned path ends with a directory separator
#ifdef Q_OS_WIN
HANDLE getPrimaryToken() const; ///< Used to impersonnate the unelevated user
#endif
private:
bool portable;
static constexpr const char* SETTINGS_FILE = "qtox.ini";
#ifdef Q_OS_WIN
HANDLE hPrimaryToken;
#endif
};
#endif // SETTINGS_H

134
updater/update.cpp
View File

@ -1,134 +0,0 @@
/*
Copyright © 2014-2019 by The qTox Project Contributors
This file is part of qTox, a Qt-based graphical interface for Tox.
qTox is libre software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
qTox is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with qTox. If not, see <http://www.gnu.org/licenses/>.
*/
#include "update.h"
#include "serialize.h"
#include "widget.h"
#include <QCoreApplication>
#include <QDebug>
#include <QDir>
#include <QFile>
#include <QMessageBox>
unsigned char key[crypto_sign_PUBLICKEYBYTES] = {0x20, 0x89, 0x39, 0xaa, 0x9a, 0xe8, 0xb5, 0x21,
0x0e, 0xac, 0x02, 0xa9, 0xc4, 0x92, 0xd9, 0xa2,
0x17, 0x83, 0xbd, 0x78, 0x0a, 0xda, 0x33, 0xcd,
0xa5, 0xc6, 0x44, 0xc7, 0xfc, 0xed, 0x00, 0x13};
QByteArray getLocalFlist()
{
QByteArray flist;
QFile flistFile("flist");
if (!flistFile.open(QIODevice::ReadOnly)) {
qWarning() << "getLocalFlist: Can't open local flist";
return flist;
}
flist = flistFile.readAll();
flistFile.close();
return flist;
}
bool isUpToDate(UpdateFileMeta fileMeta)
{
QString appDir = qApp->applicationDirPath();
QFile file(appDir + QDir::separator() + fileMeta.installpath);
if (!file.open(QIODevice::ReadOnly))
return false;
// If the data we have is corrupted or old, mark it for update
QByteArray data = file.readAll();
if (crypto_sign_verify_detached(fileMeta.sig, (unsigned char*)data.data(), data.size(), key) != 0)
return false;
return true;
}
QList<UpdateFileMeta> genUpdateDiff(QList<UpdateFileMeta> updateFlist, Widget* w)
{
QList<UpdateFileMeta> diff;
float progressDiff = 45;
float progress = 5;
for (UpdateFileMeta file : updateFlist) {
if (!isUpToDate(file))
diff += file;
progress += progressDiff / updateFlist.size();
w->setProgress(progress);
}
return diff;
}
QList<UpdateFileMeta> parseFlist(QByteArray flistData)
{
QList<UpdateFileMeta> flist;
if (flistData.isEmpty()) {
qWarning() << "AutoUpdater::parseflist: Empty data";
return flist;
}
// Check version
if (flistData[0] != '1') {
qWarning() << "AutoUpdater: parseflist: Bad version " << (uint8_t)flistData[0];
return flist;
}
flistData = flistData.mid(1);
// Check signature
if (flistData.size() < (int)(crypto_sign_BYTES)) {
qWarning() << "AutoUpdater::parseflist: Truncated data";
return flist;
} else {
QByteArray msgData = flistData.mid(crypto_sign_BYTES);
unsigned char* msg = (unsigned char*)msgData.data();
if (crypto_sign_verify_detached((unsigned char*)flistData.data(), msg, msgData.size(), key)
!= 0) {
qCritical() << "AutoUpdater: parseflist: FORGED FLIST FILE";
return flist;
}
flistData = flistData.mid(crypto_sign_BYTES);
}
// Parse. We assume no errors handling needed since the signature is valid.
while (!flistData.isEmpty()) {
UpdateFileMeta newFile;
memcpy(newFile.sig, flistData.data(), crypto_sign_BYTES);
flistData = flistData.mid(crypto_sign_BYTES);
newFile.id = dataToString(flistData);
flistData = flistData.mid(newFile.id.size() + getVUint32Size(flistData));
newFile.installpath = dataToString(flistData);
flistData = flistData.mid(newFile.installpath.size() + getVUint32Size(flistData));
newFile.size = dataToUint64(flistData);
flistData = flistData.mid(8);
flist += newFile;
}
return flist;
}

60
updater/update.h
View File

@ -1,60 +0,0 @@
/*
Copyright © 2014-2019 by The qTox Project Contributors
This file is part of qTox, a Qt-based graphical interface for Tox.
qTox is libre software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
qTox is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with qTox. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef UPDATE_H
#define UPDATE_H
#include <QByteArray>
#include <QString>
#include <sodium.h>
class Widget;
struct UpdateFileMeta
{
unsigned char sig[crypto_sign_BYTES]; ///< Signature of the file (ed25519)
QString id; ///< Unique id of the file
QString installpath; ///< Local path including the file name. May be relative to qtox-updater or
/// absolute
uint64_t size; ///< Size in bytes of the file
bool operator==(const UpdateFileMeta& other)
{
return (size == other.size && id == other.id && installpath == other.installpath
&& memcmp(sig, other.sig, crypto_sign_BYTES) == 0);
}
};
struct UpdateFile
{
UpdateFileMeta metadata;
QByteArray data;
};
/// Gets the local flist. Returns an empty array on error
QByteArray getLocalFlist();
/// Parses and validates a flist file. Returns an empty list on error
QList<UpdateFileMeta> parseFlist(QByteArray flistData);
/// Generates a list of files we need to update
QList<UpdateFileMeta> genUpdateDiff(QList<UpdateFileMeta> updateFlist, Widget* w);
extern unsigned char key[crypto_sign_PUBLICKEYBYTES];
#endif // UPDATE_H

42
updater/updater.pro
View File

@ -1,42 +0,0 @@
#-------------------------------------------------
#
# Project created by QtCreator 2014-11-09T21:09:08
#
#-------------------------------------------------
QT += core gui
greaterThan(QT_MAJOR_VERSION, 4): QT += widgets
TARGET = qtox-updater
TEMPLATE = app
CONFIG += c++11
QMAKE_CXXFLAGS += -fno-exceptions
SOURCES += main.cpp\
widget.cpp \
update.cpp \
serialize.cpp \
settings.cpp
HEADERS += widget.h \
update.h \
serialize.h \
settings.h
FORMS += widget.ui
RESOURCES += \
res.qrc
INCLUDEPATH += libs/include
RC_FILE = windows/updater.rc
LIBS += -L$$PWD/libs/lib/ -lsodium
win32 {
LIBS += -lshell32 -luuid
}

237
updater/widget.cpp
View File

@ -1,237 +0,0 @@
/*
Copyright © 2014-2019 by The qTox Project Contributors
This file is part of qTox, a Qt-based graphical interface for Tox.
qTox is libre software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
qTox is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with qTox. If not, see <http://www.gnu.org/licenses/>.
*/
#include "widget.h"
#include "ui_widget.h"
#include <QDebug>
#include <QDir>
#include <QFile>
#include <QMessageBox>
#include <QMetaObject>
#include <QProcess>
#include <QSettings>
#include "update.h"
#ifdef Q_OS_WIN
#ifdef _WIN32_WINNT
#undef _WIN32_WINNT
#endif
#define _WIN32_WINNT 0x0600 // Vista for SHGetKnownFolderPath
#include <exdisp.h>
#include <shldisp.h>
#include <shlobj.h>
#include <windows.h>
const bool supported = true;
const QString QTOX_PATH = "qtox.exe";
#else
const bool supported = false;
const QString QTOX_PATH;
#endif
const QString SETTINGS_FILE = "settings.ini";
Widget::Widget(const Settings& s)
: QWidget(nullptr)
, ui(new Ui::Widget)
, settings{s}
{
ui->setupUi(this);
// Updates only for supported platforms
if (!supported)
fatalError(tr("The qTox updater is not supported on this platform."));
QMetaObject::invokeMethod(this, "update", Qt::QueuedConnection);
}
Widget::~Widget()
{
delete ui;
}
void Widget::setProgress(int value)
{
ui->progress->setValue(value);
ui->progress->repaint();
qApp->processEvents();
}
void Widget::fatalError(QString message)
{
qCritical() << "Update aborted with error:" << message;
QMessageBox::critical(this, tr("Error"), message + '\n' + tr("qTox will restart now."));
deleteUpdate();
restoreBackups();
startQToxAndExit();
}
void Widget::deleteUpdate()
{
QDir updateDir(settings.getSettingsDirPath() + "/update/");
updateDir.removeRecursively();
}
void Widget::startQToxAndExit()
{
#ifdef Q_OS_WIN
// Try to restart qTox as the actual user with our unelevated token
STARTUPINFOW si;
PROCESS_INFORMATION pi;
SecureZeroMemory(&si, sizeof(si));
SecureZeroMemory(&pi, sizeof(pi));
si.cb = sizeof(si);
bool unelevateOk = true;
auto advapi32H = LoadLibrary(TEXT("advapi32.dll"));
if ((unelevateOk = (advapi32H != nullptr))) {
auto CreateProcessWithTokenWH =
(decltype(&CreateProcessWithTokenW))GetProcAddress(advapi32H,
"CreateProcessWithTokenW");
if ((unelevateOk = (CreateProcessWithTokenWH != nullptr))) {
if (!CreateProcessWithTokenWH(settings.getPrimaryToken(), 0,
QTOX_PATH.toStdWString().c_str(), 0, 0, 0,
QApplication::applicationDirPath().toStdWString().c_str(),
&si, &pi))
unelevateOk = false;
}
}
CloseHandle(pi.hProcess);
CloseHandle(pi.hThread);
if (!unelevateOk) {
qWarning() << "Failed to start unelevated qTox";
QProcess::startDetached(QTOX_PATH);
}
#else
QProcess::startDetached(QTOX_PATH);
#endif
exit(0);
}
void Widget::deleteBackups()
{
for (QString file : backups)
QFile(file + ".bak").remove();
}
void Widget::restoreBackups()
{
for (QString file : backups)
QFile(file + ".bak").rename(file);
}
void Widget::update()
{
/// 1. Find and parse the update (0-5%)
// Check that the dir exists
QString updateDirStr = settings.getSettingsDirPath() + "/update/";
QDir updateDir(updateDirStr);
if (!updateDir.exists())
fatalError(tr("No update found."));
setProgress(2);
// Check that we have a flist and that every file on the diff exists
QFile updateFlistFile(updateDirStr + "flist");
if (!updateFlistFile.open(QIODevice::ReadOnly))
fatalError(tr("The update is incomplete!"));
QByteArray updateFlistData = updateFlistFile.readAll();
updateFlistFile.close();
QList<UpdateFileMeta> updateFlist = parseFlist(updateFlistData);
setProgress(5);
/// 2. Generate a diff (5-50%)
QList<UpdateFileMeta> diff = genUpdateDiff(updateFlist, this);
for (UpdateFileMeta fileMeta : diff)
if (!QFile::exists(updateDirStr + fileMeta.installpath))
fatalError(tr("The update is incomplete."));
if (diff.size() == 0)
fatalError(tr("The update is empty!"));
setProgress(50);
qDebug() << "Diff generated," << diff.size() << "files to update";
/// 2. Check the update (50-75%)
float checkProgressStep = 25.0 / (float)diff.size();
float checkProgress = 50;
for (UpdateFileMeta fileMeta : diff) {
UpdateFile file;
file.metadata = fileMeta;
QFile fileFile(updateDirStr + fileMeta.installpath);
if (!fileFile.open(QIODevice::ReadOnly))
fatalError(tr("Update files are unreadable."));
file.data = fileFile.readAll();
fileFile.close();
if (file.data.size() != (int)fileMeta.size)
fatalError(tr("Update files are corrupted."));
if (crypto_sign_verify_detached(file.metadata.sig, (unsigned char*)file.data.data(),
file.data.size(), key)
!= 0)
fatalError(tr("Update files are corrupted."));
checkProgress += checkProgressStep;
setProgress(checkProgress);
}
setProgress(75);
qDebug() << "Update files signature verified, installing";
/// 3. Install the update (75-95%)
float installProgressStep = 20.0 / (float)diff.size();
float installProgress = 75;
for (UpdateFileMeta fileMeta : diff) {
// Backup old files
if (QFile(fileMeta.installpath).exists()) {
QFile(fileMeta.installpath + ".bak").remove();
QFile(fileMeta.installpath).rename(fileMeta.installpath + ".bak");
backups.append(fileMeta.installpath);
}
// Install new ones
QDir().mkpath(QFileInfo(fileMeta.installpath).absolutePath());
QFile fileFile(updateDirStr + fileMeta.installpath);
if (!fileFile.copy(fileMeta.installpath))
fatalError(tr("Unable to copy the update's files from ")
+ (updateDirStr + fileMeta.installpath) + " to " + fileMeta.installpath);
installProgress += installProgressStep;
setProgress(installProgress);
}
setProgress(95);
/// 4. Delete the update and backups (95-100%)
deleteUpdate();
setProgress(97);
deleteBackups();
setProgress(100);
/// 5. Start qTox and exit
qDebug() << "Update applied, restarting qTox!";
startQToxAndExit();
}

63
updater/widget.h
View File

@ -1,63 +0,0 @@
/*
Copyright © 2014-2019 by The qTox Project Contributors
This file is part of qTox, a Qt-based graphical interface for Tox.
qTox is libre software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
qTox is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with qTox. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef WIDGET_H
#define WIDGET_H
#include "settings.h"
#include <QWidget>
#ifdef Q_OS_WIN
#include <windows.h>
#endif
namespace Ui {
class Widget;
}
class Widget : public QWidget
{
Q_OBJECT
public:
explicit Widget(const Settings& s);
~Widget();
// Utilities
void deleteBackups();
void restoreBackups();
void setProgress(int value);
// Noreturn
void fatalError(QString message); ///< Calls deleteUpdate and startQToxAndExit
void deleteUpdate();
void startQToxAndExit();
public slots:
// Finds and applies the update
void update();
private:
Ui::Widget* ui;
QStringList backups;
const Settings& settings;
};
#endif // WIDGET_H

139
updater/widget.ui
View File

@ -1,139 +0,0 @@
<?xml version="1.0" encoding="UTF-8"?>
<ui version="4.0">
<class>Widget</class>
<widget class="QWidget" name="Widget">
<property name="geometry">
<rect>
<x>0</x>
<y>0</y>
<width>401</width>
<height>224</height>
</rect>
</property>
<property name="windowTitle">
<string>qTox Updater</string>
</property>
<property name="windowIcon">
<iconset resource="res.qrc">
<normaloff>:/res/qtox-256x256.png</normaloff>:/res/qtox-256x256.png</iconset>
</property>
<widget class="QLabel" name="label">
<property name="geometry">
<rect>
<x>0</x>
<y>13</y>
<width>191</width>
<height>191</height>
</rect>
</property>
<property name="text">
<string/>
</property>
<property name="pixmap">
<pixmap resource="res.qrc">:/res/qtox-256x256.png</pixmap>
</property>
<property name="scaledContents">
<bool>true</bool>
</property>
</widget>
<widget class="QProgressBar" name="progress">
<property name="geometry">
<rect>
<x>206</x>
<y>95</y>
<width>171</width>
<height>20</height>
</rect>
</property>
<property name="minimum">
<number>0</number>
</property>
<property name="value">
<number>0</number>
</property>
<property name="alignment">
<set>Qt::AlignCenter</set>
</property>
<property name="invertedAppearance">
<bool>false</bool>
</property>
</widget>
<widget class="QLabel" name="label_2">
<property name="geometry">
<rect>
<x>205</x>
<y>115</y>
<width>171</width>
<height>20</height>
</rect>
</property>
<property name="text">
<string>Updating qTox ...</string>
</property>
<property name="alignment">
<set>Qt::AlignCenter</set>
</property>
</widget>
<widget class="QLabel" name="label_3">
<property name="geometry">
<rect>
<x>201</x>
<y>170</y>
<width>181</width>
<height>20</height>
</rect>
</property>
<property name="text">
<string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;&lt;a href=&quot;https://tox.chat&quot;&gt;&lt;span style=&quot; text-decoration: underline; color:#0000ff;&quot;&gt;https://tox.chat&lt;/span&gt;&lt;/a&gt;&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
</property>
<property name="alignment">
<set>Qt::AlignCenter</set>
</property>
<property name="openExternalLinks">
<bool>true</bool>
</property>
</widget>
<widget class="QLabel" name="label_4">
<property name="geometry">
<rect>
<x>200</x>
<y>183</y>
<width>181</width>
<height>20</height>
</rect>
</property>
<property name="text">
<string>&lt;a href=&quot;https://github.com/qTox/qtox&quot;&gt;https://github.com/qTox/qtox&lt;/a&gt;</string>
</property>
<property name="alignment">
<set>Qt::AlignCenter</set>
</property>
</widget>
<widget class="QLabel" name="label_5">
<property name="geometry">
<rect>
<x>195</x>
<y>32</y>
<width>191</width>
<height>31</height>
</rect>
</property>
<property name="font">
<font>
<pointsize>14</pointsize>
</font>
</property>
<property name="text">
<string>qTox Update</string>
</property>
<property name="alignment">
<set>Qt::AlignCenter</set>
</property>
</widget>
</widget>
<layoutdefault spacing="6" margin="11"/>
<resources>
<include location="res.qrc"/>
</resources>
<connections/>
</ui>

12
updater/windows/updater.exe.manifest
View File

@ -1,12 +0,0 @@
<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0">
<trustInfo xmlns="urn:schemas-microsoft-com:asm.v2">
<security>
<requestedPrivileges>
<requestedExecutionLevel
level="requireAdministrator"
uiAccess="false"/>
</requestedPrivileges>
</security>
</trustInfo>
</assembly>

BIN
updater/windows/updater.ico
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 17 KiB

2
updater/windows/updater.rc
View File

@ -1,2 +0,0 @@
ID_ICON ICON DISCARDABLE "updater.ico"
1 24 "updater.exe.manifest"