Scripts Avanzados: Un script para manejar básicamente iptables

Y otra vez, hemos vuelto. Ésta vez, os mostraré un script para manejar funcionalidades básicas de IPTABLES. El objetivo de éste script, aparte de manejar IPTABLES, es el de enseñar el su uso, dado que cada vez que lo usemos, hará una traducción de lo que escribimos a lo que hace iptables, de modo que poco a poco nos iremos quedando con el funcionamiento de IPTABLES.

También se puede usar para aprender a hacer scripts en consola, ya que en él aparecen prácticamente todos los mandatos de la consola.

Aunque claro está, también puede usarse para no tener que aprender IPTABLES ;)

Script:

#!/bin/bash
# ########################
# IAL Script versión 2.5
#    Daniel Perella
# ########################
complete_rule=iptables
part_rule=

function _aplicar
{
  echo -e "Aplicar $part_rule a $complete_rule? (s/n)"
  read a
  if [[ $a = "s" ]]
  then
      complete_rule=$(echo $complete_rule $part_rule)
      echo regla:$complete_rule
  else
      echo regla:$complete_rule
  fi
}

function asistente # asistente: Ejecuta un asistente guiado para añadir una regla
{

  echo "añadir o quitar norma?"
  echo "añadir | quitar [INPUT|OUTPUT|FORWARD]"
  echo -e "que hacer)\c"
  read aa
  $aa

  echo "protocolos admitidos: tcp udp icmp all"
  echo -e "protocolo)\c"
  read pro
  protocolo "$pro"

  echo "seleccione política"
  echo "acciones: aceptar | rechazar | ignorar "
  echo -e "accion)\c"
  read ac
  $ac

  echo "direccion: origen | destino [IP o host]"
  echo -e "direccion)\c"
  read di
  $di

  if test  $pro = "tcp" -o  $pro = "udp"
  then
      echo "puerto al que aplicar la norma"
      echo -e "puerto)\c"
      read pu
      puerto $pu
  fi

  echo "Puede Aplicar la norma ahora o añadir"
  echo "más propiedades en éste mismo CLI" 
  echo -e "Aplicar la norma ahora (s/n)?\c"
  read ap
  if [[ $ap = "s" ]]
  then
      aa=$(echo $aa | cut -d " " -f 1)
      if [[ $aa = "añadir" ]]
      then
          ejecutar
      else
          echo -e "Desea borrar ésta norma?? (s/n)?\c"
          read bbb
          if [[ $bbb = "s" ]]
          then
              ejecutar
          else
              echo "No Borrada"
          fi
      fi
  else
      echo "Use la ayuda para ver que propiedades"
      echo "tiene disponibles"
      echo " "
  fi

}

function añadir # añadir [INPUT|OUTPUT|FORWARD]: Añade al tipo de Norma
{
  echo "-A"
  part_rule="-A $1"
  _aplicar
}

function quitar # quitar [INPUT|OUTPUT|FORWARD]
{
  echo "-D"
  part_rule="-D $1"
  _aplicar
}

function protocolo # protocolo [tcp|udp|icmp|all]: Añade un tipo de protocolo
{
  echo "-p $1"
  part_rule="-p $1"
  _aplicar
}

function puerto # puerto [n]: Define el puerto de la norma
{
  echo Puerto: $1
  part_rule="--dport $1"
  _aplicar
}

function aceptar # aceptar: Aplica la norma ACCEPT a los paquetes
{
  echo "-j ACCEPT"
  part_rule="-j ACCEPT"
  _aplicar
}

function rechazar # rechazar: Aplica la norma REJECT a los paquetes
{
  echo "-j REJECT"
  part_rule="-j REJECT"
  _aplicar
}

function ignorar # ignorar: Aplica la norma DROP a los paquetes
{
  echo "-j DROP"
  part_rule="-j DROP"
  _aplicar
}

