- no dockerhub

- trafic masking

client/protocols/openvpnovercloakprotocol.cpp

@@ -0,0 +1,105 @@
+#include "openvpnovercloakprotocol.h"
+#include "core/servercontroller.h"
+
+#include "utils.h"
+#include "protocols/protocols_defs.h"
+
+#include <QCryptographicHash>
+#include <QDebug>
+#include <QJsonDocument>
+#include <QJsonObject>
+
+OpenVpnOverCloakProtocol::OpenVpnOverCloakProtocol(const QJsonObject &configuration, QObject *parent):
+    OpenVpnProtocol(configuration, parent)
+{
+    readCloakConfiguration(configuration);
+}
+
+OpenVpnOverCloakProtocol::~OpenVpnOverCloakProtocol()
+{
+    qDebug() << "OpenVpnOverCloakProtocol::~OpenVpnOverCloakProtocol";
+    OpenVpnOverCloakProtocol::stop();
+    QThread::msleep(200);
+    m_ckProcess.close();
+}
+
+ErrorCode OpenVpnOverCloakProtocol::start()
+{
+    if (Utils::processIsRunning(Utils::executable("ck-client", false))) {
+        Utils::killProcessByName(Utils::executable("ck-client", false));
+    }
+
+#ifdef QT_DEBUG
+    m_cloakCfgFile.setAutoRemove(false);
+#endif
+    m_cloakCfgFile.open();
+    m_cloakCfgFile.write(QJsonDocument(m_cloakConfig).toJson());
+    m_cloakCfgFile.close();
+
+    QStringList args = QStringList() << "-c" << m_cloakCfgFile.fileName()
+                                     << "-s" << m_cloakConfig.value("Remote").toString()
+                                     << "-p" << amnezia::protocols::cloak::ckDefaultPort()
+                                     << "-l" << amnezia::protocols::openvpn::openvpnDefaultPort();
+
+    qDebug().noquote() << "OpenVpnOverCloakProtocol::start()"
+                       << cloakExecPath() << args.join(" ");
+
+    m_ckProcess.setProcessChannelMode(QProcess::MergedChannels);
+
+    m_ckProcess.setProgram(cloakExecPath());
+    m_ckProcess.setArguments(args);
+
+    connect(&m_ckProcess, &QProcess::readyReadStandardOutput, this, [this](){
+        qDebug().noquote() << "ck-client:" << m_ckProcess.readAllStandardOutput();
+    });
+
+    connect(&m_ckProcess, QOverload<int, QProcess::ExitStatus>::of(&QProcess::finished), this, [this](int exitCode, QProcess::ExitStatus exitStatus){
+        qDebug().noquote() << "OpenVpnOverCloakProtocol finished, exitCode, exiStatus" << exitCode << exitStatus;
+        setConnectionState(VpnProtocol::ConnectionState::Disconnected);
+        if (exitStatus != QProcess::NormalExit){
+            emit protocolError(amnezia::ErrorCode::CloakExecutableCrashed);
+            stop();
+        }
+        if (exitCode !=0 ){
+            emit protocolError(amnezia::ErrorCode::InternalError);
+            stop();
+        }
+    });
+
+    m_ckProcess.start();
+    m_ckProcess.waitForStarted();
+
+    if (m_ckProcess.state() == QProcess::ProcessState::Running) {
+        setConnectionState(ConnectionState::Connecting);
+
+        return OpenVpnProtocol::start();
+    }
+    else return ErrorCode::CloakExecutableMissing;
+}
+
+void OpenVpnOverCloakProtocol::stop()
+{
+    OpenVpnProtocol::stop();
+
+    qDebug() << "OpenVpnOverCloakProtocol::stop()";
+
+#ifdef Q_OS_WIN
+    Utils::signalCtrl(m_ckProcess.processId(), CTRL_C_EVENT);
+#endif
+
+    m_ckProcess.terminate();
+}
+
+QString OpenVpnOverCloakProtocol::cloakExecPath()
+{
+#ifdef Q_OS_WIN
+    return Utils::executable(QString("cloak/ck-client"), true);
+#else
+    return Utils::executable(QString("/ck-client"), true);
+#endif
+}
+
+void OpenVpnOverCloakProtocol::readCloakConfiguration(const QJsonObject &configuration)
+{
+    m_cloakConfig = configuration.value(config::key_cloak_config_data()).toObject();
+}

