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

domingo, 27 de noviembre de 2016

Fundamentales. Directorios II


Para terminar con el tema de los directorios y después de ver en el post anterior los comandos relativos a ellos, vamos a ver algunos directorios que debemos de conocer en Linux y que contienen. Hay que tener en cuenta que cada distribución de Linux puede tener otros directorios o tener una ubicación distinta. Los que vamos a ver son, hasta donde yo conozco, comunes a muchos sistemas *nix (SCO-UNIX, HP-UX, Linux…etc.).


/home: Es el directorio donde se van a crear los subdirectorios de cada usuario del sistema a excepción del usuario root. Por ejemplo, cuando creemos un usuario llamado pepe se creará, al menos, un subdirectorio con ese nombre en /home.

sábado, 19 de noviembre de 2016

Fundamentales. Directorios


Hoy vamos a ver dos cosas: como movernos en el árbol de directorios y otros comandos útiles para manipularlos

Que es un directorio

Pues de forma básica es eso que conocemos en Windows como carpeta (para mí siempre serán directorios a pesar de Microsoft J). En la Wikipedia podemos encontrar esta definición de directorio:
“En informática, un directorio es un contenedor virtual en el que se almacenan una agrupación de archivos informáticos y otros subdirectorios, atendiendo a su contenido, a su propósito o a cualquier criterio que decida el usuario. Técnicamente, el directorio almacena información acerca de los archivos que contiene: como los atributos de los archivos o dónde se encuentran físicamente en el dispositivo de almacenamiento.”

domingo, 6 de noviembre de 2016

Fundamentals: HTTP – REFERER



Autor: @txambe

En el articulo de hoy vamos a revisar el tema de las cabeceras de HTTP REFERER , para aquello que desconozcáis de que son , os pongo el resumen que hay en la wikipedia.

Fuente:  WiKipedia

HTTP referer (inicialmente un error ortográfico del término referrer) es una cabecera HTTP que identifica la dirección de la página web (es decir, la URI o IRI) que creó el vínculo con el recurso que está siendo solicitado. A través del chequeo del campo referer, la nueva página web puede determinar dónde se originó la solicitud.

En la mayoría de los casos esto significa que cuando un usuario hace clic a un hipervínculo en un navegador web, el navegador envía una solicitud al servidor que hospeda la página web destino y dicha solicitud incluye el campo referer, que indica la última página que el usuario visitó (aquella donde el usuario hizo clic al vínculo).

El registro del campo referer es utilizado con propósitos estadísticos y promocionales por los sitios web y servidores web, pues les permite identificar desde qué localización están siendo visitados.1
También es muy recomendable revisarse la RFC 2616, sección 14.36  que explica en detalle el HTTP Referer y en la sesión 15.1.3 se ven las  consideraciones de seguridad que deben cumplir los agentes de usuario como por ejemplo no incluir el Referer cuando se pase de HTTPS a HTTP por los problemas de exposición de información sensible.

En la siguiente imagen podemos ver un encabezado HTTP y como el navegador web esta informando al servidor , a través de referer ,  que esta solicitando el recurso htaccess.html  
se está realizando desde la portada de  /http-headers-tool


No hay que confundirse con el  metadato HTML Referrer  que se ocupa de especificar que valores va a contener el campo de encabezado  de petición Referer, según la política de Referrer de la W3C  que se aplique. El Referer, al igual que el Etag  han suscitado bastantes sospechas respecto a su uso, utilizados por afectar la privacidad de los usuarios. Mediante el Referer puede registrarse los hábitos de navegación de las personas a través de la recolección de los saltos realizados entre páginas, estableciéndose patrones de comportamiento en Internet.

  Al realizar una prueba de pentesting es importante revisar cual es el Referer entre peticiones ,  para lo cual podemos aplicar la prueba de seguridad  OTG-AUTHN-001  para entender si las credenciales son enviadas a través de un canal seguro.

sábado, 22 de octubre de 2016

Fundamentals: Instalación de Proxychain y Tor en Kali



Autor: @txambe

En el articulo de hoy vamos a ver  cómo instalar, configurar y utilizar Proxychains y Tor en Kali Linux de manera a que nuestra privacidad esté siempre garantizada y podamos que, aunque el servidor nos identifique, poder cambiar nuestra identidad fácilmente pudiendo seguir manteniendo al máximo nuestro anonimato.
Lo primero que debemos hacer es actualizar el sistema con los parches y con las aplicaciones más recientes, para ello abriremos un terminal y teclearemos:
  • sudo apt-get update && sudo apt-get upgrade
