{"id":20284,"date":"2026-08-03T11:50:45","date_gmt":"2026-08-03T09:50:45","guid":{"rendered":"https:\/\/webhosting.de\/linux-capabilities-root-rechte-granular-aufteilen-sicherheitskonzept\/"},"modified":"2026-08-03T11:50:45","modified_gmt":"2026-08-03T09:50:45","slug":"capacidades-de-linux-derechos-de-root-distribucion-granular-concepto-de-seguridad","status":"publish","type":"post","link":"https:\/\/webhosting.de\/es\/linux-capabilities-root-rechte-granular-aufteilen-sicherheitskonzept\/","title":{"rendered":"Capacidades de Linux: distribuir los derechos de root de forma segura y granular"},"content":{"rendered":"<p>Con Linux Capabilities, divido los derechos de root en privilegios peque\u00f1os y claramente definidos, lo que reduce dr\u00e1sticamente el riesgo. De este modo, controlo de forma espec\u00edfica qu\u00e9 procesos pueden realizar acciones especiales y limito la superficie de ataque de cada aplicaci\u00f3n.<\/p>\n\n<h2>Puntos centrales<\/h2>\n\n<ul>\n  <li><strong>De grano fino<\/strong> En lugar de ser todopoderoso: dividir los derechos de root en privilegios m\u00e1s espec\u00edficos.<\/li>\n  <li><strong>Capacidades de los archivos<\/strong> En lugar de Set-UID: vincular los permisos necesarios directamente a los archivos binarios.<\/li>\n  <li><strong>Conjuntos de capacidades<\/strong> Configurar de forma espec\u00edfica los par\u00e1metros \u00absteueren\u00bb: \u00abPermitted\u00bb, \u00abEffective\u00bb, \u00abInheritable\u00bb y \u00abBounding\u00bb.<\/li>\n  <li><strong>Separaci\u00f3n de privilegios<\/strong>: Separar estrictamente los servicios, las herramientas y las tareas.<\/li>\n  <li><strong>Defensa en profundidad<\/strong>: Completar las capacidades con sudo, roles y protocolos.<\/li>\n<\/ul>\n\n\n<figure class=\"wp-block-image size-full is-resized\">\n  <img fetchpriority=\"high\" decoding=\"async\" src=\"https:\/\/webhosting.de\/wp-content\/uploads\/2026\/08\/linux-serververwaltung-8291.png\" alt=\"\" width=\"1536\" height=\"1024\"\/>\n<\/figure>\n\n\n<h2>\u00bfPor qu\u00e9 separar los derechos de root?<\/h2>\n\n<p>Una cuenta de root permite <strong>Acceso total<\/strong> en el \u00e1mbito de los archivos y los procesos, pero precisamente eso da pie a errores con graves consecuencias. Basta un comando err\u00f3neo o un exploit para que se bloquee toda la instalaci\u00f3n. Por eso limito las acciones de gran alcance a lo estrictamente necesario, reduciendo as\u00ed la magnitud de los da\u00f1os y el tiempo de recuperaci\u00f3n. El principio de los derechos m\u00ednimos mantiene los servicios reducidos y controlables. Desactivo el inicio de sesi\u00f3n directo como root, apuesto por los roles y genero registros exhaustivos.<\/p>\n\n<h2>Explicaci\u00f3n breve de las capacidades de Linux<\/h2>\n\n<p>Las capacidades de Linux desglosan los poderes cl\u00e1sicos del usuario \u00abroot\u00bb en derechos claramente definidos <strong>Privilegios<\/strong>. Cada proceso recibe \u00fanicamente los componentes que realmente necesita para su tarea, como la asignaci\u00f3n de puertos por debajo de 1024 o el env\u00edo de se\u00f1ales especiales. De este modo, evito el antiguo enfoque de \u00abtodo o nada\u00bb. El n\u00facleo gestiona estos componentes por cada proceso y los aplica de forma estricta. De este modo, el control sigue siendo minucioso y trazable.<\/p>\n\n<p>Desde el punto de vista t\u00e9cnico, relaciono las habilidades con <strong>Procesos<\/strong> (a trav\u00e9s de sus conjuntos de capacidades) o a <strong>Archivos<\/strong> (como atributos extendidos <code>capacidad de seguridad<\/code> en los binarios ELF). En el <code>execve()<\/code>-Al iniciarse, el n\u00facleo fusiona las capacidades de los archivos con los conjuntos de privilegios de los procesos: en t\u00e9rminos sencillos, las capacidades permitidas del atributo del archivo, junto con los derechos heredables del proceso que realiza la llamada, se combinan para formar el nuevo conjunto \u00abPermitted\u00bb y, si as\u00ed se ha indicado, se activan al mismo tiempo en el conjunto \u00abEffective\u00bb. Esto evita los rodeos de Set-UID y mantiene los privilegios visibles y verificables.<\/p>\n\n\n<figure class=\"wp-block-image size-full is-resized\">\n  <img decoding=\"async\" src=\"https:\/\/webhosting.de\/wp-content\/uploads\/2026\/08\/linux_rechte_besprechung_3820.png\" alt=\"\" width=\"1536\" height=\"1024\"\/>\n<\/figure>\n\n\n<h2>Comprender los conjuntos de capacidades en el contexto de los procesos<\/h2>\n\n<p>Cada proceso cuenta con varios conjuntos de derechos que yo gestiono de forma espec\u00edfica <strong>control<\/strong>. El \u00abPermitted-Set\u00bb define lo que un proceso puede tener en principio. El \u00abEffective-Set\u00bb establece lo que est\u00e1 activo en cada momento. El \u00abInheritable-Set\u00bb regula qu\u00e9 privilegios pueden transmitirse a los procesos hijos. El \u00abBounding-Set\u00bb establece un l\u00edmite m\u00e1ximo estricto e impide que los procesos lo superen.<\/p>\n\n<h2>Ambient Capabilities y Securebits<\/h2>\n\n<p>Adem\u00e1s de los sets ya conocidos, est\u00e1 el <strong>Conjunto de m\u00fasica ambiental<\/strong>, que en el <code>execve()<\/code> no caduca autom\u00e1ticamente. Lo utilizo cuando un proceso sin privilegios necesita, de forma espec\u00edfica, derechos m\u00ednimos en varios <code>exec<\/code>-que se mantengan a pesar de los saltos (por ejemplo, al ejecutar programas auxiliares externos). Los derechos \u00abambient\u00bb solo se tienen en cuenta en los derechos efectivos si el propio archivo ejecutado no establece capacidades de archivo; de este modo, evito una escalada no deseada.<\/p>\n\n<p>Con los <strong>Securebits<\/strong> controlo los detalles de las transiciones, por ejemplo, si un proceso puede conservar las capacidades que ten\u00eda antes tras el cambio de UID (<code>keepcaps<\/code>) o si, en general, no puede obtener nuevos privilegios (<code>no_new_privs<\/code>). En la pr\u00e1ctica, configuro Securebits de forma estricta y renuncio a la comodidad para romper las cadenas de exploits.<\/p>\n\n<h2>Capacidades de archivo en lugar de Set-UID<\/h2>\n\n<p>Sustituyo los binarios con Set-UID por capacidades de archivo para reducir el riesgo de <strong>bajar<\/strong>. En lugar de otorgar privilegios de root a un programa, solo le asigno los derechos necesarios. Un cambio t\u00edpico es el siguiente: <code>setcap 'cap_net_bind_service=+ep' \/usr\/bin\/meinserver<\/code>. Con <code>getcap -r \/<\/code> Compruebo qu\u00e9 archivos contienen las competencias. Esto reduce notablemente las v\u00edas de escalaci\u00f3n.<\/p>\n\n<p>Es importante que las capacidades de los archivos solo se apliquen a <strong>Archivos binarios ELF<\/strong> funcionan. Los scripts de int\u00e9rprete (por ejemplo, Python, Bash) no los heredan de forma fiable. En esos casos, encapsulo la acci\u00f3n privilegiada en una peque\u00f1a utilidad sometida a comprobaci\u00f3n est\u00e1tica o utilizo la activaci\u00f3n por socket, para que mi servicio ni siquiera tenga que establecer la conexi\u00f3n por s\u00ed mismo. Adem\u00e1s, presto atenci\u00f3n a los permisos de los archivos: las capacidades otorgan derechos especiales frente al n\u00facleo, pero sustituyen <strong>ninguno<\/strong> las ACL habituales o los permisos POSIX.<\/p>\n\n<p>Al copiar o empaquetar, las habilidades se pierden r\u00e1pidamente: <code>cp<\/code> sin compatibilidad con XATTR, configurado incorrectamente <code>umask<\/code> o eliminar un artefacto de compilaci\u00f3n de un sistema de archivos sin atributos extendidos <code>capacidad de seguridad<\/code> De forma impl\u00edcita. Por eso trabajo de manera reproducible y utilizo: <code>cp --preserve=xattr ...<\/code>, <code>tar --xattrs<\/code>, <code>rsync -X<\/code>. En las compilaciones de paquetes, configuro expl\u00edcitamente las capacidades de los archivos en el script de instalaci\u00f3n, pruebo la instalaci\u00f3n en una m\u00e1quina virtual limpia y compruebo <code>getcap<\/code> en el CI.<\/p>\n\n<h2>Separaci\u00f3n de privilegios con escenarios realistas<\/h2>\n\n<p>Un servidor web necesita acceso a los puertos 80 y 443, pero no a los m\u00f3dulos del n\u00facleo ni a los reinicios del sistema, por lo que configuro <strong>CAP_NET_BIND_SERVICE<\/strong> y nada m\u00e1s. Un agente de copia de seguridad puede leer y escribir archivos, pero no modificar la configuraci\u00f3n de red. Una herramienta de supervisi\u00f3n tiene acceso de lectura a los indicadores clave, pero carece de derechos de modificaci\u00f3n. Estas restricciones limitan los ataques al \u00e1mbito local, en lugar de permitir que afecten a todo el sistema. Es precisamente esta separaci\u00f3n la que permite que los servicios sean manejables y mantiene a raya las configuraciones err\u00f3neas.<\/p>\n\n\n<figure class=\"wp-block-image size-full is-resized\">\n  <img decoding=\"async\" src=\"https:\/\/webhosting.de\/wp-content\/uploads\/2026\/08\/balancing-linux-capabilities-5618.png\" alt=\"\" width=\"1536\" height=\"1024\"\/>\n<\/figure>\n\n\n<h2>Combinar con \u00absudo\u00bb y los roles<\/h2>\n\n<p>Las capacidades no sustituyen a una <strong>Estructura de funciones<\/strong>, las complementan. Concedo los permisos de sudo con mucha cautela, utilizo rutas completas de comandos y evito reglas generales como \u201eALL=(ALL) ALL\u201c. Registro cada concesi\u00f3n de permisos. Los grupos agrupan responsabilidades, mientras que las capacidades establecen l\u00edmites t\u00e9cnicos en los procesos. De este modo se crean competencias claras sin privilegios excesivos.<\/p>\n\n<h2>Errores habituales y buenas pr\u00e1cticas<\/h2>\n\n<ul>\n  <li><strong>No se utiliza CAP_SYS_ADMIN como abreviatura:<\/strong> Este derecho es un caj\u00f3n de sastre. Lo sustituyo por alternativas m\u00e1s espec\u00edficas (p. ej.,. <code>CAP_SYS_CHROOT<\/code>, <code>CAP_SYS_TIME<\/code>, <code>CAP_SYS_NICE<\/code>) o prescinde de ello por completo.<\/li>\n  <li><strong>Los permisos de los archivos se mantienen estrictos:<\/strong> Las capacidades no anulan el DAC de forma general. Sin <code>CAP_DAC_OVERRIDE<\/code> El n\u00facleo sigue respetando los bits de propietario y de modo. Por lo tanto, sigo concediendo los derechos de lectura de forma m\u00ednima.<\/li>\n  <li><strong>Endurecimiento por v\u00eda:<\/strong> Si asigno capacidades de archivo a un binario, evito la suplantaci\u00f3n de PATH (rutas absolutas en <code>sudoers<\/code>, derechos de escritura restringidos en los directorios de la ruta de b\u00fasqueda).<\/li>\n  <li><strong>Publica pronto y con frecuencia:<\/strong> Es posible que los procesos se inicien con m\u00e1s permisos de los necesarios. Retiro los permisos innecesarios inmediatamente despu\u00e9s de realizar el paso delicado (<code>prctl()<\/code>\/libcap) y establezco <code>no_new_privs<\/code>, siempre que sea posible.<\/li>\n  <li><strong>Limitar la herencia:<\/strong> Mantengo reducidos los conjuntos \u00abInheritable\u00bb y \u00abAmbient\u00bb. Los procesos hijos no deben abrir nuevas puertas.<\/li>\n  <li><strong>Comprobar el proceso de compilaci\u00f3n y despliegue:<\/strong> Confirmo que <code>capacidad de seguridad<\/code> se conserve y que ning\u00fan paso de preparaci\u00f3n (capas de contenedores, NFS, esc\u00e1ner de artefactos) elimine los XATTR.<\/li>\n<\/ul>\n\n<h2>Resumen de las capacidades y los riesgos m\u00e1s importantes<\/h2>\n\n<p>Antes de asignar privilegios, defino claramente los que son necesarios y eval\u00fao su riesgo. La siguiente tabla muestra ejemplos t\u00edpicos con sus efectos y su clasificaci\u00f3n. Siempre tengo en cuenta alternativas para evitar conceder derechos excesivos. Precisamente <strong>CAP_SYS_ADMIN<\/strong> Los concedo con mucha moderaci\u00f3n. Siempre que es posible, sustituyo los privilegios de amplio alcance por variantes espec\u00edficas y m\u00e1s limitadas.<\/p>\n\n<table>\n  <thead>\n    <tr>\n      <th>Capacidad<\/th>\n      <th>Prop\u00f3sito<\/th>\n      <th>Riesgo<\/th>\n      <th>Ejemplo<\/th>\n    <\/tr>\n  <\/thead>\n  <tbody>\n    <tr>\n      <td>CAP_NET_BIND_SERVICE<\/td>\n      <td>Enlazar a puertos &lt; 1024<\/td>\n      <td>Bajo a medio<\/td>\n      <td>Servidor web en los puertos 80 y 443<\/td>\n    <\/tr>\n    <tr>\n      <td>CAP_SYS_BOOT<\/td>\n      <td>Reiniciar el sistema<\/td>\n      <td>Alta<\/td>\n      <td>Reinicio programado<\/td>\n    <\/tr>\n    <tr>\n      <td>CAP_SYS_MODULE<\/td>\n      <td>Cargar\/eliminar m\u00f3dulos del n\u00facleo<\/td>\n      <td>Muy alta<\/td>\n      <td>Gesti\u00f3n de controladores<\/td>\n    <\/tr>\n    <tr>\n      <td>CAP_SYS_ADMIN<\/td>\n      <td>Operaciones administrativas vers\u00e1tiles<\/td>\n      <td>Muy alta<\/td>\n      <td>Diversas tareas de mantenimiento<\/td>\n    <\/tr>\n    <tr>\n      <td>CAP_SETUID \/ CAP_SETGID<\/td>\n      <td>Cambiar el UID\/GID<\/td>\n      <td>Media a alta<\/td>\n      <td>Cambio de turnos en el servicio<\/td>\n    <\/tr>\n  <\/tbody>\n<\/table>\n\n\n<figure class=\"wp-block-image size-full is-resized\">\n  <img loading=\"lazy\" decoding=\"async\" src=\"https:\/\/webhosting.de\/wp-content\/uploads\/2026\/08\/linux_capabilities_tech-office_4738.png\" alt=\"\" width=\"1536\" height=\"1024\"\/>\n<\/figure>\n\n\n<p>M\u00e1s all\u00e1 de la tabla, ahora mismo estoy evaluando <code>CAP_SYS_PTRACE<\/code> (Depuraci\u00f3n de procesos), <code>CAP_NET_ADMIN<\/code> (parametrizaci\u00f3n de la red) y <code>CAP_DAC_OVERRIDE<\/code> (Eludir las restricciones de acceso a los archivos) es algo muy delicado. A menudo existen patrones que permiten evitar estos derechos: puntos finales de m\u00e9tricas espec\u00edficos en lugar de \u00abprocess snooping\u00bb, activaci\u00f3n de sockets o reenv\u00edos de puertos en lugar de derechos \u00abbind\u00bb, y derechos de archivo bien definidos en lugar de una elusi\u00f3n generalizada del DAC.<\/p>\n\n<h2>Endurecimiento en contenedores y alojamiento web<\/h2>\n\n<p>En entornos multitenant, considero que las competencias son radicalmente <strong>peque\u00f1o<\/strong> y evito la herencia en los procesos hijos. Los contenedores se benefician notablemente en cuanto el conjunto delimitador (bounding set) queda bien ajustado. Combino esto con espacios aislados para el sistema de archivos y los procesos. Para tener una visi\u00f3n general de los enfoques de aislamiento, me resulta \u00fatil esta introducci\u00f3n a <a href=\"https:\/\/webhosting.de\/es\/proceso-aislamiento-alojamiento-chroot-cagefs-contenedores-jails-seguridad-comparacion\/\">Aislamiento de procesos<\/a>. De este modo, los servicios permanecen independientes, incluso si una aplicaci\u00f3n falla.<\/p>\n\n<p>En la pr\u00e1ctica, configuro los contenedores de forma predeterminada en \u201eeliminar todo, a\u00f1adir de forma selectiva\u201c: <code>--cap-drop=ALL --cap-add=NET_BIND_SERVICE<\/code> para servicios web, sin derechos de montaje, sin <code>SYS_ADMIN<\/code>. En entornos orquestados, mantengo el perfil de forma centralizada y lo compruebo en las pol\u00edticas. Importante: no me baso en las capacidades de los archivos de la imagen, sino que asigno derechos en tiempo de ejecuci\u00f3n en el orquestador, de forma reproducible y auditable.<\/p>\n\n<h2>Interacci\u00f3n con SELinux y AppArmor<\/h2>\n\n<p>Las capacidades controlan lo que un proceso puede hacer, mientras que los perfiles MAC determinan a qu\u00e9 tiene acceso, y ambos se complementan <strong>bien<\/strong>. Establezco las capacidades de forma restrictiva y dejo que SELinux o AppArmor limiten el acceso a los archivos y sockets. De este modo se crea una protecci\u00f3n por capas que plantea varios obst\u00e1culos a los exploits. Aqu\u00ed encuentro una comparaci\u00f3n r\u00e1pida: <a href=\"https:\/\/webhosting.de\/es\/selinux-frente-a-apparmor-seguridad-en-linux-refuerzo-de-servidores-proteccion\/\">SELinux frente a AppArmor<\/a>. De este modo, un servicio comprometido queda aislado y puede causar menos da\u00f1os.<\/p>\n\n\n<figure class=\"wp-block-image size-full is-resized\">\n  <img loading=\"lazy\" decoding=\"async\" src=\"https:\/\/webhosting.de\/wp-content\/uploads\/2026\/08\/entwickler_schreibtisch2345.png\" alt=\"\" width=\"1536\" height=\"1024\"\/>\n<\/figure>\n\n\n<h2>Pr\u00e1ctica: proceder paso a paso<\/h2>\n\n<p>Voy a empezar por hacer un inventario de todos los servicios y sus <strong>Requisitos<\/strong>. A continuaci\u00f3n, elimino los binarios Set-UID innecesarios o los sustituyo por capacidades de archivo espec\u00edficas. Configuro \u00absudo\u00bb de forma restrictiva y documento cada entrada. Asigno tareas a roles y grupos, y mantengo los permisos al m\u00ednimo. A continuaci\u00f3n, realizo pruebas bajo carga y compruebo las entradas de los registros en busca de rechazos inesperados.<\/p>\n\n<p>Una breve lista de comprobaci\u00f3n me ayuda con el cambio:<\/p>\n<ul>\n  <li>Establecer por escrito los requisitos de cada servicio (solo lo que sea realmente necesario).<\/li>\n  <li>Hacer un inventario de los derechos especiales existentes (<code>find \/ -perm -4000<\/code>, <code>getcap -r \/<\/code>).<\/li>\n  <li>Sustituci\u00f3n selectiva: eliminar el Set-UID, establecer las capacidades de los archivos y retirar los permisos lo antes posible.<\/li>\n  <li>Cerrar herencias: optimizar el conjunto delimitador, minimizar \u00abInheritable\u00bb y \u00abAmbient\u00bb.<\/li>\n  <li>Proteger los perfiles de systemd y de contenedores (<code>CapacidadBoundingSet=<\/code>, <code>NoNewPrivileges=yes<\/code>).<\/li>\n  <li>Realizar pruebas bajo carga, revisar los registros y las entradas de auditor\u00eda, y documentar las excepciones.<\/li>\n<\/ul>\n\n<h2>Supervisi\u00f3n, espacios de nombres y auditor\u00edas continuas<\/h2>\n\n<p>Superviso los archivos de registro, las alertas y las llamadas al sistema para que cualquier acci\u00f3n no deseada se detecte de inmediato <strong>destacar<\/strong>. Valido peri\u00f3dicamente los cambios en las capacidades, las reglas de sudo y los roles. Cuando resulta conveniente, a\u00edslo adicionalmente las cargas de trabajo mediante mecanismos de aislamiento del n\u00facleo. Este resumen ofrece un buen punto de partida para <a href=\"https:\/\/webhosting.de\/es\/servidor-contexto-aislamiento-namespaces-cgroups-alojamiento-seguridad\/\">Espacios de nombres y cgroups<\/a>. As\u00ed detecto las anomal\u00edas a tiempo y mantengo limpio el entorno.<\/p>\n\n<p>En mi d\u00eda a d\u00eda utilizo pruebas sencillas: <code>capsh --print<\/code> me muestra el conjunto actual de habilidades, <code>getpcaps<\/code> enumera los derechos procesales y en <code>\/proc\/\/status<\/code> leo <code>CapEff<\/code>, <code>CapPrm<\/code>, <code>CapBnd<\/code>. Con <code>auditd<\/code> Realizo un seguimiento de los cambios en el estado de la capacidad (por ejemplo, regla en <code>capset<\/code>), relaciono los eventos con las implementaciones y configuro alertas cuando aparecen de repente permisos de alto nivel. En los casos m\u00e1s complicados, me ayuda <code>strace -e capget,capset<\/code>, con el fin de poner de manifiesto las manipulaciones de los derechos.<\/p>\n\n\n<figure class=\"wp-block-image size-full is-resized\">\n  <img loading=\"lazy\" decoding=\"async\" src=\"https:\/\/webhosting.de\/wp-content\/uploads\/2026\/08\/linux-capabilities-8123.png\" alt=\"\" width=\"1536\" height=\"1024\"\/>\n<\/figure>\n\n\n<h2>Ejemplos pr\u00e1cticos de systemd y contenedores<\/h2>\n\n<p>Muchos servicios los ejecuto como unidades de systemd y all\u00ed configuro los permisos:<\/p>\n<ul>\n  <li><code>CapabilityBoundingSet=CAP_NET_BIND_SERVICE<\/code> reduce la ventana de derechos a lo estrictamente necesario.<\/li>\n  <li><code>AmbientCapabilities=CAP_NET_BIND_SERVICE<\/code> Otorga al servicio el derecho a conectarse a los puertos 80\/443 sin \u00abfile-capabilities\u00bb.<\/li>\n  <li><code>NoNewPrivileges=yes<\/code> impide futuras ampliaciones de derechos.<\/li>\n  <li><code>Usuario=<\/code>, <code>Grupo=<\/code>, <code>ProtectSystem=estricto<\/code>, <code>PrivateTmp=yes<\/code> completan el aislamiento.<\/li>\n<\/ul>\n<p>En los contenedores, inicio los procesos de la forma m\u00e1s minimalista posible: <code>docker run --cap-drop=ALL --cap-add=NET_BIND_SERVICE --read-only<\/code>. Para tareas de corta duraci\u00f3n, utilizo las capacidades de tiempo de ejecuci\u00f3n en lugar de las capacidades de archivo en la imagen, para que las compilaciones sigan siendo reproducibles y los permisos est\u00e9n vinculados al entorno.<\/p>\n\n<h2>Casos concretos de migraci\u00f3n extra\u00eddos de la pr\u00e1ctica<\/h2>\n\n<ul>\n  <li><strong>ping sin Set-UID:<\/strong> En lugar de <code>setuid root<\/code> pongo <code>setcap 'cap_net_raw=+ep' \/bin\/ping<\/code>. De este modo, cualquier usuario puede abrir sockets ICMP sin necesidad de tener todos los privilegios de root. Lo compruebo peri\u00f3dicamente con <code>getcap \/bin\/ping<\/code>, si se ha conservado el atributo.<\/li>\n  <li><strong>Servicio web en los puertos 80\/443:<\/strong> Ejecuto mi servicio como usuario sin privilegios y solo introduzco <code>cap_net_bind_service<\/code>. Si el servicio ya est\u00e1 conectado a un proxy inverso, tambi\u00e9n puedo, como alternativa, vincularlo all\u00ed a los puertos 80\/443 y utilizar un puerto alto internamente, sin necesidad de conocimientos adicionales.<\/li>\n  <li><strong>Cambio de partes en el proceso:<\/strong> Para las herramientas que necesitan derechos elevados durante un breve periodo de tiempo (por ejemplo, para establecer los niveles de prioridad), configuro <code>cap_sys_nice<\/code>, realiza la acci\u00f3n cuanto antes y, a continuaci\u00f3n, deja de usar la habilidad. Evito aumentar los derechos de forma permanente.<\/li>\n<\/ul>\n\n<h2>L\u00edmites y alternativas<\/h2>\n\n<p>No todos los casos de uso requieren \u00abcapabilities\u00bb. A menudo existen alternativas seguras que entra\u00f1an un menor riesgo:<\/p>\n<ul>\n  <li><strong>Activaci\u00f3n del socket:<\/strong> El servicio de inicio (por ejemplo, systemd) abre sockets con privilegios y se los pasa al proceso. De este modo, mi servicio no necesita derechos de Bind.<\/li>\n  <li><strong>Reenv\u00edo de puertos:<\/strong> Mediante reglas de cortafuegos, redirijo los puertos 80 y 443 a un puerto alto. El servicio sigue sin tener privilegios y el comportamiento del sistema no cambia.<\/li>\n  <li><strong>Puertos de bajo nivel sin privilegios:<\/strong> Cuando sea adecuado, puedo elevar el umbral para los puertos no privilegiados. Sin embargo, eso ampl\u00eda el margen de maniobra para todos los procesos; por eso sopeso cuidadosamente el riesgo y la comodidad.<\/li>\n  <li><strong>Peque\u00f1os ayudantes en lugar de todoterrenos:<\/strong> Prefiero un binario diminuto y auditado con una sola habilidad que un gran monolito con un amplio cat\u00e1logo de derechos.<\/li>\n<\/ul>\n\n<h2>Brevemente resumido<\/h2>\n\n<p>Con <strong>Capacidades de Linux<\/strong> Divido los poderes de root en peque\u00f1os privilegios f\u00e1ciles de controlar. Las capacidades de archivo sustituyen a los binarios Set-UID, que entra\u00f1an riesgos, y reducen las consecuencias de un ataque. En combinaci\u00f3n con reglas estrictas de sudo, roles y perfiles MAC, se crea una protecci\u00f3n por capas con l\u00edmites claros. Los conjuntos \u00abBounding\u00bb e \u00abInheritable\u00bb limitan la herencia y mantienen los procesos bajo control. Quien proceda de esta manera reduce notablemente la superficie de ataque y mantiene la carga administrativa dentro de unos l\u00edmites razonables.<\/p>","protected":false},"excerpt":{"rendered":"<p>Las capacidades de Linux dividen los derechos de root en privilegios granulares. Descubre c\u00f3mo el modelo de capacidades refuerza la seguridad de tu servidor y permite la separaci\u00f3n de privilegios en los sistemas Linux.<\/p>","protected":false},"author":1,"featured_media":20277,"comment_status":"","ping_status":"","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"inline_featured_image":false,"footnotes":""},"categories":[794],"tags":[],"class_list":["post-20284","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-sicherheit-computer_und_internet"],"acf":[],"_wp_attached_file":null,"_wp_attachment_metadata":null,"litespeed-optimize-size":null,"litespeed-optimize-set":null,"_elementor_source_image_hash":null,"_wp_attachment_image_alt":null,"stockpack_author_name":null,"stockpack_author_url":null,"stockpack_provider":null,"stockpack_image_url":null,"stockpack_license":null,"stockpack_license_url":null,"stockpack_modification":null,"color":null,"original_id":null,"original_url":null,"original_link":null,"unsplash_location":null,"unsplash_sponsor":null,"unsplash_exif":null,"unsplash_attachment_metadata":null,"_elementor_is_screenshot":null,"surfer_file_name":null,"surfer_file_original_url":null,"envato_tk_source_kit":null,"envato_tk_source_index":null,"envato_tk_manifest":null,"envato_tk_folder_name":null,"envato_tk_builder":null,"envato_elements_download_event":null,"_menu_item_type":null,"_menu_item_menu_item_parent":null,"_menu_item_object_id":null,"_menu_item_object":null,"_menu_item_target":null,"_menu_item_classes":null,"_menu_item_xfn":null,"_menu_item_url":null,"_trp_menu_languages":null,"rank_math_primary_category":null,"rank_math_title":null,"inline_featured_image":null,"_yoast_wpseo_primary_category":null,"rank_math_schema_blogposting":null,"rank_math_schema_videoobject":null,"_oembed_049c719bc4a9f89deaead66a7da9fddc":null,"_oembed_time_049c719bc4a9f89deaead66a7da9fddc":null,"_yoast_wpseo_focuskw":null,"_yoast_wpseo_linkdex":null,"_oembed_27e3473bf8bec795fbeb3a9d38489348":null,"_oembed_c3b0f6959478faf92a1f343d8f96b19e":null,"_trp_translated_slug_en_us":null,"_wp_desired_post_slug":null,"_yoast_wpseo_title":null,"tldname":null,"tldpreis":null,"tldrubrik":null,"tldpolicylink":null,"tldsize":null,"tldregistrierungsdauer":null,"tldtransfer":null,"tldwhoisprivacy":null,"tldregistrarchange":null,"tldregistrantchange":null,"tldwhoisupdate":null,"tldnameserverupdate":null,"tlddeletesofort":null,"tlddeleteexpire":null,"tldumlaute":null,"tldrestore":null,"tldsubcategory":null,"tldbildname":null,"tldbildurl":null,"tldclean":null,"tldcategory":null,"tldpolicy":null,"tldbesonderheiten":null,"tld_bedeutung":null,"_oembed_d167040d816d8f94c072940c8009f5f8":null,"_oembed_b0a0fa59ef14f8870da2c63f2027d064":null,"_oembed_4792fa4dfb2a8f09ab950a73b7f313ba":null,"_oembed_33ceb1fe54a8ab775d9410abf699878d":null,"_oembed_fd7014d14d919b45ec004937c0db9335":null,"_oembed_21a029d076783ec3e8042698c351bd7e":null,"_oembed_be5ea8a0c7b18e658f08cc571a909452":null,"_oembed_a9ca7a298b19f9b48ec5914e010294d2":null,"_oembed_f8db6b27d08a2bb1f920e7647808899a":null,"_oembed_168ebde5096e77d8a89326519af9e022":null,"_oembed_cdb76f1b345b42743edfe25481b6f98f":null,"_oembed_87b0613611ae54e86e8864265404b0a1":null,"_oembed_27aa0e5cf3f1bb4bc416a4641a5ac273":null,"_oembed_time_27aa0e5cf3f1bb4bc416a4641a5ac273":null,"_tldname":null,"_tldclean":null,"_tldpreis":null,"_tldcategory":null,"_tldsubcategory":null,"_tldpolicy":null,"_tldpolicylink":null,"_tldsize":null,"_tldregistrierungsdauer":null,"_tldtransfer":null,"_tldwhoisprivacy":null,"_tldregistrarchange":null,"_tldregistrantchange":null,"_tldwhoisupdate":null,"_tldnameserverupdate":null,"_tlddeletesofort":null,"_tlddeleteexpire":null,"_tldumlaute":null,"_tldrestore":null,"_tldbildname":null,"_tldbildurl":null,"_tld_bedeutung":null,"_tldbesonderheiten":null,"_oembed_ad96e4112edb9f8ffa35731d4098bc6b":null,"_oembed_8357e2b8a2575c74ed5978f262a10126":null,"_oembed_3d5fea5103dd0d22ec5d6a33eff7f863":null,"_eael_widget_elements":null,"_oembed_0d8a206f09633e3d62b95a15a4dd0487":null,"_oembed_time_0d8a206f09633e3d62b95a15a4dd0487":null,"_aioseo_description":null,"_eb_attr":null,"_eb_data_table":null,"_oembed_819a879e7da16dd629cfd15a97334c8a":null,"_oembed_time_819a879e7da16dd629cfd15a97334c8a":null,"_acf_changed":null,"_wpcode_auto_insert":null,"_edit_last":null,"_edit_lock":null,"_oembed_e7b913c6c84084ed9702cb4feb012ddd":null,"_oembed_bfde9e10f59a17b85fc8917fa7edf782":null,"_oembed_time_bfde9e10f59a17b85fc8917fa7edf782":null,"_oembed_03514b67990db061d7c4672de26dc514":null,"_oembed_time_03514b67990db061d7c4672de26dc514":null,"rank_math_news_sitemap_robots":null,"rank_math_robots":null,"_eael_post_view_count":"71","_trp_automatically_translated_slug_ru_ru":null,"_trp_automatically_translated_slug_et":null,"_trp_automatically_translated_slug_lv":null,"_trp_automatically_translated_slug_fr_fr":null,"_trp_automatically_translated_slug_en_us":null,"_wp_old_slug":null,"_trp_automatically_translated_slug_da_dk":null,"_trp_automatically_translated_slug_pl_pl":null,"_trp_automatically_translated_slug_es_es":null,"_trp_automatically_translated_slug_hu_hu":null,"_trp_automatically_translated_slug_fi":null,"_trp_automatically_translated_slug_ja":null,"_trp_automatically_translated_slug_lt_lt":null,"_elementor_edit_mode":null,"_elementor_template_type":null,"_elementor_version":null,"_elementor_pro_version":null,"_wp_page_template":null,"_elementor_page_settings":null,"_elementor_data":null,"_elementor_css":null,"_elementor_conditions":null,"_happyaddons_elements_cache":null,"_oembed_75446120c39305f0da0ccd147f6de9cb":null,"_oembed_time_75446120c39305f0da0ccd147f6de9cb":null,"_oembed_3efb2c3e76a18143e7207993a2a6939a":null,"_oembed_time_3efb2c3e76a18143e7207993a2a6939a":null,"_oembed_59808117857ddf57e478a31d79f76e4d":null,"_oembed_time_59808117857ddf57e478a31d79f76e4d":null,"_oembed_965c5b49aa8d22ce37dfb3bde0268600":null,"_oembed_time_965c5b49aa8d22ce37dfb3bde0268600":null,"_oembed_81002f7ee3604f645db4ebcfd1912acf":null,"_oembed_time_81002f7ee3604f645db4ebcfd1912acf":null,"_elementor_screenshot":null,"_oembed_7ea3429961cf98fa85da9747683af827":null,"_oembed_time_7ea3429961cf98fa85da9747683af827":null,"_elementor_controls_usage":null,"_elementor_page_assets":[],"_elementor_screenshot_failed":null,"theplus_transient_widgets":null,"_eael_custom_js":null,"_wp_old_date":null,"_trp_automatically_translated_slug_it_it":null,"_trp_automatically_translated_slug_pt_pt":null,"_trp_automatically_translated_slug_zh_cn":null,"_trp_automatically_translated_slug_nl_nl":null,"_trp_automatically_translated_slug_pt_br":null,"_trp_automatically_translated_slug_sv_se":null,"rank_math_analytic_object_id":null,"rank_math_internal_links_processed":"1","_trp_automatically_translated_slug_ro_ro":null,"_trp_automatically_translated_slug_sk_sk":null,"_trp_automatically_translated_slug_bg_bg":null,"_trp_automatically_translated_slug_sl_si":null,"litespeed_vpi_list":null,"litespeed_vpi_list_mobile":null,"rank_math_seo_score":null,"rank_math_contentai_score":null,"ilj_limitincominglinks":null,"ilj_maxincominglinks":null,"ilj_limitoutgoinglinks":null,"ilj_maxoutgoinglinks":null,"ilj_limitlinksperparagraph":null,"ilj_linksperparagraph":null,"ilj_blacklistdefinition":null,"ilj_linkdefinition":null,"_eb_reusable_block_ids":null,"rank_math_focus_keyword":"Linux Capabilities","rank_math_og_content_image":null,"_yoast_wpseo_metadesc":null,"_yoast_wpseo_content_score":null,"_yoast_wpseo_focuskeywords":null,"_yoast_wpseo_keywordsynonyms":null,"_yoast_wpseo_estimated-reading-time-minutes":null,"rank_math_description":null,"surfer_last_post_update":null,"surfer_last_post_update_direction":null,"surfer_keywords":null,"surfer_location":null,"surfer_draft_id":null,"surfer_permalink_hash":null,"surfer_scrape_ready":null,"_thumbnail_id":"20277","footnotes":null,"_links":{"self":[{"href":"https:\/\/webhosting.de\/es\/wp-json\/wp\/v2\/posts\/20284","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/webhosting.de\/es\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/webhosting.de\/es\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/webhosting.de\/es\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/webhosting.de\/es\/wp-json\/wp\/v2\/comments?post=20284"}],"version-history":[{"count":0,"href":"https:\/\/webhosting.de\/es\/wp-json\/wp\/v2\/posts\/20284\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/webhosting.de\/es\/wp-json\/wp\/v2\/media\/20277"}],"wp:attachment":[{"href":"https:\/\/webhosting.de\/es\/wp-json\/wp\/v2\/media?parent=20284"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/webhosting.de\/es\/wp-json\/wp\/v2\/categories?post=20284"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/webhosting.de\/es\/wp-json\/wp\/v2\/tags?post=20284"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}