palera1n/src/wx/ExploitPanel.cpp

#ifdef WITH_GUI

#include "ExploitPanel.hpp"

#include <wx/wx.h>

#include <thread>
#ifdef __cplusplus
#include <atomic>
using std::atomic_int;
using std::atomic_bool;
#else
#include <stdatomic.h>
#endif
#include <memory>

#include "AppFrame.hpp"
#include "../m8/run.h"
#include "../utils.h"

static const char* stage_to_string(int stage)
{
    switch (stage) {
        case STAGE_SETUP:       return "Checking if device is ready";
        case STAGE_SPRAY:       return "Setting up the exploit (this is the heap spray)";
        case STAGE_PATCH:       return "Right before trigger (this is the real bug setup)";
        case STAGE_YOLODFU:     return "Booting PongoOS...";
        case STAGE_PONGO:       return "Booting...";
        case STAGE_DONE:        return "Done.";
        default:                return "Idle.";
    }
}

static int stage_to_progress(int stage)
{
    switch (stage) {
        case STAGE_SETUP:       return 30;
        case STAGE_SPRAY:       return 40;
        case STAGE_PATCH:       return 50;
        case STAGE_YOLODFU:     return 60;
        case STAGE_PONGO:       return 70;
        case STAGE_DONE:        return 100;
        default:                return 0;
    }
}

ExploitPanel::ExploitPanel(MainFrame* frame, wxWindow* parent)
    : DevicePanel(frame, parent)
{
    auto* root = new wxBoxSizer(wxVERTICAL);

    auto* descriptionText = new wxStaticText(this, wxID_ANY,
        "Installing jailbreak, this will take a moment. If the device asks for a passcode\n"
        "please enter it. Do not disconnect the device until finished."
    );

    m_statusText = new wxStaticText(this, wxID_ANY, stage_to_string(STAGE_RESET));

    m_progressBar = new wxGauge(this, wxID_ANY, 100);
    m_progressBar->SetValue(0);

    m_backButton = new wxButton(this, wxID_ANY, "Back");
    m_backButton->Disable();
    m_backButton->Bind(wxEVT_BUTTON, [this, frame](wxCommandEvent&) {
        m_statusText->SetLabel(stage_to_string(STAGE_RESET));
        m_progressBar->SetValue(0);
        m_backButton->Disable();
        frame->ShowMain();
    });

    root->Add(descriptionText, 0, wxALL, 10);
    root->Add(m_statusText, 0, wxALL, 10);
    root->Add(m_progressBar, 0, wxALL | wxEXPAND, 20);

    root->AddStretchSpacer();
    auto* bottomRow = new wxBoxSizer(wxHORIZONTAL);
    bottomRow->AddStretchSpacer();
    bottomRow->Add(m_backButton, 0, wxRIGHT | wxBOTTOM, 12);

    root->Add(bottomRow, 0, wxEXPAND);

    SetSizer(root);
}

void ExploitPanel::SetDeviceState(const DeviceState& state)
{
    DevicePanel::SetDeviceState(state);

    if (!IsShown())
        return;
}

void ExploitPanel::StartExploit()
{
    m_backButton->Disable();

    std::thread([this]()
    {
        const auto deviceState = GetDeviceState();
        if (!deviceState.connected || deviceState.mode != DeviceMode::DFU) {
            wxTheApp->CallAfter([this]() { m_backButton->Enable(); });
            return;
        }

        auto state = std::make_shared<shared_t>();
        atomic_init(&state->stage, STAGE_RESET);
        atomic_init(&state->stop, false);
        atomic_init(&state->result, 0);

        auto isFinished = std::make_shared<std::atomic<bool>>(false);

        std::thread worker([state, isFinished]()
        {
            exploit(state.get());
            isFinished->store(true);
        });

        for (;;)
        {
            int stage = atomic_load(&state->stage);
            int progress = stage_to_progress(stage);
            bool finished = isFinished->load();

            wxTheApp->CallAfter([this, stage, progress, finished]()
            {
                m_statusText->SetLabel(stage_to_string(stage));
                m_progressBar->SetValue(progress);

                if (finished || stage == STAGE_DONE) {
                    m_backButton->Enable();
                }
            });

            if (stage == STAGE_DONE || finished) {
                atomic_store(&state->stop, true);
                break;
            }

            std::this_thread::sleep_for(std::chrono::milliseconds(100));
        }

        if (worker.joinable())
            worker.join();
    }).detach();
}

#endif // WITH_GUI