Esperaremos a que se actualicen los repositorios y se instalen todas las actualizaciones antes de continuar con este proceso. Una vez actualizado nuestro sistema instalaremos Tor en él desde los mismos repositorios tecleando:

  • sudo apt-get install tor


Cuando finalice la instalación de este módulo iniciamos el servicio :
  • sudo service tor start
Comprobamos que se ha iniciado correctamente con:
  • sudo service tor status

Con Tor ya iniciado vamos a modificar el archivo de configuración de Proxychains, para ello teclearemos:
  • sudo nano /etc/proxychains.conf
En este archivo debemos realizar los siguientes cambios:
  • Des-comentar borrando el # la línea dynamic_chain
  • Comentar con un # la línea strict_chain
  • Añadir al final de archivo: socks5 127.0.0.1 9050


Con estos pasos ya tenemos todo listo. Ya podemos abrir una nueva pestaña de navegación anónima tecleando:
  • proxychains iceweasel www.loquesea.net
Y comprobar desde cual-es-mi-ip.net que la IP que obtenemos no es la misma que tenemos realmente en nuestra conexión, sino que está ofuscada por la red Tor.

A partir de ahora, todo el tráfico que generemos en la ventana del navegador abierta desde el comando anterior mucho cuidado con esto ,será totalmente anónima, pudiendo establecer una conexión directa no anónima desde cualquier otra ventana que abramos manualmente del mismo navegador.

Happy h@cking

jueves, 13 de octubre de 2016

NMAP SCRIPTING ENGINE




Autor : @txambe

En el articulo de hoy vamos a ver una forma distinta de utilizar esta herramienta tan potente como es nmap normalmente utilizada como escaneador de puertos, en esta ocasión la utilizaremos como escaner de vulnerabilidades , no llega a la potencia de Nessus , Openvas , pero en determinados escenarios que no podamos utilizar dichos programas, nmap es un gran aliado a tener en cuenta.

Nmap Scripting Engine ( NSE ) es una de las opciones mas potentes que tiene nmap a parte de su función como escaner de red. Permite escribir scripts para automatizar tareas de red. Esos scripts pueden ser ejecutados en paralelo para así aprovecharse de de la velocidad y eficiencia de nmap.

Con NSE podemos acabar distintas tareas.

·         Auth: Verifica procesos de autenticación.
·         brute: Obtención de información por medio de fuerza bruta.
·         discovery: Recuperación de información de equipos.
·         dos: Relacionados con ataques del tipo DoS.
·         external: Script que utilizan servicios de terceras partes.
·         intrusive: Utiliza scripts que son considerados intrusivos para la víctima o target.
·         safe: ejecuta scripts “seguros” en cuanto a la intrusión de sistemas.
·         vuln: Verifica la existencia de las vulnerabilidades más conocidas.

Para mantener actualizados los scripts debemos ejecutar el comando nmap con –script-updatedb como parámetro.

En /usr/share/nmap/scripts/ (dependiendo el SO que corremos), se encuentran todos los scripts disponibles.

Comentar que los script de nmap están realizados en lenguaje LUA.

Para activar NSE deberemos escribir en la linea de comandos la opción -sC o --script si se quiere indicar un conjunto de scripts. Nmap soporte dos tipos de scripts de tipo servicio y de host..

Los  de tipo servicio relacionan  puertos abiertos ( servicio asociado )  en el objetivo.



Usando NSE

Para iniciar el motor de scripts:

 $nmap -sC 

Para seleccionar un script:

 $nmap –script

Pasar argumentos a los scripts:

   --script-args “http.useragent=0, hhtp.pipeline=15”
   --script-args  http.useragent=CUM,pipeline=10
   --script-args  whois={whodb=”no follow”}


Para realizar una selección  avanzada de scripts:

 nmap -p80 –script “http-*and(not(httpd-brute or http-slowloris))” < objetivo>


Recomendaciones de uso

No usar los dns de tu ISP , mejor usar los de google , por ejemplo:

nmap –dns-servers 8.8.8.8,8.8.4.4


Variar la configuración de tiempo:

