LinuxParty

El comando Nmap también conocido como Network Mapper es una herramienta de código abierto muy versátil para los administradores de sistemas Linux / red. Nmap se utiliza para explorar redes, realizar análisis de seguridad, auditoría de red y búsquedas de puertos abiertos en lmáquinas remotas. Analiza en busca de hosts directo, sistemas operativos, filtros de paquetes y puertos abiertos que se ejecutan en máquinas remotas.

Los comandos de Nmap

Comandos y ejemplos de Nmap

Voy a cubrir la mayor parte del uso de NMAP. Aquí, en esta configuración, he utilizado dos servidores sin firewall para probar el funcionamiento del comando de Nmap.

 
 192.168.0.100 – server1.mimaquina.com
 192.168.0.101 – server2.mimaquina.com

En otro momento, hemos hablado de: Instalar Linux Malware Detect (LMD) que es un elemento importante a usar de forma conjunta con esta otra que le vamos a presentar. neopy.py

El script de Python neopy.py, es una utilidad que sirve sobre todo para buscar ficheros "sospechosos", que no lo hace maldet por dos principales razones, estar encriptado o ser un fichero ofuscado.

Por favor, lee nuestro artículo: Instalar Linux Malware Detect (LMD) en RHEL, CentOS y Fedora

Este es el código fuente. Abajo indicaremos como se usa:

#!/usr/bin/python
# Name: neopi.py
# Description: Utility to scan a file path for encrypted and obfuscated files
# Authors: Ben Hagen (Esta dirección de correo electrónico está siendo protegida contra los robots de spam. Necesita tener JavaScript habilitado para poder verlo.)
# Scott Behrens (Esta dirección de correo electrónico está siendo protegida contra los robots de spam. Necesita tener JavaScript habilitado para poder verlo.)
#
# Date: 11/4/2010
#
# pep-0008 - Is stupid. TABS FO'EVER!

# Try catch regular expressions/bad path/bad filename/bad regex/

# Library imports
import math
import sys
import os
import re
import csv
import zlib
import time
from collections import defaultdict
from optparse import OptionParser

#
# Globals
#
   
# Smallest filesize to checkfor in bytes.
SMALLEST = 60

class LanguageIC:
   """Class that calculates a file's Index of Coincidence as
as well as a a subset of files average Index of Coincidence.
"""
   def __init__(self):
       """Initialize results arrays as well as character counters."""
       self.char_count = defaultdict(int)
       self.total_char_count = 0
       self.results = []
       self.ic_total_results = ""

   def calculate_char_count(self,data):
       """Method to calculate character counts for a particular data file."""
       if not data:
           return 0
       for x in range(256):
           char = chr(x)
           charcount = data.count(char)
           self.char_count[char] += charcount
           self.total_char_count += charcount
       return

   def calculate_IC(self):
       """Calculate the Index of Coincidence for the self variables"""
       total = 0
       for val in self.char_count.values():

           if val == 0:
               continue
           total += val * (val-1)

       try:
           ic_total = float(total)/(self.total_char_count * (self.total_char_count - 1))
       except:
           ic_total = 0
       self.ic_total_results = ic_total
       return

   def calculate(self,data,filename):
       """Calculate the Index of Coincidence for a file and append to self.ic_results array"""
       if not data:
           return 0
       char_count = 0
       total_char_count = 0

       for x in range(256):
           char = chr(x)
           charcount = data.count(char)
           char_count += charcount * (charcount - 1)
           total_char_count += charcount

       ic = float(char_count)/(total_char_count * (total_char_count - 1))
       self.results.append({"filename":filename, "value":ic})
       # Call method to calculate_char_count and append to total_char_count
       self.calculate_char_count(data)
       return ic

   def sort(self):
       self.results.sort(key=lambda item: item["value"])
       self.results = resultsAddRank(self.results)

   def printer(self, count):
       """Print the top signature count match files for a given search"""
       # Calculate the Total IC for a Search
       self.calculate_IC()
       print "\n[[ Average IC for Search ]]"
       print self.ic_total_results
       print "\n[[ Top %i lowest IC files ]]" % (count)
       if (count > len(self.results)): count = len(self.results)
       for x in range(count):
           print ' {0:>7.4f}{1}'.format(self.results[x]["value"], self.results[x]["filename"])
       return

