Adiciona / apaga o ip da estação de trabalho em / etc / sysconfig / iptables e depois executa o recarregamento do serviço iptables

Question

Eu preciso de um script para adicionar um ip de estação de trabalho de usuários a /etc/sysconfig/iptables e, em seguida, executar um service iptables reload . Eu preciso do mesmo tipo de script para remover esta regra do iptables.

Encontrei o código abaixo em um fórum diferente.
É um pouco o que preciso fazer. Inclui opções add e remove , mas em vez de adduser ele precisa refletir a regra do iptable como iptables -I INPUT 1 -p tcp -s xxx.xxx.xx.xxx --dport 22 -m comment --**comment "testing for user1" -j ACCEPT .

O próprio endereço IP precisa ser passado como um parâmetro, para que eu possa executar como% ./script 155.154.15.00

Estou usando o RHEL versão 6.4.
Qualquer feedback é apreciado.

#!/bin/bash

clear
  echo "########## MENU ############\n"
  options=("add_user" "delete_user" "exit")
  select opt in "${options[@]}"
  do
    case $opt in
    "add_user")
      clear
      while [ 1 ]
      do
        clear
        echo "1. Add user manually"
        echo "2. Add user via TXT file"
        read -p "Enter your choice" ch
        case $ch in 
          1)
            read -p "Enter user name : " useradd
            read -p "Enter user password:" passwd
            echo -e "Successfully added the user"
          ;;
          2)
          if [ $(id -u) -eq 0 ]; then
            for row in 'more $1'
            do
              username=${row%:*}
              password=${row#*:}    
              egrep "^$username" /etc/passwd >/dev/null
              if [ $? -eq 0 ]; then
                echo "$username exists!"
                exit 1
              else
                pass=$(perl -e 'print crypt($ARGV[0], "password")' $password)
                useradd -m -p $pass $username
                [ $? -eq 0 ] && echo "User has been added to system!" || echo "Failed to add a user!"    
              fi
            done
          else
            echo "Only root may add a user to the system"
            exit 2
          fi    
        esac  
      done
    ;;
    "delete_user")
      read -p "Enter a User name to delete "UNAME
      passwd
      userdel $UNAME
      echo "User $UNAME has been deleted"            
    ;;
    "exit")
      break
    ;;
    esac
  done

    

Answer 1

Eu lidei com isso de forma um pouco diferente. Eu mantenho uma configuração estática do iptables que pula para cadeias especiais (inicialmente vazias).

Eu atualizo essas cadeias especiais de forma assíncrona através de um cron job. Você poderia fazer loop em uma fonte de dados secundária que tenha apenas os endereços IP / nomes de host e libera e atualiza a cadeia a cada N minutos (ou melhor, não libere e exclua as regras obsoletas ...)

Isso isola um pouco o iptables do seu sistema reduzindo o escopo do que sua automação está editando.

Observação: você pode editar as regras ativas de duas maneiras:

 -D, --delete chain rule-specification
 -D, --delete chain rulenum
              Delete  one or more rules from the selected chain.  There are two versions of this command: the rule can be specified as a num-
              ber in the chain (starting at 1 for the first rule) or a rule to match.

Se você usar o número da regra, despeja as regras e escolha o número da regra com base no seu número. NOTA! Isso tem uma condição de corrida inerente! Se você especificar especificação de regra, basta especificar todos os parâmetros que a regra possui e ela será selecionada para exclusão.

    

Answer 2

Não há ferramentas exatas e comparáveis para adicionar ou remover uma única regra do conjunto de regras iptables .

Pessoalmente, eu usaria iptables-save para emitir o conjunto de regras atual para um arquivo temporário e você poderá modificá-lo usando ferramentas como awk ou grep (por exemplo, use grep -v "$WORKSTATION_IP" para remover qualquer duplicata em potencial já existente e, em seguida, cat "$NEWRULE" >> $TMPFILE para anexar a nova regra) e, em seguida, use iptables-restore para enviar o conjunto de regras atualizado.

Não tenho certeza se service iptables restart é necessário após uma restauração. Eu não esperava, mas a página man não é explícita, então eu experimentei.