nmap T5
Usar el filtro -p si solo interesa el resultado de cierto servicio:

$nmap -p80 –script http-trace 

Si trabajamos con scripts de tipo HTTP , mi recomendación es cambiar el user-agent:

$nmap -p80 –script http-enum 

Debido a la cantidad de argumentos que tiene , es recomendable tener otra consola abierta , en la carpeta donde están los scripts y usar:

c a t < script > | grep @args

O también entrar dentro de la carpeta de los scripts y desde ahí lanzar los scripts.


También una buena fuente de información sobre scripts no aceptados al repositorio oficial:


Enlaces interesantes a scripts no oficiales:

·         vulscan
·         http-google-email
·         http-screenshot

En este punto quería hablaros de una herramienta interesante , NSEarch no es mas que un buscador de scripts la podéis descargar de https://github.com/JKO/nsearch


Una vez descargada la herramienta , solo hay que descomprimir y lanzar su instalador. Cuando ya se encuentra instalada se puede ejecutar con el siguiente comando:

python nsearch.py



En el siguiente enlace podéis encontrar mas información:


Para distinguir entre versiones:

            Para la versión 5:  local http = require “http”

            Para la versión 6:  require “http”


Reglas de ejecución

Todos los scripts tendrán por lo menos una  de las siguientes funciones:

·         prerule()
·         hostrule(host)
·         postrule(host,port)
·         postrule()

Ejemplos de reglas de ejecución

Hay aliases como shortport.http

http = shortport_or_service ({80, 443 , 631 , 7080 , 8080 , 8088 , 5800 , 3872 , 8180 , 8000 }, {“http”,”https”,”ipp”,”http-alt”,”vnc-http”,”oem-agent”})

Una regla para servidores:

posrtrule = shortport.http


Formatos de salida

Nmap soporta distintos formatos de salida de datos XML, greppable ( aunque esta ya en desuso todavia nos puede ser útil en ciertas situaciones )  y normal. Pero solo se guardarán los datos si seleccionamos los formatos XML o normal.

Formato XML

Nmap genera elementos para el escaneo de puertos, detección de servicios y NSE. Anteriormente se guardaba en un elemento llamado ·         EXPOITABLE
·         VULNERABLE
·         NOT_VULN
 
Es muy recomendable asignarlo durante la ejecución:
 
vuln.state = vulns.STAT.VULN
 
Para generar el reporte se utiliza la función vulns.Report.make_output():
 
local report = vulns.Report:new(SCRIPT_NAME,host,port) return report:make_output(vuln_table)
 
 
Referencias:
 
·         https://nmap.org/book/nse.html
·         https://nmap.org/nsedoc/
 
 
Espero que os resulte de interés.
 
 
Happy h@cking.
 

 


-->< script > dentro del atributo ouput.

Al usar la función stdnse.output_table para guardar nuestros datos de salida se auto genera todo el árbol XML.

            Nse:

            local ouput_tab = stdnse.ouput_table()
            ouput_tab.ip = host.ip
            output_tab.hosts = domains

            return output_tab

Reporte de vulnerabilidades

Para realizar un reporte de vulnerabilidades, utilizaremos la librería vulns. La librería tiene una variable que lleva el registro del estado de la vulnerabilidad encontrada:

·         EXPOITABLE
·         VULNERABLE
·         NOT_VULN

Es muy recomendable asignarlo durante la ejecución:

vuln.state = vulns.STAT.VULN

Para generar el reporte se utiliza la función vulns.Report.make_output():

local report = vulns.Report:new(SCRIPT_NAME,host,port) return report:make_output(vuln_table)


Referencias:

·         https://nmap.org/book/nse.html
·         https://nmap.org/nsedoc/


Espero que os resulte de interés.


Happy h@cking.


domingo, 9 de octubre de 2016

Error de GPG al actualizar paquetes en Kali


Autor: @txambe

Esta semana se estrena en nuestro blog @txambe y nos cuenta sus problemas al actualizar Kali Linux, esta fue su experiencia.

Después de actualizar Kali Linux a la última versión  cuando ejecute un apt-get update me daba el error de GPG :
 “ GPG error: http://http.kali.org /kali Release: The following signatures couldn't be verified because  the  public key is not available  “


root@kali:~# aptitude update

