¿Qué es nexmon?

Nexmon es nuestro framework de parcheo de firmware basado en C para chips WiFi Broadcom/Cypress que te permite escribir tus propios parches de firmware, por ejemplo, para habilitar el modo monitor con cabeceras radiotap e inyección de tramas.

A continuación, encontrarás una visión general de lo que es posible con nexmon. Este repositorio se centra principalmente en habilitar el modo monitor y la inyección de tramas en muchos chips. Si quieres funciones adicionales, los siguientes proyectos pueden resultarte interesantes:

• http://nexmon.org/jammer: Un bloqueador Wi-Fi real que permite superponer transmisiones de tramas en curso con una señal de interferencia arbitraria.
  • Utiliza el chip WiFi como una radio definida por software para generar señales de interferencia
  • Permite utilizar canales no estándar, como un ancho de banda de 80 MHz en las bandas de 2.4 GHz
  • Permite establecer potencias de transmisión arbitrarias
  • Permite parchear la implementación MAC en tiempo real del núcleo D11
• http://nexmon.org/csi: Extractor de información de estado del canal (CSI) para varios chips WiFi
  • Permite extraer CSI de transmisiones MIMO de hasta 4x4 a un ancho de banda de 80 MHz
• http://nexmon.org/debugger: Depuración de microcontroladores ARM sin acceso JTAG
  • Permite el acceso de bajo nivel a los registros de depuración para establecer puntos de interrupción y puntos de vigilancia, y permite la ejecución paso a paso
• http://nexmon.org/covert_channel: Canal encubierto que oculta información en señales Wi-Fi
  • Capacidades de radio definida por software más avanzadas que el bloqueador
  • Aplicación de ejemplo para la extracción de información de estado del canal
• http://nexmon.org/sdr: Utiliza tu chip WiFi como radio definida por software
  • Actualmente solo funcionan las transmisiones en las bandas Wi-Fi de 2.4 y 5 GHz

ADVERTENCIA

Nuestro software puede dañar tu hardware y puede anular la garantía de tu hardware. Usas nuestras herramientas bajo tu propio riesgo y responsabilidad. ¡Si no te gustan estos términos, no uses nexmon!

Dispositivos Compatibles

Los siguientes dispositivos son actualmente compatibles con nuestro parche de firmware nexmon.

¹ bcm43430a1 fue etiquetado erróneamente como bcm43438 en el pasado.

² usa LD_PRELOAD=libnexmon.so en lugar de LD_PRELOAD=libfakeioctl.so para inyectar tramas a través de ioctls

³ los parches de flash deben tener 8 bytes de longitud y estar alineados en un límite de 8 bytes

⁴ chip Wi-Fi 802.11ad del primer router Wi-Fi de 60 GHz Talon AD7200. Parchea tu firmware usando nexmon-arc y ejecútalo con nuestra imagen LEDE personalizada lede-ad7200

⁵ Se deshabilitó la protección de ejecución (llamada Execute Never) en la región 1, porque interfiere con el código de nexmon (Permission fault on Section)

⁶ Para usar nexutil, debes desactivar SELinux o ponerlo en modo permisivo

⁷ Consulta pico-nexmon para ver aplicaciones de ejemplo que usan Pico SDK con nexmon.

⁸ los parches de flash deben tener 16 bytes de longitud y estar alineados en un límite de 16 bytes.

⁹ Usa el módulo Magisk para instalar firmware, nexutil y configurar las políticas de SELinux.

Leyenda

• M = Modo monitor
• RT = Modo monitor con cabeceras RadioTap
• I = Inyección de tramas
• FP = Parcheo de flash
• UC = Compresión de ucode
• CT = Soporte del artículo de c't (para un soporte consistente, usa nuestra rama ct-artikel)

Pasos para crear tus propios parches de firmware

Compila parches para bcm4330, bcm4339 y bcm4358 usando un equipo x86 con Linux (p. ej., Ubuntu 16.04)

