from http.server import HTTPServer, BaseHTTPRequestHandler import json import random import string import ssl from datetime import datetime import user_agents import geoip2.database # Configuration HOST = 'sub1.kalkikrivadna.com' PORT = 5000 # In-memory storage url_database = {} tracking_data = {} def generate_short_code(): chars = string.ascii_letters + string.digits return ''.join(random.choice(chars) for _ in range(6)) def get_location_info(ip): try: reader = geoip2.database.Reader('/usr/share/GeoIP/GeoLite2-City.mmdb') response = reader.city(ip) return { 'country': response.country.name, 'city': response.city.name, 'latitude': response.location.latitude, 'longitude': response.location.longitude, 'timezone': response.location.time_zone, 'continent': response.continent.name } except Exception as e: print(f"Error getting location info: {e}") return None def get_isp_info(ip): try: reader = geoip2.database.Reader('/usr/share/GeoIP/GeoLite2-ASN.mmdb') response = reader.asn(ip) return { 'isp': response.autonomous_system_organization, 'asn': response.autonomous_system_number } except Exception as e: print(f"Error getting ISP info: {e}") return None def detect_vpn(ip): vpn_indicators = { 'is_vpn': False, 'reasons': [] } vpn_keywords = ['vpn', 'proxy', 'hosting', 'cloud', 'datacenter'] isp_info = get_isp_info(ip) if isp_info and isp_info['isp']: isp_lower = isp_info['isp'].lower() for keyword in vpn_keywords: if keyword in isp_lower: vpn_indicators['is_vpn'] = True vpn_indicators['reasons'].append(f"ISP contains VPN indicator: {keyword}") return vpn_indicators def get_device_info(user_agent_string): try: user_agent = user_agents.parse(user_agent_string) return { 'browser': { 'family': user_agent.browser.family, 'version': user_agent.browser.version_string }, 'os': { 'family': user_agent.os.family, 'version': user_agent.os.version_string }, 'device': { 'family': user_agent.device.family, 'brand': user_agent.device.brand, 'model': user_agent.device.model }, 'is_mobile': user_agent.is_mobile, 'is_tablet': user_agent.is_tablet, 'is_pc': user_agent.is_pc, 'is_bot': user_agent.is_bot } except Exception as e: print(f"Error getting device info: {e}") return None class URLShortenerHandler(BaseHTTPRequestHandler): def send_html(self, title, content): """Helper method to send HTML with consistent styling""" html = f""" {title}

⚡ CYBER KALKI MATRIX ⚡

WELCOME TO THE MOST SECURE AND ADVANCED URL SHORTENER IN THE MATRIX

{content}

🌟 SUPPORT THE MATRIX 🌟

Help keep our servers running in the cybernet

ETH: 0x6D16adD0B9576CfCc533371f7e9A92Fa0806Aa13