Hit http://dl.google.com stable Release.gpg
Hit http://dl.google.com stable Release                                                      
Hit http://dl.google.com stable/main amd64 Packages                                          
Des: 1 http://repo.kali.org kali-bleeding-edge Release.gpg [819 B]                                                                                      
Des: 2 http://repo.kali.org kali-bleeding-edge Release [11,0 kB]
Err http://repo.kali.org kali-bleeding-edge Release                                             
Ign http://dl.google.com stable/main Translation-es_SV         
Ign http://dl.google.com stable/main Translation-es
Ign http://dl.google.com stable/main Translation-en
Des: 3 http://security.kali.org kali/updates Release.gpg [819 B]
Des: 4 http://http.kali.org kali Release.gpg [819 B]
Des: 5 http://security.kali.org kali/updates Release [11,0 kB]
Err http://security.kali.org kali/updates Release             
Des: 6 http://http.kali.org kali Release [21,1 kB]
Err http://http.kali.org kali Release
Descargados 23,6 kB en 3seg. (7.332 B/s)
W: Se produjo un error durante la verificación de las firmas. El repositorio no está actualizado y se utilizarán los ficheros de índice antiguos. El error GPG es: http://repo.kali.org kali-bleeding-edge Release: Las siguientes firms fueron inválidas: KEYEXPIRED 1425567400 KEYEXPIRED 1425567400 KEYEXPIRED 1425567400

W: Se produjo un error durante la verificación de las firmas. El repositorio no está actualizado y se utilizarán los ficheros de índice antiguos. El error GPG es: http://security.kali.org kali/updates Release: Las siguientes firms fueron inválidas: KEYEXPIRED 1425567400 KEYEXPIRED 1425567400 KEYEXPIRED 1425567400

W: Se produjo un error durante la verificación de las firmas. El repositorio no está actualizado y se utilizarán los ficheros de índice antiguos. El error GPG es: http://http.kali.org kali Release: Las siguientes firms fueron inválidas: KEYEXPIRED 1425567400 KEYEXPIRED 1425567400 KEYEXPIRED 1425567400

W: Se produjo un fallo al descargar http://repo.kali.org/kali/dists/kali-bleeding-edge/Release:
W: Se produjo un fallo al descargar http://security.kali.org/kali-security/dists/kali/updates/Release:
W: Se produjo un fallo al descargar http://http.kali.org/kali/dists/kali/Release:
W: Some index files failed to download. They have been ignored, or old ones used instead.


El problema tal como se muestra es que la llave pública GPG ha caducado, así que tenemos que importar la llave nueva que firma y da validez a los repositorios de Kali Linux.


Primero, debemos listar las claves de los repositorios que tenemos en el llavero (key-ring) con el comando apt-key list, por aquí el comando y su resultado:



root@kali:~# apt-key list



/etc/apt/trusted.gpg
--------------------
pub   1024D/7FAC5991 2007-03-08
uid                  Google, Inc. Linux Package Signing Key
sub   2048g/C07CB649 2007-03-08

/etc/apt/trusted.gpg.d//debian-archive-jessie-automatic.gpg
-----------------------------------------------------------
pub   4096R/2B90D010 2014-11-21 [caduca: 2022-11-19]
uid                  Debian Archive Automatic Signing Key (8/jessie)

/etc/apt/trusted.gpg.d//debian-archive-jessie-security-automatic.gpg
--------------------------------------------------------------------
pub   4096R/C857C906 2014-11-21 [caduca: 2022-11-19]
uid                  Debian Security Archive Automatic Signing Key (8/jessie)

/etc/apt/trusted.gpg.d//debian-archive-jessie-stable.gpg
--------------------------------------------------------
pub   4096R/518E17E1 2013-08-17 [caduca: 2021-08-15]
uid                  Jessie Stable Release Key

/etc/apt/trusted.gpg.d//debian-archive-squeeze-automatic.gpg
------------------------------------------------------------
pub   4096R/473041FA 2010-08-27 [caduca: 2018-03-05]
uid                  Debian Archive Automatic Signing Key (6.0/squeeze)

/etc/apt/trusted.gpg.d//debian-archive-squeeze-stable.gpg
---------------------------------------------------------
pub   4096R/B98321F9 2010-08-07 [caduca: 2017-08-05]
uid                  Squeeze Stable Release Key