class Entropy:
   """Class that calculates a file's Entropy."""

   def __init__(self):
       """Instantiate the entropy_results array."""
       self.results = []

   def calculate(self,data,filename):
       """Calculate the entropy for 'data' and append result to entropy_results array."""

       if not data:
           return 0
       entropy = 0
       self.stripped_data =data.replace(' ', '')
       for x in range(256):
           p_x = float(self.stripped_data.count(chr(x)))/len(self.stripped_data)
           if p_x > 0:
               entropy += - p_x * math.log(p_x, 2)
       self.results.append({"filename":filename, "value":entropy})
       return entropy

   def sort(self):
       self.results.sort(key=lambda item: item["value"])
       self.results.reverse()
       self.results = resultsAddRank(self.results)

   def printer(self, count):
       """Print the top signature count match files for a given search"""
       print "\n[[ Top %i entropic files for a given search ]]" % (count)
       if (count > len(self.results)): count = len(self.results)
       for x in range(count):
           print ' {0:>7.4f}{1}'.format(self.results[x]["value"], self.results[x]["filename"])
       return

class LongestWord:
   """Class that determines the longest word for a particular file."""
   def __init__(self):
       """Instantiate the longestword_results array."""
       self.results = []

   def calculate(self,data,filename):
       """Find the longest word in a string and append to longestword_results array"""
       if not data:
           return "", 0
       longest = 0
       longest_word = ""
       words = re.split("[\s,\n,\r]", data)
       if words:
           for word in words:
               length = len(word)
               if length > longest:
                   longest = length
                   longest_word = word
       self.results.append({"filename":filename, "value":longest})
       return longest

   def sort(self):
       self.results.sort(key=lambda item: item["value"])
       self.results.reverse()
       self.results = resultsAddRank(self.results)

   def printer(self, count):
       """Print the top signature count match files for a given search"""
       print "\n[[ Top %i longest word files ]]" % (count)
       if (count > len(self.results)): count = len(self.results)
       for x in range(count):
           print ' {0:>7}{1}'.format(self.results[x]["value"], self.results[x]["filename"])
       return

class SignatureNasty:
   """Generator that searches a given file for nasty expressions"""

   def __init__(self):
       """Instantiate the results array."""
       self.results = []

   def calculate(self, data, filename):
       if not data:
           return "", 0
       # Lots taken from the wonderful post at http://stackoverflow.com/questions/3115559/exploitable-php-functions
       valid_regex = re.compile('(eval\(|file_put_contents|base64_decode|python_eval|exec\(|passthru|popen|proc_open|pcntl|assert\(|system\(|shell)', re.I)
       matches = re.findall(valid_regex, data)
       self.results.append({"filename":filename, "value":len(matches)})
       return len(matches)

   def sort(self):
       self.results.sort(key=lambda item: item["value"])
       self.results.reverse()
       self.results = resultsAddRank(self.results)

   def printer(self, count):
       """Print the top signature count match files for a given search"""
       print "\n[[ Top %i signature match counts ]]" % (count)
       if (count > len(self.results)): count = len(self.results)
       for x in range(count):
           print ' {0:>7}{1}'.format(self.results[x]["value"], self.results[x]["filename"])
       return

class SignatureSuperNasty:
   """Generator that searches a given file for SUPER-nasty expressions (These are almost always bad!)"""

   def __init__(self):
       """Instantiate the results array."""
       self.results = []

   def calculate(self, data, filename):
       if not data:
           return "", 0
       valid_regex = re.compile('(@\$_\[\]=|\$_=@\$_GET|\$_\[\+""\]=)', re.I)
       matches = re.findall(valid_regex, data)
       self.results.append({"filename":filename, "value":len(matches)})
       return len(matches)

   def sort(self):
       self.results.sort(key=lambda item: item["value"])
       self.results.reverse()
       self.results = resultsAddRank(self.results)

   def printer(self, count):
       """Print the top signature count match files for a given search"""
       print "\n[[ Top %i SUPER-signature match counts (These are usually bad!) ]]" % (count)
       if (count > len(self.results)): count = len(self.results)
       for x in range(count):
           print ' {0:>7}{1}'.format(self.results[x]["value"], self.results[x]["filename"])
       return

