├── README.md ├── Rubery-Kernel.sln ├── Rubery-Kernel ├── Rubery-Kernel.inf ├── Rubery-Kernel.vcxproj ├── Rubery-Kernel.vcxproj.filters ├── Rubery-Kernel.vcxproj.user ├── definitions.h ├── hook.cpp ├── hook.h ├── main.cpp ├── memory.cpp └── memory.h └── Rubery-Usermode ├── Rubery-Usermode.vcxproj ├── Rubery-Usermode.vcxproj.filters ├── Rubery-Usermode.vcxproj.user └── main.cpp /README.md: -------------------------------------------------------------------------------- 1 | # RuberyKernel 2 | Kernel Call Of Duty Cold War zombies trainer 3 | 4 | https://prnt.sc/106z86m 5 | 6 | Credits to Jaykoza for the offsets 7 | -------------------------------------------------------------------------------- /Rubery-Kernel.sln: -------------------------------------------------------------------------------- 1 |  2 | Microsoft Visual Studio Solution File, Format Version 12.00 3 | # Visual Studio Version 16 4 | VisualStudioVersion = 16.0.30907.101 5 | MinimumVisualStudioVersion = 10.0.40219.1 6 | Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "Rubery-Kernel", "Rubery-Kernel\Rubery-Kernel.vcxproj", "{44754120-68B0-41BC-B445-C91327F75F84}" 7 | EndProject 8 | Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "Rubery-Usermode", "Rubery-Usermode\Rubery-Usermode.vcxproj", "{BB9DFCB3-C8A8-4316-9669-1F7DE88231F7}" 9 | EndProject 10 | Global 11 | GlobalSection(SolutionConfigurationPlatforms) = preSolution 12 | Debug|Any CPU = Debug|Any CPU 13 | Debug|ARM = Debug|ARM 14 | Debug|ARM64 = Debug|ARM64 15 | Debug|x64 = Debug|x64 16 | Debug|x86 = Debug|x86 17 | Release|Any CPU = Release|Any CPU 18 | Release|ARM = Release|ARM 19 | Release|ARM64 = Release|ARM64 20 | Release|x64 = Release|x64 21 | Release|x86 = Release|x86 22 | EndGlobalSection 23 | GlobalSection(ProjectConfigurationPlatforms) = postSolution 24 | {44754120-68B0-41BC-B445-C91327F75F84}.Debug|Any CPU.ActiveCfg = Debug|Win32 25 | {44754120-68B0-41BC-B445-C91327F75F84}.Debug|ARM.ActiveCfg = Debug|ARM 26 | {44754120-68B0-41BC-B445-C91327F75F84}.Debug|ARM.Build.0 = Debug|ARM 27 | {44754120-68B0-41BC-B445-C91327F75F84}.Debug|ARM.Deploy.0 = Debug|ARM 28 | {44754120-68B0-41BC-B445-C91327F75F84}.Debug|ARM64.ActiveCfg = Debug|ARM64 29 | {44754120-68B0-41BC-B445-C91327F75F84}.Debug|ARM64.Build.0 = Debug|ARM64 30 | {44754120-68B0-41BC-B445-C91327F75F84}.Debug|ARM64.Deploy.0 = Debug|ARM64 31 | {44754120-68B0-41BC-B445-C91327F75F84}.Debug|x64.ActiveCfg = Debug|x64 32 | {44754120-68B0-41BC-B445-C91327F75F84}.Debug|x64.Build.0 = Debug|x64 33 | {44754120-68B0-41BC-B445-C91327F75F84}.Debug|x64.Deploy.0 = Debug|x64 34 | {44754120-68B0-41BC-B445-C91327F75F84}.Debug|x86.ActiveCfg = Debug|Win32 35 | {44754120-68B0-41BC-B445-C91327F75F84}.Debug|x86.Build.0 = Debug|Win32 36 | {44754120-68B0-41BC-B445-C91327F75F84}.Debug|x86.Deploy.0 = Debug|Win32 37 | {44754120-68B0-41BC-B445-C91327F75F84}.Release|Any CPU.ActiveCfg = Release|Win32 38 | {44754120-68B0-41BC-B445-C91327F75F84}.Release|ARM.ActiveCfg = Release|ARM 39 | {44754120-68B0-41BC-B445-C91327F75F84}.Release|ARM.Build.0 = Release|ARM 40 | {44754120-68B0-41BC-B445-C91327F75F84}.Release|ARM.Deploy.0 = Release|ARM 41 | {44754120-68B0-41BC-B445-C91327F75F84}.Release|ARM64.ActiveCfg = Release|ARM64 42 | {44754120-68B0-41BC-B445-C91327F75F84}.Release|ARM64.Build.0 = Release|ARM64 43 | {44754120-68B0-41BC-B445-C91327F75F84}.Release|ARM64.Deploy.0 = Release|ARM64 44 | {44754120-68B0-41BC-B445-C91327F75F84}.Release|x64.ActiveCfg = Release|x64 45 | {44754120-68B0-41BC-B445-C91327F75F84}.Release|x64.Build.0 = Release|x64 46 | {44754120-68B0-41BC-B445-C91327F75F84}.Release|x64.Deploy.0 = Release|x64 47 | {44754120-68B0-41BC-B445-C91327F75F84}.Release|x86.ActiveCfg = Release|Win32 48 | {44754120-68B0-41BC-B445-C91327F75F84}.Release|x86.Build.0 = Release|Win32 49 | {44754120-68B0-41BC-B445-C91327F75F84}.Release|x86.Deploy.0 = Release|Win32 50 | {BB9DFCB3-C8A8-4316-9669-1F7DE88231F7}.Debug|Any CPU.ActiveCfg = Debug|Win32 51 | {BB9DFCB3-C8A8-4316-9669-1F7DE88231F7}.Debug|ARM.ActiveCfg = Debug|Win32 52 | {BB9DFCB3-C8A8-4316-9669-1F7DE88231F7}.Debug|ARM64.ActiveCfg = Debug|Win32 53 | {BB9DFCB3-C8A8-4316-9669-1F7DE88231F7}.Debug|x64.ActiveCfg = Debug|x64 54 | {BB9DFCB3-C8A8-4316-9669-1F7DE88231F7}.Debug|x64.Build.0 = Debug|x64 55 | {BB9DFCB3-C8A8-4316-9669-1F7DE88231F7}.Debug|x86.ActiveCfg = Debug|Win32 56 | {BB9DFCB3-C8A8-4316-9669-1F7DE88231F7}.Debug|x86.Build.0 = Debug|Win32 57 | {BB9DFCB3-C8A8-4316-9669-1F7DE88231F7}.Release|Any CPU.ActiveCfg = Release|Win32 58 | {BB9DFCB3-C8A8-4316-9669-1F7DE88231F7}.Release|ARM.ActiveCfg = Release|Win32 59 | {BB9DFCB3-C8A8-4316-9669-1F7DE88231F7}.Release|ARM64.ActiveCfg = Release|Win32 60 | {BB9DFCB3-C8A8-4316-9669-1F7DE88231F7}.Release|x64.ActiveCfg = Release|x64 61 | {BB9DFCB3-C8A8-4316-9669-1F7DE88231F7}.Release|x64.Build.0 = Release|x64 62 | {BB9DFCB3-C8A8-4316-9669-1F7DE88231F7}.Release|x86.ActiveCfg = Release|Win32 63 | {BB9DFCB3-C8A8-4316-9669-1F7DE88231F7}.Release|x86.Build.0 = Release|Win32 64 | EndGlobalSection 65 | GlobalSection(SolutionProperties) = preSolution 66 | HideSolutionNode = FALSE 67 | EndGlobalSection 68 | GlobalSection(ExtensibilityGlobals) = postSolution 69 | SolutionGuid = {1E3D8DE5-9866-466C-BA0A-B694A2DEDB93} 70 | EndGlobalSection 71 | EndGlobal 72 | -------------------------------------------------------------------------------- /Rubery-Kernel/Rubery-Kernel.inf: -------------------------------------------------------------------------------- 1 | ; 2 | ; Rubery-Kernel.inf 3 | ; 4 | 5 | [Version] 6 | Signature="$WINDOWS NT$" 7 | Class=Sample ; TODO: edit Class 8 | ClassGuid={78A1C341-4539-11d3-B88D-00C04FAD5171} ; TODO: edit ClassGuid 9 | Provider=%ManufacturerName% 10 | CatalogFile=Rubery-Kernel.cat 11 | DriverVer= ; TODO: set DriverVer in stampinf property pages 12 | PnpLockDown=1 13 | 14 | [DestinationDirs] 15 | DefaultDestDir = 12 16 | Rubery-Kernel_Device_CoInstaller_CopyFiles = 11 17 | 18 | ; ================= Class section ===================== 19 | 20 | [ClassInstall32] 21 | Addreg=SampleClassReg 22 | 23 | [SampleClassReg] 24 | HKR,,,0,%ClassName% 25 | HKR,,Icon,,-5 26 | 27 | [SourceDisksNames] 28 | 1 = %DiskName%,,,"" 29 | 30 | [SourceDisksFiles] 31 | Rubery-Kernel.sys = 1,, 32 | WdfCoInstaller$KMDFCOINSTALLERVERSION$.dll=1 ; make sure the number matches with SourceDisksNames 33 | 34 | ;***************************************** 35 | ; Install Section 36 | ;***************************************** 37 | 38 | [Manufacturer] 39 | %ManufacturerName%=Standard,NT$ARCH$ 40 | 41 | [Standard.NT$ARCH$] 42 | %Rubery-Kernel.DeviceDesc%=Rubery-Kernel_Device, Root\Rubery-Kernel ; TODO: edit hw-id 43 | 44 | [Rubery-Kernel_Device.NT] 45 | CopyFiles=Drivers_Dir 46 | 47 | [Drivers_Dir] 48 | Rubery-Kernel.sys 49 | 50 | ;-------------- Service installation 51 | [Rubery-Kernel_Device.NT.Services] 52 | AddService = Rubery-Kernel,%SPSVCINST_ASSOCSERVICE%, Rubery-Kernel_Service_Inst 53 | 54 | ; -------------- Rubery-Kernel driver install sections 55 | [Rubery-Kernel_Service_Inst] 56 | DisplayName = %Rubery-Kernel.SVCDESC% 57 | ServiceType = 1 ; SERVICE_KERNEL_DRIVER 58 | StartType = 3 ; SERVICE_DEMAND_START 59 | ErrorControl = 1 ; SERVICE_ERROR_NORMAL 60 | ServiceBinary = %12%\Rubery-Kernel.sys 61 | 62 | ; 63 | ;--- Rubery-Kernel_Device Coinstaller installation ------ 64 | ; 65 | 66 | [Rubery-Kernel_Device.NT.CoInstallers] 67 | AddReg=Rubery-Kernel_Device_CoInstaller_AddReg 68 | CopyFiles=Rubery-Kernel_Device_CoInstaller_CopyFiles 69 | 70 | [Rubery-Kernel_Device_CoInstaller_AddReg] 71 | HKR,,CoInstallers32,0x00010000, "WdfCoInstaller$KMDFCOINSTALLERVERSION$.dll,WdfCoInstaller" 72 | 73 | [Rubery-Kernel_Device_CoInstaller_CopyFiles] 74 | WdfCoInstaller$KMDFCOINSTALLERVERSION$.dll 75 | 76 | [Rubery-Kernel_Device.NT.Wdf] 77 | KmdfService = Rubery-Kernel, Rubery-Kernel_wdfsect 78 | [Rubery-Kernel_wdfsect] 79 | KmdfLibraryVersion = $KMDFVERSION$ 80 | 81 | [Strings] 82 | SPSVCINST_ASSOCSERVICE= 0x00000002 83 | ManufacturerName="" ;TODO: Replace with your manufacturer name 84 | ClassName="Samples" ; TODO: edit ClassName 85 | DiskName = "Rubery-Kernel Installation Disk" 86 | Rubery-Kernel.DeviceDesc = "Rubery-Kernel Device" 87 | Rubery-Kernel.SVCDESC = "Rubery-Kernel Service" 88 | -------------------------------------------------------------------------------- /Rubery-Kernel/Rubery-Kernel.vcxproj: -------------------------------------------------------------------------------- 1 |  2 | 3 | 4 | 5 | Debug 6 | Win32 7 | 8 | 9 | Release 10 | Win32 11 | 12 | 13 | Debug 14 | x64 15 | 16 | 17 | Release 18 | x64 19 | 20 | 21 | Debug 22 | ARM 23 | 24 | 25 | Release 26 | ARM 27 | 28 | 29 | Debug 30 | ARM64 31 | 32 | 33 | Release 34 | ARM64 35 | 36 | 37 | 38 | {44754120-68B0-41BC-B445-C91327F75F84} 39 | {1bc93793-694f-48fe-9372-81e2b05556fd} 40 | v4.5 41 | 12.0 42 | Debug 43 | Win32 44 | Rubery_Kernel 45 | 46 | 47 | 48 | Windows10 49 | true 50 | WindowsKernelModeDriver10.0 51 | Driver 52 | KMDF 53 | Universal 54 | 55 | 56 | Windows10 57 | false 58 | WindowsKernelModeDriver10.0 59 | Driver 60 | KMDF 61 | Universal 62 | 63 | 64 | Windows10 65 | true 66 | WindowsKernelModeDriver10.0 67 | Driver 68 | KMDF 69 | Universal 70 | 71 | 72 | Windows10 73 | false 74 | WindowsKernelModeDriver10.0 75 | Driver 76 | KMDF 77 | Universal 78 | NotSet 79 | 80 | 81 | Windows10 82 | true 83 | WindowsKernelModeDriver10.0 84 | Driver 85 | KMDF 86 | Universal 87 | 88 | 89 | Windows10 90 | false 91 | WindowsKernelModeDriver10.0 92 | Driver 93 | KMDF 94 | Universal 95 | 96 | 97 | Windows10 98 | true 99 | WindowsKernelModeDriver10.0 100 | Driver 101 | KMDF 102 | Universal 103 | 104 | 105 | Windows10 106 | false 107 | WindowsKernelModeDriver10.0 108 | Driver 109 | KMDF 110 | Universal 111 | 112 | 113 | 114 | 115 | 116 | 117 | 118 | 119 | 120 | 121 | DbgengKernelDebugger 122 | 123 | 124 | DbgengKernelDebugger 125 | 126 | 127 | DbgengKernelDebugger 128 | 129 | 130 | DbgengKernelDebugger 131 | false 132 | 133 | 134 | DbgengKernelDebugger 135 | 136 | 137 | DbgengKernelDebugger 138 | 139 | 140 | DbgengKernelDebugger 141 | 142 | 143 | DbgengKernelDebugger 144 | 145 | 146 | 147 | DriverEntry 148 | C:\Users\x\Documents\Visual Studio 2019 149 | 150 | 151 | false 152 | 153 | 154 | 155 | 156 | 157 | 158 | 159 | 160 | 161 | 162 | 163 | 164 | 165 | 166 | 167 | 168 | 169 | 170 | 171 | 172 | 173 | -------------------------------------------------------------------------------- /Rubery-Kernel/Rubery-Kernel.vcxproj.filters: -------------------------------------------------------------------------------- 1 |  2 | 3 | 4 | 5 | {4FC737F1-C7A5-4376-A066-2A32D752A2FF} 6 | cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx 7 | 8 | 9 | {93995380-89BD-4b04-88EB-625FBE52EBFB} 10 | h;hpp;hxx;hm;inl;inc;xsd 11 | 12 | 13 | {67DA6AB6-F800-4c08-8B7A-83BB121AAD01} 14 | rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms 15 | 16 | 17 | {8E41214B-6785-4CFE-B992-037D68949A14} 18 | inf;inv;inx;mof;mc; 19 | 20 | 21 | 22 | 23 | Driver Files 24 | 25 | 26 | 27 | 28 | Header Files 29 | 30 | 31 | Header Files 32 | 33 | 34 | Header Files 35 | 36 | 37 | 38 | 39 | Source Files 40 | 41 | 42 | Source Files 43 | 44 | 45 | Source Files 46 | 47 | 48 | -------------------------------------------------------------------------------- /Rubery-Kernel/Rubery-Kernel.vcxproj.user: -------------------------------------------------------------------------------- 1 |  2 | 3 | 4 | Off 5 | WindowsLocalDebugger 6 | 7 | -------------------------------------------------------------------------------- /Rubery-Kernel/definitions.h: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #pragma comment(lib, "ntoskrnl.lib") 8 | 9 | typedef enum _SYSTEM_INFORMATION_CLASS 10 | { 11 | SystemBasicInformation, 12 | SystemProcessorInformation, 13 | SystemPerformanceInformation, 14 | SystemTimeOfDayInformation, 15 | SystemPathInformation, 16 | SystemProcessInformation, 17 | SystemCallCountInformation, 18 | SystemDeviceInformation, 19 | SystemProcessorPerformanceInformation, 20 | SystemFlagsInformation, 21 | SystemCallTimeInformation, 22 | SystemModuleInformation = 0x0B 23 | } SYSTEM_INFORMATION_CLASS, 24 | * PSYSTEM_INFORMATION_CLASS; 25 | 26 | 27 | typedef struct _RTL_PROCESS_MODULE_INFORMATION 28 | { 29 | HANDLE Section; 30 | PVOID MappedBase; 31 | PVOID ImageBase; 32 | ULONG ImageSize; 33 | ULONG Flags; 34 | USHORT LoadOrderIndex; 35 | USHORT InitOrderIndex; 36 | USHORT LoadCount; 37 | USHORT OffsetToFileName; 38 | UCHAR FullPathName[256]; 39 | 40 | } RTL_PROCESS_MODULE_INFORMATION, * PRTL_PROCESS_MODULE_INFORMATION; 41 | 42 | typedef struct _RTL_PROCESS_MODULES 43 | { 44 | ULONG NumberOfModules; 45 | RTL_PROCESS_MODULE_INFORMATION Modules[1]; 46 | } RTL_PROCESS_MODULES, * PRTL_PROCESS_MODULES; 47 | 48 | typedef struct _PEB_LDR_DATA 49 | { 50 | ULONG Length; 51 | BOOLEAN Initialized; 52 | PVOID SsHandle; 53 | LIST_ENTRY ModuleListLoadOrder; 54 | LIST_ENTRY ModuleListMemoryOrder; 55 | LIST_ENTRY ModuleListInitOrder; 56 | } PEB_LDR_DATA, * PPEB_LDR_DATA; 57 | 58 | typedef struct _LDR_DATA_TABLE_ENTRY 59 | { 60 | LIST_ENTRY InLoadOrderModuleList; 61 | LIST_ENTRY InMemoryOrderModuleList; 62 | LIST_ENTRY InInitializationOrderModuleList; 63 | PVOID DllBase; 64 | PVOID EntryPoint; 65 | ULONG SizeOfImage; 66 | UNICODE_STRING FullDllName; 67 | UNICODE_STRING BaseDllName; 68 | ULONG Flags; 69 | USHORT LoadCount; 70 | USHORT TlsIndex; 71 | LIST_ENTRY HashLinks; 72 | PVOID SectionPointer; 73 | ULONG CheckSum; 74 | ULONG TimeDateStamp; 75 | 76 | } LDR_DATA_TABLE_ENTRY, * PLDR_DATA_TABLE_ENTRY; 77 | 78 | typedef struct _RTL_USER_PROCESS_PARAMETERS 79 | { 80 | BYTE Reserved1[16]; 81 | PVOID Reserved2[10]; 82 | UNICODE_STRING ImagePathName; 83 | UNICODE_STRING CommandLine; 84 | }RTL_USER_PROCESS_PARAMETERS, * PRTL_USER_PROCESS_PARAMETERS; 85 | 86 | typedef void(__stdcall* PPS_POST_PROCESS_INIT_ROUTINE)(void); 87 | 88 | typedef struct _PEB 89 | { 90 | BYTE Reserved1[2]; 91 | BYTE BeingDebugged; 92 | BYTE Reserved2[1]; 93 | PVOID Reserved3[2]; 94 | PPEB_LDR_DATA Ldr; 95 | PRTL_USER_PROCESS_PARAMETERS ProcessParameters; 96 | PVOID Reserved4[3]; 97 | PVOID AtlThunkSListPtr; 98 | PVOID Reserved5; 99 | ULONG Reserved6; 100 | PVOID Reserved7; 101 | ULONG Reserved8; 102 | ULONG AtlThunkSListPtr32; 103 | PVOID Reserved9[45]; 104 | BYTE Reserved10[96]; 105 | PPS_POST_PROCESS_INIT_ROUTINE PostProcessInitRoutine; 106 | BYTE Reserved11[128]; 107 | PVOID Reserved12[1]; 108 | ULONG SessionId; 109 | } PEB, * PPEB; 110 | 111 | extern "C" __declare_lock_level(dllimport) 112 | NTSTATUS NTAPI ZwProtectVirtualMemory( 113 | HANDLE ProcessHandle, 114 | PVOID * BaseAddress, 115 | PULONG ProtectSize, 116 | ULONG NewProtect, 117 | PULONG OldProtect 118 | ); 119 | 120 | extern "C" NTKERNELAPI 121 | PVOID 122 | NTAPI 123 | RtlFindExportedRoutineByName( 124 | _In_ PVOID ImageBase, 125 | _In_ PCCH RoutineName 126 | ); 127 | 128 | extern "C" NTSTATUS ZwQuerySystemInformation(ULONG InfoClass, PVOID Buffer, ULONG Length, PULONG ReturnLength); 129 | 130 | extern "C" NTKERNELAPI 131 | PPEB 132 | PsGetProcessPeb( 133 | IN PEPROCESS Process 134 | ); 135 | 136 | extern "C" NTSTATUS NTAPI MmCopyVirtualMemory 137 | ( 138 | PEPROCESS SourceProcess, 139 | PVOID SourceAddress, 140 | PEPROCESS TargetProcess, 141 | PVOID TargetAddress, 142 | SIZE_T BufferSize, 143 | KPROCESSOR_MODE PreviousMode, 144 | PSIZE_T ReturnSize 145 | ); -------------------------------------------------------------------------------- /Rubery-Kernel/hook.cpp: -------------------------------------------------------------------------------- 1 | #include "hook.h" 2 | 3 | bool nullhook::call_kernel_function(void* kernel_function_address) 4 | { 5 | if (!kernel_function_address) 6 | { 7 | return false; 8 | } 9 | PVOID* function = reinterpret_cast(get_system_module_export("\\SystemRoot\\System32\\drivers\\dxgkrnl.sys", 10 | "NtQueryCompositionSurfaceStatistics")); 11 | 12 | if (!function) 13 | { 14 | return false; 15 | } 16 | 17 | BYTE orig[] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }; 18 | 19 | BYTE shell_code[] = { 0x48, 0xB8 }; 20 | BYTE shell_code_end[] = { 0xFF, 0xE0 }; 21 | 22 | RtlSecureZeroMemory(&orig, sizeof(orig)); 23 | memcpy((PVOID)((ULONG_PTR)orig), &shell_code, sizeof(shell_code)); 24 | uintptr_t hook_address = reinterpret_cast(kernel_function_address); 25 | memcpy((PVOID)((ULONG_PTR)orig + sizeof(shell_code)), &hook_address, sizeof(void*)); 26 | memcpy((PVOID)((ULONG_PTR)orig + sizeof(shell_code)+ sizeof(void*)), &shell_code_end, sizeof(shell_code_end)); 27 | 28 | write_to_read_only_memory(function, &orig, sizeof(orig)); 29 | 30 | return true; 31 | 32 | 33 | } 34 | 35 | NTSTATUS nullhook::hook_handler(PVOID called_param) 36 | { 37 | NULL_MEMORY* instructions = (NULL_MEMORY*)called_param; 38 | 39 | if (instructions->req_base != FALSE) 40 | { 41 | ANSI_STRING AS; 42 | UNICODE_STRING ModuleName; 43 | 44 | RtlInitAnsiString(&AS, instructions->module_name); 45 | RtlAnsiStringToUnicodeString(&ModuleName, &AS, TRUE); 46 | PEPROCESS process; 47 | PsLookupProcessByProcessId((HANDLE)instructions->pid, &process); 48 | ULONG64 base_address64 = NULL; 49 | base_address64 = get_module_base_x64(process,ModuleName); 50 | instructions->base_address = base_address64; 51 | RtlFreeUnicodeString(&ModuleName); 52 | } 53 | if(instructions->write != FALSE) 54 | { 55 | if (instructions->address < 0x7FFFFFFFFFFF && instructions->address > 0) 56 | { 57 | PVOID kernelBuff = ExAllocatePool(NonPagedPool, instructions->size); 58 | 59 | if (!kernelBuff) 60 | { 61 | return STATUS_UNSUCCESSFUL; 62 | } 63 | if (!memcpy(kernelBuff, instructions->buffer_address, instructions->size)) 64 | { 65 | return STATUS_UNSUCCESSFUL; 66 | } 67 | 68 | PEPROCESS process; 69 | PsLookupProcessByProcessId((HANDLE)instructions->pid, &process); 70 | write_kernel_memory((HANDLE)instructions->pid, instructions->address, kernelBuff, instructions->size); 71 | ExFreePool(kernelBuff); 72 | } 73 | } 74 | if (instructions->read != FALSE) 75 | { 76 | if (instructions->address < 0x7FFFFFFFFFFF && instructions->address > 0) 77 | { 78 | read_kernel_memory((HANDLE)instructions->pid, instructions->address, instructions->output, instructions->size); 79 | 80 | } 81 | } 82 | return STATUS_SUCCESS; 83 | } -------------------------------------------------------------------------------- /Rubery-Kernel/hook.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "memory.h" 3 | 4 | namespace nullhook 5 | { 6 | bool call_kernel_function(void* kernel_funciton_address); 7 | NTSTATUS hook_handler(PVOID called_param); 8 | } 9 | -------------------------------------------------------------------------------- /Rubery-Kernel/main.cpp: -------------------------------------------------------------------------------- 1 | #include "hook.h" 2 | 3 | extern "C" NTSTATUS DriverEntry(PDRIVER_OBJECT driver_object, PUNICODE_STRING reg_path) 4 | { 5 | UNREFERENCED_PARAMETER(driver_object); 6 | UNREFERENCED_PARAMETER(reg_path); 7 | 8 | nullhook::call_kernel_function(&nullhook::hook_handler); 9 | 10 | return STATUS_SUCCESS; 11 | } -------------------------------------------------------------------------------- /Rubery-Kernel/memory.cpp: -------------------------------------------------------------------------------- 1 | #include "memory.h" 2 | 3 | 4 | 5 | PVOID get_system_module_base(const char* module_name) 6 | { 7 | ULONG bytes = 0; 8 | NTSTATUS status = ZwQuerySystemInformation(SystemModuleInformation, NULL, bytes, &bytes); 9 | 10 | if (!bytes) 11 | return NULL; 12 | PRTL_PROCESS_MODULES modules = (PRTL_PROCESS_MODULES)ExAllocatePoolWithTag(NonPagedPool, bytes, 0x4e554c4c); 13 | 14 | status = ZwQuerySystemInformation(SystemModuleInformation, modules, bytes, &bytes); 15 | 16 | if (!NT_SUCCESS(status)) 17 | return NULL; 18 | 19 | PRTL_PROCESS_MODULE_INFORMATION module = modules->Modules; 20 | PVOID module_base = 0, module_size = 0; 21 | 22 | for (ULONG i = 0; i < modules->NumberOfModules; i++) 23 | { 24 | if (strcmp((char*)module[i].FullPathName, module_name) == NULL) 25 | { 26 | module_base = module[i].ImageBase; 27 | module_size = (PVOID)module[i].ImageSize; 28 | break; 29 | 30 | } 31 | } 32 | 33 | if (modules) 34 | ExFreePoolWithTag(modules, NULL); 35 | 36 | if (module_base <= NULL) 37 | return NULL; 38 | 39 | return module_base; 40 | } 41 | 42 | PVOID get_system_module_export(const char* module_name, LPCSTR routine_name) 43 | { 44 | 45 | PVOID lpModule = get_system_module_base(module_name); 46 | 47 | if (!lpModule) { 48 | return NULL; 49 | } 50 | return RtlFindExportedRoutineByName(lpModule, routine_name); 51 | } 52 | 53 | bool write_memory(void* address, void* buffer, size_t size) 54 | { 55 | if (!RtlCopyMemory(address, buffer, size)) { 56 | return false; 57 | } 58 | else { 59 | return true; 60 | } 61 | } 62 | 63 | bool write_to_read_only_memory(void* address, void* buffer, size_t size) 64 | { 65 | PMDL Mdl = IoAllocateMdl(address, size, FALSE, FALSE, NULL); 66 | if (!Mdl) 67 | { 68 | return false; 69 | } 70 | MmProbeAndLockPages(Mdl, KernelMode, IoReadAccess); 71 | PVOID Mapping = MmMapLockedPagesSpecifyCache(Mdl, KernelMode, MmNonCached, NULL, FALSE, NormalPagePriority); 72 | MmProtectMdlSystemAddress(Mdl, PAGE_READWRITE); 73 | 74 | write_memory(Mapping, buffer, size); 75 | 76 | MmUnmapLockedPages(Mapping, Mdl); 77 | MmUnlockPages(Mdl); 78 | IoFreeMdl(Mdl); 79 | 80 | return true; 81 | 82 | } 83 | 84 | ULONG64 get_module_base_x64(PEPROCESS proc, UNICODE_STRING module_name) 85 | { 86 | PPEB pPeb = PsGetProcessPeb(proc); 87 | 88 | if (!pPeb) 89 | { 90 | return NULL; 91 | } 92 | 93 | KAPC_STATE state; 94 | 95 | KeStackAttachProcess(proc, &state); 96 | 97 | PPEB_LDR_DATA pLdr = (PPEB_LDR_DATA)pPeb->Ldr; 98 | 99 | if (!pLdr) 100 | { 101 | KeUnstackDetachProcess(&state); 102 | return NULL; 103 | } 104 | 105 | for (PLIST_ENTRY list = (PLIST_ENTRY)pLdr->ModuleListLoadOrder.Flink; list != &pLdr->ModuleListLoadOrder; list = (PLIST_ENTRY)list->Flink) 106 | { 107 | PLDR_DATA_TABLE_ENTRY pEntry = CONTAINING_RECORD(list, LDR_DATA_TABLE_ENTRY, InLoadOrderModuleList); 108 | 109 | if (RtlCompareUnicodeString(&pEntry->BaseDllName, &module_name, TRUE) == NULL) 110 | { 111 | ULONG64 baseAddr = (ULONG64)pEntry->DllBase; 112 | KeUnstackDetachProcess(&state); 113 | return baseAddr; 114 | } 115 | } 116 | KeUnstackDetachProcess(&state); 117 | return NULL; 118 | } 119 | 120 | bool read_kernel_memory(HANDLE pid, uintptr_t address, void* buffer, SIZE_T size) 121 | { 122 | if (!address || !buffer || !size) 123 | return false; 124 | 125 | SIZE_T bytes = 0; 126 | NTSTATUS status = STATUS_SUCCESS; 127 | PEPROCESS process; 128 | PsLookupProcessByProcessId((HANDLE)pid, &process); 129 | 130 | status = MmCopyVirtualMemory(process, (void*)address, (PEPROCESS)PsGetCurrentProcess(), (void*)buffer, size, KernelMode, &bytes); 131 | 132 | if (!NT_SUCCESS(status)) 133 | { 134 | return false; 135 | } 136 | else 137 | { 138 | return true; 139 | } 140 | } 141 | 142 | bool write_kernel_memory(HANDLE pid, uintptr_t address, void* buffer, SIZE_T size) 143 | { 144 | if (!address || !buffer || !size) 145 | return false; 146 | 147 | NTSTATUS status = STATUS_SUCCESS; 148 | PEPROCESS process; 149 | PsLookupProcessByProcessId((HANDLE)pid, &process); 150 | 151 | KAPC_STATE state; 152 | KeStackAttachProcess((PEPROCESS)process, &state); 153 | MEMORY_BASIC_INFORMATION info; 154 | 155 | status = ZwQueryVirtualMemory(ZwCurrentProcess(), (PVOID)address, MemoryBasicInformation, &info, sizeof(info), NULL); 156 | 157 | if (!NT_SUCCESS(status)) 158 | { 159 | KeUnstackDetachProcess(&state); 160 | return false; 161 | } 162 | 163 | if (((uintptr_t)info.BaseAddress + info.RegionSize) < (address + size)) 164 | { 165 | KeUnstackDetachProcess(&state); 166 | return false; 167 | } 168 | 169 | if (!(info.State & MEM_COMMIT) || (info.Protect & (PAGE_GUARD | PAGE_NOACCESS))) 170 | { 171 | KeUnstackDetachProcess(&state); 172 | return false; 173 | } 174 | 175 | if ((info.Protect & PAGE_EXECUTE_READWRITE) || (info.Protect & PAGE_EXECUTE_WRITECOPY) 176 | || (info.Protect & PAGE_READWRITE) || (info.Protect & PAGE_WRITECOPY)) 177 | { 178 | RtlCopyMemory((void*)address, buffer, size); 179 | 180 | } 181 | KeUnstackDetachProcess(&state); 182 | return true; 183 | } 184 | -------------------------------------------------------------------------------- /Rubery-Kernel/memory.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "definitions.h" 3 | 4 | PVOID get_system_module_base(const char* module_name); 5 | PVOID get_system_module_export(const char* module_name, LPCSTR routine_name); 6 | bool write_memory(void* address, void* buffer, size_t size); 7 | bool write_to_read_only_memory(void* address, void* buffer, size_t size); 8 | ULONG64 get_module_base_x64(PEPROCESS proc, UNICODE_STRING module_name); 9 | bool read_kernel_memory(HANDLE pid, uintptr_t address, void* buffer, SIZE_T size); 10 | bool write_kernel_memory(HANDLE pid, uintptr_t address, void* buffer, SIZE_T size); 11 | 12 | typedef struct _NULL_MEMORY 13 | { 14 | void* buffer_address; 15 | UINT_PTR address; 16 | ULONGLONG size; 17 | ULONG pid; 18 | BOOLEAN write; 19 | BOOLEAN read; 20 | BOOLEAN req_base; 21 | void* output; 22 | const char* module_name; 23 | ULONG64 base_address; 24 | }NULL_MEMORY; -------------------------------------------------------------------------------- /Rubery-Usermode/Rubery-Usermode.vcxproj: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | Debug 6 | Win32 7 | 8 | 9 | Release 10 | Win32 11 | 12 | 13 | Debug 14 | x64 15 | 16 | 17 | Release 18 | x64 19 | 20 | 21 | 22 | 16.0 23 | Win32Proj 24 | {bb9dfcb3-c8a8-4316-9669-1f7de88231f7} 25 | RuberyUsermode 26 | 10.0 27 | 28 | 29 | 30 | Application 31 | true 32 | v142 33 | Unicode 34 | 35 | 36 | Application 37 | false 38 | v142 39 | true 40 | Unicode 41 | 42 | 43 | Application 44 | true 45 | v142 46 | Unicode 47 | 48 | 49 | Application 50 | false 51 | v142 52 | true 53 | NotSet 54 | 55 | 56 | 57 | 58 | 59 | 60 | 61 | 62 | 63 | 64 | 65 | 66 | 67 | 68 | 69 | 70 | 71 | 72 | 73 | 74 | true 75 | 76 | 77 | false 78 | 79 | 80 | true 81 | 82 | 83 | false 84 | 85 | 86 | 87 | Level3 88 | true 89 | WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions) 90 | true 91 | 92 | 93 | Console 94 | true 95 | 96 | 97 | 98 | 99 | Level3 100 | true 101 | true 102 | true 103 | WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions) 104 | true 105 | 106 | 107 | Console 108 | true 109 | true 110 | true 111 | 112 | 113 | 114 | 115 | Level3 116 | true 117 | _DEBUG;_CONSOLE;%(PreprocessorDefinitions) 118 | true 119 | 120 | 121 | Console 122 | true 123 | 124 | 125 | 126 | 127 | Level3 128 | true 129 | true 130 | true 131 | NDEBUG;_CONSOLE;%(PreprocessorDefinitions) 132 | true 133 | stdcpp17 134 | 135 | 136 | Console 137 | true 138 | true 139 | true 140 | 141 | 142 | 143 | 144 | 145 | 146 | 147 | 148 | -------------------------------------------------------------------------------- /Rubery-Usermode/Rubery-Usermode.vcxproj.filters: -------------------------------------------------------------------------------- 1 |  2 | 3 | 4 | 5 | {4FC737F1-C7A5-4376-A066-2A32D752A2FF} 6 | cpp;c;cc;cxx;c++;cppm;ixx;def;odl;idl;hpj;bat;asm;asmx 7 | 8 | 9 | {93995380-89BD-4b04-88EB-625FBE52EBFB} 10 | h;hh;hpp;hxx;h++;hm;inl;inc;ipp;xsd 11 | 12 | 13 | {67DA6AB6-F800-4c08-8B7A-83BB121AAD01} 14 | rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms 15 | 16 | 17 | 18 | 19 | Source Files 20 | 21 | 22 | -------------------------------------------------------------------------------- /Rubery-Usermode/Rubery-Usermode.vcxproj.user: -------------------------------------------------------------------------------- 1 |  2 | 3 | 4 | -------------------------------------------------------------------------------- /Rubery-Usermode/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | 11 | 12 | typedef struct _NULL_MEMORY 13 | { 14 | void* buffer_address; 15 | UINT_PTR address; 16 | ULONGLONG size; 17 | ULONG pid; 18 | BOOLEAN write; 19 | BOOLEAN read; 20 | BOOLEAN req_base; 21 | void* output; 22 | const char* module_name; 23 | ULONG64 base_address; 24 | }NULL_MEMORY; 25 | 26 | uintptr_t base_address = 0; 27 | std::uint32_t process_id = 0; 28 | bool god = false; 29 | bool xp = false; 30 | bool ammo = false; 31 | bool gun = false; 32 | bool hp = false; 33 | bool tp = false; 34 | 35 | template 36 | uint64_t call_hook(const Arg ... args) 37 | { 38 | void* hooked_func = GetProcAddress(LoadLibrary("win32u.dll"), "NtQueryCompositionSurfaceStatistics"); 39 | 40 | auto func = static_cast(hooked_func); 41 | 42 | return func(args ...); 43 | } 44 | 45 | struct HandleDisposer 46 | { 47 | using pointer = HANDLE; 48 | void operator()(HANDLE handle) const 49 | { 50 | if (handle != NULL || handle != INVALID_HANDLE_VALUE) 51 | { 52 | CloseHandle(handle); 53 | } 54 | } 55 | }; 56 | 57 | using unique_handle = std::unique_ptr; 58 | 59 | std::uint32_t get_process_id(std::string_view process_name) 60 | { 61 | PROCESSENTRY32 processentry; 62 | const unique_handle snapshot_handle(CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, NULL)); 63 | 64 | if (snapshot_handle.get() == INVALID_HANDLE_VALUE) 65 | return NULL; 66 | 67 | processentry.dwSize = sizeof(MODULEENTRY32); 68 | 69 | while (Process32Next(snapshot_handle.get(), &processentry) == TRUE) 70 | { 71 | if (process_name.compare(processentry.szExeFile) == NULL) 72 | { 73 | return processentry.th32ProcessID; 74 | } 75 | } 76 | return NULL; 77 | } 78 | 79 | ULONG64 get_client_base(const char* module_name) 80 | { 81 | 82 | NULL_MEMORY instructions = { 0 }; 83 | instructions.pid = process_id; 84 | instructions.req_base = TRUE; 85 | instructions.read = FALSE; 86 | instructions.write = FALSE; 87 | instructions.module_name = module_name; 88 | call_hook(&instructions); 89 | 90 | ULONG64 base = NULL; 91 | base = instructions.base_address; 92 | return base; 93 | } 94 | 95 | template 96 | T Read(UINT_PTR read_address) 97 | { 98 | T response{}; 99 | NULL_MEMORY instructions; 100 | instructions.pid = process_id; 101 | instructions.size = sizeof(T); 102 | instructions.address = read_address; 103 | instructions.read = TRUE; 104 | instructions.write = FALSE; 105 | instructions.req_base = FALSE; 106 | instructions.output = &response; 107 | call_hook(&instructions); 108 | 109 | return response; 110 | } 111 | 112 | bool write_memory(UINT_PTR write_address, UINT_PTR source_address, SIZE_T write_size) 113 | { 114 | NULL_MEMORY instructions; 115 | instructions.address = write_address; 116 | instructions.pid = process_id; 117 | instructions.write = TRUE; 118 | instructions.read = FALSE; 119 | instructions.req_base = FALSE; 120 | instructions.buffer_address = (void*)source_address; 121 | instructions.size = write_size; 122 | 123 | call_hook(&instructions); 124 | 125 | return true; 126 | } 127 | 128 | template 129 | bool write(UINT_PTR write_address, const S& value) 130 | { 131 | return write_memory(write_address, (UINT_PTR)&value, sizeof(S)); 132 | 133 | } 134 | 135 | void money() // set money for all players 136 | { 137 | INT_PTR PlayerCompPtr = Read(base_address + 0x10AC72F8); // 0x10AC72F8 = playerbase 138 | if (GetAsyncKeyState(VK_F1)) 139 | { 140 | printf("money set\n"); 141 | write(PlayerCompPtr + 0x5D14 + 0x20, 100000); 142 | write(PlayerCompPtr + 0x5D14 + 0xB940 + 0x20, 100000); 143 | write(PlayerCompPtr + 0x5D14 + (2 * 0xB940) + 0x20, 100000); 144 | write(PlayerCompPtr + 0x5D14 + (3 * 0xB940) + 0x20, 100000); 145 | 146 | Sleep(1000); 147 | } 148 | } 149 | 150 | void raygun() 151 | { 152 | if (GetAsyncKeyState(VK_F2)) 153 | { 154 | INT_PTR PlayerCompPtr = Read(base_address + 0x10AC72F8); 155 | 156 | gun = !gun; 157 | if (gun == true) { 158 | 159 | printf("raygun set\n"); 160 | write(PlayerCompPtr + 0xB0 + 0 * 0x40, 22); 161 | write(PlayerCompPtr + 0xB0 + 1 * 0x40, 22); 162 | 163 | Sleep(1000); 164 | } 165 | else { 166 | printf("raygun unset\n"); 167 | write(PlayerCompPtr + 0xB0 + 0 * 0x40, 1); 168 | write(PlayerCompPtr + 0xB0 + 1 * 0x40, 1); 169 | write(PlayerCompPtr + 0xB0 + 0 * 0x40 + 0xB830, 1); 170 | write(PlayerCompPtr + 0xB0 + 1 * 0x40 + 0xB830, 1); 171 | write(PlayerCompPtr + 0xB0 + 0 * 0x40 + (2 * 0xB830), 1); 172 | write(PlayerCompPtr + 0xB0 + 1 * 0x40 + (2 * 0xB830), 1); 173 | Sleep(1000); 174 | } 175 | } 176 | } 177 | 178 | void xpgun() 179 | { 180 | if (GetAsyncKeyState(VK_F4)) 181 | { 182 | INT_PTR PlayerCompPtr = Read(base_address + 0x10AC72F8); 183 | 184 | xp = !xp; 185 | if (xp == true) { 186 | printf("xp on\n"); 187 | 188 | write(base_address + 0x10AEF2F0 + 0x08, 2000); 189 | 190 | write(base_address + 0x10AEF2F0 + 0x10, 500); 191 | 192 | Sleep(1000); 193 | 194 | } 195 | else 196 | { 197 | printf("xp off\n"); 198 | write(base_address + 0x10AEF2F0 + 0x08, 1); 199 | write(base_address + 0x10AEF2F0 + 0x10, 1); 200 | 201 | 202 | Sleep(1000); 203 | 204 | } 205 | 206 | } 207 | } 208 | void godmode() 209 | { 210 | 211 | if (GetAsyncKeyState(VK_F3)) 212 | { 213 | INT_PTR PlayerCompPtr = Read(base_address + 0x10AC72F8); 214 | 215 | god = !god; 216 | if (god == true) { 217 | printf("godmode on\n"); 218 | write(PlayerCompPtr + 0xE67, 0xA0); 219 | write(PlayerCompPtr + 0xE67 + 0xB830, 0xA0); 220 | write(PlayerCompPtr + 0xE67 + (2 * 0xB830), 0xA0); 221 | write(PlayerCompPtr + 0xE67 + (3 * 0xB830), 0xA0); 222 | 223 | 224 | Sleep(1000); 225 | 226 | } 227 | else 228 | { 229 | printf("godmode off\n"); 230 | write(PlayerCompPtr + 0xE67, 0x20); 231 | write(PlayerCompPtr + 0xE67 + 0xB830, 0x20); 232 | write(PlayerCompPtr + 0xE67 + (2 * 0xB830), 0x20); 233 | write(PlayerCompPtr + 0xE67 + (3 * 0xB830), 0x20); 234 | 235 | 236 | Sleep(1000); 237 | 238 | } 239 | 240 | } 241 | 242 | } 243 | 244 | void tp1hp() // tp close to you and 1 hp 245 | { 246 | if (GetAsyncKeyState(VK_F9)) 247 | { 248 | tp = !tp; 249 | INT_PTR ZMBotBase = Read(base_address + 0x10A9FBC8 + 0x68); 250 | INT_PTR ZM_Bot_List_Offset = Read(ZMBotBase + 0x8); 251 | INT_PTR PlayerPedPtr = Read(base_address + 0x10A9FBC8 + 0x8); 252 | 253 | while (tp == true) { 254 | FLOAT playerCoords1 = Read(PlayerPedPtr + 0x2D4); 255 | FLOAT playerCoords2 = Read(PlayerPedPtr + 0x2D4 + 0x4); 256 | FLOAT playerCoords3 = Read(PlayerPedPtr + 0x2D4 + 0x8); 257 | 258 | for (int i = 0; i < 90; i++) 259 | { 260 | write(ZM_Bot_List_Offset + (0x5F8 * i) + 0x2D4, playerCoords1 + 0x100); 261 | write(ZM_Bot_List_Offset + (0x5F8 * i) + 0x2D4 + 0x4, playerCoords2); 262 | write(ZM_Bot_List_Offset + (0x5F8 * i) + 0x2D4 + 0x8, playerCoords3); 263 | write(ZM_Bot_List_Offset + (0x5F8 * i) + 0x398, 20); 264 | write(ZM_Bot_List_Offset + (0x5F8 * i) + 0x39C, 20); 265 | 266 | } 267 | if (GetAsyncKeyState(VK_F9)) 268 | { 269 | tp = !tp; 270 | } 271 | 272 | } 273 | 274 | 275 | } 276 | } 277 | void runcheat() 278 | { 279 | printf("[Rubery-Kernel]: Looking for BlackOpsColdWar.exe process...\n"); 280 | process_id = get_process_id("BlackOpsColdWar.exe"); 281 | 282 | if (process_id) { 283 | printf("[Rubery-Kernel]: Process identifier found: %d\n", process_id); 284 | printf("[Rubery-Kernel]: Looking for base address...\n"); 285 | 286 | base_address = get_client_base("BlackOpsColdWar.exe"); 287 | if (base_address) 288 | { 289 | printf("[Rubery-Kernel]: Base address found: %d\n", process_id); 290 | 291 | for (;;) 292 | { 293 | 294 | money(); 295 | godmode(); 296 | raygun(); 297 | xpgun(); 298 | tp1hp(); 299 | } 300 | 301 | 302 | 303 | } 304 | else 305 | { 306 | printf("[Rubery-Kernel]: Failed to find base address\n"); 307 | 308 | } 309 | } 310 | else 311 | { 312 | printf("[Rubery-Kernel]: Failed to find BlackOpsColdWar.exe process\n"); 313 | 314 | } 315 | } 316 | 317 | int main() 318 | { 319 | printf("[Rubery-Kernel]: Loading modules...\n"); 320 | LoadLibraryA("user32.dll"); 321 | LoadLibraryA("win32u.dll"); 322 | if (GetModuleHandleA("win32u.dll")) 323 | { 324 | printf("[Rubery-Kernel]: Modules Loaded\n"); 325 | runcheat(); 326 | 327 | } 328 | else 329 | { 330 | printf("[Rubery-Kernel]: Failed to find modules\n"); 331 | 332 | } 333 | return 0; 334 | 335 | } --------------------------------------------------------------------------------