/etc/apt/trusted.gpg.d//debian-archive-wheezy-automatic.gpg
-----------------------------------------------------------
pub   4096R/46925553 2012-04-27 [caduca: 2020-04-25]
uid                  Debian Archive Automatic Signing Key (7.0/wheezy)

/etc/apt/trusted.gpg.d//debian-archive-wheezy-stable.gpg
--------------------------------------------------------
pub   4096R/65FFB764 2012-05-08 [caduca: 2019-05-07]
uid                  Wheezy Stable Release Key

/etc/apt/trusted.gpg.d//kali-archive-keyring.gpg
------------------------------------------------
pub   4096R/7D8D0BF6 2012-03-05 [caducó: 2015-03-05]
uid                  Kali Linux Repository


Tal como se puede ver la fecha de caducidad, el uid de los repositorios de Kali Linux caducó el 5 de Marzo del año en curso 2015

Así que vamos a solucionar esto con el siguiente comando (más abajo el comando con su resultado):

apt-key adv --keyserver hkp://keys.gnupg.net --recv-keys 7D8D0BF6


root@kali:~# apt-key adv --keyserver hkp://keys.gnupg.net --recv-keys 7D8D0BF6

Executing: gpg --ignore-time-conflict --no-options --no-default-keyring --secret-keyring /tmp/tmp.sYzbsBXbRo --trustdb-name /etc/apt//trustdb.gpg --keyring /etc/apt/trusted.gpg --primary-keyring /etc/apt/trusted.gpg --keyring /etc/apt/trusted.gpg.d//debian-archive-jessie-automatic.gpg --keyring /etc/apt/trusted.gpg.d//debian-archive-jessie-security-automatic.gpg --keyring /etc/apt/trusted.gpg.d//debian-archive-jessie-stable.gpg --keyring /etc/apt/trusted.gpg.d//debian-archive-squeeze-automatic.gpg --keyring /etc/apt/trusted.gpg.d//debian-archive-squeeze-stable.gpg --keyring /etc/apt/trusted.gpg.d//debian-archive-wheezy-automatic.gpg --keyring /etc/apt/trusted.gpg.d//debian-archive-wheezy-stable.gpg --keyring /etc/apt/trusted.gpg.d//kali-archive-keyring.gpg --keyserver hkp://keys.gnupg.net --recv-keys 7D8D0BF6

gpg: solicitando clave 7D8D0BF6 de hkp servidor keys.gnupg.net
gpg: clave 7D8D0BF6: "Kali Linux Repository " 32 firmas nuevas
gpg: no se encuentran claves absolutamente fiables
gpg: Cantidad total procesada: 1
gpg:               nuevas firmas: 32



root@kali:~# apt-key list

/etc/apt/trusted.gpg
--------------------
pub   1024D/7FAC5991 2007-03-08
uid                  Google, Inc. Linux Package Signing Key
sub   2048g/C07CB649 2007-03-08

/etc/apt/trusted.gpg.d//debian-archive-jessie-automatic.gpg
-----------------------------------------------------------
pub   4096R/2B90D010 2014-11-21 [caduca: 2022-11-19]
uid                  Debian Archive Automatic Signing Key (8/jessie)

/etc/apt/trusted.gpg.d//debian-archive-jessie-security-automatic.gpg
--------------------------------------------------------------------
pub   4096R/C857C906 2014-11-21 [caduca: 2022-11-19]
uid                  Debian Security Archive Automatic Signing Key (8/jessie)

/etc/apt/trusted.gpg.d//debian-archive-jessie-stable.gpg
--------------------------------------------------------
pub   4096R/518E17E1 2013-08-17 [caduca: 2021-08-15]
uid                  Jessie Stable Release Key

/etc/apt/trusted.gpg.d//debian-archive-squeeze-automatic.gpg
------------------------------------------------------------
pub   4096R/473041FA 2010-08-27 [caduca: 2018-03-05]
uid                  Debian Archive Automatic Signing Key (6.0/squeeze)

/etc/apt/trusted.gpg.d//debian-archive-squeeze-stable.gpg
---------------------------------------------------------
pub   4096R/B98321F9 2010-08-07 [caduca: 2017-08-05]
uid                  Squeeze Stable Release Key

