added import/export functions (untested)

Author: Skycoder42

src/datasync/authenticator.cpp

@@ -1,12 +1,33 @@
 #include "authenticator.h"
 #include "remoteconnector.h"
 
+#include <QtCore/QBuffer>
+
 using namespace QtDataSync;
 
 Authenticator::Authenticator(QObject *parent) :
 	QObject(parent)
 {}
 
+QByteArray Authenticator::exportUserData() const
+{
+	QBuffer buffer;
+	buffer.open(QIODevice::WriteOnly);
+	exportUserData(&buffer);
+	auto res = buffer.data();
+	buffer.close();
+	return res;
+}
+
+GenericTask<void> Authenticator::importUserData(QByteArray data)
+{
+	QBuffer buffer(&data);
+	buffer.open(QIODevice::ReadOnly);
+	auto res = importUserData(&buffer);
+	buffer.close();
+	return res;
+}
+
 GenericTask<void> Authenticator::resetIdentity(const QVariant &extraData, bool resetLocalStore)
 {
 	QFutureInterface<QVariant> futureInterface;

src/datasync/authenticator.h

@@ -6,6 +6,7 @@
 
 #include <QtCore/qobject.h>
 #include <QtCore/qpointer.h>
+#include <QtCore/qiodevice.h>
 
 #include <functional>
 #include <type_traits>
@@ -23,6 +24,15 @@ class Q_DATASYNC_EXPORT Authenticator : public QObject
 	//! Constructor
 	explicit Authenticator(QObject *parent = nullptr);
 
+	//! Export all user-related remote data to the given device
+	virtual void exportUserData(QIODevice *device) const = 0;
+	//! Export all user-related remote data
+	QByteArray exportUserData() const;
+	//! Import user-related remote data from the given device
+	virtual GenericTask<void> importUserData(QIODevice *device) = 0;
+	//! Import user-related remote data
+	GenericTask<void> importUserData(QByteArray data);
+
 protected:
 	//! Call this method to reset the users identity.
 	GenericTask<void> resetIdentity(const QVariant &extraData = {}, bool resetLocalStore = true);

src/datasync/encryptor.h

@@ -21,7 +21,7 @@ class Encryptor : public QObject
 	//! Called from the engine to finalize the encryptor
 	virtual void finalize();
 
-	//! Returns the current encryption key
+	//! Returns the current encryption key (must be thread-safe)
 	virtual QByteArray key() const = 0;
 	//! Sets the encryption key
 	virtual void setKey(const QByteArray &key) = 0;

src/datasync/exceptions.cpp

@@ -51,6 +51,29 @@ QException *SetupLockedException::clone() const
 	return new SetupLockedException(this);
 }
 
+InvalidDataException::InvalidDataException(const QString &what) :
+	_what(what.toUtf8())
+{}
+
+InvalidDataException::InvalidDataException(const QByteArray &what) :
+	_what(what)
+{}
+
+const char *InvalidDataException::what() const noexcept
+{
+	return _what.constData();
+}
+
+void InvalidDataException::raise() const
+{
+	throw *this;
+}
+
+QException *InvalidDataException::clone() const
+{
+	return new InvalidDataException(_what);
+}
+
 DataSyncException::DataSyncException(const QString &what) :
 	QException(),
 	_what(what.toUtf8())

src/datasync/exceptions.h

@@ -58,6 +58,27 @@ class Q_DATASYNC_EXPORT SetupLockedException : public SetupException
 	SetupLockedException(const SetupException *cloneFrom);
 };
 
+//! Exception thrown if imported user data is invalid
+class Q_DATASYNC_EXPORT InvalidDataException : public QException
+{
+public:
+	//! Constructor with error message
+	InvalidDataException(const QString &what);
+
+public:
+	//! @inherit{std::exception::what}
+	const char *what() const noexcept final;
+
+	//! @inherit{QException::raise}
+	void raise() const final;
+	//! @inherit{QException::clone}
+	QException *clone() const final;
+
+private:
+	InvalidDataException(const QByteArray &what);
+	const QByteArray _what;
+};
+
 //! Exception thrown if something goes wrong when using the async store
 class Q_DATASYNC_EXPORT DataSyncException : public QException
 {

src/datasync/qtinyaesencryptor.cpp

@@ -9,7 +9,8 @@ using namespace QtDataSync;
 QTinyAesEncryptor::QTinyAesEncryptor(QObject *parent) :
 	Encryptor(parent),
 	_defaults(nullptr),
-	_key()
+	_key(),
+	_keyMutex()
 {}
 
 void QTinyAesEncryptor::initialize(Defaults *defaults)
@@ -25,11 +26,13 @@ void QTinyAesEncryptor::initialize(Defaults *defaults)
 
 QByteArray QTinyAesEncryptor::key() const
 {
+	QMutexLocker _(&_keyMutex);
 	return _key;
 }
 
 void QTinyAesEncryptor::setKey(const QByteArray &key)
 {
+	QMutexLocker _(&_keyMutex);
 	if((quint32)_key.size() != QTinyAes::KEYSIZE)
 		throw InvalidKeyException();
 	_key = key;

src/datasync/qtinyaesencryptor_p.h

@@ -5,6 +5,7 @@
 #include "encryptor.h"
 
 #include <QtCore/QException>
+#include <QtCore/QMutex>
 
 namespace QtDataSync {
 
@@ -42,6 +43,7 @@ class Q_DATASYNC_EXPORT QTinyAesEncryptor : public Encryptor
 private:
 	Defaults *_defaults;
 	QByteArray _key;
+	mutable QMutex _keyMutex;
 };
 
 }

src/datasync/remoteconnector.cpp

@@ -10,6 +10,7 @@ class RemoteConnectorPrivate {
 	RemoteConnectorPrivate();
 
 	Defaults *defaults;
+	Encryptor *cryptor;
 };
 }
 