""" self.send_response(200) self.send_header('Content-type', 'text/html') self.end_headers() self.wfile.write(html.encode()) def do_GET(self): if self.path == '/': content = '''

URL MATRIX GATEWAY

''' self.send_html("Cyber Kalki Matrix Gateway", content) return elif self.path.startswith('/s/'): short_code = self.path[3:] if short_code in url_database: client_ip = self.client_address[0] user_agent_string = self.headers.get('User-Agent', 'Unknown') # Fetch private IP using WebRTC in the tracking information private_ip = "" # Placeholder for the private IP tracking_info = { 'timestamp': datetime.now().strftime('%Y-%m-%d %H:%M:%S'), 'ip': client_ip, 'private_ip': private_ip, # Adding private IP here 'user_agent': user_agent_string, 'referer': self.headers.get('Referer', 'Direct'), 'location': get_location_info(client_ip), 'isp_info': get_isp_info(client_ip), 'vpn_info': detect_vpn(client_ip), 'device_info': get_device_info(user_agent_string) } if short_code not in tracking_data: tracking_data[short_code] = [] tracking_data[short_code].append(tracking_info) self.send_response(302) self.send_header('Location', url_database[short_code]) self.end_headers() elif self.path.startswith('/track/'): short_code = self.path[7:] if short_code in tracking_data: clicks = len(tracking_data[short_code]) original_url = url_database[short_code] content = f'''

🔍 NEURAL TRACKING DATA

SOURCE URL: {original_url}

MATRIX HITS: {clicks}

HASH ID: {short_code}

NEURAL LOG:

''' for entry in reversed(tracking_data[short_code]): location = entry.get('location', {}) or {} isp_info = entry.get('isp_info', {}) or {} vpn_info = entry.get('vpn_info', {}) or {} device_info = entry.get('device_info', {}) or {} content += f'''

TIMESTAMP: {entry['timestamp']}

NEURAL IP: {entry['ip']}

PRIVATE IP: {entry.get('private_ip', 'Unknown')}

📱 DEVICE MATRIX

BROWSER: {device_info.get('browser', {}).get('family', 'Unknown')} {device_info.get('browser', {}).get('version', '')}

OS: {device_info.get('os', {}).get('family', 'Unknown')} {device_info.get('os', {}).get('version', '')}

DEVICE: {device_info.get('device', {}).get('family', 'Unknown')} {device_info.get('device', {}).get('brand', '')} {device_info.get('device', {}).get('model', '')}

TYPE: {'Mobile' if device_info.get('is_mobile') else 'Tablet' if device_info.get('is_tablet') else 'PC' if device_info.get('is_pc') else 'Unknown'}

📍 LOCATION MATRIX

COUNTRY: {location.get('country', 'Unknown')}

CITY: {location.get('city', 'Unknown')}

CONTINENT: {location.get('continent', 'Unknown')}

TIMEZONE: {location.get('timezone', 'Unknown')}

COORDINATES: {location.get('latitude', 'Unknown')}, {location.get('longitude', 'Unknown')}

🌐 NETWORK MATRIX

ISP: {isp_info.get('isp', 'Unknown')}

ASN: {isp_info.get('asn', 'Unknown')}

VPN STATUS: {'DETECTED' if vpn_info.get('is_vpn') else 'CLEAN'}

{f"

VPN SIGNATURES: {', '.join(vpn_info.get('reasons', []))}

" if vpn_info.get('is_vpn') else ''}

ORIGIN: {entry['referer']}

USER SIGNATURE: {entry['user_agent']}

''' self.send_html("Neural Tracking Matrix", content) else: content = '

❌ ERROR: NEURAL DATA NOT FOUND IN MATRIX

' self.send_html("Matrix Error", content) def do_POST(self): if self.path == '/shorten': content_length = int(self.headers['Content-Length']) post_data = self.rfile.read(content_length) data = json.loads(post_data.decode()) try: url = data['url'].strip() short_code = generate_short_code() while short_code in url_database: short_code = generate_short_code() url_database[short_code] = url base_url = f"https://{self.headers.get('Host', f'{HOST}:{PORT}')}" response = { 'short_url': f"{base_url}/s/{short_code}", 'tracking_url': f"{base_url}/track/{short_code}" } self.send_response(200) self.send_header('Content-type', 'application/json') self.end_headers() self.wfile.write(json.dumps(response).encode()) except Exception as e: self.send_response(400) self.send_header('Content-type', 'application/json') self.end_headers() self.wfile.write(json.dumps({'error': str(e)}).encode()) def run(server_class=HTTPServer, handler_class=URLShortenerHandler, port=PORT): server_address = ('0.0.0.0', port) httpd = server_class(server_address, handler_class) context = ssl.create_default_context(ssl.Purpose.CLIENT_AUTH) certfile = '/etc/letsencrypt/live/sub1.kalkikrivadna.com/fullchain.pem' keyfile = '/etc/letsencrypt/live/sub1.kalkikrivadna.com/privkey.pem' context.load_cert_chain(certfile=certfile, keyfile=keyfile) httpd.socket = context.wrap_socket(httpd.socket, server_side=True) print(f'Starting HTTPS Matrix Gateway server on {HOST}:{port}...') try: httpd.serve_forever() except KeyboardInterrupt: print('\nShutting down the Matrix Gateway...') httpd.socket.close() if __name__ == "__main__": run()