💾 Archived View for gmi.osiux.com › linux-sysadmin.gmi captured on 2023-01-29 at 15:51:27. Gemini links have been rewritten to link to archived content
⬅️ Previous capture (2023-01-29)
-=-=-=-=-=-=-
Los objetivos con que se creó determinaron una *filosofía* de *UNIX* caracterizada por:
Algunas directivas son:
En estos conceptos se basa la mayoría del software libre existente, por lo que servidores como `sendmail` o `postfix`, están diseñados en pequeños servidores y/o programas que hacen partes de todo un proceso y, mediante sus ficheros de configuración, se pueden enlazar de una u otra forma, así como usar otros programas y/o servidores en lugar de los que vienen por defecto y, así, extender su funcionalidad.
Sobre *filosofía Unix*, de una forma más extensa, *Mike Gancarz*, escribe las siguientes líneas:
La *filosofía UNIX* supone crear programas rápidos, simples, con poca intervención por parte del usuario, o en caso de necesitarla, esta se produzca al principio o lo más mínima posible. Esta se acopla perfectamente a las necesidades de computación de los laboratorios científicos, puesto que *Unix* fue originalmente desarrollado en uno de estos.
A continuación algunas premisas:
En resumidas cuentas la *filosofía Unix* se puede describir como bien lo dice *Doug Mcllroy*:
"Escribe programas que hagan una cosa y la hagan bien, que trabajen en armonía con otros y que manejen flujos de texto, pues esta es una interfaz universal." - *Doug Mcllroy*
"Aquellos que no pueden entender UNIX, están condenados a reinventarlo, pobremente." - *Henry Spencer*, 1987
/ +-- bin binarios +-- boot inicio del sistema, imágenes del kernel +-- dev dispositivos, presentes y futuros +-- etc configuraciones +-- home directorios personales de los usuarios +-- lib bibliotecas +-- lost+found archivos y/o cadenas perdidas +-- media dispositivos extraerles +-- mnt dispositivos montados +-- opt binarios fuera de la distro +-- proc procesos en ejecución +-- root directorio personal del /root/ +-- run archivos de procesos en ejecución +-- sbin binarios del sistema +-- selinux secure linux +-- srv servicios ej: ftp +-- sys system +-- tmp temporales +-- usr archivos compartidos +-- var archivos que varían de tamaño, ej: logs
Es un pseudo-sistema de ficheros que se usa como interfaz para las estructuras de datos del núcleo en lugar de leer e interpretar /dev/kmem. La mayor parte de este sistema de ficheros es de sólo lectura, pero algunos ficheros permiten cambiar variables del núcleo.
Podemos ver las particiones que leyó el *kernel*:
cat /proc/partitions
major minor #blocks name
:
8 0 488386584 sda 8 1 52428800 sda1 8 2 52428800 sda2 8 3 383527960 sda3 11 0 1048575 sr0 254 0 383525912 dm-0
El `uptime` de nuestro equipo puede ser consultado directamente en `/proc/uptime`,
cat /proc/uptime
1901728.32 3010323.20
Si utilizamos el comando `uptime`, éste lee el valor expresado en **epoc** (segundos que pasaron desde el 01/01/1970) y nos informa hace cuántos días y horas nuestro servidor está prendido, además de informar otros valores, como la cantidad de usuarios y el **average**:
uptime
10:53:05 up 22 days, 15 min, 6 users, load average: 1,63, 1,70, 1,58
Aquí se encuentran todos los dispositivos del sistema, presentes y futuros.
Este dispositivo es muy especial y sumamente útil, es un agujero negro, todo lo que se envía a `/dev/null` desaparece
ls -lh /dev/null
crw-rw-rw- 1 root root 1, 3 ene 20 10:37 /dev/null
Si enviamos algo y luego miramos con un `ls` no vemos que se incremente el tamaño del archivo:
echo "hola" >/dev/null ls -lh /dev/null
crw-rw-rw- 1 root root 1, 3 ene 20 10:37 /dev/null
Los discos están identificados con el prefijo `sd`, luego una letra `a`, `b`, `c`, etc y finalmente un número `1`, `2`, `3`, etc que identifica la partición:
Listamos el disco `sda`
ls /dev/sda*
/dev/sda /dev/sda1 /dev/sda2 /dev/sda3
Vemos si esta montado `sda`:
mount | grep sda
/dev/sda1 on /mnt/sda1 type ext4 (rw,relatime,user_xattr,barrier=1,data=ordered)
Visualizamos el espacio disponible:
df -h | grep sda
/dev/sda1 50G 14G 34G 29% /mnt/sda1
Existen 3 descriptores básicos de archivos:
┌─────┬──────────┬───────────────────┐ │ │ │ │ ╞═════╪══════════╪═══════════════════╡ │ `0` │ `stdin` │ entrada estándar │ ├─────┼──────────┼───────────────────┤ │ `1` │ `stdout` │ salida estándar │ ├─────┼──────────┼───────────────────┤ │ `2` │ `stderr` │ salida de errores │ └─────┴──────────┴───────────────────┘
Es posible redireccionar cada uno de éstos descriptores mediante los operadores `>`, `<` y `|`
Buscar el texto **model** en el archivo `/proc/cpuinfo` y enviar el resultado a un nuevo archivo llamado `/tmp/cpu` que contendrá únicamente las líneas que coinciden con el texto **model**:
grep model /proc/cpuinfo > /tmp/cpu cat /tmp/cpu
model : 28 model name : Intel(R) Atom(TM) CPU D425 @ 1.80GHz model : 28 model name : Intel(R) Atom(TM) CPU D425 @ 1.80GHz
Buscar el texto **cache** en el archivo `/proc/cpuinfo` y agregar el resultado al archivo `/tmp/cpu`
grep cache /proc/cpuinfo >> /tmp/cpu cat /tmp/cpu
model : 28 model name : Intel(R) Atom(TM) CPU D425 @ 1.80GHz model : 28 model name : Intel(R) Atom(TM) CPU D425 @ 1.80GHz cache size : 512 KB cache_alignment : 64 cache size : 512 KB cache_alignment : 64
Enviar la salida con errores a `/dev/null`:
xkcd 2>/dev/null
Redireccionar la salida con errores a la salida estandar:
echo "xkcd" | grep 2>&1
El símbolo `|` es usado para redireccionar la salida de un comando a la entrada de otro comando.
Ejemplo:
Lista el directorio `/var/log` ordenando los archivos más nuevos al principio y muestra sólo las primeras 10 líneas mediante el comando `head`
ls -lht /var/log | head
total 14M -rw-rw-r-- 1 root utmp 107K feb 10 20:46 wtmp -rw-r----- 1 root adm 769K feb 10 20:45 mail.info -rw-r----- 1 root adm 769K feb 10 20:45 mail.log -rw-r----- 1 root adm 356K feb 10 20:45 syslog -rw-r----- 1 root adm 337K feb 10 20:45 auth.log -rw-r----- 1 root adm 3,1K feb 10 19:49 messages -rw-r----- 1 root adm 2,9K feb 10 19:49 kern.log -rw-r--r-- 1 root root 29K feb 10 16:42 Xorg.0.log -rw-r----- 1 root adm 1,9K feb 10 16:42 daemon.log
lista el directorio `/var/log` mostrando el tamaño de cada archivo, se filtra el resultando por Megabytes (`M`), luego ordena de mayor a menor y finalmente limita la lista a los primeros 10 archivos que más espacio ocupan, incluyendo el total del directorio:
cd /var/log;du -ch * | grep M | sort -nr | head
496M total 468M atop 15M installer 14M installer/cdebconf 3,3M mail.log.1 3,3M mail.info.1 1,5M auth.log.1
El separador de archivos y directorios es la barra `/`
ejemplos:
/ directorio raíz (*root*) /etc directorio usr (sub-directorio de la raíz =/=) /etc/apache2 apache2 subdirectorio de /etc
1. `pwd`
Muestra el directorio actual.
2. `cd`
Cambia al directorio definido en `HOME`
3. `cd /etc/php5`
Cambia el directorio actual a `/etc/php5`
4. `cd apache2`
Cambia al subdirectorio `apache2` del directorio actual
5. `cd ..`
Cambia al directorio inmediato superior
6. `cd $HOME`
Cambia al directorio definido en la variable `HOME`
7. `cd ~osiris`
Cambia al directorio del usuario osiris
1. `ls -l`
Listar en formato ancho, de esta manera se visualizan gran parte de los atributos de cada archivo y/o directorio
2. `ls` Listar directorio actual 3. `ls -a` Listar directorio actual incluyendo archivos ocultos (comienzan con `.`) ## Cambiando permisos y atributos
r = read 4
w = write 2
x = execute 1
propietario 7 = rwx lectura, escritura y ejecución
grupo 5 = rx- lectura y ejecución
todos 0 = --- ningún permiso
Es necesario ser el propietario del archivo/directorio (o *root*) para realizar el cambio de `usuario` o `grupo`. ### `chmod 750 archivo` Listamos los permisos del archivo `~/.bash_history`
ls -l ~/.bash_history
-rwxr-x--- 1 osiris osiris 326316 feb 10 21:55 /home/osiris/.bash_history
Cambiamos el permiso a `750` y volvemos a listar:
chmod 750 ~/.bash_history
ls -l ~/.bash_history
-rwxr-x--- 1 osiris osiris 326316 feb 10 21:55 /home/osiris/.bash_history
Finalmente cambiamos el permiso a `600` y volvemos a listar:
chmod 600 ~/.bash_history
ls -l ~/.bash_history
-rw------- 1 osiris osiris 326316 feb 10 21:55 /home/osiris/.bash_history
### `chgrp grupo archivo` Establece el grupo al archivo ### `chown usuario archivo` Establece el usuario como propietario del archivo ### `chown usuario archivo` Establece el usuario como propietario del directorio y todo su contenido recursivamente. ## Moviendo, renombrando y copiando archivos:o Copiamos el archivo `~/.bash_history` a `~/.bash_history.bak` y verificamos que sea igual:
ls -lh ~/.bash_history
cp ~/.bash_history ~/.bash_history.bak
ls -lh ~/.bash_history.bak
md5sum ~/.bash_history ~/.bash_history.bak
-rw------- 1 osiris osiris 310K feb 11 11:07 /home/osiris/.bash_history
-rw------- 1 osiris osiris 310K feb 11 11:07 /home/osiris/.bash_history
7b862a967fc7096882583f9a6f662230 /home/osiris/.bash_history
7b862a967fc7096882583f9a6f662230 /home/osiris/.bash_history.bak
#+END~SRC~ Movemos el archivo `~/.bash_history.bak` a `~/historial.bak`:
mv -vi ~/.bash_history.bak ~/historial.bak
ls -l ~/.bash_history ~/historial.bak
«/home/osiris/.bash_history.bak» -> «/home/osiris/historial.bak»
-rw------- 1 osiris osiris 316801 feb 11 11:07 /home/osiris/.bash_history
-rw------- 1 osiris www-data 316801 feb 11 11:13 /home/osiris/historial.bak
Renombramos el archivo `~/historial.bak` a `~/historial.log`
mv -vi ~/historial.bak ~/historial.log
ls -l ~/historial.log
«/home/osiris/historial.bak» -> «/home/osiris/historial.log»
-rw------- 1 osiris www-data 316801 feb 11 11:13 /home/osiris/historial.log
## Ver y editar arhivos: ### `cat`
cat /etc/issue
Debian GNU/Linux 7.0 \n \l
: ### `head`
head /proc/meminfo | head
MemTotal: 2062464 kB
MemFree: 872100 kB
Buffers: 56052 kB
Cached: 642468 kB
SwapCached: 10928 kB
Active: 520204 kB
Inactive: 570096 kB
Active(anon): 366124 kB
Inactive(anon): 211844 kB
Active(file): 154080 kB
### `head -2`
head /proc/meminfo | head -2
MemTotal: 2062464 kB
MemFree: 871860 kB
### `tail`
tail /etc/passwd
hplip:x:106:7:HPLIP system user,,,:/var/run/hplip:/bin/false
pulse:x:107:114:PulseAudio daemon,,,:/var/run/pulse:/bin/false
saned:x:108:118::/home/saned:/bin/false
Debian-gdm:x:109:119:Gnome Display Manager:/var/lib/gdm3:/bin/false
alumno:x:1001:1000:alumno,,,:/home/alumno:/bin/bash
osiris:x:2222:33:OSiRiS,,,:/home/osiris:/bin/bash
sshd:x:110:65534::/var/run/sshd:/usr/sbin/nologin
postfix:x:111:120::/var/spool/postfix:/bin/false
rodrigo:x:1002:1001:Rodrigo Fernandez,,,:/mnt/data/musica:/bin/bash
davfs2:x:112:122::/var/cache/davfs2:/bin/false
tail -2 /etc/passwd
rodrigo:x:1002:1001:Rodrigo Fernandez,,,:/mnt/data/musica:/bin/bash
davfs2:x:112:122::/var/cache/davfs2:/bin/false
### `sed`
cat /etc/issue
sed s/"7.0"/"8.0"/g /etc/issue
cat /etc/issue
Debian GNU/Linux 7.0 \n \l
:
Debian GNU/Linux 8.0 \n \l
:
Debian GNU/Linux 7.0 \n \l
: ## Expresiones regulares Se utilizan para definir patrones para la búsqueda y filtrado: ### `[a-z]` Minúsculas Rango de la **a** a la **z** ### `[A-Z]` Mayúsculas Rango de la **A** a la **Z** ### `[0-9]` Números Rango de 0 a 9 ### `[^..]` Patrón distinto Negación ### `^` comienzo de línea ### `gemini - kennedy.gemi.dev fin de línea ### `.` cualquier carácter ### `?` cero o una aparición ### `*` ninguna o muchas repeticiones ### `+` una o más repeticiones # Acceso remoto usando ssh # AUTHOR: Osiris Alejandro Gomez # EMAIL: osiux@osiux.com ## ¿qué es `ssh` y para qué sirve? `ssh` permite la ejecución remota de un intérprete de comandos como `bash` # Más información en: https://es.wikipedia.gmi/wiki/Ssh%5B1%5D[1] ## ¿qué ventajas tiene? # ****Es seguro**** porque cifra la conexión y nadie puede ver qué estamos haciendo # ****Es rápido**** porque sólo envía texto, por ello envía menos datos que si fuera una imagen de pantalla como programas como `vnc` # ****Es versátil**** porque permite interactuar con otros comandos obteniendo control total de un sistema de manera remota. ## ¿qué necesito para usar SSH? # **computadora remota**
En una terminal hay que escribir el comando `ssh` luego el usuario remoto, por ejemplo: ****pepe**** y separado por un *@* arroba la dirección ****IP**** o el dominio (ej: `192.168.0.9` ó `osiux.com`)
## ¿qué sucede la primera vez? Siempre que nos conectamos por primera vez a un servidor SSH, nos aparece un mensaje para que confirmemos la autenticidad de la computadora a la que estamos conectándonos, por ahora somos confiados y le decimos que sí, tipeando ****yes****
Ahora podemos hacer todo lo que el usuario que usamos para conectarnos (en este caso ****pepe****) pueda hacer!
Ahora bien, resulta que este sistema remoto cuenta con un administrador, que ve que alguien que no es él, ingresó al sistema con su usuario! Entonces va a matar todos los procesos del usuario ****pepe****, a fin de dejarnos afuera del sistema.
Para esto, utiliza la herramienta `htop` que muestra todos los procesos y presionando la tecla `F4` nos permite filtrar por la palabra ****pepe**** y luego presionando `F9` y eligiendo `SIGKILL` termina cada uno de los procesos del usuario ****pepe****.
También se puede hacer desde la consola sin usar `htop`
## El intruso va por la revancha! Como lo dejamos afuera a ****pepe**** matando sus procesos, ahora está enojado! Entonces nos empieza a crear ****carpetas**** en el ****Escritorio**** de la siguiente manera:
Si sigue así en algún momento nos va a llenar el ****Escritorio****
Matar los procesos activos no es suficiente, debemos eliminar al usuario, para esto hacemos:
# Listo! ahora ****pepe**** no puede ingresar a nuestro sistema ## El intruso es duro de domar! Resulta que ****pepe**** cuando ingresó la primera vez, fue astuto y cambió la contraseña de ****root****. ¿Y cómo pudo hacerlo? es simple, el usuario ****pepe**** tenía permisos para usar ****sudo**** que permite convertirse en ****root**** (y ser el ****DIOS**** del sistema). Para cambiar la password hizo lo siguiente:
root@lab2:/# passwd Cambiando la contraseña de root. Introduzca la nueva contraseña de UNIX: Vuelva a escribir la nueva contraseña de UNIX: ```
Si un intruso logró obtener cuenta ****root****, estamos fritos! tiene completo control del sistema y sin que nos demos cuenta, salvo que haga algo muy evidente como borrar todo el disco, va a pasar desapercibido. Qué podemos hacer, para evitar esto?
# Mucho más fácil de recordar, frases de paso:
Si bien usamos el ejemplo de un intruso, lo más probable es que nosotros seamos root en muchos otros sistemas, como la compu del trabajo, la de casa, la de un amigo/a, etc. Y poder administrar varios sistemas remotos usando **SSH** u una sola terminal es posible.
Para esto instalamos ****Terminator****
Iniciamos ****Terminator**** y presionando ****CTRL-SHIFT-E**** y ****CTRL-SHIFT-O**** podemos dividir la pantalla vertical y horizontalmente tantas veces como sea necesario, obteniendo muchas terminales dentro de una sola y eligiendo la opción ****retransmitir a todas**** podemos tipear una sola vez y que ese comando vaya a todas las terminales conectadas! :-D => https://es.wikipedia.gmi/wiki/Ssh[3] 1: https://es.wikipedia.gmi/wiki/Ssh[4] => https://es.wikipedia.gmi/wiki/PuTTY[5] 2: https://es.wikipedia.gmi/wiki/PuTTY[6] => https://es.wikipedia.gmi/wiki/PuTTY[7] 3: https://es.wikipedia.gmi/wiki/PuTTY[8] # Entornos gráficos, ejecución remota de aplicaciones gráficas ## `ssh -X` Es posible ejecutar una aplicación gráfica de un servidor remoto visualizando en el equipo local por medio de `ssh`, solo es necesario incluir el parámetro `-X` y el servidor *X* se redireciona a nuestro *host*
ssh -X caipiroska 'gnome-calculator'
## `DISPLAY\`:0= Utilizando la aplicación `notify-send` se puede enviar un mensaje de notificación, normalmente es utilizado para visualizar eventos del sistema, y estoy lo podemos hacer en un equipo remoto mediante `ssh`:
ssh -X osiris@localhost "DISPLAY=:0 notify-send 'hola!'"
## `vnc4server` Habitualmente se utiliza **VNC** para compartir la sesión actual, pero también se pueden levantar instancias nuevas, pudiendo tener entornos gráficos diferentes en cada sesión de usuario en el mismo servidor. Es necesario ejecutar en el servidor:
vnc4server
# Procesos # AUTHOR: Osiris Alejandro Gomez # EMAIL: osiux@osiux.com # DATE: 2012-11-06 02:33 ## ¿Qué es proceso? # Un proceso es la instancia de un programa en ejecución. # También se lo conoce como tarea. ## ¿Por qué? # GNU/Linux es un sistema multitarea, permite la ejecución de múltiples procesos al mismo tiempo. # Comprender el concepto de procesos nos permite administrar el rendimiento de nuestro equipo. ## Lo que el usuario ve: => img/cfp-procesos-01.png [IMG] ## Lo que el sistema ve: => img/cfp-procesos-03.png [IMG] => img/cfp-procesos-04.png [IMG] ## `PID` # Todo proceso que se inicia tiene un número asignado llamado ****PID****. # Este ****PID**** permite identificar el proceso y administrarlo (detenerlo, reanudarlo etc...) # Ejemplo: Para obtener el ****PID**** de un proceso podemos usar el comando `pidof`:
El comando `ps` puede listar el estado de los procesos:
Los procesos se pueden controlar de manera externa.
El comando `kill`, `xkill` o `killall` permite enviarle señales a los procesos. Por ejemplo la señal de terminación:
El comando pstree nos permite ver la organización de los procesos en ejecución:
Para visualizar los procesos en ejecución, también se puede usar `htop` o `top`:
PID USER PR NI VIRT RES SHR S %CPU %MEM TIME+ COMMAND 8203 root 20 0 121m 18m 6500 S 5,9 0,9 3:47.59 Xorg 26355 osiris 20 0 26096 1488 1080 R 5,9 0,1 0:00.02 top 1 root 20 0 10648 788 652 S 0,0 0,0 0:12.03 init 2 root 20 0 0 0 0 S 0,0 0,0 0:00.16 kthreadd 3 root 20 0 0 0 0 S 0,0 0,0 14:15.93 ksoftirqd/0 6 root rt 0 0 0 0 S 0,0 0,0 0:00.00 migration/0 7 root -2 0 0 0 0 S 0,0 0,0 3:50.22 rcuc/0 8 root rt 0 0 0 0 S 0,0 0,0 0:00.00 rcun/0 9 root -2 0 0 0 0 S 0,0 0,0 0:00.00 rcub/0 10 root rt 0 0 0 0 S 0,0 0,0 0:00.00 rcun/1 11 root -2 0 0 0 0 S 0,0 0,0 0:00.00 rcub/1 12 root rt 0 0 0 0 S 0,0 0,0 0:00.00 migration/1 14 root -2 0 0 0 0 S 0,0 0,0 5:24.04 rcuc/1 ```
[2013-03-18 lun] migro slides pdf[1] de Hugo Ruscitti a `.gmi`
1: http://wiki.gcoop.coop/_media/apuntes:procesos.pdf[10]
Cada vez que ejecutamos un comando en una terminal, éste comando se convierte en un proceso hijo de la terminal que estamos ejecutando. Por ejemplo, si estamos en la interfase gráfica, la terminal sería ****gnome-terminal**** quien a su vez invoca al intérprete ****bash**** y desde ahí podríamos invocar a ****firefox****. Esto se puede visualizar de la siguiente manera:
4444 ? Ssl 0:13 gnome-terminal 4453 ? Z 0:00 \_ gnome-pty-helper 4454 pts/10 Ss 0:00 \_ bash 4509 pts/10 S+ 0:52 \_ firefox 6347 pts/13 Ss 0:00 \_ bash 11781 pts/13 S+ 0:01 | \_ ps fax 11782 pts/13 S+ 0:01 | \_ grep -C3 firefox ``` Lo que vemos es el árbol de ejecución de procesos y si cerramos la terminal, también se cerraría ****firefox**** por depender del proceso ****terminal****. ## Para mí, vos estás en segundo plano Al ejecutar un comando en una terminal, por ejemplo ****top****, este comando pasa a estar en primer plano y hasta que no interrumpamos el comando presionando ****CTRL-C**** o saliendo del mismo mediante la tecla ****q****, no se puede ejecutar ningún otro comando en el misma terminal. Para solucionar este inconveniente es posible pasar el proceso a ****segundo plano****, para esto sólo basta presionar ****CTRL-Z****, lo cual nos devuelve el ****PROMPT**** de la terminal para que invoquemos nuevos comandos. Es posible visualizar la lista de tareas mediante el comando ****jobs****, en este caso nos mostraría que está detenido:
Iniciamos Firefox como es costumbre de todos los días y empezamos a saltar de un sitio web a otro. Nada extraño sucede, leemos y escribimos comentarios, ingresamos a algún chat, en fin nos comunicamos con otras personas a través de la red.
Suponemos que debido a que estamos solos frente a la compu, nadie más está viendo todo lo que enviamos y recibimos a través de la red... :-S
Si mientras estamos usando la red, se nos ocurre ver qué datos pasan a través de la red, sólo necesitamos usar `tcpdump`:
Su uso es muy simple, solo basta indicar la interfaz de red:
El resultado es similar al siguiente:
Lo que vemos, es la información del encabezado de cada paquete que pasa por la interfaz de red, en este caso `eth2`. Si no sabemos qué interfaz de red utilizar o simplemente ver cuáles están disponibles, usamos el comando `ifconfig`:
Veríamos un listado similar al siguiente:
eth2 Link encap:Ethernet direcciónHW 00:15:84:2b:6b:8e Direc. inet:192.168.1.18 Difus.:192.168.1.255 Másc:255.255.255.0 Dirección inet6: fe80::215:84ff:fe2b:6b8e/64 Alcance:Enlace ACTIVO DIFUSIÓN FUNCIONANDO MULTICAST MTU:1500 Métrica:1 Paquetes RX:632042 errores:0 perdidos:0 overruns:0 frame:0 Paquetes TX:647823 errores:0 perdidos:0 overruns:0 carrier:0 colisiones:0 long.colaTX:1000 Bytes RX:207733278 (207.7 MB) TX bytes:291419413 (291.4 MB) Interrupción:18 Dirección base: 0xc800 lo Link encap:Bucle local Direc. inet:127.0.0.1 Másc:255.0.0.0 Dirección inet6: ::1/128 Alcance:Anfitrión ACTIVO BUCLE FUNCIONANDO MTU:16436 Métrica:1 Paquetes RX:186169 errores:0 perdidos:0 overruns:0 frame:0 Paquetes TX:186169 errores:0 perdidos:0 overruns:0 carrier:0 colisiones:0 long.colaTX:0 Bytes RX:37061384 (37.0 MB) TX bytes:37061384 (37.0 MB) ``` En este caso contamos con `eth0`, `eth2` y `lo` que es la interfaz local. Como se puede ver, la `eth2` tiene la dirección ****IP**** `192.168.1.18`. Si quisieramos ver las ****IPs**** y los números de puertos en lugar de los nombres de dominio y servicios asociados, debemos usar el parámetro `-n`:
Ahora se reemplaza `osiale.gcoop.com.ar` por `192.168.1.18`, `ssh` por `22`, `domain` por `53` y `malbec` por `192.168.1.1`:
El tráfico de red que capturamos depende mucho de en que lugar de la red estamos parados, no es lo mismo hacerlo desde un punto terminal que hacerlo entre un ****router**** y un ****switch**** o desde el ****gateway**** de salida a internet de toda la red. En los puntos donde se concentran todas conexiones vamos va ver el tráfico de más máquinas, es decir más personas! ## mirando en profundidad Es posible el contenido de los paquetes en formato ASCII mediante el parámetro `-A`, indicar la cantidad de paquetes a capturar con `-c` y aplicar filtros, como por ejemplo que solo nos interesar capturar el tráfico que enviamos a los sitios web, o sea filtrar por puerto de destino `80`. La sentencia sería la siguiente:
En este caso logramos capturar la consulta al sitio `osiux.com` que corresponde a la ****IP**** `67.208.113.123` y puerto `80`, para esto se está usando un `Firefox` versión `15.0.1` en una máquina con `Ubuntu` y el idioma preferido es `es~ar~` (Español, Argentina).
En este caso, el que realiza la consulta es la ****IP**** `192.168.1.18` desde el puerto `57935`.
Es muchísima información la que se puede obtener con observar un sólo paquete de red! Entonces podemos saber: # qué sitios se visitan # quiénes los miran # qué escriben # qué leen ## y si chateamos? Probemos que sucede si chateamos en la red local, sin salir a Internet. Para esto, usamos ****Pidgin****, un programa que soporta casi todos los protocolos y servicios de chat existentes. Primero instalamos ****Pidgin****:
Luego lo iniciamos, escribiendo `pidgin` en una terminal o lo buscamos en el menú de la interfaz gráfica, debería estar en ****Aplicaciones->Internet->Pidgin****
Al iniciar, nos solicita ****añadir**** una cuenta, elegimos el protocolo ****Bonjour**** e ingresamos nuestro ****Nombre**** y ****Apodo****, para finalizar presionamos ****Aceptar**** y luego ****Cerrar****.
Listo, ahora vamos a poder chatear con todos aquellos que en la red local, tengan instalando un programa que soporte el protocolo ****Bonjour****, también conocido como ****IChat**** o ****Avahi****.
Comenzamos a chatear con nuestros amigos y al mismo tiempo ejecutamos `tcpdump` filtrando por el puerto `5298`
El resultado de capturar 5 paquetes es:
Si miramos el primer paquete ignorando los caracteres especiales, se puede ver que el mensaje es para ****Leito**** desde la máquina ****zapata**** y lo envía ****osiris**** desde la máquina ****osiale**** y el cuerpo del mensaje se encuentra entre las ****etiquetas**** `<body>` y `</body>`.
Entonces, quiere decir que tanto lo que navegamos como lo que chateamos puede ser interceptado y leído por cualquiera en la red, solo basta usar `tcpdump`. ## el fin de la privacidad? Cualquier ****sniffer**** como `tcpdump` puede capturar todo el tráfico de la red y hasta se podría modificar el contenido de los paquetes que viajan a través de la red sin que nos demos cuenta. Y entonces, cómo hacemos para tener algo de privacidad? La respuesta es ****no enviar mensajes en texto plano****, para esto lo mejor es ****cifrar todos los mensajes****, hay varios protocolos que envían y reciben todos los datos de manera cifrada. En el caso de los sitios webs es posible acceder por ****HTTPS**** en lugar de ****HTTP****, por ejemplo, en lugar de ir a `http://google.com%5C%60[19] podemos acceder a `https://encrypted.google.com/%5C%60[20] y asi todo lo que enviemos a ****google**** irá cifrado y aunque alguien capture ese tráfico de red, ****no podrá entenderlo****, aunque no evitaremos que sepan que estamos ingresando al sitio ****google.com****. Tener que tipear ****https**** en lugar de ****http**** todo el tiempo no es algo cómodo y además la mayoría de las páginas web hacen enlaces a los sitios usando ****http****. La solución a este problema es instalar un ****plugin**** en el navegador, por ejemplo para ****Firefox**** existe ****HTTPSEveryWhere****, que hace esto por nosotros y soporta una gran lista de sitios webs, obviamente los más usados. Para instalarlo, acceder a: https://www.eff.gmi/https-everywhere-node%5B1%5D[21] También existen otras alternativas como usar un ****túnel SSH****. Siempre que dispongamos de una máquina remota con GNU/Linux conectada a internet (en nuestra casa, por ejemplo) podríamos usarla para cifrar nuestra conexión y lograr (por lo menos) que en la red local, en la que estamos actualmente nadie pueda ver lo que hacemos. Para esto, podemos hacer lo siguiente:
De esta manera, de ahora en más vamos a tener un ****Proxy SOCKS**** corriendo en el puerto `9090`, sólo bastaría decirle a todas las aplicaciones que usan la red, que no se conecten directamente, sino que utilicen `localhost:9090` como servidor ****Proxy****.
En ****Firefox**** ir a ****Editar->Preferencias->Avanzadas->Red->Configuración****
Ahí seleccionamos ****Configuración manual de proxy**** e ingresamos en ****Servidor proxy SOCKS**** la dirección ****localhost y el puerto 9090****, presionamos ****Aceptar****, y listo, ya podemos navegar tranquilos.
En realidad, sólo estamos cifrando un tramo de la conexión, desde la máquina en donde estamos hasta la máquina remota, desde esta última el tráfico viajará sin el cifrado de ****SSH****.
Podemos decirle a `tcpdump` que en lugar de mostrarnos el tráfico de red, lo guarde en un archivo, para luego analizarlo en profundidad. También se utiliza para hacer monitoreo remoto o buscar la causa de algún problema en la red, detectar alguna intrusión no autorizada, hacer auditorías, etc.
Mediante `-s 0` indicamos que capture el paquete completo y con `-w` se especifica el archivo donde se guarda el tráfico.
Existen muchas herramientas que leen archivos `.pcap`, una de ellas es ****Wireshark****, que es un analizador de protocolos muy completo y que además posee interfaz gráfica. Lo instalamos:
Podemos indicar a ****WireShark**** que inicie leyendo el archivo:
También se puede iniciar desde el menú ****Aplicaciones->Internet->Wireshark**** Una vez iniciado, se puede apreciar que la pantalla está dividida en tres partes, que serían: # el listado de paquetes # panel de detalles del paquete seleccionado # panel de bytes del paquete seleccionado Es bastante intuitivo y muy interesante para los curiosos! :-D ## no entendí nada! :-( El análisis de tráfico de red, requiere de ciertos conocimientos básicos de redes, sobre el modelo ****OSI**** y el modelo ****TCP/IP****, saber sobre ****DNS****, ****ARP**** y otras tantas cosas como los ****RFC****, pero a no desesperar, leer aunque sea muy por arriba los siguiente links: # https://es.wikipedia.gmi/wiki/Modelo_osi%5B2%5D[22] # https://es.wikipedia.gmi/wiki/Modelo_TCP/IP%5B3%5D[23] La próxima entrega veremos en un lenguaje muy simple y claro, lo básico de cómo funcionan las redes y sobre todo cómo interactúan los distintos elementos que la componen. La idea de usar ****tcpdump**** era volverlos un poquito paranoicos, ahora saben que es muy probable que alguien en algún punto de la red, esté mirando (y hasta guardando) todos los datos que enviamos y recibimos, aunque sólo se trate del **Administrador de la Red**. => https://www.eff.gmi/https-everywhere-node[24] 1: https://www.eff.gmi/https-everywhere-node[25] => https://es.wikipedia.gmi/wiki/Modelo_osi[26] 2: https://es.wikipedia.gmi/wiki/Modelo_osi[27] => https://es.wikipedia.gmi/wiki/Modelo_TCP/IP[28] 3: https://es.wikipedia.gmi/wiki/Modelo_TCP/IP[29] # Introducción a las redes TCP/IP # Configuración de servicios básicos ## Apache # AUTHOR: Osiris Alejandro Gómez # EMAIL: osiux@osiux.com # DATE: 2014-02-10 11:56 Instalar Apache
Crear un VirtualHost
Primero se debe crear un archivo preferentemente con el nombre del dominio y ubicarlo en `sites-available`.
El contenido debe tener al menos los siguientes parámetros:
Luego se debe habilitar el sitio, de la siguiente manera:
Iniciar, Detener y Reiniciar Apache Los cambios en los VirtualHost son aplicados sólo cuando se reinicia el servicio, es posible hacerlo de dos maneras:
## Configurar PHP
memory~limit~ = 128M error~reporting~ = E~ALL~ upload~maxfilesize~ = 20M ```
![[IMG]](/kennedy.gemi.dev/archive/cached?url=gemini%3a%2f%2fgmi.osiux.com%2fimg%2fstdout-file.png&t=638106042870000000&raw=False){kind=link}
![[IMG]](/kennedy.gemi.dev/archive/cached?url=gemini%3a%2f%2fgmi.osiux.com%2fimg%2fstderr-file.png&t=638106042870000000&raw=False){kind=link}
![[IMG]](/kennedy.gemi.dev/archive/cached?url=gemini%3a%2f%2fgmi.osiux.com%2fimg%2fstderr-stdout-file.png&t=638106042870000000&raw=False){kind=link}
![[IMG]](/kennedy.gemi.dev/archive/cached?url=gemini%3a%2f%2fgmi.osiux.com%2fimg%2fstderr-stdout.png&t=638106042870000000&raw=False){kind=link}
![[IMG]](/kennedy.gemi.dev/archive/cached?url=gemini%3a%2f%2fgmi.osiux.com%2fimg%2fstdout-dev-null.png&t=638106042870000000&raw=False){kind=link}
![[IMG]](/kennedy.gemi.dev/archive/cached?url=gemini%3a%2f%2fgmi.osiux.com%2fimg%2fstderr-stdout-dev-null.png&t=638106042870000000&raw=False){kind=link}
![[IMG]](/kennedy.gemi.dev/archive/cached?url=gemini%3a%2f%2fgmi.osiux.com%2fimg%2fstdin-file.png&t=638106042870000000&raw=False){kind=link}
![[IMG]](/kennedy.gemi.dev/archive/cached?url=gemini%3a%2f%2fgmi.osiux.com%2fimg%2ftee-stdout-file.png&t=638106042870000000&raw=False){kind=link}
![[IMG]](/kennedy.gemi.dev/archive/cached?url=gemini%3a%2f%2fgmi.osiux.com%2fimg%2fstdout-pipe-stdin.png&t=638106042870000000&raw=False){kind=link}
![[IMG]](/kennedy.gemi.dev/archive/cached?url=gemini%3a%2f%2fgmi.osiux.com%2fimg%2fcfp-procesos-07.png&t=638106042870000000&raw=False){kind=link}
![[IMG]](/kennedy.gemi.dev/archive/cached?url=gemini%3a%2f%2fgmi.osiux.com%2fimg%2fcfp-procesos-08.png&t=638106042870000000&raw=False){kind=link}
![[IMG]](/kennedy.gemi.dev/archive/cached?url=gemini%3a%2f%2fgmi.osiux.com%2fimg%2fcfp-procesos-11.png&t=638106042870000000&raw=False){kind=link}
<? include "DB.php"; mysql = new DB(); $dsn = 'mysqli://usuario:secreto@localhost/mibase; b = $mysql->connect($dsn); echo '<table bgcolor="gray" border="0" cellspacing="1" cellpadding="1">'; $query = "SELECT c.name, e.email~address~ from contacts c INNER JOIN contacts~emails~ ce on ce.contact~id~ = c.id INNER JOIN emails e on e.id = ce.email~id~ ORDER BY c.name, e.address;"; $result = $db->query($query); while($row = $result->fetchRow (DB~FETCHMODEASSOC~)) { printf('<tr> <td bgcolor="white">%s</td> <td bgcolor="white">%s</td> </tr>',$row['name'],$row['address']); } echo '</table>'; ?> ```
## MySQL
# AUTHOR: Osiris Alejandro Gomez
# EMAIL: osiux@osiux.com
# DATE: 2009-12-01 01:15
## Crear Base y Usuario
## UTF8 Definir UTF8 en el cliente
Definir UTF8
## MySQL de Bash Definir Alias
Ejecutar consulta
Listado de Tablas
Listado Tabla Campo
Quitar nombre de campo
Vaciar todas las tablas que contengan la palabra ****calls****
## MySQL desde Vim Agregar en `.vimrc`
Ejecutar todo el archivo
Ejecutar la línea actual
Ejecutar un rango de líneas
Ejecutar desde línea actual hasta el final
Usar diccionarios
CTRL-X CTRL-K ``` ## Reemplazar Texto ### Traducir valores
## Buscar duplicados1 ORDER BY last~name~, first~name~; ```">
500 ORDER BY total DESC; ```"> ## Cruzando tablas Explicito mejor que implicito
SELECT COUNT(cc.id) AS total FROM calls~contacts~ cc, contacts co WHERE co.deleted = 0 AND co.id = cc.contact~id~ AND cc.deleted = 0 ```
Contactos con llamadas
Contactos con llamadas entrantes
Actualizar las llamadas de un contacto
UPDATE calls ca INNER JOIN calls~contacts~ cc ON cc.call~id~ = ca.id INNER JOIN contacts co ON co.id = cc.contact~id~ SET ca.assigned~userid~ = ( SELECT id FROM users WHERE user~name~ = 'osiris' ) WHERE co. = '2a756d50-ae20-0754-a7c7-49beb64cee37'; ``` ## Insertar desde otra tabla
CREATE TABLE `calls~contactstoday~` ( `id` varchar(36) NOT NULL, `contact~id~` varchar(36) NOT NULL, `call~id~` varchar(36) NOT NULL, `status` varchar(25) default NULL, `direction` varchar(25) default NULL, PRIMARY KEY (`call~id~`) );
INSERT INTO calls~contactstoday~ (id, contact~id~, call~id~, status, direction) SELECT UUID(), cc.contact~id~, ca.id, ca.status, ca.direction FROM calls ca INNER JOIN calls~contacts~ cc ON cc.call~id~ = ca.id WHERE DATE(ca.date~start~) = CURDATE(); ```
SELECT FROM t<Presionar TAB> ``` ## COUNT
## INDEX
## AUTO~INCREMENT~
AND postal REGEXP '^[A-Z]{3}[0-9]{4}