Você poderia escrever funções que simulam o que você quer. Talvez algo como:

function add_iptables_rule {
    cat <(iptables-save) <(echo "$@") | iptables-restore
}

function del_iptables_rule {
    iptables-save | grep -v "$@" | iptables-restore
}

Automatizar isso é muito arriscado, no entanto. Tenha muito cuidado para testar completamente. Eu começaria com iptables-save > /etc/iptables.backup para que você sempre possa voltar à estaca zero.

Eu gosto da ideia de aumentar essa abordagem usando cadeias de regras separadas, como sugerido por @rrauenza em uma resposta separada para limitar o escopo de sua automação. Menos para dar errado.

REFERENCES link
link

    

Answer 3

Aqui o container de forma simplificada ... Você precisa preencher o código que você quer

#!/bin/bash 
#
# ----------------------------------------------------------------------- #
#   Here below it prints the help function                                #
#   Each time in printf                                                   #
#     (-) "\n" is a newline                                               #
#     (-) "\t" is tab (some spaces)                                       #
#   $0 is the the name that you give to the script                        #
#   $1 is the 1st parameter passed to script or function. In this case:   #
#     (+) Out of any function $1 is the 1st parameter given to the script #
#     (+) Inside a function $1 is the 1st given to the function           #
#                                                                         #
# ------------------------- # ------------------------------------------- #
                            #                                             #
Print_Help(){               #  Here it starts the function Print_Help()   #
    printf  "\n$1\n\n"      #  Here you are inside a function and $1 is   #
    printf  "SYNOPSIS \n"   #   the 1st parameter given to the function   #
                            #------------------------#                    #
    printf  "\t $0 [OPTION] [IP]\n\n"                # ------------------ #
    printf  "\t $0 -a 127.0.0.1   # to add     \n"   # <- hash(#) chars   #
    printf  "\t $0 -r 127.0.0.1   # to remove\n\n"   # <-   out of the    #
}                           #     ^                  #    "double quote"  #
                            # --- | ---------------- #  ----------------- #
                            #     +-- those hash(#) chars are inside the   #
                            #         "double quote" and they will be      #
                            #          printed as normal letters.          #
                            # ------------------------------------------- # 

Add_Function(){
  echo $IP #  Put here the code to add rule
  #  iptables -I INPUT 1 -p tcp -s $IP --dport 22 -m comment --**comment "testing for user1" -j ACCEPT.
  service iptables reload  # you need to run as root (or with sudo) 
  exit 0
}

Remove_Function(){
  echo $IP  #  Put here the code to remove rule
  service iptables reload  # you need to run as root (or with sudo)
  exit 0 
}