• Instala algunas dependencias: sudo apt-get install git gawk qpdf adb flex bison
• Solo necesario para sistemas x86_64, instala las bibliotecas i386: ``` sudo dpkg --add-architecture i386 sudo apt-get update sudo apt-get install libc6:i386 libncurses5:i386 libstdc++6:i386
  root@kitploit:~

• Clona nuestro repositorio: git clone https://github.com/seemoo-lab/nexmon.git
• En el directorio raíz del repositorio: cd nexmon
  • Configura el entorno de compilación: source setup_env.sh
  • Compila algunas herramientas de compilación y extrae la ucode y los flashpatches de los archivos de firmware originales: make
• Ve a la carpeta patches de tu dispositivo objetivo (p. ej. bcm4339 para el Nexus 5): cd patches/bcm4339/6_37_34_43/nexmon/
  • Compila un firmware parcheado: make
  • Genera una copia de seguridad de tu archivo de firmware original: make backup-firmware
  • Instala el firmware parcheado en tu smartphone: make install-firmware (asegúrate de que tu smartphone esté conectado a tu máquina de antemano)

Uso del parche de modo monitor

• Instala al menos nexutil y libfakeioctl desde nuestras utilidades. La forma más fácil de hacerlo es usando esta aplicación: https://nexmon.org/app. Pero también puedes compilarlos desde el código fuente ejecutando make en la carpeta utilties (Nota: necesitarás tener el Android NDK correctamente instalado para ello).
• Conecta tu teléfono Android usando las herramientas ADB: adb shell
• Asegúrate de no estar conectado a un punto de acceso
• Usa nexutil para habilitar el modo monitor: nexutil -m2
• En este punto el modo monitor está activo. No es necesario llamar a airmon-ng.
• Importante: La mayoría de las herramientas necesitan una interfaz Radiotap para funcionar correctamente. libfakeioctl emula este tipo de interfaz por ti, por lo tanto, usa LD_PRELOAD para cargar esta biblioteca cuando invoques tu herramienta favorita (p. ej. tcpdump o airodump-ng): LD_PRELOAD=libfakeioctl.so tcpdump -i wlan0
• consejo no probado: Gracias al miembro de XDA ruleh, existe un parche del controlador bcmdhd para activar el modo monitor nativo, ver: https://github.com/ruleh/misc/tree/master/monitor

Uso de nexutil a través de UDP en Nexus 5

Para poder comunicarte con el firmware sin privilegios de root, creamos una interfaz UDP accesible a través de libnexio, que también usa nexutil. Primero tienes que demostrar al firmware que en general tienes privilegios de root estableciendo una cookie de seguridad. Luego puedes usarla para conexiones basadas en UDP. Tu interfaz wlan0 también necesita una dirección IP en el rango 192.168.222.0/24 o tendrás que cambiar el broadcast-ip predeterminado de nexutil:

• Establece la dirección IP de la interfaz wlan0: ifconfig wlan0 192.168.222.1 netmask 255.255.255.0
• Establece la cookie de seguridad como root: nexutil -x<cookie (uint)>
• Inicia una conexión UDP, por ejemplo para activar el modo monitor: nexutil -X<cookie> -m1

Compilar parches para bcm43430a1 en la RPI3/Zero W o bcm434355c0 en la RPI3+/RPI4 o bcm43436b0 en la RPI Zero 2W usando Raspbian/Raspberry Pi OS (recomendado)

Nota: Actualmente soportamos las versiones de Kernel 4.4 (obsoleta), 4.9, 4.14, 4.19, 5.4, 5.10 y 5.15. Raspbian contiene la versión de firmware 7.45.154 para la bcm43455c0. También soportamos la versión de firmware más reciente 7.45.189 de Cypress. Raspberry Pi OS contiene la versión de firmware 7.45.206. Por favor, prueba cuál te funciona mejor.

• Asegúrate de que los siguientes comandos se ejecuten como root: sudo su

• Actualiza tu instalación de Raspbian: apt-get update && apt-get upgrade

• Instala las cabeceras del kernel para compilar el controlador y algunas dependencias: sudo apt install raspberrypi-kernel-headers git libgmp3-dev gawk qpdf bison flex make autoconf libtool texinfo

• Clona nuestro repositorio: git clone https://github.com/seemoo-lab/nexmon.git

• Ve al directorio raíz de nuestro repositorio: cd nexmon

• En Raspbian/Raspberry Pi OS de 32 bits

  • Comprueba si existe /usr/lib/arm-linux-gnueabihf/libisl.so.10; si no, compílalo desde el código fuente:
  • cd buildtools/isl-0.10, ./configure, make, ,

Uso del parche de modo monitor

• Gracias al trabajo previo de Mame82, puedes configurar una nueva interfaz de modo monitor ejecutando:iw phy `iw dev wlan0 info | gawk '/wiphy/ {printf "phy" $2}'` interface add mon0 type monitor
• To activate monitor mode in the firmware, simply set the interface up: ifconfig mon0 up.
• At this point, monitor mode is active. There is no need to call airmon-ng.
• The interface already set the Radiotap header, therefore, tools like tcpdump or airodump-ng can be used out of the box: tcpdump -i mon0
• Optional: To make the RPI3 load the modified driver after reboot:
  • Find the path of the default driver at reboot: modinfo brcmfmac #the first line should be the full path
  • Backup the original driver: mv "<PATH TO THE DRIVER>/brcmfmac.ko" "<PATH TO THE DRIVER>/brcmfmac.ko.orig"
  • Copy the modified driver (Kernel 4.9): cp /home/pi/nexmon/patches/bcm43430a1/7_45_41_46/nexmon/brcmfmac_kernel49/brcmfmac.ko "<PATH TO THE DRIVER>/"
  • Copy the modified driver (Kernel 4.14): cp /home/pi/nexmon/patches/bcm43430a1/7_45_41_46/nexmon/brcmfmac_4.14.y-nexmon/brcmfmac.ko "<PATH TO THE DRIVER>/"
  • Probe all modules and generate new dependency: depmod -a

How to build the utilities

To build the utilities such as nexmon or dhdutil for Android, you need to download the old NDK version 11c, extract it and export the environment variable NDK_ROOT pointing to the directory where you extracted the NDK files.

How to extract the ROM

The Wi-Fi firmware consists of a read-only part stored in the ROM of every Wi-Fi chip and another part that is loaded by the driver into the RAM. To analyze the whole firmware, one needs to extract the ROM. There are two options to do this. Either you write a firmware patch that simply copies the contents of the ROM to RAM and then you dump the RAM, or you directly dump the ROM after loading the regular firmware into the RAM. Even though, the second option is easier, it only works, if the ROM can be directly accessed by the driver, which is not always the case. Additionally, the firmware loaded into RAM can contain ROM patches that overlay the data stored in ROM. By dumping the ROM after loading the original RAM firmware, it contains flash patches. Hence, the ROM needs to be dumped again for every RAM firmware update to be consistent. As a conclusion, we prefer to dump the clean ROM after copying it to RAM.

Dumping the ROM directly

To dump the ROM directly, you need to know, where to find it and how large it is. On chips with Cortex-M3 it is usually at upper addresses such as 0x800000, while on chips with Cortex-R4 it is likely at 0x0. Run dhdutil to perform the dump:

dhdutil membytes -r 0x0 0xA0000 > rom.bin```