@@ -22,13 +23,19 @@ RemoteConnector::RemoteConnector(QObject *parent) :
 
 RemoteConnector::~RemoteConnector() {}
 
-void RemoteConnector::initialize(Defaults *defaults, Encryptor *)
+void RemoteConnector::initialize(Defaults *defaults, Encryptor *cryptor)
 {
 	d->defaults = defaults;
+	d->cryptor = cryptor;
 }
 
 void RemoteConnector::finalize() {}
 
+Encryptor *RemoteConnector::cryptor() const
+{
+	return d->cryptor;
+}
+
 void RemoteConnector::resetUserId(QFutureInterface<QVariant> futureInterface, const QVariant &extraData, bool resetLocalStore)
 {
 	if(resetLocalStore)//resync is always done, only clear explicitly needed
@@ -61,5 +68,6 @@ QByteArray RemoteConnector::getDeviceId() const
 
 
 RemoteConnectorPrivate::RemoteConnectorPrivate() :
-	defaults(nullptr)
+	defaults(nullptr),
+	cryptor(nullptr)
 {}

src/datasync/remoteconnector.h

@@ -40,6 +40,9 @@ class Q_DATASYNC_EXPORT RemoteConnector : public QObject
 	//! Called from the engine to finalize the connector
 	virtual void finalize();
 
+	//! Returns the encryptor this connector uses (can be nullptr)
+	virtual Encryptor *cryptor() const;
+
 	//! Method to create an authenticator for this connector
 	virtual Authenticator *createAuthenticator(Defaults *defaults, QObject *parent) = 0;
 

src/datasync/wsauthenticator.cpp

@@ -3,6 +3,8 @@
 #include "wsauthenticator_p.h"
 #include "wsremoteconnector_p.h"
 
+#include <QtCore/QJsonDocument>
+
 using namespace QtDataSync;
 
 WsAuthenticator::WsAuthenticator(WsRemoteConnector *connector, Defaults *defaults, QObject *parent) :
@@ -18,6 +20,34 @@ WsAuthenticator::WsAuthenticator(WsRemoteConnector *connector, Defaults *default
 
 WsAuthenticator::~WsAuthenticator() {}
 
+void WsAuthenticator::exportUserData(QIODevice *device) const
+{
+	QJsonObject data;
+	data[QStringLiteral("key")] = QString::fromUtf8(d->connector->cryptor()->key().toBase64());
+	data[QStringLiteral("identity")] = QString::fromUtf8(userIdentity());
+
+	device->write(QJsonDocument(data).toJson(QJsonDocument::Indented));
+}
+
+GenericTask<void> WsAuthenticator::importUserData(QIODevice *device)
+{
+	QJsonParseError error;
+	auto data = QJsonDocument::fromJson(device->readAll(), &error);
+	if(error.error != QJsonParseError::NoError) {
+		QFutureInterface<QVariant> futureInterface;
+		futureInterface.reportStarted();
+		futureInterface.reportException(InvalidDataException(error.errorString()));
+		futureInterface.reportFinished();
+		return futureInterface;
+	}
+
+	auto obj = data.object();
+	auto key = QByteArray::fromBase64(obj[QStringLiteral("key")].toString().toUtf8());
+	QMetaObject::invokeMethod(d->connector->cryptor(), "setKey", Qt::QueuedConnection,
+							  Q_ARG(QByteArray, key));
+	return setUserIdentity(obj[QStringLiteral("identity")].toString().toUtf8());
+}
+
 bool WsAuthenticator::isRemoteEnabled() const
 {
 	return d->settings->value(WsRemoteConnector::keyRemoteEnabled, true).toBool();