function interfaz # interfaz [ethn] Define el interfaz para la norma
{
  echo "-i $1"
  part_rule="-i $1"
  _aplicar
}

function numero # numero [n]: Define el número de norma (útil para borrar)
{
  echo "-I $1"
  part_rule="-I $1"
  _aplicar
}

function origen # origen [IP o HOST]: Define el origen del paquete para la norma
{
  echo "-s $1"
  part_rule="-s $1"
  _aplicar
}

function destino # destino [IP o HOST] Define el destino del pquete de la norma
{
  echo "-d $1"
  part_rule="-d $1"
  _aplicar
}

function normas # normas: Hace un listado de las normas existentes
{
  echo "Norma que está siendo editada"
  echo $complete_rule
  echo "Ultima parte aplicada o no a la norma"
  echo $part_rule
  echo " "
  echo " " 
  i=$(whoami)
  if [[ $i != "root" ]]
  then
      echo "No eres root, no se puede hacer iptables"
  else
      iptables -n -L
  fi 

}

function nueva # nueva: Empieza a hacer una norma nueva
{
  complete_rule="iptables"
  part_rule=""
  echo "Nueva norma iniciada"
}


function ejecutar # ejecutar: Aplica la norma
{
  echo "Aplicando norma: $complete_rule"
  $complete_rule
  echo "Hecho"
}

function guardar # guardar Volca en un archivo las normas
{
  echo "Guardar normas en fichero"
  if test -n $1
  then
      nom=$1
  else 
      echo -e "nombre del fichero)\c"
      read nom
  fi
  iptables-save > $nom
  echo "Guardado como $nom"
}

function cargar # cargar Lee un fichero de normas y lo aplica
{
      echo "Cargar Normas IPTABLES"
  if test -n $1
  then
      nom=$1
  else
      echo -e "nombre del fichero)\c"
          read nom
  fi
      cat $nom | grep "-" | grep -v "#" | while read lin
      do
              echo -e "Cargando: $lin\r\c"
              complete_rule=$(echo $complete_rule $lin)
              ejecutar
              nueva
      done;
}

function vaciar # vaciar [INPUT|OUTPUT|FORWARD] Vacia del todo un juego de normas
{
  if test -n $1
  then
          iptables -F $1
          echo Normas de $1 Limpio
  else
      echo "Vaciar Normas de: INPUT OUTPUT FORWARD"
      echo -e "normas)\c"
      read nor
      iptables -F $nor
      echo Normas de $nor Limpio
  fi
}

function _backup
{
  guardar backup_normas
}

function _restore
{
  cargar backup_normas
}
  # exit 0 : sale del script

case $1 in

  --directo|-d)
      $2 $3 $4 $5 $6 $7 $8 $9 
  ;;
  --backup|-b)
      _backup
  ;;
  --restore-backup|-r)
      _restore
  ;;
  *)
      while [[ $? ]]
      do 
          i=$(whoami)
          if [[ $i != "root" ]]
          then
              echo "No eres root, no se aplicará ningún cambio"
          fi 
          echo "Use: ayuda"
          echo -e "root)\c"
          read rul
          if [[ $rul = "ayuda" ]]
          then
               cat blacklist.sh | grep "#" | grep -v "grep" | grep -v "_" | grep -v "bash" | cut -d "#" -f 2
            
          else
              $rul
          fi
      done;
  ;;
esac

_backup

Uso:

Ejecutaremos el script con permisos de root y accederemos a su consola. Podemos usar la orden "ayuda" para obtener ayuda acerca de las funciones que podemos usar.

La idea es ir completando una variable con las posibles opciones que podemos usar en iptables, claro está, el script nos dice en cada momento lo que podemos introducir. Después ésa variable se le pasa a IPTABLES y es aplicada.

Para empezar, podemos usar la órden "asistente" y cuando cojamos soltura iremos probando las funciones sueltas.

Si tenéis dudas, ya sabéis donde estamos!

Suerte