Etiqueta: tips

Publicado el

Ejecutar scripts desde GEdit

Para muchos de nosotros Gedit no es más que un editor de textos, reemplazo del clásico bloc de notas de Windows, en el que podemos modificar pequeños y simples (al carecer de formato) ficheros de texto como ficheros de configuración y/o propiedades.

Aunque mi entorno de desarrollo (IDE) suele ser Eclipse, de un tiempo a esta parte vengo utilizándolo muy a menudo para la creación y edición de scripts tanto en Bash como en Groovy (lenguaje que, por necesidades del cliente, me he visto “obligado” a aprender).

Cansado de la rutina de editar el fichero con GEdit (o vim si se terciaba), y tener abierta una terminal para probar lo que iba modificando me dio por investigar qué otras alternativas existen para ello descubriendo la potencia y flexibilidad del complemento Herramientas externas.

Activando el complemento

Tan sencillo como buscarlo en las preferencias de GEdit

null

y marcar la casilla correspondiente

null

para finalizar no queda más que configurarlo

null

Definiendo el primer script

Como introducción y, a modo de ejemplo, nos limitaremos a mostrar en consola el resultado de listar el contenido del directorio temporal del sistema (/tmp) para lo cual añadiremos un nuevo comando pulsando el botón existente para ello

null

y escribiremos el siguiente código en la zona de edición habilitada

ls -l /tmp

null

A modo de referencia podéis ver cómo he definido el resto de parámetros del script en la siguiente captura

null

destacando entre ellos

  1. Tecla rápida para lanzar el script cuando estemos editando en GEdit sin tener que buscar el script en los menús de la aplicación
  2. Guardar: Documento actual para evitarnos tener que preocuparnos de guardar el documento antes de lanzar el script. Con el valor Documento actual se guardará el fichero que estemos editando de modo que lo que se ejecute sea exactamente lo último que hemos escrito evitando de este modo falsos resultados (imagina que haces algunos cambios y ejecutas el script: se ejecutaría sobre lo último que tienes en disco que no coincide en absoluto con lo que estás viendo en pantalla)

Ejecutando scripts

Tan sencillo como pulsar la combinación de teclas definida en el paso anterior (CTRL+SHIFT+E en la configuración de referencia) y observar el resultado en el panel inferior del editor

null

NOTA: Curiosamente, si estás editando un documento nuevo que no ha sido guardado nunca en disco, el complemento se limita a pedirte dónde guardarlo y no ejecuta el script  . En dicho caso dale un nombre y vuelve a lanzarlo pulsando nuevamente la combinación de teclas asociada.

El script definitivo

Una vez que hemos aprendido cómo funciona el complemento con un ejemplo sencillo (listar el contenido del directorio /tmp) pasemos a la finalidad de este artículo: ejecutar el contenido del script que estamos editando.

No tenemos más que cambiar el código del script anterior por éste:

chmod a+x $GEDIT_CURRENT_DOCUMENT_PATH;
$GEDIT_CURRENT_DOCUMENT_PATH;

null

donde:

  1. chmod a+x $GEDIT_CURRENT_DOCUMENT_PATH; le da permisos de ejecución (a todos los usuarios) al fichero actual.
  2. $GEDIT_CURRENT_DOCUMENT_PATH; permite ejecutarlo.

para entender la segunda línea debe tenerse en cuenta el significado y utilidad de las distintas variables que admite el complemento.

Conclusión

GEdit es, en apariencia, un sencillo editor de textos que consume muy pocos recursos y que está llamado a convertirse en el equivalente a editores de textos como el UltraEdit de Windows (que al escribir este artículo acabo de descubrir que ya existe versión para Linux :O aunque, como era de esperar, no es Software libre :( )

Bonus tip

Para aquellos que les haya llamada la posibilidad de ejecutar scripts desde Gedit les recomiendo que le echen un vistazo a la colección de ejemplos de scripts que existe pues es mucho lo que se puede aprender de ellos.

fuente : http://andalinux.wordpress.com/2010/07/19/gedit-avanzado-ejecutar-scripts-desde-el-editor

fuente : andalinux.wordpress.com

Publicado el

Buscar un archivo creado entre dos fechas en al shell de Linux

Te acuerdas que creaste un archivo entre el 15 de Septiembre de 2010 y el 30 de Septiembre de ese mismo año. ¿Cómo lo puedes buscar en Linux? Fácil, usando el comando find y estos truquitos:

Primera forma para versiones antiguas del comando find (< =2.4)

$ touch -d "15 sep 2010" /tmp/begin
$ touch -d "30 sep 2010" /tmp/end
$ find . -newer /tmp/begin -a \! -newer /tmp/end

Segunda forma (Para versiones nuevas de find (>=2.4), te lo puedes hacer con un solo comando mediante la opción ‘-newerXY’)

$ find . -newermt “15 sep 2010″ \! -newermt “30 sep 2010″)

