nmap-wazuh

ChatGPT
Claro, aquí tienes una guía paso a paso detallada para la instalación y configuración de la integración de Nmap y ChatGPT con Wazuh.

Parte 1: Configuración en el Servidor Wazuh
1.1: Agregar Reglas de Wazuh
Editar el archivo de reglas locales

Abre el archivo /var/ossec/etc/rules/local_rules.xml:
bash
Copiar código
sudo nano /var/ossec/etc/rules/local_rules.xml
Agregar las siguientes reglas dentro del archivo:

xml
Copiar código
<group name="linux,nmap,">
  <rule id="100100" level="3">
    <decoded_as>json</decoded_as>
    <field name="nmap_port">\.+</field>
    <field name="nmap_port_service">\.+</field>
    <description>NMAP: Host scan. Port $(nmap_port) is open and hosting the $(nmap_port_service) service.</description>
    <options>no_full_log</options>
  </rule>
</group>

<group name="linux,chat_gpt">
  <rule id="100101" level="5">
    <if_sid>100100</if_sid>
    <field name="nmap_port">\d+</field>
    <description>NMAP: Host scan. Port $(nmap_port) is open.</description>
  </rule>
  <rule id="100103" level="5">
    <if_sid>100100</if_sid>
    <field name="nmap_port_service">^\s$</field>
    <description>NMAP: Port $(nmap_port) is open but no service is found.</description>
  </rule>
</group>
Guardar y cerrar el archivo presionando Ctrl + X, luego Y y Enter.

1.2: Crear el Script de Integración de ChatGPT
Crear el archivo del script de integración

Crea el archivo /var/ossec/integrations/custom-chatgpt.py:
bash
Copiar código
sudo nano /var/ossec/integrations/custom-chatgpt.py
Copiar el contenido del script en el archivo:

python
Copiar código
#!/var/ossec/framework/python/bin/python3
import json
import sys
import time
import os
from socket import socket, AF_UNIX, SOCK_DGRAM
try:
    import requests
    from requests.auth import HTTPBasicAuth
except Exception as e:
    print("No module 'requests' found. Install: pip install requests")
    sys.exit(1)

debug_enabled = False
pwd = os.path.dirname(os.path.dirname(os.path.realpath(__file__)))
print(pwd)

json_alert = {}
now = time.strftime("%a %b %d %H:%M:%S %Z %Y")

log_file = '{0}/logs/integrations.log'.format(pwd)
socket_addr = '{0}/queue/sockets/queue'.format(pwd)

def main(args):
    debug("# Starting")
    alert_file_location = args[1]
    apikey = args[2]
    debug("# API Key")
    debug(apikey)
    debug("# File location")
    debug(alert_file_location)
    with open(alert_file_location) as alert_file:
        json_alert = json.load(alert_file)
    debug("# Processing alert")
    debug(json_alert)
    msg = request_chatgpt_info(json_alert,apikey)
    if msg:
        send_event(msg, json_alert["agent"])

def debug(msg):
    if debug_enabled:
        msg = "{0}: {1}\n".format(now, msg)
    print(msg)
    f = open(log_file,"a")
    f.write(str(msg))
    f.close()

def collect(data):
  nmap_port_service = data['nmap_port_service']
  choices = data['content']
  return nmap_port_service, choices

def in_database(data, nmap_port_service):
  result = data['nmap_port_service']
  if result == 0:
    return False
  return True

def query_api(nmap_port_service, apikey):
  headers = {
        'Authorization': 'Bearer ' + apikey,
        'Content-Type': 'application/json',
    }
  json_data = {
        'model': 'gpt-3.5-turbo',
        'messages': [
            {
                'role': 'user',
                'content': 'In 4 or 5 sentences, tell me about this service and if there are past vulnerabilities: ' + nmap_port_service,
            },
        ],
    }
  response = requests.post('https://api.openai.com/v1/chat/completions', headers=headers, json=json_data)
  if response.status_code == 200:
      ip = {"nmap_port_service": nmap_port_service}
      new_json = {}
      new_json = response.json()["choices"][0]["message"]
      new_json.update(ip)
      json_response = new_json
      data = json_response
      return data
  else:
      alert_output = {}
      alert_output["chatgpt"] = {}
      alert_output["integration"] = "custom-chatgpt"
      json_response = response.json()
      debug("# Error: The chatgpt encountered an error")
      alert_output["chatgpt"]["error"] = response.status_code
      alert_output["chatgpt"]["description"] = json_response["errors"][0]["detail"]
      send_event(alert_output)
      exit(0)