class UsesEval:
   """Generator that searches a given file for nasty eval with variable"""

   def __init__(self):
      """Instantiate the eval_results array."""
      self.results = []

   def calculate(self, data, filename):
      if not data:
               return "", 0
           # Lots taken from the wonderful post at http://stackoverflow.com/questions/3115559/exploitable-php-functions
      valid_regex = re.compile('(eval\(\$(\w|\d))', re.I)
      matches = re.findall(valid_regex, data)
      self.results.append({"filename":filename, "value":len(matches)})
      return len(matches)

   def sort(self):
      self.results.sort(key=lambda item: item["value"])
      self.results.reverse()
      self.results = resultsAddRank(self.results)

   def printer(self, count):
      """Print the files that use eval"""
      print "\n[[ Top %i eval match counts ]]" % (count)
      if (count > len(self.results)): count = len(self.results)
      for x in range(count):
        print ' {0:>7}{1}'.format(self.results[x]["value"], self.results[x]["filename"])
      return


class Compression:
   """Generator finds compression ratio"""

   def __init__(self):
       """Instantiate the results array."""
       self.results = []

   def calculate(self, data, filename):
       if not data:
           return "", 0
       compressed = zlib.compress(data)
       ratio = float(len(compressed)) / float(len(data))
       self.results.append({"filename":filename, "value":ratio})
       return ratio

   def sort(self):
       self.results.sort(key=lambda item: item["value"])
       self.results.reverse()
       self.results = resultsAddRank(self.results)

   def printer(self, count):
       """Print the top files for a given search"""
       print "\n[[ Top %i compression match counts ]]" % (count)
       if (count > len(self.results)): count = len(self.results)
       for x in range(count):
           print ' {0:>7.4f}{1}'.format(self.results[x]["value"], self.results[x]["filename"])
       return

def resultsAddRank(results):
   rank = 1
   offset = 1
   previousValue = False
   newList = []
   for file in results:
       if (previousValue and previousValue != file["value"]):
           rank = offset
       file["rank"] = rank
       newList.append(file)
       previousValue = file["value"]
       offset = offset + 1
   return newList

class SearchFile:
   """Generator that searches a given filepath with an optional regular
expression and returns the filepath and filename"""
   def search_file_path(self, args, valid_regex):
       for root, dirs, files in os.walk(args[0]):
           for file in files:
               filename = os.path.join(root, file)
               if (valid_regex.search(file) and os.path.getsize(filename) > SMALLEST):
                   try:
                       data = open(root + "/" + file, 'rb').read()
                   except:
                       data = False
                       print "Could not read file :: %s/%s" % (root, file)
                   yield data, filename