if [[  $# != 2 ]] ;then #if the number of parameter is not 2
   #  Here we call the help function with 
   #+ "a single parameter in double quote" in this case:
   #+ "Error wrong number of parameters for $0"  
    Print_Help "Error wrong number of parameters for $0"
    exit 1
fi

IP=$2
if [[ "$1" == "-a" ]] ; then  Add_Function  ; fi
if [[ "$1" == "-r" ]] ; then  Remove_Function  ; fi
# Here below we call again the help function with 
# "another single parameter in double quote" in this case
# "Error Unknown option $1 for $0 "  
# In the "main" $1 is the 1st parameter that you pass to the script
 Print_Help "Error Unknown option $1 for $0 "  
exit 2    

Este é apenas um exemplo para se familiarizar com o shell script e as seleções. Você pode executá-lo com uma linha de comando como sudo /bin/bash script.sh -a nnn.mmm.ooo.ppp ou -r , onde nnn.mmm.ooo.ppp é o IP que você deseja usar. Se você alterar a permissão (por exemplo, chmod u+x script.sh ), poderá executar com sudo ./script.sh -a nnn.mmm.ooo.ppp .

Você tem que preencher a função com o código que você precisa.
Você pode adicionar outras funções relativas a outras opções. Nesse caso, talvez seja mais limpo usar a construção case ... esac , como no código proposto por Cristopher, que inclui alguns recursos que você achará úteis ao concluir a fase de teste. A partir do cheque para ver se o script é executado pelo root, em um shell interativo ou não, para decidir onde redirecionar mensagens, a definição da data atual ... Comece verificando o que você precisa e adicione todos os opcionais < Passo a passo.

Atualizar
De man bash você pode obter muitas dicas interessantes. Da seção COMENTÁRIOS:

COMMENTS
In a non-interactive shell, or an interactive shell in which the interactive_comments option to the shopt builtin is enabled (see SHELL BUILTIN COMMANDS below), a word beginning with # causes that word and all remaining characters on that line to be ignored. An interactive shell without the interactive_comments option enabled does not allow comments. The interactive_comments option is on by default in interactive shells.

Da seção QUOTING:

...
Words of the form $'string' are treated specially. The word expands to string, with backslash-escaped characters replaced as specified by the ANSI C standard. Backslash escape sequences, if present, are decoded as follows:

         ...
         **\n     new line**  
         **\t     horizontal tab**  
         \v     vertical tab  
         \     backslash  
         \'     single quote  
         \"     double quote  
         ...

    

Answer 4

Aqui está outro protótipo para um script BASH que possui opções e argumentos, e outros recursos modelados. Não é perfeito, talvez um erro de digitação ou dois, mas espero que ajude um pouco.

#!/usr/bin/env bash
if [[ $EUID -ne 0 ]]; then
    echo "This script must be run as root" 1>&2
    exit 1
fi

variable_1="value"
readonly variable_2="value"

# Example: Backticks vs. parentheses: in general parentheses are preferred.
#
hostname='hostname -s'
date=$(date +%Y%m%d)

# Determine if the script is running interactively.
# PS1 (the prompt) is not present in non-interactive shells, like cron.
# On [ ] vs [[ ]] : http://mywiki.wooledge.org/BashFAQ/031
# Initialize a Boolean variable as true or 1.
b_interactive=1
if [[ -v PS1 ]] ; then # "The "-v PS1" method is for BASH 4.2+.
    b_interactive=0    # Could also use [[ -z "$PS1" ]]
fi

# Send messages to console or syslog...
function notify() {
    message=$1
    if [[ $b_interactive -eq 1 ]] ; then
        echo "$message"
    else
        # eval combines args for execution and returns an exit code.
        eval logger -p err "$0: $message"
    fi
}

function add() {
    eval /bin/true # put your actual command here instead of /bin/true
    exit_code=$? # Save exit code before running another command.

    if [[ $exit_code -eq 0 ]] ; then
        notify "The process succeeded.";
    else
        notify "The process failed.";
    fi
}

function delete() {
    // commands similar to those in add()
}

function verify() {
    // commands similar to those in add()
}

function version() {
    echo "$0 Version 1.0"
}

function usage() {
    echo "Usage: $0"
    echo "[-a,--add <IP address> | -d,--delete <IP address> | -v,--verify <IP address>]"
    echo "[-h,--help]"
    echo "[-v,--version]"
}

# Parse command-line. The $1 refers to the first value passed the script.
b_need_arg=0
case "$1" in
    -a|--add)
        function=add
        b_need_arg=1 # -a|--add parameter needs and argument
        ;;
    -d|--delete)
        function=delete
        b_need_arg=1 # -d|--delete parameter needs an argument
        ;;
    -m|--verify)
        function=verify
        b_need_arg=1 # -v|--verify parameter needs an argument
        ;;
    -v|--version)
        function=version
        ;;
    -h|--help)
        function=usage
        ;;
     *)
        notify "Error: unknown parameter: '$1'."
        if [[ $b_interactive -eq 1 ]] ; then
            function=usage
            exit 2
        else
            # If we are here, the use is non-interactive.
            # A syslog message has been generated. Exit.
            # http://tldp.org/LDP/abs/html/exitcodes.html
            exit 2
        fi
        ;;
esac

if [[ $b_need_arg -eq 1 ]] ; then
    if [[ -z $2 ]] ; then
        # Could do argument checks here too.
        notify "Error: option '$1' requires an argument."
        usage
        exit 2
    fi
fi

# Execute the function specified by the command-line switch.
${function} $2

unset b_interactive
unset variable_1
unset variable_2
unset hostname
unset date