Lo he necesitado varias veces y nunca me acordaba de la receta, así que la dejo aquí compartida para todos. ¡Que os aproveche!

Publicado el

Script para optimizar las tablas fragmentadas en MySQL

Bueno otro buen script a la huchaca… esta escrito en bash aparte de ser utilisisimo porque chequea las tablas fragmentadas y tambien chequea todas las bbdds en busca de tablas MyISAM o INNODB y las optimiza.

#!/bin/bash

VERSION="0.7.2"
log="$PWD/mysql_error_log.txt"

echo "MySQL fragmentation finder (and fixer) v$VERSION, written by Phil Dufault ( http://www.dufault.info/ )"

showHelp() {
echo -e "\tThis script only repairs MyISAM and InnoDB tables"
echo -e "\t--help or -h\t\tthis menu"
echo -e "\t--user username\tspecify mysql username to use\n\t\t\tusing this flag means the script will ask for a password during runtime, unless you supply..."
echo -e "\t--password \"yourpassword\""
echo -e "\t--host hostname\tspecify mysql hostname to use, be it local (default) or remote"
}

#s parse arguments
while [[ $1 == -* ]]; do
case "$1" in
--help|-h) showHelp; exit 0;;
--user) mysqlUser="$2"; shift 2;;
--password) mysqlPass="$2"; shift 2;;
--host) mysqlHost="$2"; shift 2;;
--) shift; break;;
esac
done