client/protocols/openvpnovercloakprotocol.h

@@ -0,0 +1,30 @@
+#ifndef OPENVPNOVERCLOAKPROTOCOL_H
+#define OPENVPNOVERCLOAKPROTOCOL_H
+
+#include "openvpnprotocol.h"
+#include "QProcess"
+
+class OpenVpnOverCloakProtocol : public OpenVpnProtocol
+{
+public:
+    OpenVpnOverCloakProtocol(const QJsonObject& configuration, QObject* parent = nullptr);
+    virtual ~OpenVpnOverCloakProtocol() override;
+
+    ErrorCode start() override;
+    void stop() override;
+
+protected:
+    void readCloakConfiguration(const QJsonObject &configuration);
+
+protected:
+    QJsonObject m_cloakConfig;
+
+private:
+    static QString cloakExecPath();
+
+private:
+    QProcess m_ckProcess;
+    QTemporaryFile m_cloakCfgFile;
+};
+
+#endif // OPENVPNOVERCLOAKPROTOCOL_H

client/protocols/protocols_defs.h

@@ -0,0 +1,36 @@
+#ifndef PROTOCOLS_DEFS_H
+#define PROTOCOLS_DEFS_H
+
+#include <QObject>
+
+namespace amnezia {
+namespace protocols {
+namespace openvpn {
+static QString caCertPath() { return "/opt/amnezia/openvpn/pki/ca.crt"; }
+static QString clientCertPath() { return "/opt/amnezia/openvpn/pki/issued"; }
+static QString taKeyPath() { return "/opt/amnezia/openvpn/ta.key"; }
+static QString clientsDirPath() { return "/opt/amnezia/openvpn/clients"; }
+static QString openvpnDefaultPort() { return "1194"; }
+
+}
+
+namespace shadowsocks {
+static int ssRemotePort() { return 6789; }
+static int ssContainerPort() { return 8585; }
+static QString ssEncryption() { return "chacha20-ietf-poly1305"; }
+}
+
+namespace cloak {
+static QString ckPublicKeyPath() { return "/opt/amnezia/cloak/cloak_public.key"; }
+static QString ckBypassUidKeyPath() { return "/opt/amnezia/cloak/cloak_bypass_uid.key"; }
+static QString ckAdminKeyPath() { return "/opt/amnezia/cloak/cloak_admin_uid.key"; }
+static QString ckDefaultPort() { return "443"; }
+static QString ckDefaultRedirSite() { return "mail.ru"; }
+}
+
+
+
+} // namespace protocols
+} // namespace amnezia
+
+#endif // PROTOCOLS_DEFS_H

client/protocols/shadowsocksvpnprotocol.cpp

@@ -3,6 +3,7 @@
 
 #include "debug.h"
 #include "utils.h"
+#include "protocols/protocols_defs.h"
 
 #include <QCryptographicHash>
 #include <QJsonDocument>
@@ -99,11 +100,11 @@ QJsonObject ShadowSocksVpnProtocol::genShadowSocksConfig(const ServerCredentials
 {
     QJsonObject ssConfig;
     ssConfig.insert("server", credentials.hostName);
-    ssConfig.insert("server_port", ServerController::ssRemotePort());
-    ssConfig.insert("local_port", ServerController::ssContainerPort());
+    ssConfig.insert("server_port", amnezia::protocols::shadowsocks::ssRemotePort());
+    ssConfig.insert("local_port", amnezia::protocols::shadowsocks::ssContainerPort());
     ssConfig.insert("password", QString(QCryptographicHash::hash(credentials.password.toUtf8(), QCryptographicHash::Sha256).toHex()));
     ssConfig.insert("timeout", 60);
-    ssConfig.insert("method", ServerController::ssEncryption());
+    ssConfig.insert("method", amnezia::protocols::shadowsocks::ssEncryption());
     return ssConfig;
 }