/etc/apt/trusted.gpg.d//debian-archive-wheezy-automatic.gpg
-----------------------------------------------------------
pub   4096R/46925553 2012-04-27 [caduca: 2020-04-25]
uid                  Debian Archive Automatic Signing Key (7.0/wheezy)

/etc/apt/trusted.gpg.d//debian-archive-wheezy-stable.gpg
--------------------------------------------------------
pub   4096R/65FFB764 2012-05-08 [caduca: 2019-05-07]
uid                  Wheezy Stable Release Key

/etc/apt/trusted.gpg.d//kali-archive-keyring.gpg
------------------------------------------------
pub   4096R/7D8D0BF6 2012-03-05 [caduca: 2018-02-02]
uid                  Kali Linux Repository
sub   4096R/FC0D0DCB 2012-03-05 [caduca: 2018-02-02]


Como se puede ver, el llavero de claves del repositorio de Kali ahora caducará hasta el 2 de Febrero de 2018

Despues de actualizar la clave, ya pude ejecutar apt-get update sin problemas y actualizar la versión de los paquetes con apt-get upgrade


Happy H@cking

miércoles, 31 de agosto de 2016

Fundamentales. Vi


Autor: @jantoniorobledo

Soy uno de esos nostálgicos que pese a existir alternativas sigo editando ficheros de texto con “vi” (ahora “vim”), será porque después de tantos años trabajando en entornos *nix (Unix, HP-UX, Linux de distintos sabores…) en un elemento común a todos ellos, por costumbre, por pereza a usar otras herramientas, por masoquismo…no lo sé.

Lo que sí sé es que uses o no “vi” hay una serie de comandos que no se usan solo en este editor. ¿Cuántas veces te has encontrado frente a una pantalla con texto que en su parte inferior izquierda tenía el símbolo dos puntos “:” y no sabías como salir de allí?


Pues la solución está en los comandos del vetusto editor, que siguen usándose en utilidades tan usuales como “man”, “less”, “more”, etc.

Por ejemplo, sabemos que con el comando “man” seguido por el nombre de un programa obtenemos la ayuda de este programa (siempre que tenga sus entradas en la relación de manuales). ¿Cómo buscamos un texto en el manual?, ¿Cómo encontramos la siguiente ocurrencia de la búsqueda?, ¿Cómo nos movemos a lo largo del manual? Las respuestas a continuación.

Comandos básicos de vi

Los comandos suelen consistir en la pulsación de una tecla o una combinación de estas:


Adicionalmente en “vim” (Linux) podemos usar las teclas Inicio, Fin, Av. Pág, Re. Pág y el cursor para movernos a lo largo y ancho del documento. Estos comandos son válidos también en “man”, “less”, “more”, etc.


Comandos de edición de vi

Los siguientes comandos nos permitirán editar el fichero. También veremos cómo guardar cambios, deshacerlos, etc.


¿Cómo se usan estos comandos? Veamos un ejemplo:

Vamos a editar un fichero nuevo llamado texto.txt. 
  1. Abrimos el fichero con vi ejecutando vi texto.txt
  2. Pulsamos la tecla i para insertar texto
  3. Tecleamos el texto que queramos
  4. Pulsamos ESC (escape) para salir del modo inserción
  5. Guardamos y salimos tecleando :x


Y con esto ya hemos visto cómo usar vi de forma casi profesional. Hay comandos más avanzados para búsqueda y sustitución, edición, movimiento, borrado…etc. Para nosotros es más que suficiente con esto. Os animo a probar y aunque sigáis usando “nano” por lo menos sepáis que hacer cuando os aparezcan los dos puntos en la parte inferior de una pantalla ;)



sábado, 18 de junio de 2016

Fundamentales. De unos y ceros




Hoy vamos a ver un tema muy cercano al hierro y a su vez a las matemáticas pero unido con los sistemas operativos, aplicaciones, lenguajes de programación... Vamos a ver en qué consisten las unidades de información, los diferentes sistemas numéricos usados en nuestro mundillo y algo de lógica booleana.

Definiciones

Lo primero es lo primero, ¿qué es eso de los unos y los ceros? Casi seguro que todos lo sabéis. Se trata de bits (acrónimo de Binary Digits), que es la unidad mínima de información que puede manejar un sistema digital. A nivel de la máquina, de una forma muy simplista pero válida, la presencia o ausencia de señal eléctrica es lo que define a su vez el estado uno o cero: encendido o apagado. Se suele representar con la letra b minúscula

