Ubuntu 24. Problemas con la tarjeta nueva de la ACCV G&D SmartCafe Expert 7 (JavaCard)

 1. Problemas surgidos

Para identificar la tarjeta se ejecuta pcsc_scan y nos dice que la tarjeta es del tipo G&D SmartCafe Expert 7 (JavaCard)

Y no había manera de poder configurar dicha tarjeta

1. Ya había drivers anteriores libaetpkss.so pero eran de 32 bits y por tanto incompatibles. Cuando se ejecutaba: pkcs11-tool --module /usr/lib/libaetpkss.so --list-slots respondía:

   sc_dlopen failed: /usr/lib/libaetpkss.so: wrong ELF class: ELFCLASS32
   error: Failed to load pkcs11 module
   Aborting.

2. La localizacion de dichos drivers anteriores era en /usr/lib
3. Los drivers "bit4id" que aparecen el la ACCV parece ser que son para el lector y no para la tarjeta por tanto al ejecutar pkcs11-tool --module /usr/lib/bit4id/libbit4npki.so --list-slots respondía que podía reconocer al lector pero no la tarjeta: 

   Available slots:
   Slot 0 (0x0): Identiv uTrust 2700 R Smart Card Reader [CCID Interface] (536915
     (token not recognized)
   

2. La posible solución

Le indiqué a Claude AI  que el tipo de tarjeta era G&D SmartCafe Expert 7 (JavaCard) según pscs_scan y me indicó que descargara los drivers de 64 bits de KPN (que es el distribuidor oficial de AET), los descomprimiera y los copiara a /usr/lib machacando los drivers antiguos de 32 bits.

#Paso 1 — Descargar el .deb para Ubuntu 22.04 de KPN (distribuidor oficial de AET)
cd /tmp
wget "https://certificaat.kpn.com/files/drivers/SafeSign/SafeSign IC Standard Linux 4.0.0.0-AET.000 ub2204 x86_64.deb" -O safesign4_ub2204.deb

#Paso 2 — Extraer solo la librería .deb sin instalar
dpkg-deb -x safesign4_ub2204.deb /tmp/safesign_extracted

# Ver dónde está la librería
find /tmp/safesign_extracted -name "libaetpkss*"

#Paso 3 — Copiar la librería al sistema
sudo cp /tmp/safesign_extracted/usr/lib/libaetpkss.so* /usr/lib/
sudo ldconfig

#Paso 4 — Verificar
pkcs11-tool --module /usr/lib/libaetpkss.so --list-slots
pkcs11-tool --module /usr/lib/libaetpkss.so --list-objects --type cert --login

Y si que funcinó ahora, me muestra correctamente

pkcs11-tool --module /tmp/safesign_extracted/usr/lib/libaetpkss.so   --list-objects --type cert --login
Using slot 0 with a present token (0xcd01)
Logging in to "ACCV".
Please enter User PIN: 
Certificate Object; type = X.509 cert
  label:      EPN1
  subject:    DN: CN=MI_NOMBRE MI_APELLIDO1 MI_APELLIDO2 - DNI 00000001X/serialNumber=00000001X, GN=MI_NOMBRE, SN=MI_APELLIDO1 MI_APELLIDO2, OU=CERTIFICADO ELECTRONICO DE EMPLEADO PUBLICO, O=AYUNTAMIENTO DEL BROSQUIL, C=ES
  ID:         112233abcd44efgji6asdfsa121sdfsdfsdf

Ubuntu 24.Ver información de los certificados nss, p12 y pkcs11

1. nss 

Ver los alias de los certificados p12 guardados en nss

certutil -L -d sql:$HOME/.pki/nssdb

Y muestra

Certificate Nickname                                         Trust Attributes
                                                             SSL,S/MIME,JAR/XPI

EPN1                                                         u,u,u
ACCVCA-120 - ACCV                                            ,,   
Ximet Dante - YO MISMO                                       u,u,u
SocketAutoFirma                                              CT,C,C
FIRMA                                                        u,u,u
ACCV ROOT RSA EIDAS 2023 - ISTEC                             ,,   
ACCV RSA1 PROFESIONALES - ISTEC                              ,,   
ACCV RSA1 CLIENTE - ISTEC                                    ,,   

Ver los alias de los certificados pkcs11 guardados en nss

modutil -list -dbdir sql:$HOME/.pki/nssdb

Y muestra

Listing of PKCS #11 Modules
-----------------------------------------------------------
  1. NSS Internal PKCS #11 Module
	   uri: pkcs11:library-manufacturer=Mozilla%20Foundation;library-description=NSS%20Internal%20Crypto%20Services;library-version=3.98
	 slots: 2 slots attached
	status: loaded

	 slot: NSS Internal Cryptographic Services
	token: NSS Generic Crypto Services
	  uri: pkcs11:token=NSS%20Generic%20Crypto%20Services;manufacturer=Mozilla%20Foundation;serial=0000000000000000;model=NSS%203

	 slot: NSS User Private Key and Certificate Services
	token: NSS Certificate DB
	  uri: pkcs11:token=NSS%20Certificate%20DB;manufacturer=Mozilla%20Foundation;serial=0000000000000000;model=NSS%203

  2. DNIe
	library name: /usr/lib/x86_64-linux-gnu/opensc-pkcs11.so
	   uri: pkcs11:library-manufacturer=OpenSC%20Project;library-description=OpenSC%20smartcard%20framework;library-version=0.22
	 slots: 1 slot attached
	status: loaded

	 slot: bit4id miniLector-EVO 00 00
	token: DNI electrónico (PIN1)
	  uri: pkcs11:token=DNI%20electr%C3%B3nico%20(PIN1);manufacturer=DGP-FNMT;serial=020338240b552f;model=PKCS%2315%20emulated
-----------------------------------------------------------

También se puede utilizar el comando p11tool (previa instacion con sudo apt install gnutls-bin) 

p11tool --list-tokens

Y muestra

Token 0:
	URL: pkcs11:model=p11-kit-trust;manufacturer=PKCS%2311%20Kit;serial=1;token=System%20Trust
	Label: System Trust
	Type: Trust module
	Flags: uPIN uninitialized
	Manufacturer: PKCS#11 Kit
	Model: p11-kit-trust
	Serial: 1
	Module: p11-kit-trust.so


Token 1:
	URL: pkcs11:model=PKCS%2315%20emulated;manufacturer=DGP-FNMT;serial=020338240b552f;token=DNI%20electr%C3%B3nico%20%28PIN1%29
	Label: DNI electrónico (PIN1)
	Type: Hardware token
	Flags: RNG, Requires login
	Manufacturer: DGP-FNMT
	Model: PKCS#15 emulated
	Serial: 020338240b552f
	Module: opensc-pkcs11.so

T

2. Firefox 

Firefox puede tener vaios perfiles, por tanto debemos averiguar primero el perfil antes de listar los certificados:

cat ~/.mozilla/firefox/profiles.ini

Y devuelve (el marcado en azul es el correcto)

[Install4F96D1932A9F858E]
Default=tiorqkz7.default-release-1695576053842
Locked=1

[Profile1]
Name=default
IsRelative=1
Path=iyig11y7.default
Default=1

[Profile0]
Name=default-release
IsRelative=1
Path=tiorqkz7.default-release-1695576053842

[General]
StartWithLastProfile=1
Version=2

Ver los alias de los certificados guardados en firefox en ese perfil (nss)

certutil -L -d sql:$HOME/.mozilla/firefox/tiorqkz7.default-release-1695576053842

Y muestra

Certificate Nickname                                         Trust Attributes
                                                             SSL,S/MIME,JAR/XPI

ACCVCA-120 - ACCV                                            ,,   
EPN1                                                         u,u,u
SocketAutoFirma                                              C,,

Y para ver los certificados pkcs11 que ve mozilla:

modutil -list -dbdir sql:$HOME/.mozilla/firefox/tiorqkz7.default-release-1695576053842

Y muestra

Listing of PKCS #11 Modules
-----------------------------------------------------------
  1. NSS Internal PKCS #11 Module
	   uri: pkcs11:library-manufacturer=Mozilla%20Foundation;library-description=NSS%20Internal%20Crypto%20Services;library-version=3.98
	 slots: 2 slots attached
	status: loaded

	 slot: NSS Internal Cryptographic Services
	token: NSS Generic Crypto Services
	  uri: pkcs11:token=NSS%20Generic%20Crypto%20Services;manufacturer=Mozilla%20Foundation;serial=0000000000000000;model=NSS%203

	 slot: NSS User Private Key and Certificate Services
	token: NSS Certificate DB
	  uri: pkcs11:token=NSS%20Certificate%20DB;manufacturer=Mozilla%20Foundation;serial=0000000000000000;model=NSS%203

  2. Nuevo módulo PKCS#11
	library name: /usr/lib/x86_64-linux-gnu/opensc-pkcs11.so
	   uri: pkcs11:library-manufacturer=OpenSC%20Project;library-description=OpenSC%20smartcard%20framework;library-version=0.22
	 slots: 1 slot attached
	status: loaded

	 slot: bit4id miniLector-EVO 00 00
	token: DNI electrónico (PIN1)
	  uri: pkcs11:token=DNI%20electr%C3%B3nico%20(PIN1);manufacturer=DGP-FNMT;serial=020338240b552f;model=PKCS%2315%20emulated
-----------------------------------------------------------

Ubuntu 24. Instalar certificados de tarjeta pkcs#11. Problemas de certificados caducados.

Ya se vio en una entrada anterior cómo hacerlo con Ubuntu 18.

Veamos ahora para Ubuntu 24.

1. Instalación de drivers y reconocimiento de la tarjeta

#1. Instalar drivers
sudo apt update
sudo apt install pcscd pcsc-tools libccid opensc

#2. Activar el servicio
sudo systemctl enable --now pcscd

#3. Conectar el lector y meter el DNIe
pcs_scan

#4. Verificar que se detecta el lector y aparece DNIe Spain (eid)

#5. Salir con Ctrl + C
La salida de pcsc_scan debería mostrar algo parecido a esto:

pcsc_scan
PC/SC device scanner
V 1.7.1 (c) 2001-2022, Ludovic Rousseau <ludovic.rousseau@free.fr>
Using reader plug'n play mechanism
Scanning present readers...
0: Identiv uTrust 2700 R Smart Card Reader [CCID Interface] (53691541213332) 00 00
 
Tue Apr 14 08:48:06 2026
 Reader 0: Identiv uTrust 2700 R Smart Card Reader [CCID Interface] (53691541213332) 00 00
  Event number: 25
  Card state: Card inserted, 
  ATR: 3B 7F 96 00 00 00 6A 44 4E 49 65 10 01 01 55 04 21 03 90 00

ATR: 3B 7F 96 00 00 00 6A 44 4E 49 65 10 01 01 55 04 21 03 90 00
+ TS = 3B --> Direct Convention
+ T0 = 7F, Y(1): 0111, K: 15 (historical bytes)
  TA(1) = 96 --> Fi=512, Di=32, 16 cycles/ETU
    250000 bits/s at 4 MHz, fMax for Fi = 5 MHz => 312500 bits/s
  TB(1) = 00 --> VPP is not electrically connected
  TC(1) = 00 --> Extra guard time: 0
+ Historical bytes: 00 6A 44 4E 49 65 10 01 01 55 04 21 03 90 00
  Category indicator byte: 00 (compact TLV data object)
    Tag: 6, len: A (pre-issuing data)
      Data: 44 4E 49 65 10 01 01 55 04 21
    Mandatory status indicator (3 last bytes)
      LCS (life card cycle): 03 (Initialisation state)
      SW: 9000 (Normal processing.)

Possibly identified card (using /home/eduard/.cache/smartcard_list.txt):
3B 7F 96 00 00 00 6A 44 4E 49 65 10 01 01 55 04 21 
3B 7F 96 00 00 00 6A 44 4E 49 65 10 01 01 55 04 .. 03 90 00
	DNIE Spain (eID)
	http://www.dnielectronico.es/PortalDNIe/

2. Comprobar que el sistema ve los certificados

Ejecutamos:

pkcs11-tool --module /usr/lib/x86_64-linux-gnu/opensc-pkcs11.so -O

y nos da información sobre los certificados de autenticación, firma y certificados intermedios:
CertAutentication (comprobaremos nuestros datos de autenticación)
CertFirmaDigital (mostrará nuestrso datos de firma)
Pueden aparecer otros certificados intermedios como CertCAIntermediaDGP
Y ahora debemos comprobar que los certificados de autenticación y firma no estén caducados

#Autenticación
pkcs11-tool --module /usr/lib/x86_64-linux-gnu/opensc-pkcs11.so \
--read-object --type cert --label CertAutenticacion \
| openssl x509 -inform DER -noout -dates

# Firma
pkcs11-tool --module /usr/lib/x86_64-linux-gnu/opensc-pkcs11.so \
--read-object --type cert --label CertFirmaDigital \
| openssl x509 -inform DER -noout -dates
Y para cada sentencia contesta las fechas de validez:
Using slot 0 with a present token (0x0)
notBefore=Feb 12 10:29:00 2024 GMT
notAfter=Feb 12 10:29:00 2026 GMT

3. Problema de certificado caducado

Si se ha renovado el certificado pero sigue apareciendo como caducado, puede deberse a la caché de OpenSC.ara ello conviene borrar caché y reinciar el servicio

#1. Borrar la caché del opensc
sudo rm -rf ~/.cache/opensc

#2. Matar y reiniciar el servicio pcscd
sudo pkill -f opensc
sudo systemctl restart pcscd

#3. Esperar 2-3 segundos y volver a verificar
pkcs11-tool --module /usr/lib/x86_64-linux-gnu/opensc-pkcs11.so \
--read-object --type cert --label CertAutenticacion \
| openssl x509 -inform DER -noout -dates

Y ahora ya sale bien:

Using slot 0 with a present token (0x0)
notBefore=Apr 14 07:41:32 2026 GMT
notAfter=Apr 14 07:41:32 2028 GMT

4. Instalación en Mozilla Firefox

Con esto ya funciona en Chrome y Brave. A veces puede que no funcione y para solucionarlo se explica en el punto 5. Para que funcione en Mozilla Firefox, podemos tener el mismo problema de que se guarde el certificado antiguo en la caché.

4.1 Arreglar el tema de los certificados caducados

4.1 Ver dónde están los perfiles de Firefox

Primeramente vamos a ver donde estan los certificados de Mozilla

#1. Ver donde estan los certificados
ls ~/.mozilla/firefox/

#2. Y devuelve_
  35j7fxvk.default   
  72s3mnjv.default-release-1588245081987
  'Crash Reports'   
  installs.ini  
  'Pending Pings'   
  profiles.ini

Los dos candidatos son :

35j7fxvk.default   
72s3mnjv.default-release-1588245081987

Ahora hacemos 

cat ~/.mozilla/firefox/profiles.ini

y nos muestra:

[Install4F96D1932A9F858E]
Default=72s3mnjv.default-release-1588245081987
Locked=1

[Profile1]
Name=default
IsRelative=1
Path=35j7fxvk.default
Default=1

[Profile0]
Name=default-release
IsRelative=1
Path=72s3mnjv.default-release-1588245081987

[General]
StartWithLastProfile=1
Version=2


con lo que el candidato es 35j7fxvk.default

Y para listar los certificados o si tiene el OpenSC

#1. Listar certificados instalados
certutil -L -d sql:$HOME/.mozilla/firefox/35j7fxvk.default

#2. Ver si está el OpenSC instalado
modutil -dbdir sql:$HOME/.mozilla/firefox/35j7fxvk.default -list

4.1.2 Borrar la BD del perfil (solo si continua con los certificados caducados)
rm ~/.mozilla/firefox/35j7fxvk.default/cert9.db
rm ~/.mozilla/firefox/35j7fxvk.default/key4.db
rm ~/.mozilla/firefox/35j7fxvk.default/pkcs11.txt

4.2 Instalar el pkcs11 en Mozilla

Si no hay problemas de caducados se puede comenzar aquí.

Abrimos mozilla y en la url "about:preferences#privacy"

Tenemos que buscar Certificados - Dispositivos de Seguridad

Pulsa “Cargar”

Asumimos el niombre por defecto y escribimos (y no vamos al selector de archivos pues falla):

Ruta del módulo: /usr/lib/x86_64-linux-gnu/opensc-pkcs11.so

Aceptar

5. Instalación en Chrome

Si no funciona, reaiizar estos pasos:

1. Instalar soporte NSS tools

sudo apt install libnss3-tools

2. Añadir módulo manualmente

modutil -dbdir sql:$HOME/.pki/nssdb -add "DNIe" -libfile \ /usr/lib/x86_64-linux-gnu/opensc-pkcs11.so

Seguramente dirá que se cierre Chrome (y también hay que cerrar Brave) pues puede dañar la base de datos.

3. Reiniciar Chrome (y Brave)

Python ASYNC (III). Ejecutando otros procesos

 1. Llamada a comandos de la shell SINCRONA

Veamos como se llama a un proceso síncronamente ya sea por el ecomando entero o pasándole parámetros:

def run_text(cmd):
    '''
    Executes a command and captures its output as text.
    Parameters:
        cmd: A list of command arguments to execute (e.g., ["certutil", "-L", "-d", "sql:/home/user/.pki/nssdb"]).
    Returns:
    The standard output of the command as a string if successful, or None if an error occurs.
    Example usage:
        # List certificates in the NSS database
        output = run_text(["certutil", "-L", "-d", "sql:/home/user/.pki/nssdb"])
    '''
    try:
        res = subprocess.run(
            cmd,
            capture_output=True,
            text=True,
            check=True
        )
        return res.stdout
    except subprocess.CalledProcessError as e:
        print(f"Error ejecutando: {' '.join(cmd)}", file=sys.stderr)
        return None


def run_bytes(cmd, input_data=None):
    '''
    Executes a command and captures its output as bytes.
    Parameters:
        cmd: A list of command arguments to execute (e.g., ["openssl", "x509", "-in", "cert.pem", "-outform", "DER"]).
        input_data: Optional bytes to be sent to the command's standard input.
    Returns:
    The standard output of the command as bytes if successful, or None if an error occurs.
    Example usage:
        # Get the PEM-encoded certificate for a given nickname from the NSS database
        pem_bytes = run_bytes(["certutil", "-L", "-d", "sql:/home/user/.pki/nssdb", "-n", "My Certificate", "-a"])
    '''
    try:
        res = subprocess.run(
            cmd,
            input=input_data,
            capture_output=True,
            check=True
        )
        return res.stdout
    except subprocess.CalledProcessError:
        return None

 2. Llamada a comandos de la shell ASINCRONA

Veamos como se llama a un proceso asíncronamente ya sea por el ecomando entero o pasándole parámetros:

async def run_text_async(cmd: list[str]) -> str | None:
    '''
    Executes a command asynchronously and captures its output as text.
    Parameters:
        cmd: A list of command arguments to execute (e.g., ["ls", "-l"]).
    Returns:
        The standard output of the command as a string if successful, or None if an error occurs.
    Example usage:
        # List files in the current directory asynchronously
        output = await run_text_async(["ls", "-l"])    
    '''
    try:
        proc = await asyncio.create_subprocess_exec(
            *cmd,
            stdout=asyncio.subprocess.PIPE,
            stderr=asyncio.subprocess.PIPE,
        )
        stdout, stderr = await proc.communicate()
        if proc.returncode != 0:
            print(f"Error ejecutando: {' '.join(cmd)}", file=sys.stderr)
            if stderr:
                print(stderr.decode(errors="ignore").strip(), file=sys.stderr)
            return None
        return stdout.decode(errors="ignore")
    except Exception as e:
        print(f"Excepción ejecutando {' '.join(cmd)}: {e}", file=sys.stderr)
        return None


async def run_bytes_async(cmd: list[str], input_data: bytes | None = None) -> bytes | None:
    '''
    Executes a command asynchronously and captures its output as bytes.
    Parameters:
        cmd: A list of command arguments to execute (e.g., ["openssl", "x509", "-in", "cert.pem", "-outform", "DER"]).
        input_data: Optional bytes to be sent to the command's standard input.
    Returns:
        The standard output of the command as bytes if successful, or None if an error occurs.
    Example usage:
        # Get the PEM-encoded certificate for a given nickname from the NSS database asynchronously
        pem_bytes = await run_bytes_async(["certutil", "-L", "-d", "    
    '''
    try:
        proc = await asyncio.create_subprocess_exec(
            *cmd,
            stdin=asyncio.subprocess.PIPE if input_data is not None else None,
            stdout=asyncio.subprocess.PIPE,
            stderr=asyncio.subprocess.PIPE,
        )
        stdout, stderr = await proc.communicate(input=input_data)
        if proc.returncode != 0:
            print(f"Error ejecutando: {' '.join(cmd)}", file=sys.stderr)
            if stderr:
                print(stderr.decode(errors="ignore").strip(), file=sys.stderr)
            return None
        return stdout
    except Exception as e:
        print(f"Excepción ejecutando {' '.join(cmd)}: {e}", file=sys.stderr)
        return None

Python ASYNC (II). El event loop

1. Introducción

El event loop es el organizador de las tareas que se ejecutan dentro de é.

 El event loop normalmente se crea desde un una función síncrona con asyncio.run() 

def funcion_sync():
    resultado = asyncio.run(mi_funcion_async())
    print(resultado)

2. Entornos FastAPI (como FastHTML)

En este caso ya se ha creado un event loop. Para ello lo mas normal es utilizar funciones asíncronas.

Los puntos de partida para llamadas a las funciones suelen ser los "endpoints"(o urls) y conviene definirlas como asíncronas:

@app.post("/softprop/validate_login")

async def post_login(req, login: xmclasses.Login):

	''' 1. Verifica usuario y contraseña '''
	ldap_authenticated= await xmldap.autheticate_by_login(login.usuari, login.paraula_de_pass)
	if not ldap_authenticated:
		print ("returning to first login page")
		return fh.Div("Error en l'usuari o la paraula de pas", cls="alert alert-danger")

Pero puede haber casos que  "recojamos el event loop con asyncio.get_event_loop()  y ejcutemos funciones dendro de él con asyncio.run_coroutine_threadsafe() y recogiendo el resultado con .result() .

import asyncio

loop = asyncio.get_event_loop()
future = asyncio.run_coroutine_threadsafe(mi_funcion_async(), loop)
resultado = future.result()

Python ASYNC (I). Introducción

 1. Introducción

Async ejecuta una tarea mientras otra tarea está esperando. No es paraleleismo real pues no utiliza varios núcleos.

Veamos un ejemplo de programa sj́ncrono y su homólogo asíncrono.

La versión síncrona ejecuta el proceso tarea() dos veces que espera 2 segundos cada vez por tanto tarda 4 segundos

import time

def tarea():
    time.sleep(2)
    print("Hecho")

tarea()
tarea()

La versión asíncrona solo tarda 2 segundos pues cuando lanza la primera tarea(), no se espera a que termine para lanzar la segunda tarea() 

import asyncio

async def tarea():
    await asyncio.sleep(2)
    print("Hecho")

async def main():
    await asyncio.gather(
        tarea(),
        tarea()
    )

asyncio.run(main())

2. Cuando usar async?

• Redes (HTTP, APIs)
• Escaneo de red
• I/O (archivos, sockets)
• Bots, servidores

No sirve para:

• CPU intensivo (usar multiprocessing mejor)

Librerías async importantes:

• asyncio (core)
• aiohttp (HTTP)
• asyncssh (SSH)
• aiomysql, asyncpg (DB)
• aiofiles (archivos)

3. Conceptos clave

1. Las funciones asíncronas se definen con async def

async def mi_funcion():
    pass

2. El comando async ejecuta funciones asíncronas dentro de otras funciones asíncronas

async def mi_funcion():
    await my_async_func()

3. Para el main utilizar asyncio.run(my_async_fun()) (es el event loop)

if __name__ == "__main__":
    asyncio.run(run_from_yaml())

4. courutines, problematica de su ejecución. Si una función asíncrono no se la llama con async, entonces es una courutina y no se ejecuta aún

import asyncio

async def tarea():
    await asyncio.sleep(2)
    return 'hola'

async def main():
    #MALA llamada, a1 es una corrutina y no se ejecuta aún
    #  a1 es una referencia a la función tarea()
    a1= tarea()
 
    #BUENA llamada
    a2=await tarea()
    
asyncio.run(main())

5. ejecución de varias fuinciones (a la vez)con asyncio.gather

import asyncio

async def main():
    await asyncio.gather(tarea1(), tarea2(), tarea3()) 
    
asyncio.run(main())

6. await asyncio.sleep(1) para parar la ejecución dentro de una función asíncrona pero sin parar otras funciones que se ejecutan en paralelo

import asyncio

async def my_async_func():
    #Para 1 sefundo esta tarea solo y no el resto de funciones asíncronas
    await asyncio.sleep(1)

WEBPROPv2 (XIX). Ejecución de procesos en modo sudo

 A veces hay librerías como python-nmap que algunas opciones se tienen que ejecutar como sudo para ello se plantea ejecutar esta sentencia:

#Poder utiliza algunas capacidades de nmpa sin sudo
sudo setcap cap_net_raw,cap_net_admin,cap_net_bind_service+eip $(which nmap)

#Revertir al estado anterior
sudo setcap -r $(which nmap)

⚙️ Desglose por partes

1. setcap

Herramienta de Linux para asignar capabilities a ejecutables.Las capabilities son permisos finos (más seguros que sudo).

2. $(which nmap)

Devuelve la ruta de nmap, normalmente:

/usr/bin/nmap

3. Las capabilities

🔹 cap_net_raw

Permite usar sockets RAW. Necesario para:

• Ping SYN
• OS fingerprinting (-O)
• Escaneos stealth

🔹 cap_net_admin

Permite operaciones de red avanzadas. Necesario para:

• manipular paquetes
• técnicas avanzadas de escaneo

🔹 cap_net_bind_service

Permite usar puertos < 1024. No es crítico para nmap, pero útil en algunos casos

4. +eip

Significa que las capabilities se aplican en:

• e → effective
• i → inheritable
• p → permitted

En resumen: el binario puede usar esos permisos al ejecutarse

🎯 Concretando

No hace falta ejecutar sudo en

sudo nmap -O 192.168.1.1

pero  cualquier usuario que ejecute nmap tiene esos privilegios