def request_chatgpt_info(alert, apikey):
    alert_output = {}
    if not "nmap_port_service" in alert["data"]:
        return(0)
    data = query_api(alert["data"]["nmap_port_service"], apikey)
    alert_output["chatgpt"] = {}
    alert_output["integration"] = "custom-chatgpt"
    alert_output["chatgpt"]["found"] = 0
    alert_output["chatgpt"]["source"] = {}
    alert_output["chatgpt"]["source"]["alert_id"] = alert["id"]
    alert_output["chatgpt"]["source"]["rule"] = alert["rule"]["id"]
    alert_output["chatgpt"]["source"]["description"] = alert["rule"]["description"]
    alert_output["chatgpt"]["source"]["full_log"] = alert["full_log"]
    alert_output["chatgpt"]["source"]["nmap_port_service"] = alert["data"]["nmap_port_service"]
    nmap_port_service = alert["data"]["nmap_port_service"]
    if in_database(data, nmap_port_service):
      alert_output["chatgpt"]["found"] = 1
    if alert_output["chatgpt"]["found"] == 1:
        nmap_port_service, choices = collect(data)
        alert_output["chatgpt"]["nmap_port_service"] = nmap_port_service
        alert_output["chatgpt"]["choices"] = choices
        debug(alert_output)
    return(alert_output)

def send_event(msg, agent = None):
    if not agent or agent["id"] == "000":
        string = '1:chatgpt:{0}'.format(json.dumps(msg))
    else:
        string = '1:[{0}] ({1}) {2}->chatgpt:{3}'.format(agent["id"], agent["name"], agent["ip"] if "ip" in agent else "any", json.dumps(msg))
    debug(string)
    sock = socket(AF_UNIX, SOCK_DGRAM)
    sock.connect(socket_addr)
    sock.send(string.encode())
    sock.close()

if __name__ == "__main__":
    try:
        bad_arguments = False
        if len(sys.argv) >= 4:
            msg = '{0} {1} {2} {3} {4}'.format(now, sys.argv[1], sys.argv[2], sys.argv[3], sys.argv[4] if len(sys.argv) > 4 else '')
            debug_enabled = (len(sys.argv) > 4 and sys.argv[4] == 'debug')
        else:
            msg = '{0} Wrong arguments'.format(now)
            bad_arguments = True
        f = open(log_file, 'a')
        f.write(str(msg) + '\n')
        f.close()
        if bad_arguments:
            debug("# Exiting: Bad arguments.")
            sys.exit(1)
        main(sys.argv)
    except Exception as e:
        debug(str(e))
        raise
Guardar y cerrar el archivo presionando Ctrl + X, luego Y y Enter.

Otorgar permisos de ejecución y modificar el propietario y grupo del script:

bash
Copiar código
sudo chmod 750 /var/ossec/integrations/custom-chatgpt.py
sudo chown root:wazuh /var/ossec/integrations/custom-chatgpt.py
1.3: Configurar el Archivo ossec.conf
Editar el archivo ossec.conf:

bash
Copiar código
sudo nano /var/ossec/etc/ossec.conf
Agregar el siguiente bloque de integración dentro del bloque <ossec_config>:

xml
Copiar código
<!-- ChatGPT Integration -->
<integration>
  <name>custom-chatgpt.py</name>
  <hook_url>https://api.openai.com/v1/chat/completions</hook_url>
  <api_key>YOUR_CHATGPT_API_KEY</api_key>
  <level>5</level>
  <rule_id>100101</rule_id>
  <alert_format>json</alert_format>
</integration>
Reemplaza YOUR_CHATGPT_API_KEY con tu clave API de ChatGPT.

Guardar y cerrar el archivo presionando Ctrl + X, luego Y y Enter.

1.4: Agregar la Regla de Integración
Editar el archivo de reglas locales nuevamente:

bash
Copiar código
sudo nano /var/ossec/etc/rules/local_rules.xml
Agregar la siguiente regla:

xml
Copiar código
<group name="local,linux,">
  <rule id="100102" level="6">
    <field name="chatgpt.nmap_port_service">\w+</field>
    <description>The service $(chatgpt.nmap_port_service) is on an open port.</description>
  </rule>
</group>
Guardar y cerrar el archivo presionando Ctrl + X, luego Y y Enter.

1.5: Reiniciar el Manager de Wazuh
Reiniciar el manager de Wazuh para aplicar los cambios:

bash
Copiar código
sudo systemctl restart wazuh-manager
Parte 2: Configuración en los Endpoints
Configuración en Ubuntu
2.1: Instalar Dependencias
Actualizar paquetes e instalar Python, pip y Nmap:

bash
Copiar código
sudo apt-get update && sudo apt-get install python3 python3-pip nmap
sudo pip3 install python-nmap
2.2: Crear el Script de Nmap
Crear el archivo del script de Nmap:

bash
Copiar código
sudo nano /var/ossec/nmapscan.py
Copiar el contenido del script:

python
Copiar código
#!/var/ossec/framework/python/bin/python3
import nmap
import time
import json
import platform

def scan_subnet(subnet):
    nm = nmap.PortScanner()
    nm.scan(subnet)
    results = []
    for host in nm.all_hosts():
        for proto in nm[host].all_protocols():
            if proto not in ["tcp", "udp"]:
                continue
            lport = list(nm[host][proto].keys())
            lport.sort()
            for port in lport:
                hostname = ""
                json_output = {
                    'nmap_host': host,
                    'nmap_protocol': proto,
                    'nmap_port': port,
                    'nmap_hostname': "",
                    'nmap_hostname_type': "",
                    'nmap_port_name': "",
                    'nmap_port_state': "",
                    'nmap_port_service': ""
                }
                if nm[host]["hostnames"]:
                    hostname = nm[host]["hostnames"][0]["name"]
                    hostname_type = nm[host]["hostnames"][0]["type"]
                    json_output['nmap_hostname'] = hostname
                    json_output['nmap_hostname_type'] = hostname_type
                if 'name' in nm[host][proto][port]:
                    json_output['nmap_port_name'] = nm[host][proto][port]['name']
                if 'state' in nm[host][proto][port]:
                    json_output['nmap_port_state'] = nm[host][proto][port]['state']
                if 'product' in nm[host][proto][port] and 'version' in nm[host][proto][port]:
                    service = nm[host][proto][port]['product'] + " " + nm[host][proto][port]['version']
                    json_output['nmap_port_service'] = service
                results.append(json_output)
    return results

def append_to_log(results, log_file):
    with open(log_file, "a") as active_response_log:
        for result in results:
            active_response_log.write(json.dumps(result))
            active_response_log.write("\n")

subnets = ['127.0.0.1']

if platform.system() == 'Windows':
    log_file = "C:\\Program Files (x86)\\ossec-agent\\active-response\\active-responses.log"
elif platform.system() == 'Linux':
    log_file = "/var/ossec/logs/active-responses.log"
else:
    log_file = "/Library/Ossec/logs/active-responses.log"

for subnet in subnets:
    results = scan_subnet(subnet)
    append_to_log(results, log_file)
    time.sleep(2)
Guardar y cerrar el archivo presionando Ctrl + X, luego Y y Enter.

2.3: Configurar el Agente Wazuh
Editar el archivo ossec.conf:

bash
Copiar código
sudo nano /var/ossec/etc/ossec.conf
Agregar el siguiente bloque dentro de <ossec_config>:

xml
Copiar código
<!-- Run nmap python script -->
<localfile>
  <log_format>full_command</log_format>
  <command>python3 /var/ossec/nmapscan.py</command>
  <frequency>604800</frequency>
</localfile>
Guardar y cerrar el archivo presionando Ctrl + X, luego Y y Enter.

2.4: Reiniciar el Agente Wazuh
Reiniciar el agente Wazuh:

bash
Copiar código
sudo systemctl restart wazuh-agent
Configuración en Windows
2.5: Instalar Dependencias
Instalar Python 3.8.7 o superior (con pip preinstalado):
Asegúrate de marcar las opciones "Install launcher for all users (recommended)" y "Add Python to PATH".
Instalar Microsoft Visual C++ 2015 Redistributable.
Instalar Nmap v7.94 o superior: Añade Nmap a PATH.
2.6: Instalar la Biblioteca python-nmap
Abrir PowerShell como administrador y ejecutar:

powershell
Copiar código
pip3 install python-nmap
2.7: Crear el Script de Nmap
Crear el archivo del script de Nmap:

powershell
Copiar código
New-Item -Path "C:\Program Files (x86)\ossec-agent\nmapscan.py" -ItemType "file"
Editar el archivo del script:

powershell
Copiar código
notepad "C:\Program Files (x86)\ossec-agent\nmapscan.py"
Copiar el contenido del script en el archivo Notepad y guardarlo:

python
Copiar código
#!/var/ossec/framework/python/bin/python3
import nmap
import time
import json
import platform

def scan_subnet(subnet):
    nm = nmap.PortScanner()
    nm.scan(subnet)
    results = []
    for host in nm.all_hosts():
        for proto in nm[host].all_protocols():
            if proto not in ["tcp", "udp"]:
                continue
            lport = list(nm[host][proto].keys())
            lport.sort()
            for port in lport:
                hostname = ""
                json_output = {
                    'nmap_host': host,
                    'nmap_protocol': proto,
                    'nmap_port': port,
                    'nmap_hostname': "",
                    'nmap_hostname_type': "",
                    'nmap_port_name': "",
                    'nmap_port_state': "",
                    'nmap_port_service': ""
                }
                if nm[host]["hostnames"]:
                    hostname = nm[host]["hostnames"][0]["name"]
                    hostname_type = nm[host]["hostnames"][0]["type"]
                    json_output['nmap_hostname'] = hostname
                    json_output['nmap_hostname_type'] = hostname_type
                if 'name' in nm[host][proto][port]:
                    json_output['nmap_port_name'] = nm[host][proto][port]['name']
                if 'state' in nm[host][proto][port]:
                    json_output['nmap_port_state'] = nm[host][proto][port]['state']
                if 'product' in nm[host][proto][port] and 'version' in nm[host][proto][port]:
                    service = nm[host][proto][port]['product'] + " " + nm[host][proto][port]['version']
                    json_output['nmap_port_service'] = service
                results.append(json_output)
    return results

def append_to_log(results, log_file):
    with open(log_file, "a") as active_response_log:
        for result in results:
            active_response_log.write(json.dumps(result))
            active_response_log.write("\n")

subnets = ['127.0.0.1']

if platform.system() == 'Windows':
    log_file = "C:\\Program Files (x86)\\ossec-agent\\active-response\\active-responses.log"
elif platform.system() == 'Linux':
    log_file = "/var/ossec/logs/active-responses.log"
else:
    log_file = "/Library/Ossec/logs/active-responses.log"

for subnet in subnets:
    results = scan_subnet(subnet)
    append_to_log(results, log_file)
    time.sleep(2)
2.8: Convertir el Script en un Ejecutable
Abrir PowerShell como administrador y usar pyinstaller para crear un ejecutable:

powershell
Copiar código
pip install pyinstaller
pyinstaller -F "C:\Program Files (x86)\ossec-agent\nmapscan.py"
Mover el archivo nmapscan.exe generado a C:\Program Files (x86)\ossec-agent\nmapscan.exe.

2.9: Configurar el Agente Wazuh
Editar el archivo ossec.conf:

powershell
Copiar código
notepad "C:\Program Files (x86)\ossec-agent\ossec.conf"
Agregar el siguiente bloque dentro de <ossec_config>:

xml
Copiar código
<!-- Run nmap python script -->
<localfile>
  <log_format>full_command</log_format>
  <command>C:\Program Files (x86)\ossec-agent\nmapscan.exe</command>
  <frequency>604800</frequency>
</localfile>
Guardar y cerrar el archivo en Notepad.

2.10: Reiniciar el Agente Wazuh
Reiniciar el agente Wazuh:

powershell
Copiar código
Restart-Service -Name wazuh
Con estos pasos, habrás configurado la integración de Nmap y ChatGPT con Wazuh tanto en el servidor como en los endpoints de manera detallada y organizada. Si tienes alguna duda o necesitas más detalles, no dudes en preguntar.