if __name__ == "__main__":
   """Parse all the options"""

   timeStart = time.clock()

   print """
) ( (
( /( )\ ))\ )
)\()) ( (()/(()/(
((_)\ ))\ ( /(_))(_))
_((_)/((_))\(_))(_))
| \| (_)) ((_) _ \_ _|
| .` / -_) _ \ _/| |
|_|\_\___\___/_| |___| Ver. *.USEGIT
"""

   parser = OptionParser(usage="usage: %prog [options] <start directory> <OPTIONAL: filename regex>",
                         version="%prog 1.0")
   parser.add_option("-c", "--csv",
                     action="store",
                     dest="is_csv",
                     default=False,
                     help="generate CSV outfile",
                     metavar="FILECSV")
   parser.add_option("-a", "--all",
                     action="store_true",
                     dest="is_all",
                     default=False,
                     help="Run all (useful) tests [Entropy, Longest Word, IC, Signature]",)
   parser.add_option("-z", "--zlib",
                     action="store_true",
                     dest="is_zlib",
                     default=False,
                     help="Run compression Test",)
   parser.add_option("-e", "--entropy",
                     action="store_true",
                     dest="is_entropy",
                     default=False,
                     help="Run entropy Test",)
   parser.add_option("-E", "--eval",
                     action="store_true",
                     dest="is_eval",
                     default=False,
                     help="Run signiture test for the eval",)
   parser.add_option("-l", "--longestword",
                     action="store_true",
                     dest="is_longest",
                     default=False,
                     help="Run longest word test",)
   parser.add_option("-i", "--ic",
                     action="store_true",
                     dest="is_ic",
                     default=False,
                     help="Run IC test",)
   parser.add_option("-s", "--signature",
                     action="store_true",
                     dest="is_signature",
                     default=False,
                     help="Run signature test",)
   parser.add_option("-S", "--supersignature",
                     action="store_true",
                     dest="is_supersignature",
                     default=False,
                     help="Run SUPER-signature test",)
   parser.add_option("-A", "--auto",
                     action="store_true",
                     dest="is_auto",
                     default=False,
                     help="Run auto file extension tests",)
   parser.add_option("-u", "--unicode",
                     action="store_true",
                     dest="ignore_unicode",
                     default=False,
                     help="Skip over unicode-y/UTF'y files",)

   (options, args) = parser.parse_args()

   # Error on invalid number of arguements
   if len(args) < 1:
       parser.print_help()
       print ""
       sys.exit()

   # Error on an invalid path
   if os.path.exists(args[0]) == False:
       parser.error("Invalid path")

   valid_regex = ""
   if (len(args) == 2 and options.is_auto is False):
       try:
           valid_regex = re.compile(args[1])
       except:
           parser.error("Invalid regular expression")
   else:
       valid_regex = re.compile('.*')
   tests = []

   if options.is_auto:
       valid_regex = re.compile('(\.php|\.asp|\.aspx|\.scath|\.bash|\.zsh|\.csh|\.tsch|\.pl|\.py|\.txt|\.cgi|\.cfm|\.htaccess)$')

   if options.is_all:
       tests.append(LanguageIC())
       tests.append(Entropy())
       tests.append(LongestWord())
       tests.append(SignatureNasty())
       tests.append(SignatureSuperNasty())
   else:
       if options.is_entropy:
           tests.append(Entropy())
       if options.is_longest:
           tests.append(LongestWord())
       if options.is_ic:
           tests.append(LanguageIC())
       if options.is_signature:
           tests.append(SignatureNasty())
       if options.is_supersignature:
           tests.append(SignatureSuperNasty())
       if options.is_eval:
           tests.append(UsesEval())
       if options.is_zlib:
           tests.append(Compression())

   # Instantiate the Generator Class used for searching, opening, and reading files
   locator = SearchFile()

   # CSV file output array
   csv_array = []
   csv_header = ["filename"]

   # Grab the file and calculate each test against file
   fileCount = 0
   fileIgnoreCount = 0
   for data, filename in locator.search_file_path(args, valid_regex):
       if data:
           # a row array for the CSV
           csv_row = []
           csv_row.append(filename)

           if options.ignore_unicode:
               asciiHighCount = 0
               for character in data:
                   if ord(character) > 127:
                       asciiHighCount = asciiHighCount + 1

               fileAsciiHighRatio = float(asciiHighCount) / float(len(data))

           if (options.ignore_unicode == False or fileAsciiHighRatio < .1):
               for test in tests:
                   calculated_value = test.calculate(data, filename)
                   # Make the header row if it hasn't been fully populated, +1 here to account for filename column
                   if len(csv_header) < len(tests) + 1:
                       csv_header.append(test.__class__.__name__)
                   csv_row.append(calculated_value)
                   fileCount = fileCount + 1
               csv_array.append(csv_row)
           else:
               fileIgnoreCount = fileIgnoreCount + 1

   if options.is_csv:
       csv_array.insert(0,csv_header)
       fileOutput = csv.writer(open(options.is_csv, "wb"))
       fileOutput.writerows(csv_array)

   timeFinish = time.clock()

   # Print some stats
   print "\n[[ Total files scanned: %i ]]" % (fileCount)
   print "[[ Total files ignored: %i ]]" % (fileIgnoreCount)
   print "[[ Scan Time: %f seconds ]]" % (timeFinish - timeStart)

   # Print top rank lists
   rank_list = {}
   for test in tests:
       test.sort()
       test.printer(10)
       for file in test.results:
           rank_list[file["filename"]] = rank_list.setdefault(file["filename"], 0) + file["rank"]

   rank_sorted = sorted(rank_list.items(), key=lambda x: x[1])

   print "\n[[ Top cumulative ranked files ]]"
   count = 10
   if (count > len(rank_sorted)): count = len(rank_sorted)
   for x in range(count):
       print ' {0:>7}{1}'.format(rank_sorted[x][1], rank_sorted[x][0])