## Dumping a clean ROM after copying to RAM
For the BCM4339 and BCM4358, we created `rom_extraction` projects that load a firmware patch that copies ROM to 
RAM and them dumps it using dhdutil. To dump the ROM simply execute the following in the project directory:

make dump-rom```

After ROM extraction, the rom.bin file will be copies to the corresponding firmwares subdirectory. To apply the flash patches of a specific RAM firmware version, enter its directory and execute:

make rom.bin```



# Structure of this repository
* `buildtools`: Contains compilers and other tools to build the firmware
* `firmwares`
  * `<chip version>`
    * `<firmware version>`
      * `<firmware file>`: The original firmware that will be loaded into the RAM of the WiFi Chip
      * `definitions.mk`: Contains mainly firmware specific addresses
      * `structs.h`: Structures only valid for this firmware version
      * `Makefile`: Used to extract flashpatches and ucode
      * `flashpatches.c` (generated by Makefile): Contains flashpatches
      * `ucode.bin` (extracted by Makefile): Contains uncompressed Ucode
    * `structs.common.h`: Structures that are common between firmware versions
* `patches`
  * `<chip version>`
    * `<firmware version>`
      * `nexmon`
        * `Makefile`: Used to build the firmware
        * `patch.ld`: Linker file
        * `src`
          * `patch.c`: General patches to the firmware
          * `injection.c`: Code related to frame injection
          * `monitormode.c`: Code related to monitor mode with radiotap headers
          * `ioctl.c`: Handling of custom IOCTLs
          * ...
        * `obj` (generated by Makefile): Object files created from C files
        * `log` (generated by Makefile): Logs written during compilation
        * `gen` (generated by Makefile): Files generated during the build process
          * `nexmon.pre` (generated by gcc plugin): Extracted at-attributes and targetregion-pragmas
          * `nexmon.ld` (generated from nexmon.pre): Linker file use to place patch code at defined addresses in the firmware
          * `nexmon.mk` (generated from nexmon.pre): Make file used take code from patch.elf and place it into firmware
          * `flashpatches.ld` (generated from nexmon.pre): Linker file that places flashpatches at target locations in firmware ROM
          * `flashpatches.mk` (generated from nexmon.pre): Make file used to insert flashpatch config and data structures into firmware
          * `patch.elf` (generated from object files and linker scripts): contains the newly compiled code placed at predefined addresses
    * `common`
      * `wrapper.c`: Wrappers for functions that already exist in the firmware
      * `ucode_compression.c`: [tinflate](http://achurch.org/tinflate.c) based ucode decompression
      * `radiotap.c`: RadioTap header parser
      * `helper.c`: Helpful utility functions
    * `driver`: Patched brcmfmac driver
    * `include`: Common include files
      * `firmware_version.h`: Definitions of chip and firmware versions
      * `patcher.h`: Macros use to perform patching for existing firmware code (e.g., BPatch patches a branch instruction)
      * `capabilities.h`: Allows to indicate capabilities (such as, monitor mode and frame injection)
      * `nexioctl.h`: Defines custom IOCTL numbers

# Related projects
* [bcmon](https://bcmon.blogspot.de/): Monitor Mode and Frame Injection for the bcm4329 and bcm4330
* [monmob](https://github.com/tuter/monmob): Monitor Mode and Frame Injection for the bcm4325, bcm4329 and bcm4330
* [P4wnP1](https://github.com/mame82/P4wnP1): Highly customizable attack platform, based on Raspberry Pi Zero W and Nexmon
* [kali Nethunter OS](https://github.com/nethunteros): ROM that brings Kali Linux to smartphones with Nexmon support
* [dustcloud-nexmon](https://github.com/dgiese/dustcloud-nexmon): Nexmon for Xiaomi IoT devices (ARM based)
* [InternalBlue](https://github.com/seemoo-lab/internalblue): Bluetooth experimentation framework based on Reverse Engineering of Broadcom Bluetooth Controllers

# Interesting articles on firmware hacks
If you know more projects that use nexmon or perform similar firmware hacks, let us know and we will add a link.

* [Project Zero](https://googleprojectzero.blogspot.de/2017/09/over-air-vol-2-pt-1-exploiting-wi-fi.html): Over The Air - Vol. 2, Pt. 1: Exploiting The Wi-Fi Stack on Apple Devices
* [broadpwn](https://blog.exodusintel.com/2017/07/26/broadpwn/): Remotely Compromising Android and IOS via a Bug in Broadcom's Wi-Fi Chipsets
* [Project Zero](https://googleprojectzero.blogspot.de/2017/04/over-air-exploiting-broadcoms-wi-fi_4.html): Over The Air: Exploiting Broadcom's Wi-Fi Stack (Part 1)
* [Project Zero](https://googleprojectzero.blogspot.de/2017/04/over-air-exploiting-broadcoms-wi-fi_11.html): Over The Air: Exploiting Broadcom's Wi-Fi Stack (Part 2) 

# Read my PhD thesis
* Matthias Schulz. [**Teaching Your Wireless Card New Tricks: Smartphone Performance and Security Enhancements through Wi-Fi Firmware Modifications**](http://tuprints.ulb.tu-darmstadt.de/7243/). Dr.-Ing. thesis, Technische Universität Darmstadt, Germany, February 2018. [pdf](http://tuprints.ulb.tu-darmstadt.de/7243/7/dissertation_2018_matthias_thomas_schulz.pdf)

# Read our papers
* F. Gringoli, M. Schulz, J. Link, and M. Hollick. [**Free Your CSI: A Channel State Information Extraction Platform For Modern Wi-Fi Chipsets**](https://doi.org/10.1145/3349623.3355477). Accepted to appear in *Proceedings of the 13th Workshop on Wireless Network Testbeds, Experimental evaluation & CHaracterization (WiNTECH 2019)*, October 2019. [code](https://nexmon.org/csi)
* D. Mantz, J. Classen, M. Schulz, and M. Hollick. [**InternalBlue - Bluetooth Binary Patching and Experimentation Framework**](https://dl.acm.org/citation.cfm?id=3326089). *In Proceedings of the 17th Annual International Conference on Mobile Systems, Applications, and Services (MobiSys '19)*. June 2019.
* M. Schuß, C. A. Boano, M. Weber, M. Schulz, M. Hollick, K. Römer. [**JamLab-NG: Benchmarking Low-Power Wireless Protocols under Controlable and Repeatable Wi-Fi Interference**](https://dl.acm.org/citation.cfm?id=3324331). *Proceedings of the 2019 International Conference on Embedded Wireless Systems and Networks (EWSN 2019)*, February 2019.
* M. Schulz, D. Wegemer, and M. Hollick. [**The Nexmon Firmware Analysis and Modification Framework: Empowering Researchers to Enhance Wi-Fi Devices**](https://doi.org/10.1016/j.comcom.2018.05.015). *Elsevier Computer Communications (COMCOM) Journal*. 2018.
* M. Schulz, J. Link, F. Gringoli, and M. Hollick. [**Shadow Wi-Fi: Teaching Smart- phones to Transmit Raw Signals and to Extract Channel State Information to Implement Practical Covert Channels over Wi-Fi**](https://dl.acm.org/citation.cfm?id=3210333). Accepted to appear in *Proceedings of the 16th ACM International Conference on Mobile Systems, Applications, and Services*, MobiSys 2018, June 2018.
* D. Steinmetzer, D. Wegemer, M. Schulz, J. Widmer, M. Hollick. [**Compressive Millimeter-Wave Sector Selection in Off-the-Shelf IEEE 802.11ad Devices**](https://dl.acm.org/citation.cfm?id=3143384). *Proceedings of the 13th International Conference on emerging Networking EXperiments and Technologies*, CoNEXT 2017, December 2017.
* M. Schulz, D. Wegemer, M. Hollick. [**Nexmon: Build Your Own Wi-Fi Testbeds With Low-Level MAC and PHY-Access Using Firmware Patches on Off-the-Shelf Mobile Devices**](https://dl.acm.org/citation.cfm?id=3131476). *Proceedings of the 11th ACM International Workshop on Wireless Network Testbeds, Experimental Evaluation & Characterization (WiNTECH 2017)*, October 2017. [pdf](https://www.seemoo.tu-darmstadt.de/mschulz/wintech2017) [video](https://youtu.be/m5Zrk4n4hoE)
* M. Schulz, F. Knapp, E. Deligeorgopoulos, D. Wegemer, F. Gringoli, M. Hollick. [**DEMO: Nexmon in Action: Advanced Applications Powered by the Nexmon Firmware Patching Framework**](https://dl.acm.org/citation.cfm?id=3133333), Accepted for publication in *Proceedings of the 11th ACM International Workshop on Wireless Network Testbeds, Experimental Evaluation & Characterization (WiNTECH 2017)*, October 2017. [pdf](https://www.seemoo.tu-darmstadt.de/mschulz/wintech2017demo)
* M. Schulz, F. Gringoli, D. Steinmetzer, M. Koch and M. Hollick. [**Massive Reactive Smartphone-Based Jamming using Arbitrary Waveforms and Adaptive Power Control**](https://dl.acm.org/citation.cfm?id=3098253). Proceedings of the *10th ACM Conference on Security and Privacy in Wireless and Mobile Networks (WiSec 2017)*, July 2017. [pdf](https://www.seemoo.tu-darmstadt.de/mschulz/wisec2017) [video](https://youtu.be/S2XPBK0KdiQ)
* M. Schulz, E. Deligeorgopoulos, M. Hollick and F. Gringoli. [**DEMO: Demonstrating Reactive Smartphone-Based Jamming**](https://dl.acm.org/citation.cfm?id=3106022). Proceedings of the *10th ACM Conference on Security and Privacy in Wireless and Mobile Networks (WiSec 2017)*, July 2017. [pdf](https://www.seemoo.tu-darmstadt.de/mschulz/wisec2017demo)
* M. Schulz. [**Nexmon - Wie man die eigene WLAN-Firmware hackt**](http://heise.de/-3538660), 
c't 26/2016, S. 168, Heise Verlag, 2016.
* M. Schulz, D. Wegemer, M. Hollick. [**DEMO: Using NexMon, the C-based WiFi 
firmware modification framework**](https://dl.acm.org/citation.cfm?id=2942419), 
Proceedings of the *9th ACM Conference on Security and Privacy in Wireless and 
Mobile Networks (WiSec 2016)*, July 2016. [pdf](https://www.seemoo.tu-darmstadt.de/mschulz/wisec2016demo1)
* M. Schulz, D. Wegemer and M. Hollick. [**NexMon: A Cookbook for Firmware 
Modifications on Smartphones to Enable Monitor Mode**](http://arxiv.org/abs/1601.07077), 
CoRR, vol. abs/1601.07077, December 2015. 
[bibtex](http://dblp.uni-trier.de/rec/bibtex/journals/corr/SchulzWH16)

[Get references as bibtex file](https://nexmon.org/bib)

# Reference our project
Any use of this project which results in an academic publication or other publication which includes a bibliography should include a citation to the Nexmon project and probably one of our papers depending on the code you use. Find all references in our [bibtex file](https://github.com/seemoo-lab/nexmon/blob/HEAD/nexmon.bib). Here is the reference for the project only:

@electronic{nexmon:project, author = {Schulz, Matthias and Wegemer, Daniel and Hollick, Matthias}, title = {Nexmon: The C-based Firmware Patching Framework}, url = {https://nexmon.org}, year = {2017} }```

Contact

• Matthias Schulz [email protected]
• Daniel Wegemer [email protected]

Powered By

Secure Mobile Networking Lab (SEEMOO)

Networked Infrastructureless Cooperation for Emergency Response (NICER)

Multi-Mechanisms Adaptation for the Future Internet (MAKI)

Technische Universität Darmstadt