# prevent overwriting the commandline args with the ones in .my.cnf, and check that .my.cnf exists
if [[ ! $mysqlUser && -f "$HOME/.my.cnf" ]]; then
if grep "user=" "$HOME/.my.cnf" >/dev/null 2>&1; then
if grep "pass=" "$HOME/.my.cnf" >/dev/null 2>&1; then
mysqlUser=$(grep user= < "$HOME/.my.cnf" | awk -F\" '{print $2}'); mysqlPass=$(grep pass= < "$HOME/.my.cnf" | awk -F\" '{print $2}'); if grep "host=" "$HOME/.my.cnf" >/dev/null 2>&1; then
mysqlHost=$(grep host= < "$HOME/.my.cnf" | awk -F\" '{print $2}'); fi else echo "Found no pass line in your .my.cnf,, fix this or specify with --password" fi else echo "Found no user line in your .my.cnf, fix this or specify with --user" exit 1; fi fi # set localhost if no host is set anywhere else if [[ ! $mysqlHost ]]; then mysqlHost="127.0.0.1" fi # error out if [[ ! $mysqlUser ]]; then echo "Authentication information not found as arguments, nor in $HOME/.my.cnf" echo showHelp exit 1 fi if [[ ! $mysqlPass ]]; then echo -n "Enter your MySQL password: " read -s mysqlPass fi # Test connecting to the database: mysql -u"$mysqlUser" -p"$mysqlPass" -h"$mysqlHost" --skip-column-names --batch -e "show status" >/dev/null 2>&1
if [[ $? -gt 0 ]]; then
echo "An error occured, check $log for more information.";
exit 1;
fi

# Retrieve the listing of databases:
databases=( $(mysql -u"$mysqlUser" -p"$mysqlPass" -h"$mysqlHost" --skip-column-names --batch -e "show databases;" 2>"$log") );
if [[ $? -gt 0 ]]; then
echo "An error occured, check $log for more information."
exit 1;
fi

echo -e "Found ${#databases[@]} databases";
for i in ${databases[@]}; do
# get a list of all of the tables, grep for MyISAM or InnoDB, and then sort out the fragmented tables with awk
fragmented=( $(mysql -u"$mysqlUser" -p"$mysqlPass" -h"$mysqlHost" --skip-column-names --batch -e "SHOW TABLE STATUS FROM $i;" 2>"$log" | awk '{print $1,$2,$10}' | egrep "MyISAM|InnoDB" | awk '$3 > 0' | awk '{print $1}') );
if [[ $? -gt 0 ]]; then
echo "An error occured, check $log for more information."
exit 1;
fi
tput sc
echo -n "Checking $i ... ";
if [[ ${#fragmented[@]} -gt 0 ]]; then
if [[ ${#fragmented[@]} -gt 0 ]]; then
if [[ ${#fragmented[@]} -gt 1 ]]; then
echo "found ${#fragmented[@]} fragmented tables."
else
echo "found ${#fragmented[@]} fragmented table."
fi
fi
for table in ${fragmented[@]}; do
let fraggedTables=$fraggedTables+1;
echo -ne "\tOptimizing $table ... ";
mysql -u"$mysqlUser" -p"$mysqlPass" -h"$mysqlHost" -D "$i" --skip-column-names --batch -e "optimize table $table" 2>"$log" >/dev/null
if [[ $? -gt 0 ]]; then
echo "An error occured, check $log for more information."
exit 1;
fi
echo done
done
else
tput rc
tput el
fi
unset fragmented
done

# footer message
if [[ ! $fraggedTables -gt 0 ]]; then
echo "No tables were fragmented, so no optimizing was done.";
else
if [[ $fraggedTables -gt 1 ]]; then
echo "$fraggedTables tables were fragmented, and were optimized.";
else
echo "$fraggedTables table was fragmented, and was optimized.";
fi
fi

if [[ ! -s $log ]]; then
rm -f "$log"
fi

unset fraggedTables

Link | http://www.dufault.info/blog/a-script-to-optimize-fragmented-tables-in-mysql/

Publicado el

Funciones a deshabilitar en php.ini – Tips para securizar php

Y es que, cada vez se ven mas destrozos a causa de las webs mal hechas (o poco actualizadas) en php . Que si postnuke, que si phpnuke, phpbb, mybb y un larguisimo etc. Ya que esto es un dolor de cabeza para cualquier sysadmin, algo a tener en cuenta es el deshabilitar ciertas funciones de php en el php.ini, y el que las quiera.. que las habilite en el .htaccess de su virtualhost bajo su responsabilidad, no? Empezamos:

Editamos fichero de configuración de PHP php.ini

#vi /etc/php.ini

buscamos la linea que contiene disable_functions. Posiblemente tenga un ; delante, que sirve para inutilizarla. Eliminamos el ; y dejamos la linea de esta forma:

disable_functions = system, exec, popen, passthru, shell_exec, proc_close, proc_get_status, proc_nice, proc_open, proc_terminate

Asi, nos cargamos unas cuantas funciones peligrosas que a mas de uno le han dejado sin dormir.

Por otro lado, es de esperar el estar atentos a cosas como el safe_mode, allow_url_fopen y demas… pero creo que eso ya lo puse en otro post anterior 🙂

Publicado el

Secure Shell Hacks – Linux

E aqui una pequeña wiki de SSH¡¡¡

SSH hacks

Cómo me conecto por ssh sin contraseñas

En primer lugar es necesario generar una pareja de claves en tu máquina (‘client‘), en este caso ‘bender‘:

cesar@bender ~ $ ssh-keygen -t dsa

Te preguntará un passphrase que es recomendable introducir, aunque también se puede dejar en blanco. Tras esta operación obtendrás los ficheros:

cesar@bender ~ $ ls ~/.ssh
id_dsa
id_dsa.pub
known_hosts

El fichero ‘id_dsa‘ contiene la clave privada y no debería salir de tu ordenador. Debe tener permisos 600:

cesar@bender ~ $ chmod 600 .ssh/id_dsa

El fichero ‘id_dsa.pub‘ contiene tu clave pública. Para autorizar una clave pública en una máquina remota ‘kastor‘:

cesar@bender ~ $ cat ~/.ssh/id_dsa.pub | ssh kastor 'cat - >> .ssh/authorized_keys'

No olvides poner dos símbolos «>», puesto que en caso contrario te cargarás otras claves autorizadas en la máquina ‘kastor‘. La próxima vez que hagas ‘ssh kastor‘ entrará sin más. Si has puesto passphrase, tendrás que hacer primero:

cesar@bender ~ $ ssh-add

Solución de problemas

  • Sigue sin dejar conectarme: Asegúrate de que los permisos de ‘~/.ssh/authorized_keys‘ en la máquina remota son 644.
  • Cuando escribo ‘ssh-add‘ aparece el mensaje Could not open a connection to your authentication agent: La shell desde la que intentas conectarte no esta bajo el control del agente de autenticación.
  • Solucion rápida: Lanza una shell con el agente de ssh.
cesar@bender ~ $ ssh-agent bash
  • Solución mejor: lanza todas tus X bajo el ‘ssh-agent‘. Así todas las terminales colgarán de él.

El archivo /etc/hosts

Para un acceso rápido por ssh resulta muy útil definir alias de tus máquinas comunes en el fichero ‘/etc/hosts‘:

cesar@bender ~ $ sudo vim /etc/hosts
#
# Syntax:
#
# IP-Address  Full-Qualified-Hostname  Short-Hostname
#
192.168.1.4     kastor.zylk.net kastor

Esta operación requiere privilegios de administrador o superusuario.

Como manejar las llaves de ssh ? Uso de keychain

Una posibilidad es iniciar el ordenador en ‘init 3‘ sin X y redefinir tu ‘startx‘: Este es mi ‘~/bin/startx-ssh‘:

cesar@bender ~ $ vim ~/bin/startx-ssh
#!/bin/bash

keychain ~/.ssh/id_dsa || exit
source ~/.keychain/`hostname`-sh
startx

exit

Al iniciarlo, me pide el passphrase. Otra posibilidad es incluir estas dos líneas en tu archivo ‘.gnomerc‘ o similar en otros entornos gráficos.

keychain  ~/.ssh/id_dsa
source ~/.keychain/`hostname`-sh

Y ahora, si hago login desde otra máquina, o quiero que un cron pueda conectarse a otras máquinas, incluyo las siguientes líneas:

cesar@bender ~ $ source ~/.keychain/`hostname`-sh

Si quiero cerrar el acceso, hago:

cesar@bender ~ $ keychain --stop

Para volverlo a arrancar:

cesar@bender ~ $ keychain ~/.ssh/id_dsa

Cómo y por qué usar un túnel ssh?

Has trabajado alguna vez detrás de un firewall? Tienes una página web privada de una institución detrás de un firewall a la que sólo pueden acceder las máquinas de esa institución? Has intentado alguna vez mover un fichero desde detrás de un firewall a otra máquina que esta detrás de otro firewall? Entonces, lo que necesitas es hacer un túnel ssh.

La idea básica es que desde tu máquina (‘client.machine‘) tienes acceso a una máquina ‘bridge.machine‘ que no es a la que quieres acceder, pero que desde ella si podrías acceder a tu objetivo ‘target.machine‘. El túnel te permite operar de forma transparente desde ‘client.machime‘ hasta ‘target.machine‘. Hay dos tipos de túneles: túneles directos e inversos. En un túnel directo (forward) se hace corresponder un puerto de destino (‘dport‘) en la ‘target.machine‘, con un puerto local (‘lport‘) en tu máquina ‘client.machine‘. Esto se hace de la siguiente manera:

cesar@bender ~ $ ssh -NfL lport:target.machine:dport bridge.machine

Regla nemotécnica: acuérdate de la liga de futbol americano (NFL) y que la del medio es en minúscula.
HINT: Por cierto, aseguraros que el puerto local no está siendo usado, por ejemplo que apache este escuchando en ese puerto (aunque este mapeado con un virtual host deshabilitado). Por otro lado la opción verbose (-NfvL) puede ayudar en la traza de algún error.

Conectarse por ssh a target.machine

Primero construiríamos el túnel:

cesar@bender ~ $ ssh -NfL 6666:target.machine:22 bridge.machine

Y a continuación basta con hacer lo siguiente para entrar directamente en ‘target.machine‘:

cesar@bender ~ $ ssh -p6666 localhost

O bien:

cesar@bender ~ $ scp -P6666 fichero localhost:/el/path/que/te/venga/bien

Esto requiere que en tu ‘$HOME/.ssh/config‘ añadas la línea:

NoHostAuthenticationForLocalhost yes

Ejemplos de uso para los túneles ssh

Conexión a una web de una red privada

Si montas un servicio en un ordenador detrás de un firewall, este no va a estar disponible fuera porque en general los puertos estarán capados. Por ejemplo, una web dentro de una máquina de una red privada sin salida al exterior. A través de un túnel ssh se puede acceder a este servicio.

cesar@bender ~ $ ssh -NfL 8080:target.machine:80 bridge.machine

Después en el navegador, la web de ‘target.machine‘ estará disponible en ‘http://localhost:8080‘.

Conexión al LDAP de una red privada

cesar@bender ~ $ ssh -Nvf -L 9999:kastor.zylk.net:389 cesar@kastor.zylk.net

Aunque el puerto del LDAP (389) esta capado, yo puedo acceder a él desde fuera de la red si tengo un acceso a ‘kastor‘ haciéndolo pasar a través del puerto 22 (el del ssh) y mapeandolo a un puerto, digamos el 9999 en mi máquina local. Situación inicial:

               |             |
localhost:9999   ----------- | kastor.zylk.net:389
               |             |

Túnel:

               |          22 |                     |
localhost:9999   -----------   kastor.zylk.net:22    kastor.zylk.net:389
               |             |                     |

Una vez hecho el túnel, puedo configurar en mi agenda el acceso al LDAP con servidor localhost y puerto 9999. Nota: En realidad el proceso incorpora tres máquinas, la local, la de salida y la del servicio. Lo que pasa es que en este caso las dos ultimas son la misma.

Administrar el servidor CUPS de una red privada

Desde mi máquina:

cesar@bender ~ $ ssh -Nvf -L 63131:cups.zylk.net:631 cesar@kastor.zylk.net

Túnel:

               |          22 |                 |
localhost:63131   -----------   kastor.zylk.net   cups.zylk.net:631
               |             |                 |

De este modo me puedo conectar a la interfaz web de administración desde mi máquina en http://localhost:63131

Cómo definir tus propios hosts sin ser root?

Una situación bastante común es que tener acceso a una cuenta en una máquina sin privilegios de administrador o superusuario. Para conectarte a ‘kastor.zylk.net‘ con login ‘cesar‘:

cesar@bender ~ $ ssh cesar@kastor.zylk.net

La solución está en el fichero ‘$HOME/.ssh/config‘:

Host kastor
Hostname kastor.zylk.net
User cesar
Port 22
ForwardX11 no
Protocol 2,1

Host cups
Hostname localhost
User zylk
Port 9999

Con lo cual puedes hacer directamente:

cesar@bender ~ $ ssh kastor

El ssh sabe que tiene que conectarse a la máquina ‘kastor.zylk.net‘ y usar el login ‘cesar‘. Y ahora sabe que tiene que conectarse al puerto 9999 de ‘localhost‘ usando como login ‘zylk‘. Con esto tienes ya total transparencia en los túneles. Sobre todo si te haces un alias para levantarlo del tipo de:

cesar@bender ~ $ alias tncups='ssh -NfL 9999:cups.zylk.net:22 cesar@kastor'

Ejecutas el alias, que puedes copiar en tu ‘.bashrc‘:

cesar@bender ~ $ tncups

y te puedes conectar directamente a ‘cups.zylk.net‘ de forma transparente desde el exterior.

cesar@bender ~ $ ssh cups

Utilizando el sistema de ficheros sshfs

El objetivo es tener un sistema de ficheros remoto. Una especie de NFS o samba, pero seguro a través de ssh. Instalo sshfs:

$ sudo apt-get install sshfs

Me añado al grupo «fuse»:

$ sudo vi /etc/group

Luego ejecuto:

$ sshfs cesar@kastor.zylk.net:/data1/z-docs /mnt/z-docs/

Cómo conectarse unicamente via certificado?

Configurar el demonio de ssh de modo que sólo se puedan realizar conexiones ssh a la máquina si el usuario remoto está en la lista ‘authorized_keys‘.

$ sudo vim /etc/sshd_config
PasswordAuthentication no
UsePAM no

Por defecto esta opción está marcada como yes. También se puede definir donde están las listas autorizadas (claves públicas). Por defecto las define el usuario:

#AuthorizedKeysFile     %h/.ssh/authorized_keys

Reinicio el servicio:

$ /etc/init.d/sshd restart

Desactivar el login a root por ssh

Desactivo conexiones remotas ssh a la cuenta root, como medida de prevención de ataques ssh.

$ sudo vim /etc/sshd_config
PermitRootLogin no

Reinicio el servicio:

$ /etc/init.d/sshd restart