Source Undetected Valorant Cheat 2025: Free Aimbot, Triggerbot & Magnet Hack with Microsoft-Signed Driver

[exi]

Hi everyone! I previously posted the "Valo Color Bot Source" source code of a cheat for Valorant, which in general works great even now, but with some improvements. I remind you that the cheat has a great and convenient menu, there is an aimbot, trigger, magnet, in general, everything you need. You can find the original thread here.

What is the difference from the original cheat?​

The only thing that stopped from just injecting and going to play was the absence of a driver that would be undetected by Vanguard. And today I want to share it with you.

• This driver is signed with a certificate from Microsoft.
• It is unknown how long it will last, but it was uploaded on January 28 (author - s4ncak1), the kernel driver itself was signed on October 10.
• Now you can combine these two sources and get a solid undetected Valorant hack with all the functions necessary for legit and rage gameplay.

Considering how much other cheats for Valik cost now, this one is quite a good alternative to private ones.

The main thing is to do everything correctly and not forget to add or remove anything. You can find guides on YouTube to help with this, I’m not very good at it and won’t be able to help.

I know one thing, that the software at the time of publishing this article is definitely not detected, supports Windows 10 and 11, as well as HVIC, secure boot and TPM.

Spoiler: Driver.Cpp

#include "Driver.hpp"
#include <fstream>
#include <filesystem>
#include <TlHelp32.h>

std::string RandomString(const int len)
{
    static const char alphanum[] =
        "0123456789"
        "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
        "abcdefghijklmnopqrstuvwxyz";
    std::string tmp_s;
    tmp_s.reserve(len);

    for (int i = 0; i < len; ++i)
    {
        tmp_s += alphanum[rand() % (sizeof(alphanum) - 1)];
    }

    return tmp_s;
}

DWORD GetProcessPidByName(const wchar_t* ProcessName)
{
    HANDLE hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);  // Take Snapshot of All Process Running on the System
    if (!hSnapshot || hSnapshot == INVALID_HANDLE_VALUE || hSnapshot == ((HANDLE)(LONG_PTR)ERROR_BAD_LENGTH)) // Check Snapshot Is Invalid
    {
        return 0;
    }

    DWORD Pid;
    PROCESSENTRY32 ProcessEntry;
    ProcessEntry.dwSize = sizeof(ProcessEntry);
    if (Process32First(hSnapshot, &ProcessEntry)) // Copy First Process of Snapshot and Paste at PROCESSENTRY32 Struct
    {
        while (_wcsicmp(ProcessEntry.szExeFile, ProcessName)) // While Process Names not Same
        {
            if (!Process32Next(hSnapshot, &ProcessEntry)) // Copy The Next Process of the Snapshot and Paste at PROCESSENTRY32 Struct And Check if The Function Worked
            {
                CloseHandle(hSnapshot);
                return 0;
            }
        }

        Pid = ProcessEntry.th32ProcessID; // Found
    }
    else
    {
        CloseHandle(hSnapshot);
        return 0;
    }

    CloseHandle(hSnapshot);
    return Pid;
}

namespace Driver
{
    void Comms::CreateDeviceDrv()
    {
      
        hDriver = CreateFileA(("\\\\.\\cla300"), GENERIC_READ | GENERIC_WRITE,
            FILE_SHARE_READ | FILE_SHARE_WRITE, nullptr, OPEN_EXISTING,
            NULL, NULL);
    }

    void Comms::TryInitDriver()
    {
        CreateDeviceDrv();
        if (!IsConnected())
        {
            UDMapper();
            CreateDeviceDrv();
        }
    }

    void Comms::UDMapper()
    {

    }

    void Comms::Disconnect()
    {
        if (hDriver != INVALID_HANDLE_VALUE)
            CloseHandle(hDriver);
    }

    bool Comms::MouseEvent(double x, double y, MouseFlags ButtonFlags)
    {
        if (!hDriver || hDriver == INVALID_HANDLE_VALUE)
            return false;

        NF_MOUSE_REQUEST MouseRequest;
        MouseRequest.x = (int)x;
        MouseRequest.y = (int)y;
        MouseRequest.ButtonFlags = (int)ButtonFlags;

        return DeviceIoControl(hDriver, IO_SEND_MOUSE_EVENT, &MouseRequest, sizeof(NF_MOUSE_REQUEST), nullptr, NULL, nullptr, nullptr);
    }
}

Spoiler: Driver.hpp

#pragma once

#include <Windows.h>

namespace Driver
{
    enum MouseFlags
    {
        None = 0,
        LeftButtonDown = 1,
        LeftButtonUp = 2,
        RightButtonDown = 4,
        RightButtonUp = 8,
        MiddleButtonDown = 16,
        MiddleButtonUp = 32,
        XButton1Down = 64,
        XButton1Up = 128,
        XButton2Down = 256,
        XButton2Up = 512,
        MouseWheel = 1024,
        MouseHorizontalWheel = 2048
    };


    class Comms
    {
        struct NF_MOUSE_REQUEST
        {
            int x;
            int y;
            short ButtonFlags;
        };

        struct INFO_T
        {
            int Pid;
            uintptr_t Address;
            uintptr_t Value;
            int Size;
            uintptr_t Data;
        };

    public:
        Comms() { }
        ~Comms() { }

        void CreateDeviceDrv();
        void Disconnect();

        void TryInitDriver();
        void UDMapper();

        bool MouseEvent(double x, double y, MouseFlags ButtonFlags);

        bool IsConnected()
        {
            if (!hDriver || hDriver == INVALID_HANDLE_VALUE)
                return false;

            return true;
        }

    private:
    
        DWORD IO_SEND_MOUSE_EVENT = 0x23FACC00;

    private:
        HANDLE hDriver;
        bool bIsConnected;
    };
}