Mostrando entradas con la etiqueta Webserver. Mostrar todas las entradas
Mostrando entradas con la etiqueta Webserver. Mostrar todas las entradas

evomalware.sh

d
Nombre: evomalware.sh
autor: benpro@benpro.fr
Permite detectar virus, backdoors y malware especialmente en archivos PHP.
Visto en: evoforge

#!/bin/bash
# EvoMalware, script to detect infected websites.

# You can set aggressive to true to search for suspicions scripts.
aggressive=false
# Path to search for.
wwwpath=/home
# URL to download patterns and filenames.
databaseURL="http://antispam00.evolix.org/evomalware"
databasePATH=/var/lib/evomalware
# Tools.
find="ionice -c3 find -O3"
grep="nice -n 19 grep"
wc="nice -n 19 wc"
wget="wget -q -t 3"
md5sum="md5sum --status -c"
# Various.
fileslist=$(mktemp)
tmpPATH=/tmp/evomalware.tmp

trap "rm -rf $fileslist $tmpPATH" EXIT

usage() {
    cat< $fileslist 2>/dev/null
while read file; do
    # Search known filenames.
    if [[ "$file" =~ $filenames ]]; then
        echo "Known malware: $file"
    # Search .php files in WP's wp-content/uploads/
    elif [[ "$file" =~ "wp-content/uploads/" ]]; then
        echo "PHP file in a non-PHP folder detected: $file"
    # Count the length of the longest line and search if suspect php functions are used.
    elif [[ $($wc -L "$file" 2>/dev/null | cut -d' ' -f1) -gt 10000 ]]; then
        grep -q -E "$suspect" "$file"
        if [[ $? -eq 0 ]]; then
            echo "Suspect file! More than 10000 characters in one line (and suspect PHP functions): $file."
        fi
    else
        # Search for patterns.
        $grep -H -E -r -l -q "$patterns" "$file" 2>/dev/null
        if [[ $? -eq 0 ]]; then
            echo "Contains a known malware pattern: $file"
        fi
    fi
done < $fileslist

# Search for suspicious scripts... Only when in aggressive mode.
if ( $aggressive ); then
    cd $wwwpath
    $find . -name javascript.php
    $find . -name bp.pl
    $find . -name tn.php
    $find . -name tn.php3
    $find . -name tn.phtml
    $find . -name tn.txt
    $find . -name xm.php
    $find . -name logs.php
    $find . -type f -name "*.php" -exec sh -c 'cat {} | awk "{ print NF}" | sort -n | tail -1 | tr -d '\\\\n' && echo " : {}"' \; | sort -n | tail -10
    $find . -type f -name "*.php" -exec sh -c 'cat {} | awk -Fx "{ print NF}" | sort -n | tail -1 | tr -d '\\\\n' && echo " : {}"' \; | sort -n | tail -10
    $grep -r 'ini_set(chr' .
    $grep -r 'eval(base64_decode($_POST' .
    $grep -r 'eval(gzinflate(' .
    $grep -r 'ini_set(.mail.add_x_header' .
    $grep -r '@require' .
    $grep -r '@ini_set' .
    $grep -ri 'error_reporting(0' .
    $grep -r base64_decode .
    $grep -r codeeclipse .
    $grep -r 'eval(' .
    $grep -r '\x..\x..' .
    $grep -r 'chr(rand(' .
fi

Leer más...

apache_access_stats.sh

d
Nombre: apache_access_stats.sh
Autor: @linuxitux
Tomado de Linuxito
#!/bin/bash

# apache_access_stats.sh
#
#     Muestra un gráfico de accesos por hora a un servidor Apache a partir de un archivo
#     de log de accesos
#

mensaje="Muestra un gráfico de accesos por hora a un servidor Apache a partir de un archivo de log de
accesos."

# Variables
ancho=50

if [ $# -lt 1 ]
then
        printf "Uso: $0 ARCHIVO\n$mensaje\n"
        exit 1
fi

# Defino un arreglo de horas desde 0 a 23
hs=(0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)

# Contabilizo la cantidad de accesos por cada hora
for h in $(cat $* | cut -d '[' -f2 | cut -d "]" -f1 | cut -d ' ' -f1 | cut -d ':' -f2 | sed 's/^0//')
do
        (( hs[$h]++ ))
done

# Calculo la máxima cantidad de accesos
max=0
for h2 in ${hs[@]}
do
        if [ "$h2" -gt "$max" ]
        then
                max=$h2
        fi
done

# Calculo la longitud de caracteres del máximo
longitud=${#max}

# Imprimo el gráfico
echo "HORA (ACCESOS)"
hora="0"
for h3 in ${hs[@]}
do
        # Para cada hora
        # Calculo la cantidad de numerales a imprimir
        c=$(( h3 * ancho / max ))

        # Imprimo la hora con formato "HH:MM"
        if [ $hora == "0" ]
        then
                printf " 0"
        else
                printf "%2.i" "$hora"
        fi
        printf ":00"

        # Imprimo la cantidad de accesos
        printf " (%$longitud.i) " "$h3"

        # Imprimo los numerales
        for (( i=0; i<$c; i++ ))
        do
                printf "#"
        done
        echo

        # Siguiente hora
        (( hora++ ))
done
Leer más...

apache2-vhosts.sh

d
Nombre: apache2-vhosts.sh
Autor: @Tonejito
Descripción: List Apache httpd VirtualHost entries
#!/bin/bash
 
for bin in which apache2ctl grep awk sort
do
  if [ ! -x "`which $bin`" ]
  then
    exit 1
  fi
done
 
apache2ctl -S 2>/dev/null | grep vhost | awk '{print $4}' | sort -u
Leer más...

File Watcher

d
Funcionamiento de script: El script crawlea un directorio y guarda en una "base de datos" (en este caso un diccionario serializado) la ruta de los archivos y sus respectivos hash md5. Para comprobar si un archivo a sido modificado, simplemente se compara su hash md5 con el que está en la BD y obviamente si el archivo no se encuentra en la BD es porque fue creado despues. 

Además indica los archivos de backup (.*~) que encuentra.

Autor: 11sept



    # -*- coding: utf-8 -*-
     
    #11Sep
     
    import os
    import sys
    import hashlib
    import cPickle
     
    recursividad = False
    diccionario = {}
    COLORES = {
        "archivo": "\033[91m\t[Archivo nuevo] %s\033[0m",     # Rojo
        "carpeta": "\033[94m\t[Carpeta nueva] %s\033[0m",     # Azul
        "modificado": "\033[93m\t[Modificado] %s\033[0m",     # Amarillo
        "backup": "\033[91m\t[BACKUP] %s\033[0m",             # Rojo
    }
     
    MENU = """Modo de uso:
    %s ruta [parametros]
     
    -r          Modo recursivo
    -a          Actualiza la BD
    -v          Para ver archivos y hashes
    """
     
     
    def imprimir(data, color):
        if its_linux:
            print COLORES[color] % data
        else:
            print data
     
    def es_archivo(ruta):
        if os.path.isfile(ruta):
            return True
     
    def es_directorio(ruta):
        if os.path.isdir(ruta):
            return True
     
    def guardar():
        with open("./data.sf", "wb") as archivo:
            cPickle.dump(diccionario, archivo, 2)
     
    def cargar():
        global diccionario
        try:
            with open("./data.sf", "rb") as archivo:
                diccionario = cPickle.load(archivo)
            return True
        except:
            return False
     
    def get_md5(ruta):
        md5 = hashlib.md5()
        with open(ruta, "r") as hash:
            for linea in hash.readlines():
                md5.update(linea)
        return md5.hexdigest()
     
    def recorrer(path, opt):
        if es_directorio(path):
           
            if not diccionario.has_key(path):
                diccionario[path] = {}
                imprimir(path, "carpeta")
           
            archivos = os.listdir(path)
           
            for archivo in archivos:
                ruta_completa = os.path.join(path, archivo)
                if es_archivo(ruta_completa):
                    extension = os.path.splitext(ruta_completa)[1]
                    if extension.endswith("~"):
                        imprimir(ruta_completa, "backup")
                   
                    if opt == 1:
                        diccionario[path][archivo] = get_md5(ruta_completa)
                    else:
                        md5 = get_md5(ruta_completa)
                        md5_bd = diccionario[path].get(archivo)
                        if md5_bd:    
                            if md5_bd != md5:
                                imprimir(ruta_completa, "modificado")
                        else:
                            imprimir(ruta_completa, "archivo")
     
                elif es_directorio(ruta_completa) and recursividad:
                    recorrer(ruta_completa, opt)
     
    its_linux = (os.name == "posix")
     
    argumentos = sys.argv
    if len(argumentos) > 1:
        parametros = []
        ruta = argumentos[1]
        parametros = argumentos[2:]
       
        if "-r" in parametros:
            recursividad = True
       
        if not es_directorio(ruta):
            print "Ruta no valida"
            exit()
        else:
            if "-a" in parametros:
                diccionario = {}
                recorrer(ruta, 1)
                guardar()
                exit()
            if cargar():
                recorrer(ruta, 2)
            else:
                recorrer(ruta, 1)
                guardar()
       
        if "-v" in parametros:
            for x, y in diccionario.iteritems():
                print x
                for archivo, hash in sorted(y.iteritems()):
                    print "\t", archivo, hash
           
    else:
        print MENU % os.path.split(argumentos[0])[-1]

Las opciones son:

-v: para ver la BD de los archivos y hashes md5
-a: para actualizar la BD
-r: para recorrer las carpetas en modo recursivo










Regards,
Snifer  

Fuente: Underc0de
Leer más...

Script para verificar estado de los servicios.

d
Autor: @D4nnR
Descripción: El script muestra si el servicio HTTPD, MYSQL Y POSTFIX se encuentran en ejecución o si están parados.
Visto en: Por un servidor seguro :)
#!/bin/sh


#Verificar estados servicios SOLAMENTE... 


echo "///////////////////////////////////////////////////"


echo "Comprobando servicio WEB"


SERVICE='httpd'


if ps ax | grep -v grep | grep $SERVICE > /dev/null


then


echo "El servicio $SERVICE esta ejecutandose :)"


else


echo "¡¡ Cuidado !! El servicio $SERVICE esta DETENIDO x("


fi


echo "///////////////////////////////////////////////////"


echo "Comprobando servicio MYSQL"


SERVICE2='mysqld'


if ps ax | grep -v grep | grep $SERVICE2 > /dev/null


then


echo "El servicio $SERVICE2 esta ejecutandose :)"


else


echo "¡¡ Cuidado !! El servicio $SERVICE2 esta DETENIDO x("


fi


echo "///////////////////////////////////////////////////"


echo "Comprobando servicio de CORREO"


SERVICE3='postfix'


if ps ax | grep -v grep | grep $SERVICE3 > /dev/null


then


echo "El servicio $SERVICE3 esta ejecutandose :)"


else


echo "¡¡ Cuidado !! El servicio $SERVICE3 esta DETENIDO x("


fi


echo "By Daniel Romo - www.PorunServidorSeguro.com"
Leer más...

Monitoreo de Espacio en Disco

d
Muy útil si no se tiene instalado el plugin en Nagios.
Autor: nixcraft
Visto en: nixcraft
#!/bin/sh
# Shell script to monitor or watch the disk space
# It will send an email to $ADMIN, if the (free avilable) percentage 
# of space is >= 90% 
# -------------------------------------------------------------------------
# Copyright (c) 2005 nixCraft project 
# This script is licensed under GNU GPL version 2.0 or above
# -------------------------------------------------------------------------
# This script is part of nixCraft shell script collection (NSSC)
# Visit http://bash.cyberciti.biz/ for more information.
# ----------------------------------------------------------------------
# Linux shell script to watch disk space (should work on other UNIX oses )
# SEE URL: http://www.cyberciti.biz/tips/shell-script-to-watch-the-disk-space.html
# set admin email so that you can get email
ADMIN="me@somewher.com"
# set alert level 90% is default
ALERT=90
df -H | grep -vE '^Filesystem|tmpfs|cdrom' | awk '{ print $5 " " $1 }' | while read output;
do
  #echo $output
  usep=$(echo $output | awk '{ print $1}' | cut -d'%' -f1  )
  partition=$(echo $output | awk '{ print $2 }' )
  if [ $usep -ge $ALERT ]; then
    echo "Running out of space \"$partition ($usep%)\" on $(hostname) as on $(date)" | 
     mail -s "Alert: Almost out of disk space $usep" $ADMIN
  fi
done
Leer más...

Controlar la cantidad de peticiones de una IP hacia el puerto 80

d
Visto en soyadmin
#!/bin/sh
# Comando que realiza el reastreo
nroconn=`netstat -nap |grep “:80″ | awk ‘{print $5}’ | cut -d: -f1 | sort | uniq -c | sort -n | awk ‘{print $1}’ | tail -1`

# Comando que nos devolverá la ip
ip=`netstat -nap |grep “:80″ | awk ‘{print $5}’ | cut -d: -f1 | sort | uniq -c | sort -n | awk ‘{print $2}’ | tail -1`

# Limite a superar para informar, esto se puede variar según las necesidades de cada server
limite=100
if [ $nroconn -gt $limite ]; then
mensaje=”Atencion! la IP $ip tiene $nroconn conexiones activas”

# Realizamos el whois sobre la IP
infor=`whois $ip | grep country`
whois=`whois $ip`

# Generamos el correo
mailto=”"
cc_to=”"
bcc_to=”"
while read direccion mode
do
if [ -z "$direccion" -o "${direccion:0:1}" = "#" ] ; then continue; fi
if [ "x$mode" = "xcc" -o "x$mode" = "xCC" ] ; then
cc_to=${cc_to:+${cc_to},}$direccion
else
if [ "x$mode" = "xbcc" -o "x$mode" = "xBCC" ] ; then
bcc_to=${bcc_to:+${bcc_to},}$direccion
else
mailto=${mailto:+${mailto},}$direccion
fi
fi

# Llamamos al archivo donde guardamos las direcciones de correo
done <~/emails
mailto=${mailto:-operator}
cc_to=${cc_to:+"-c $cc_to"}
bcc_to=${bcc_to:+"-b $bcc_to"}
mail ${cc_to} ${bcc_to} -s "Alerta OJO Muchas conexiones SERVER: (nombre de servidor)" ${mailto} >&2 <<-EOM
$mensaje
Dicha IP es de: $infor
WHOIS de $ip
$whois
EOM
fi
Leer más...

Bash Website Backup Script

d
Nombre: backup-sitename.sh
Descripción: Script que permite realizar un backup de un sitio web
Más información del Script en loneshooter
#!/bin/sh
 
# Cron job runs with:
# bash /home/account/backup/backup-sitename.sh
 
SITEDIRNAME="sitename"
DBNAME="account_dbname"
DBUSER="account_name"
DBPASS="password"
BASEBCKPPATH="/home/account/backup"
DATE=$(date -I)
DESTINATIONDIR="$BASEBCKPPATH/$DATE/$SITEDIRNAME" #e.g. /home/account/backup/2012-07-29/sitename
ERRORLOG=$DESTINATIONDIR/error.log
 
# Delete all previous backups
if [ -d "$DESTINATIONDIR" ]; then
  rm -rf $DESTINATIONDIR
fi
 
# Create backup directory if it doesn't exist, e.g. /home/account/backup/2012-07-29/sitename
if [ ! -d "$DESTINATIONDIR" ]; then
  mkdir -p $DESTINATIONDIR
fi
 
# Backup site folder
tar -czf $DESTINATIONDIR/${SITEDIRNAME}_${DATE}.tgz -C /home/account/addon ./$SITEDIRNAME 2> $ERRORLOG
 
# Backup site database
mysqldump -u $DBUSER -p$DBPASS -h localhost $DBNAME| gzip -9 > $DESTINATIONDIR/${DBNAME}_${DATE}.sql.gz 2> $ERRORLOG
Leer más...

Webinstall.sh

d
Descripción: Shell Script to install dependencies for running PHP applications with mod_fcgi
Autor: Finn Hensner
Nombre: webinstall.sh




#!/bin/bash
# Shell script to install LAMP with dependencies for running PHP applications
# with mod_fcgi
# -------------------------------------------------------------------------
# Version 1.1 (August 18 2011)
# -------------------------------------------------------------------------
# Copyright (c) 2011 Finn Hensner 
# This script is licensed under GNU GPL version 2.0 or above
# -------------------------------------------------------------------------
apt-get update
aptitude install apache2 apache2-suexec libapache2-mod-fcgid php5-cgi
a2dismod php5
a2enmod rewrite
a2enmod suexec
a2enmod include
a2enmod fcgid

apt-get install mysql-server
apt-get install php5-gd
apt-get install php5-common php5-mysql

sleep 1
echo "Adding extensions and fixes to custom ini"
cat > /etc/php5/conf.d/custom.ini << EOF
cgi.fix_pathinfo = 1
extension=gd2.so
extension=pdo.so
extension=pdo_mysql.so 
extension=php_pgsql.so
extension=php_pdo_pgsql.so
EOF

sleep 1
echo "Add server name to Apache config"
echo "ServerName 127.0.0.1" >> /etc/apache2/apache2.conf

sleep 1
echo "Installing ProFTPd server"
apt-get purge proftpd
apt-get install proftpd
#jail users in their home directory
echo -e "\nDefaultRoot ~\n" >> /etc/proftpd/proftpd.conf

sleep 1
echo "Removing default virtual host."
rm /etc/apache2/sites-available/default
rm /etc/apache2/sites-enabled/default-000

sleep 1
echo "Restarting apache2 and proftpd"
service apache2 restart
service proftpd restart
Leer más...

Script Bash para listar correo de servidor POP3

d
Autor: efollana
Descripción: Script Bash para listar correo de servidor POP3

 #!/bin/bash
 # Configuracion de la cuenta
IP=192.168.0.1
PORT=110
MAIL_ADDRESS=pruebas@gmail.com
PASSWORD=1234
 cat < < EOF | netcat
$IP $PORT user $MAIL_ADDRESS pass $PASSWORD list EOF

  Fuente
Leer más...

Shell Script para analizar Access.log

d
Nombre: webaccess.bash
Autor: Desconocido
Descripción: Script que genera una serie de estadísticas útiles, habida cuenta de un archivo de registro de formato de Apache access_log.
Visto en Linux Party
#!/bin/bash

# webaccess - analyze an Apache-format access_log file, extracting
# useful and interesting statistics

bytes_in_gb=1048576
scriptbc="$HOME/bin/scriptbc"
nicenumber="$HOME/bin/nicenumber"
host="intuitive.com"

if [ $# -eq 0 -o ! -f "$1" ] ; then
echo "Usage: $(basename $0) logfile" >&2
exit 1
fi

firstdate="$(head -1 "$1" | awk '{print $4}' | sed 's/[//')"
lastdate="$(tail -1 "$1" | awk '{print $4}' | sed 's/[//')"

echo "Results of analyzing log file $1"
echo ""
echo " Start date: $(echo $firstdate|sed 's/:/ at /')"
echo " End date: $(echo $lastdate|sed 's/:/ at /')"

hits="$(wc -l < "$1" | sed 's/[^[:digit:]]//g')"

echo " Hits: $($nicenumber $hits) (total accesses)"

pages="$(grep -ivE '(.txt|.gif|.jpg|.png)' "$1" | wc -l | sed 's/[^[:digit:]]//g')"

echo " Pageviews: $($nicenumber $pages) (hits minus graphics)"

totalbytes="$(awk '{sum+=$10} END {print sum}' "$1")"

echo -n " Transferred: $($nicenumber $totalbytes) bytes "

if [ $totalbytes -gt $bytes_in_gb ] ; then
echo "($($scriptbc $totalbytes / $bytes_in_gb) GB)"
elif [ $totalbytes -gt 1024 ] ; then
echo "($($scriptbc $totalbytes / 1024) MB)"
else
echo ""
fi

# now let's scrape the log file for some useful data:

echo ""
echo "The ten most popular pages were:"

awk '{print $7}' "$1" | grep -ivE '(.gif|.jpg|.png)' | 
sed 's//$//g' | sort | 
uniq -c | sort -rn | head -10

echo ""

echo "The ten most common referrer URLs were:"

awk '{print $11}' "$1" | 
grep -vE "(^"-"$|/www.$host|/$host)" | 
sort | uniq -c | sort -rn | head -10

echo ""
exit 0

Permisos: chmod 700 webaccess.bash 
Ejecución: ./webaccess.bash [ log ]
Leer más...

findshell.pl

d
Nombre: findshell.pl
Autor: traps.darkmindz.com
Descripción: Script que permite detectar shells php
Hace uso del módulo File::Find
Visto en: ketan.lithiumfox.com
#!/usr/bin/perl -w
# findshell v1.0 == code taken/modified from traps.darkmindz.com
#usage: ./findshell.pl [ sensitivity 1-50 ] [ directory to scan ]
use strict;
use File::Find;
my $sens = shift  || 10;
my $folder = shift || './';
find(\&backdoor, "$folder");
sub backdoor {
    if ((/\.(php|txt)/)){
       open (my $IN,"<$_") || die "can not open datei $File::Find::name: $!";
       my @file =  <$IN>;
       #maybe evil stuffs
       my $score = grep (/function_exists\(|phpinfo\(|safe_?mode|shell_exec\(|popen\(|passthru\(|system\(|myshellexec\(|exec\(|getpwuid\(|getgrgid  \(|fileperms\(/i,@file);
       #probably evil stuffs
       my $tempscore = grep(/\`\$\_(post|request|get).{0,20}\`|(include|require|eval|system|passthru|shell_exec).{0,10}\$\_(post|request|get)|eval.{0,10}base64_decode|back_connect|backdoor|r57|PHPJackal|PhpSpy|GiX|Fx29SheLL|w4ck1ng|milw0rm|PhpShell|k1r4|FeeLCoMz|FaTaLisTiCz|Ve_cENxShell|UnixOn|C99madShell|Spamfordz|Locus7s|c100|c99|x2300|cgitelnet|webadmin|cybershell|STUNSHELL|Pr!v8|PHPShell|KaMeLeOn|S4T|oRb|tryag|sniper|noexecshell|\/etc\/passwd|revengans/i, @file);
       $score +=  50 *  $tempscore;
       print "$score - Possible backdoor : $File::Find::name\n" if ($score > $sens-1 );
       close $IN;
  }elsif((/\.(jpg|jpeg|gif|png|tar|zip|gz|rar|pdf)/)){
       open (my $IN,"<$_") || (print "can not open datei $File::Find::name: $!" && next);
       print "5000 - Possible backdoor (php in non-php file): $File::Find::name\n" if grep /(\<\?php|include(\ |\())/i, <$IN>;
       close $IN;
  }
}
Permisos: chmod 700 findshell.pl 
Ejecución: ./findhsell.pl [ sensibilidad del escaneo 1-50 ] [ directorio a escanear ]
Leer más...

Script Python para respaldar base de datos en Postgrtesql

d
Autor: Carlos Garcia
Descripción: Script en python que permite hacer un respaldo de una base de datos que reside en PostgreSql

Este archivo se ejecuta de la siguiente manera:

$ python respaldo.py

Para Restaurar la Base de Datos: -d Nombre Base Datos -U Usuario
pg_restore -d db -U postgres db.tar

#!/usr/bin/env python
import time
import datetime
import os


def nombre_archivo():
    '''
    Permite Crear el nombre del archivo que tendra el respaldo
    tomando como nombre la fecha dd-mm-aa y la hora hh:mm:ss
    Quedando de la siguiente manera suponiendo que fue realizado
    en la siguiente fecha (24/12/2011 10:30:00) , el resultado seria
    el siguiente: 24_12_2011_103000

    t = time.localtime()
    dia = t.tm_mday
    mes = t.tm_mon
    ano = t.tm_year

    hora = t.tm_hour
    minutos = t.tm_min
    seg = t.tm_sec

    nombre = '%s-%s-%s_%s:%s:%s' % (dia, mes, ano, hora, minutos, seg)
    '''

    t = datetime.datetime.now()
    nombre = t.strftime('%d_%m_%Y_%I%M%S')
    return nombre


def leer_config():
    '''
    Toma los valores del archivo de configuracion llamado config.cfg y los
     guarda en un diccionario {clave:valor} el cual retorna al finalizar.
    Informacion del archivo config.cfg:

    ipservidor=10.121.6.4
    nombrebasedatos=bdhcoromoto
    usuariobasedatos=admhc
    rutarespaldo=/media/respaldo
    nombrearchivo=pg_bdhcoromoto_
    '''
    diccionario = {}
    ruta = "/home/cgarcia/desarrollo/python/respaldo-potgres/config/config.cfg"
    for linea in file(ruta):
        if linea[0] != '#':
            separar = linea.split('=')
            if len(separar) > 1:
                dicc_clave = separar[0]
                dicc_valor = separar[1].rstrip()  # rstrip elimina el retor d c
                diccionario[dicc_clave] = dicc_valor
    return diccionario


def respaldo_pg():
    '''
    Toma los parametros del diccionario con el cual se arma el nombre y
    la ruta que tendra el archivo del respaldo asi como tambien arma
    el comando final a ejecutar
    '''

    diccio = leer_config()
    dic_ipservidor = diccio['ipservidor']
    dic_nombrebasedatos = diccio['nombrebasedatos']
    dic_usuariobasedatos = diccio['usuariobasedatos']
    dic_rutarespaldo = diccio['rutarespaldo']
    dic_nombrearchivo = diccio['nombrearchivo']

    archivofinal = os.path.join(dic_rutarespaldo, dic_nombrearchivo + \
     nombre_archivo() + '.tar')
    comando = 'pg_dump'

    '''
    -Parametros a pasar(Estos tambien se pudieran colocar dentro del
    archivo config.cfg),
    - pero por ahora lo dejaremos asi directo como texto
    -Ft Significa Format tar
    -b Inclute campos Blobs
    -h es el host o la ip del servidor
    -W password
    '''
    comando_a_ejecutar = '%s -Ft -b -h %s %s -U %s > %s' % \
        (comando, dic_ipservidor, dic_nombrebasedatos, dic_usuariobasedatos,\
         archivofinal)
    return comando_a_ejecutar

if __name__ == '__main__':
    print 'Espere un momento ejecutando Proceso de Respaldo...'
    respaldar = respaldo_pg()
    print respaldar
    os.system(respaldar)
    print '*** Respaldo Realizado con Exito ***'
Leer más...

Envio de email cuando cambia tu IP en linux

d
Nombre: Password.pl
Autor: Caymcorp
Descripción: El script se encarga de comprobar cuál era tu dirección ip antes de ejecutarse y, si ha cambiado, te envía un correo con la nueva. La dirección de correo antigua se guarda en el fichero /etc/myip,
Visto en Caymcorp

Requerimientos.


  • sendEmail
  • El paquete knetfilter, que nos proporciona el comando getip
  • Un servidor smtp al que mandar los correos 
La automatización para el envio se puede usar el amigo CRON

#!/bin/bash

FCONF=/etc/myip
MAIL=tu_direccion_de_correo
SERVER=servidor_smtp

# Get your ip
ip=`getip eth0 | head -n 1 | cut -d ":" -f 2`;
# Get your old ip
oldip=`head -n 1 $FCONF`

# If ip has changed, send email
# and save new ip in config file
if [ $ip != $oldip ];
then
	sendEmail -f $MAIL -t $MAIL -u "Your ip: ${ip}" -m " " -s $SERVER
	echo $ip > $FCONF;
fi
Necesitamos crear el archivo myip en /etc y asignar permisos.

sudo touch /etc/myip
sudo chmod a+w /etc/myip
Leer más...

WordPress Backup Script

d
Nombre: WordPress Backup
Autor: Guy Rutenberg
Descripción: Script que automatiza y permite generar Backup de Wordpress
Visto en Guy Rutenberg
#!/bin/bash
# (C) 2008 Guy Rutenberg - http://www.guyrutenberg.com
# This is a script that creates backups of blogs.
 
DB_NAME=
DB_USER=
DB_PASS=
DB_HOST=
 
#no trailing slash
BLOG_DIR=
BACKUP_DIR=
 
 
echo -n "dumping database... "
mysqldump --user=${DB_USER} --password=${DB_PASS} --host=${DB_HOST} ${DB_NAME} \
 | bzip2 -c > ${BACKUP_DIR}/${DB_NAME}-$(date +%Y%m%d).sql.bz2
if [ "$?" -ne "0" ]; then
	echo -e "\nmysqldump failed!"
	exit 1
fi
echo "done"
 
 
echo -n "Creating tarball... "
tar -cjf ${BACKUP_DIR}/${BLOG_DIR##*/}-$(date +%Y%m%d).tar.bz2 ${BLOG_DIR}
if [ "$?" -ne "0" ]; then
	echo -e "\ntarball creation failed!"
	exit 1
fi
echo "done"
Leer más...

Script de backups para MySQL

d
Autor: @NerdChileno

Descripción: Crea backups comprimidos para cada una de las bases de datos en el motor.

#!/bin/sh
# 
# syslock.cl
# Copyright GPL V.3
# 06/03/2010
# Version: 1.0.10
#
# ---------------------------------------------------------------------
 
# 
NOW="$(date +"%Y%m%d")"
MyUSER="" #USUARIO 
MyPASS=""       # PASSWORD
MyHOST="localhost"          # HOST
 
MYSQL="$(which mysql)"
MYSQLDUMP="$(which mysqldump)"
CHOWN="$(which chown)"
CHMOD="$(which chmod)"
GZIP="$(which gzip)"
DEST="/home/mysqldump/unaxuna" #DIR DE DESTINO 
MBD="$DEST/$NOW"
HOST="$(hostname)"
 
FILE=""
DBS=""
 
OMITE="test" # OMITIR BASE PARA RESPALDO
 
[ ! -d $MBD ] && mkdir -p $MBD || :
 
$CHOWN 0.0 -R $DEST
$CHMOD 0600 $DEST
 
DBS="$($MYSQL -u $MyUSER -h $MyHOST -p$MyPASS -Bse 'show databases')"
 
for db in $DBS
do
    skipdb=-1
    if [ "$OMITE" != "" ];
    then
        for i in $OMITE
        do
            [ "$db" == "$i" ] && skipdb=1 || :
        done
    fi
 
    if [ "$skipdb" == "-1" ] ; then
        FILE="$MBD/$NOW.$db.gz"
        $MYSQLDUMP -u $MyUSER -h $MyHOST -p$MyPASS $db | $GZIP -9 > $FILE
    fi
done



Leer más...

Script to Install and Secure Apache2 PHP5 MySQL5 in Ubuntu/Debian

d
Autor: @Desconocido
Descripción: Script que permite instalar de manera automática, y configurar Apache2 PHP y Mysql

MYSQL_PASS="YOUR_PASSWORD_HERE";

echo "+Updating apt-get..."
apt-get update

echo "+Installing SSH..."
apt-get install -q -y ssh

echo "+Changing default SSH port..."
sed -i 's/Port 22/Port 28/' /etc/ssh/sshd_config
/etc/init.d/ssh restart

echo "+Installing Apache2..."
apt-get install -q -y apache2
sed -i 's/ServerTokens Full/ServerTokens Prod/' /etc/apache2/conf.d/security
sed -i 's/ServerSignature On/ServerSignature Off/' /etc/apache2/conf.d/security
sed -i 's/TraceEnable On/TraceEnable Off/' /etc/apache2/conf.d/security
/etc/init.d/apache2 reload
a2enmod rewrite
/etc/init.d/apache2 restart

echo "+Installing PHP5..."
apt-get install -q -y php5
echo "+Securing PHP.ini file..."
sed -i 's/disable_functions =/disable_functions = show_source, system, exec/' /etc/php5/apache2/php.ini
sed -i 's/expose_php = On/expose_php = Off/' /etc/php5/apache2/php.ini
sed -i 's/display_errors = On/display_errors = Off/' /etc/php5/apache2/php.ini
sed -i 's/log_errors = Off/log_errors = On/' /etc/php5/apache2/php.ini
sed -i 's/allow_url_fopen = On/allow_url_fopen = Off/' /etc/php5/apache2/php.ini

echo "+Installing MySQL Server..."
DEBIAN_FRONTEND='noninteractive' apt-get install -q -y mysql-server
mysqladmin -u root password $MYSQL_PASS
apt-get install -q -y php5-mysql
mysql_secure_installation

history -c

echo "+Installation Completed!"

Fuente: Unixmen
Leer más...

Script para mostrar listado de Usuarios de un grupo

d
Autor : @Desconocido
Descripción: Script que muestra el grupo con mayor cantidad de usuarios, y el nombre de los usuarios.

#! /bin/bash
if test $# -ge 1
   then
      echo "Este Script no necestia parametros"
   exit 0
   else
ypcat passwd | awk -F: ' NR > 1 { vec[$4] +=1}
         END { VAN=1
            for (x in vec)
               if (VAN==1)
               {MAYOR=vec
;
               GRUPO=x;
               VAN=0}
               else
               if (MAYOR < vec
)
                  {MAYOR=vec
;
                   GRUPO=x;}
               print  GRUPO" " MAYOR+1
         }' > borrar

VAR1=`cat borrar | cut -d" " -f1`
VAR2=`cat borrar | cut -d" " -f2`
VAR3=`ypcat group | grep $VAR1 | cut -d":" -f1`
echo " El grupo $VAR3 tiene la mayor cantidad de usuarios con un total de 
$VAR2"
rm borrar
exit 0
fi
Leer más...

SCRIPT PARA INFORMACION DEL SISTEMA, REDHAT

d
Autor: @Desconocido
Descripción: Script que permite sacar un Reporte del Sistema, para un Reporte de Procesos, para un Reporte de Usuarios .

#! /bin/bash
if test $# -ge 1
then
echo "Este Script no utiliza parametros"
exit 0
else
clear
while true
do
echo "         **********************************************"
echo "         *                                            *"
echo "         *      Seleccione una accion a realizar      *"
echo "         *                                            *"
echo "         **********************************************"
echo "         *                                            *"
echo "         *  Presione (A) para un Reporte del Sistema  *"
echo "         *  Presione (B) para un Reporte de Procesos  *"
echo "         *  Presione (C) para un Reporte de Usuarios  *"
echo "         *  Presione (X) para salir                   *"
echo "         *                                            *"
echo "         **********************************************"
read op
clear

#VARIABLES DE ENTORNO UTILIZADAS EN A)
   #Tamaño del File System expresado en Kbytes
   TAM_FS=`df -l --block-size=1024 | awk 'BEGIN{cant=0} {cant+=$2} END{print 
"Tamaño del file system: "cant}'`

   #Porcentaje del disco usado
   PORC_DISCO_USAD=`df -l | awk 'BEGIN{cant=0} {cant+=$5} END{print 
"Porcentaje del disco utilizado: "cant, "\tLibre: "100-cant}'`

   #Tamaño del directorio actual
   TAM_DIR_AC=`ls -l --block-size=1024 | awk 'BEGIN{cant=0} {cant+=$5} 
END{print cant}'`

   #Cantidad de archivos en el dir actua
   CANT_ARCH_DIR_AC=`ls -l | cut -f1 -d" " | grep ^-......... | awk 'END{print 
NR}'`

   #Cantidad de subdirectorios en el dir actual
   CANT_SUBDIR_AC=`ls -l | cut -f1 -d" " | grep ^d......... | awk 'END{print 
NR}'`

   #Fecha del reporte
   FCHA_REP=`date '+Fecha del reporte: %d/%m/%y'`






   #VARIABLES DE ENTORNO UTILIZADAS EN B)
   #Cantidad de procesos en ejecucion
   

CANT_PROC_EJEC=`ps -aux | wc -l`

   #Tamanio total de la memoria
   TAM_TOT=`free -t | cut -f2 -d":" | cut -d" " -f7 | sort | awk 'END{print}'`

   #Porcentaje de memoria utilizada
   TAM_MEM_USA=`ps -aux | awk 'BEGIN{cant=0} {cant+=$4} END{print "Porcentaje 
de memoria utilizado: "cant, "\tLibre: "100-cant}'`

   #Uso de CPU
   USO_CPU=`ps -aux | awk 'BEGIN{cant=0} {cant+=$3} END{print "Uso de CPU: 
"cant}'`

   #Usuario que utiliza mayor cantida de memoria
   MEM_USU=`ps -aux | awk  ' NR > 1 { vec[$1] +=$4}
         END { VAN=1
            for (x in vec)
               if (VAN==1)
               {MAYOR=vec
;
               GRUPO=x;
               VAN=0}
               else
               if (MAYOR < vec
)
                  {MAYOR=vec
;
                   GRUPO=x;}
            print  "El Usuario que usa mayor cantidad de memoria: " GRUPO
         }'`

   #Usuarios con mayor cantidad de procesos
   CANT_PROC=`ps -aux | awk  ' NR >1  { vec[$1] +=1}
         END { BAN=1
            for (x in vec)
               if (BAN==1)
               {MAYOR=vec
;
               GRUPO=x;
               BAN=0}
               else
               if (MAYOR < vec
)
                  {MAYOR=vec
;
                   GRUPO=x;}
            print  "Usuario con mayor cantidad de procesos: " GRUPO " con " MAYOR " 
procesos"
         }'`


#VARIABLES DE ENTORNO UTILIZADAS EN C)
   #Cantidad total de usuarios
   


   CANT_USER_TOT=`ypcat passwd | awk 'END{print NR}'`

   #Cantidad de usuarios logueados
   CANT_USER_LOG=`who | cut -f1 -d" " | sort | uniq | awk 'END{print NR}'`


   #El usuario con que lleva mas tiempo logueado
   USER_MAS_LOG=`who | awk '{ print $5 "\t"$1}' | sort | awk ' NR==1 ' | cut 
-f2`

#COMIENZA EL MENU DE OPCIONES
case $op in
#EMPIEZA A EJECUTAR A
   A|a)
echo "        A)"
echo "         **********************************************************"
echo "         *            Reporte del Sistema de Archivos             *"
echo "              
*--------------------------------------------------------*"
   echo "         * $TAM_FS                         *"
echo "              *                                    *"
echo "              * $PORC_DISCO_USAD      *"
echo "              *                                                        
*"
echo "         * Tamaño del directorio actual: $TAM_DIR_AC (Kbytes)           
*"
echo "              *                                                        
*"
echo "              * Cantidad de archivos en el directorio actual: 
$CANT_ARCH_DIR_AC        *"
echo "              *                                                        
*"
echo "              * Cantidad de sub-directorios en el directorio actual: 
$CANT_SUBDIR_AC *"
echo "              
*--------------------------------------------------------*"
echo "              * $FCHA_REP                            *"
echo "              
**********************************************************"
sleep 12
;;
#TERMINA DE EJECUTAR A

#EMPIEZO A EJECUTAR B
   B|b)
echo "        B)"
echo "         
******************************************************************"
echo "         *                      Reporte de Procesos                      
  *"

echo "              
*----------------------------------------------------------------*"
echo "              * Cantidad de procesos en ejecucion:$CANT_PROC_EJEC      
                 *"


echo "              *                                                        
         *"
echo "              * Tamaño total de la memoria:$TAM_TOT                    
            *"
echo "              *                                                        
         *"
echo "              * $TAM_MEM_USA            *"
echo "              *                                                        
         *"
echo "              * $USO_CPU                                               
  *"
echo "              *                                                        
         *"
echo "              * $MEM_USU           *"
echo "              *                                                        
         *"
echo "              * $CANT_PROC   *"
echo "              
*----------------------------------------------------------------*"
echo "              * $FCHA_REP                                    *"
echo "              
******************************************************************"
sleep 12;;
#TERMINO DE EJECUTAR B

#EMPIEZO A EJECUTAR C
   C|c)
echo "        C)"
echo "         
******************************************************************"
echo "         *                      Reporte de Usuarios                      
  *"
echo "              
*----------------------------------------------------------------*"
echo "              * Cantidad total de usuarios: $CANT_USER_TOT             
                    *"
echo "              *                                                        
         *"
echo "              * Cantidad de usuarios logueados: $CANT_USER_LOG         
                      *"
echo "              *                                                        
         *"
echo "              * El usuario que lleva mas tiempo logueado: 
$USER_MAS_LOG               *"
echo "              
*----------------------------------------------------------------*"
echo "              * $FCHA_REP                                    *"
echo "              
******************************************************************"
sleep 12;;

#EMPIEZA A EJECUTAR X
   X|x) echo "Fin del programa"
           break
           sleep 1;;
   *) echo "opcion incorrecta"
      sleep 1;;
   esac
clear
done
exit 0
fi
Leer más...

Script para Enviar IP vía Mail

d
Autor: @Desconocido
Descripción: Este script comprueba la dirección IP pública de un PC y la envia a una dirección de correo.
Es útil si tiene el PC con una conexión a internet sin IP fija y se quiere conectar a él remotamente.
Puede ejecutarlo directamente con: ./mailip.sh o añadir la siguiente linea en un script de inicio: nohup mailip.sh &>/dev/null & Para ejecutarlo, primero debe modificar las variables del principio del script con sus datos de correo.
#!/bin/bash

# mailip.sh

# Script designed to read your public IP address from www.whatismyip.org
# at intervals and notify any changes by sending an email for you.

# wget and sendEmail with tsl support must be installed on your system.

# Usage:  mailip.sh  (if it can be found in your session environment PATH)
# or if you want to run it on the background:  nohup mailip.sh &>/dev/null &

# Please, you must modify the next variables to suit your needs:

DELIVER=an_account@gmail.com  # An account to send the email with the ip.
RECEIVE=$DELIVER  # An account to get the email. Don't modify to send it to the same address you especified above.
SMTP_SERVER=server.address.com:port  # The smtp server's port of the emailer account. Example: smtp.gmail.com:587
MAIL_USER=account-user
MAIL_PASS=UseR.p4s5vooRd-
TLS=yes  # yes|no    Does the mail server accept/require TLS or SSL encryption?

# The script starts here.

PATH=$PATH:/bin:/usr/bin:/usr/local/bin:/sbin:/usr/sbin:/usr/local/sbin  # paranoia
READ_IP()
{
wget -q -t 4 --no-proxy --no-cache --no-cookies -o /dev/null -O /var/publicip http://www.whatismyip.org
if [ $? -ne 0 ] ; then sleep 5m ; READ_IP ; fi
}
SEND_IP()
{
sendEmail -q -f $DELIVER -t $RECEIVE -u $SUBJECT -m $MESSAGE -s $SMTP_SERVER -xu $MAIL_USER -xp $MAIL_PASS -o tls=$TLS
if [ $? -ne 0 ] ; then sleep 5m ; SEND_IP ; fi
}

if [ $DELIVER == an_account@gmail.com ]
then echo ; echo "  Warning!  You must carefully edit some variables of the script first of all." ; echo
else
  if [ ! -e /var/publicip-sent ]
  then echo 0 > /var/publicip-sent
  fi
  while true
  do READ_IP ; sleep 12s ; sync  # paranoia
    if [ `cat /var/publicip` != `cat /var/publicip-sent` ]
    then
    SUBJECT=`hostname ; echo "IP changed:" ; cat /var/publicip`
    MESSAGE=`cat /var/publicip ; echo ; date +%F\ %T`
    SEND_IP && mv /var/publicip /var/publicip-sent
    else rm /var/publicip
    fi
  sleep 60m
  done
fi

# That was all.

# Perhaps you didn't like having to type your email password directly in the script,
# a workaround could be to assign a value like MAIL_PASS=`cat ~/password.txt` , then
# write a file called ~/password.txt with only the password in it and run the script.
# Don't forget that the password plain text file should only be readable by you,
# modificate it's permissions with chmod if needed.
Leer más...