Seleccione el script, cópielo y pégalo en un fichero llamado: neopy.py

Dale permisos de ejecución: chmod a+x neopy.py

La mejor forma de ejecutarlo es:

./neopy.py -a /var/www/[html]/sitioweb

El [html] dependerá (si hace falta o no) de tu propia distribución.

Proviene del artículo: Detector de ficheros encriptados, ofuscados y malware.

Proviene del artículo: 25 trucos de seguridad para servidores Linux (1 de 2)

Escriba primero:

chkconfig --list

# chkconfig --list | grep :on

O simplemente utilizar el siguiente comando para ver los servicios que se activan sólo para el nivel de ejecución 3.

# chkconfig --list | grep 3:on

A continuación, podría utilizar un comando como este para eliminar el servicio de puesta en marcha.

# chkconfig --del 'service-name'

Consejo # 13 - Desinstale X Windows
Considere la posibilidad de la eliminación total de X Windows en su sistema, y utilice sólo la línea de comandos para la gestión. No hay nada que usted pueda hacer en la interfaz gráfica que no se puede hacer desde la línea de comandos y la eliminación no sólo va a mejorar la seguridad, sino también el rendimiento porque no se desperdician los recursos del sistema cuando se muestra la interfaz gráfica de usuario.

Consejo # 14 - Secure Kernel Linux
Usted puede asegurar su Kernel Linux modificando el archivo / etc / sysctl.conf, este archivo es leído por el núcleo durante el arranque y puede ser editado con los siguientes valores para añadir seguridad adicional.

# Turn on execshield
 kernel.exec-shield =1
 kernel.randomize_va_space =1
# Don't reply to broadcasts. Prevents joining a smurf attack
 net.ipv4.icmp_echo_ignore_broadcasts =1
# Enable protection for bad icmp error messages
 net.ipv4.icmp_ignore_bogus_error_responses =1
# Enable syncookies for SYN flood attack protection
 net.ipv4.tcp_syncookies =1
# Enable IP spoofing protection
 net.ipv4.conf.all.rp_filter =1
 net.ipv4.conf.default.rp_filter =1
# Log spoofed, source routed, and redirect packets
 net.ipv4.conf.all.log_martians =1
 net.ipv4.conf.default.log_martians =1
# Don't allow source routed packets
 net.ipv4.conf.all.accept_source_route =0
 net.ipv4.conf.default.accept_source_route =0
# Don't allow outsiders to alter the routing tables
 net.ipv4.conf.all.accept_redirects =0
 net.ipv4.conf.default.accept_redirects =0
 net.ipv4.conf.all.secure_redirects =0
 net.ipv4.conf.default.secure_redirects =0
# Don't pass traffic between networks or act as a router
 net.ipv4.ip_forward =0
 net.ipv4.conf.all.send_redirects =0
 net.ipv4.conf.default.send_redirects =0

Consejo # 15 - Instalar los parches del kernel Linux
Debe tener una política de seguridad para el manejo de los parches del kernel Linux, la cual debe incluir los parches de seguridad de Linux para recibir las actualizaciones y probarlos para asegurar que los problemas no se plantean y que los parches se han instalado en el sistema. Asegúrese siempre de que los servidores en producción se actualizan con regularidad para evitar cualquier posible vulnerabilidad conocida de la explotación en el sistema.