¿Qué pasa si agrupo varios bits?: pues que obtenemos estructuras de información más complejas. Repasemos las principales:

Byte: consiste en un conjunto agrupado de 8 bits (normalmente). Ocasionalmente, y para no usar el anglicismo, también lo llamamos octeto. Lo representamos con la letra B mayúscula. Tiene 28=256 valores posibles.

Una cuestión importante cuando hablamos de los bits dentro de un byte es del peso del mismo. Todos habréis oído eso de “bit más significativo” o “bit menos significativo”.

El bit menos significativo o LSB (Least Significant Bit) hace referencia al bit más a la derecha, el que menos valor tiene ya que su peso es de 20=1 multiplicado por su valor, es decir vale 1 en decimal si el bit vale 1 y vale 0 en decimal si el bit vale 0.

El bit más significativo o MSB (Most Significant Bit) es el bit más a la izquierda, el que más valor o peso tiene: 27=128, es decir, que si el octavo bit es 1 vale 128 en decimal y si es 0, pues obviamente, también vale 0 en decimal.

En ciertos métodos estenográficos se usa el LSB para ocultar información porque su alteración es despreciable si el valor se “usa” de forma analógica, como puede ser el valor de color de un pixel o la amplitud de una onda de sonido.

Word: o palabra. En la estructura x86 es un conjunto de 16 bits, o 2 Bytes pero se mantiene por compatibilidad en la arquitectura x86-64 con el mismo tamaño. Tiene 216= 2562=65536 valores posibles.

DWord: o doble palabra…pues el doble que la anterior: 32 bits, 4 Bytes o 2 palabras. Tiene 232= 655362=4294967296 valores posibles.

QWord: o cuádruple palabra. Otra vez doblamos la anterior: 4 bits, 8 Bytes, 4 palabras o 2 doble palabras y como en los casos anteriores elevamos al cuadrado el numero anterior de valores posibles: tiene 264= 42949672962=18446744073709551616 valores posibles!

Sistemas numéricos usados en informática

En nuestro mundo usamos 4 sistemas: binario, octal, decimal y hexadecimal. La realidad es que el sistema octal apenas se usa, pero por lo menos que sepáis de su existencia.

Binario: se representa con dos dígitos o guarismos diferentes ya que solo puede tener dos posibles valores: 0 y 1. Es el mas básico y el que usa el ordenador internamente, la información se almacena, sea en disco, memoria, registros de CPU, etc., con este sistema…ya veremos qué pasa cuando llegue la informática quántica! J

Octal: en este caso que puede tener 8 valores diferentes usa 8 guarismos: 0, 1, 2, 3, 4, 5, 6, 7. En un sistema de base 8 que se usaba para representar triadas de números binarios o bits. Para que veáis un caso donde todavía se usa: cuando cambiamos los atributos de un archivo/directorio en Linux con chmod y usamos algo así como chmod 750 mifichero, ese 750 son valores octales:

·         7 octal = 111 binario = rwx en nuestros atributos de Linux.
·         5 octal = 110 binario = rw- en nuestros atributos de Linux.
·         0 octal = 000 binario = --- en nuestros atributos de Linux.

Evidentemente, en este caso, como los valores se representarían igual en decimal o hexadecimal que en octal no se ve claramente que este sea el sistema numérico usado.

Decimal: el sistema más universal y que usamos a diario en nuestra vida cotidiana. Es un sistema de base 10 cuyas cifras se representan con 10 guarismos: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9.

Hexadecimal: Este sistema se usa de forma casi exclusiva en el mundo de la computación. Es un sistema de base 16 que representamos con los siguientes 16 guarismos: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F que tienen el valor decimal de 0 a 15 para la F. Su uso esta tan extendido porque permite representar el valor de un Byte con dos dígitos: 11111111 binario = 255 decimal = FF hexadecimal.

Cuando nos referimos a valores hexadecimales, y para evitar confusión con otras bases, los debemos representar con 0x (cero x) delante del valor, como por ejemplo 0xFF o 0x1234. También los podremos encontrar con una letra h (minúscula o mayúscula) detrás de la cifra: FFh o 1234H.


Tabla ASCII con los valores decimal, hexadecimal y octal de algunos caracteres.