Consejo # 16 - particiones separadas
Debe crear particiones separadas para los directorios, modificables sólo por usuarios permitidos y bloquear el acceso de escritura y ejecución a las particiones que no sean necesarios. Usted debe considerar la colocación de los siguientes sistemas de archivos en particiones diferentes.

 /usr 
 /home 
 /var y /var/tmp 
 /tmp 
 

A continuación, puede editar el archivo /etc/fstab para impedir la ejecución de archivos binarios, desactivar los dispositivos de bloques en la partición y evitar que poner SUID / SGID en los archivos. He aquí una entrada fstab común para limitar el acceso del usuario al directorio ftpdata.

/dev/sda5 /ftpdata ext3 defaults,noexec,nodev,nosuid 1 2

Consejo # 17 - Use las extensiones de seguridad de Linux
Hacer uso de software como SELinux, AppArmor o GRSecurity para proporcionar endurecimiento adicional a su Kernel Linux. Estos productos proporcionan las políticas adicionales para restringir los procesos y servicios basados en listas de control de acceso.

SSH ofrece un canal de alta seguridad para la administración remota de servidores. Sin embargo, si se enfrentan a una auditoría de seguridad para conocer los requisitos reglamentarios o de negocios, tales como Visa / Mastercard, usted necesita ser consciente de algunas potenciales autentificaciones adicionales relacionadas con deficiencias que pueden causarles dolores de cabeza en una auditoría. Por ejemplo:

• No hay manera de controlar qué usuarios tienen la autorización de clave pública
• No hay manera de hacer cumplir la complejidad de la frase de contraseña (o incluso estar seguro de que uno se está utilizando)
• No hay manera de expirar una clave pública

Kai Kloepfer es un estudiante de secundaria de 17 años de edad, de Colorado, que acaba de ganar el Smart Tech para el desafío de armas de fuego. Kloepfer ha diseñado y construido un arma inteligente que sólo se desbloqueará y abrirá fuego para los usuarios que abastecen las huellas dactilares adecuadas.

"El arma funciona mediante la creación de un ID de usuario y bloqueo de la huella digital de cada usuario que reconoce el uso de la pistola. La pistola sólo se desbloqueará con la huella digital única de aquellos que ya tienen permiso para acceder a la pistola...

Todo el mundo dice que Linux es seguro de forma predeterminada y convino en cierta medida (el tema es discutible). Sin embargo, Linux tiene un modelo de seguridad incorporado por defecto. Pero también tiene la necesidad de ajustar  y personalizarla según sus necesidades que te pueden ayudar a hacer que el sistema sea más seguro. Haciendo Linux más difícil de manejar, y ofrece más flexibilidad y opciones de configuración.

Asegurar un sistema en producción de las manos de hackers y crackers es una tarea difícil para un administrador del sistema. Este es nuestro primer artículo relacionado a "Cómo proteger el sistema Linux" o "endurecimiento de un Linux". En este post vamos a explicar 25 consejos y trucos útiles para proteger el sistema Linux. Espero, que los consejos y trucos le ayudarán a ampliar y a proteger sus datos personales.

Nikto Web Scanner es una otra buena herramienta para el arsenal de cualquier administrador de Linux. Es un escáner de código abierto distribuido bajo la licencia GPL, que se utiliza para llevar a cabo pruebas exhaustivas en los servidores Web por varios elementos, entre ellos más de 6.500 potencialmente peligrosos archivos / CGIs.

Está escrito por Chris Solo y David Lodge para la evaluación de vulnerabilidades, comprueba versiones no actualizadas sobre 1250 servidores web y más de 250 problemas específicos de versión. También escanea e informa sobre software y plugins del servidor web obsoletas.

Maligno es una herramienta de pruebas de penetración de código abierto que sirve cargas útiles Metasploit. Genera código shell con msfvenom y la transmite a través de HTTP o HTTPS. El código shell se cifra con AES y se codifica con Base64 antes de la transmisión.

Esta es una colección de herramientas que pueden ser útiles para usted, si usted es un pentester o consultor de seguridad. Todo el código fuente publicado en este sitio web está licenciado bajo la licencia FreeBSD.

Utilice el software a su propio riesgo.