Equivalencia de los primeros valores en los cuatro sistemas de numeración


Evidentemente el cambio de base de un valor es relativamente sencillo y os recomendaría que busquéis vosotros mismos información y aprendáis a hacerlo. Familiarizarse con esta parte de las matemáticas es tremendamente útil en nuestra profesión!

Lógica binaria

Este es un tema que usamos todos los que nos dedicamos a la informática, seamos programadores, nos dediquemos a redes y o sistemas…

Esta lógica está basada en el álgebra de Boole y aunque existen más operaciones, solo vamos a ver las más usuales:

·         Negación o complemento (NOT)
·         Suma o disyunción (OR)
·         Multiplicación o conjunción (AND)
·         Suma o disyunción exclusiva (XOR)

Negación o complemento (NOT)

Este operador invierte el valor al que se le aplica. La negación del valor binario 1 es 0 o dicho de otra forma: 1 = NOT 0. En programación se suele usar el signo de la exclamación cerrada (!) para representarlo, de forma que 1!=0.

Para representar las salidas en función de las entradas de un operador lógico se usan las tablas de la verdad. La siguiente es la tabla de la verdad del operador NOT:



En secuencias lógicas, como las que podemos escribir en los filtros del Wireshark, usamos el operador para indicar que aplique el filtro si no se cumple la condición.

Si por ejemplo quiero que solo capture los paquetes UDP pondré la condición en el filtro como muestro a continuación:



Pero si lo que quiero es que capture todos los paquetes excepto los UDP usaré el operador NOT para indicarlo:



¿Qué ocurre si aplico este operador a un byte completo?, pues que todos los bits de ese byte se invierten: 10010110!=01101001.

Suma o disyunción (OR)

La suma lógica requiere de 2 o más entradas con las que operar, básicamente se puede decir que el resultado en 1 si cualquiera de las entradas tiene el valor 1.  En programación se suele usar tanto el término OR como el doble pipeline (||). La tabla de la verdad de este operador es la siguiente:



Usemos de nuevo los filtros de captura de Wireshark para mostrar cómo usar este operador en una sentencia lógica: siguiendo con el ejemplo anterior, quiero hacer un filtro que capture todos los paquetes que no sean UDP o que sean peticiones al puerto 80:


Si aplicamos el operador a un par de Bytes se hará la operación bit a bit para cada posición: 01010001 OR 11000100 = 11010101

Multiplicación o conjunción (AND)

La conjunción AND requiere que las dos entradas sean 1 para que la salida sea 1, en cualquier otro caso la salida es 0. Se suele indicar tanto con el término AND como con el doble ampersand (&&). Su tabla de la verdad es la siguiente:



Sigamos con los filtros de captura de Wireshark para ver su uso en sentencias lógicas. Ya teníamos un filtro donde capturábamos todos paquetes que no fueran UDP o que fueran peticiones al puerto 80. Ahora queremos incluir la condición que sea del protocolo IPv6 (ojo a los paréntesis para agrupar las operaciones):



Vamos a operar un par de Bytes con este operador que también se hará la operación bit a bit para cada posición: 01010001 AND 11000100 = 1000000
Este operador también se usa para calcular la dirección base de una red usando como entradas la dirección Ip y la máscara de subred (en formato binario ambas).

Suma o disyunción exclusiva (XOR)

Este operador, usada en los sumadores digitales junto a un operador AND, de una resultado de 1 solo si solo una de las entradas es 1. Esta es su tabla de la verdad:



Este operador no se usa en los filtros de Wireshark por lo que omito el ejemplo de uso, en cambio si es usado en creación de máscaras de imagen, en criptografía, generación de números pseudo-aleatorios, detección de correlación y secuencia… También nos permite calcular la dirección de broadcast de una red usando como datos de entrar la dirección Ip y la máscara de subred.

Todas estos operadores (excepto NOT) tienen sus correspondientes “versiones” negadas: NOR, NAND y XNOR que tienen el resultado de salida invertido a sus “versiones” no negadas.

En un contexto típico de programación no nos referimos a los valores lógicos 1 y 0 de esta forma, se suele usar True y False respectivamente para inicializar variables, comparar en sentencias de control, etc.


Lo que hemos visto en este post es un tema, que no es que sea de obligado conocimiento, es necesario controlar para poder desenvolvernos con soltura en el mundo de la informática.