Para ver todos los charts de Helm disponibles en el repositorio ejecuta (puedes añadir la opción `--devel` para mostrar también las versiones de lanzamiento no estables)```sh
helm search repo stackrox

Desde aquí, puedes instalar stackrox-central-services para desplegar los componentes Central y Scanner en tu clúster.

> **Nota:**
> Solo necesitas una instancia desplegada de stackrox-central-services incluso si planeas asegurar múltiples clústeres.

Para realizar la instalación, elige uno de los siguientes comandos según el tamaño de tu clúster.

#### Instalación predeterminada de Central

Si estás instalando en un clúster de tamaño razonable, usa el comando de instalación predeterminado:```sh
helm upgrade --install -n stackrox --create-namespace stackrox-central-services \
  stackrox/stackrox-central-services \
  --set central.adminPassword.value="${ROX_ADMIN_PASSWORD}" \
  --set central.persistence.none="true"

</details>

<details><summary>Instalar Servicios de Clúster Seguro de StackRox</summary>

A continuación, será necesario implementar el componente de clúster seguro para recopilar información de los nodos de Kubernetes.

Establezca un nombre de clúster significativo para su clúster seguro en la variable de shell `CLUSTER_NAME`. El clúster será identificado por este nombre en la lista de clústeres de la interfaz de usuario de StackRox.```sh
CLUSTER_NAME="my-secured-cluster"

Genere un paquete de inicialización que contenga secretos de inicialización. El paquete de inicialización se guardará en `stackrox-init-bundle.yaml`, y lo usará para aprovisionar clústeres asegurados como se muestra a continuación.```sh
echo "$ROX_ADMIN_PASSWORD" | \
kubectl -n stackrox exec -i deploy/central -- bash -c 'ROX_ADMIN_PASSWORD=$(cat) roxctl --insecure-skip-tls-verify \
  central init-bundles generate stackrox-init-bundle --output -' > stackrox-init-bundle.yaml

#### Instalación de Servicios de Clúster Seguros en Clústeres con Recursos Limitados

Si estás instalando en un clúster de un solo nodo, o la instalación predeterminada resulta en pods en estado pendiente debido a falta de recursos, usa el siguiente comando en su lugar para reducir los requisitos de recursos de stackrox-secured-cluster-services. Ten en cuenta que estos ajustes de recursos reducidos no son adecuados para una configuración de producción.```sh
helm upgrade --install -n stackrox --create-namespace stackrox-secured-cluster-services \
  stackrox/stackrox-secured-cluster-services \
  -f stackrox-init-bundle.yaml \
  --set clusterName="$CLUSTER_NAME" \
  --set centralEndpoint="$CENTRAL_ENDPOINT" \
  --set sensor.resources.requests.memory=500Mi \
  --set sensor.resources.requests.cpu=500m \
  --set sensor.resources.limits.memory=500Mi \
  --set sensor.resources.limits.cpu=500m

Después de unos minutos, todos los recursos deberían estar desplegados.

**Las credenciales del usuario 'admin' se pueden encontrar en el archivo `./deploy/k8s/central-deploy/password`.**

> **Nota:**
> El archivo de contraseña se almacena en texto plano en tu sistema de archivos local, pero el Secreto de Kubernetes que StackRox crea a partir de él está cifrado. No podrás alterar la contraseña en tiempo de ejecución. Si pierdes la contraseña, tendrás que reimplementar central.

</details>

#### OpenShift

<details><summary>Haz clic para expandir</summary>

Antes de desplegar en OpenShift, asegúrate de tener instalado [oc - OpenShift Command Line](https://github.com/openshift/oc).

Sigue la guía a continuación para desplegar rápidamente una versión específica de StackRox en tu clúster de OpenShift en el espacio de nombres `stackrox`. Asegúrate de agregar la etiqueta más reciente a la variable `MAIN_IMAGE_TAG`.

Ejecuta lo siguiente en tu directorio de trabajo de preferencia:```
git clone [email protected]:stackrox/stackrox.git
cd stackrox
MAIN_IMAGE_TAG=VERSION_TO_USE ./deploy/deploy.sh

Después de unos minutos, todos los recursos deberían estar desplegados.

**Las credenciales para el usuario 'admin' se pueden encontrar en el archivo `./deploy/k8s/deploy-local/password`.**

</details>

## Acceso a la Interfaz de Usuario (UI) de StackRox

<details><summary>Haga clic para expandir</summary>

Una vez completado el despliegue (instalación con operator, Helm o script), debería existir un port-forward, para que pueda conectarse a https://localhost:8000/. Ejecute lo siguiente```sh
kubectl port-forward -n 'stackrox' svc/central "8000:443"

Para más información, consulte <https://github.com/nodejs/node-gyp/issues/569>

</details>

#### Clonar StackRox
<details><summary>Haga clic para expandir</summary>```bash
# Create a GOPATH: this is the location of your Go "workspace".
# (Note that it is not – and must not – be the same as the path Go is installed to.)
# The default is to have it in ~/go/, or ~/development, but anything you prefer goes.
# Whatever you decide, create the directory, set GOPATH, and update PATH:
export GOPATH=$HOME/go # Change this if you choose to use a different workspace.
export PATH=$PATH:$GOPATH/bin
# You probably want to permanently set these by adding the following commands to your shell
# configuration (e.g. ~/.bash_profile)

cd $GOPATH
mkdir -p bin pkg
mkdir -p src/github.com/stackrox
cd src/github.com/stackrox
git clone [email protected]:stackrox/stackrox.git

Ahora, necesitas levantar un clúster de Kubernetes *por ti mismo* antes de continuar.
El desarrollo puede realizarse en GCP o localmente con
[Docker Desktop](https://docs.docker.com/desktop/kubernetes/), [Colima](https://github.com/abiosoft/colima#kubernetes), [minikube](https://minikube.sigs.k8s.io/docs/start/).

> **Nota:**
> Docker Desktop y Colima son más adecuados para el desarrollo en macOS, porque el clúster tendrá acceso a imágenes construidas con `make image` localmente sin configuración adicional. Además, Collector tiene mejor soporte para estos que minikube, donde los controladores pueden no estar disponibles.```bash
# To keep the StackRox Central's Postgres DB state between database upgrades and restarts, set:
$ export STORAGE=pvc

# To save time on rebuilds by skipping UI builds, set:
$ export SKIP_UI_BUILD=1

# To save time on rebuilds by skipping CLI builds, set:
$ export SKIP_CLI_BUILD=1

# When you deploy locally make sure your kube context points to the desired kubernetes cluster,
# for example Docker Desktop.
# To check the current context you can call a workflow script:
$ roxkubectx

# To deploy locally, call:
$ ./deploy/deploy-local.sh

# Now you can access StackRox dashboard at https://localhost:8000
# or simply call another workflow script:
$ logmein

</details>

#### Productividad

<details><summary>Haz clic para expandir</summary>

El [repositorio de flujo de trabajo](https://github.com/stackrox/workflow) contiene algunos scripts auxiliares
que respaldan nuestro flujo de trabajo de desarrollo. Explora más comandos con `roxhelp --list-all`.```bash
# Change directory to rox root
$ cdrox

# Handy curl shortcut for your StackRox central instance
# Uses https://localhost:8000 by default or ROX_BASE_URL env variable
# Also uses the admin credentials from your last deployment via deploy.sh
$ roxcurl /v1/metadata

# Run quickstyle checks, faster than stackrox's "make style"
$ quickstyle

# The workflow repository includes some tools for supporting
# working with multiple inter-dependent branches.
# Examples:
$ smart-branch <branch-name>    # create new branch
    ... work on branch...
$ smart-rebase                  # rebase from parent branch
    ... continue working on branch...
$ smart-diff                    # check diff relative to parent branch
    ... git push, etc.

$ docker run --rm --env POSTGRES_USER="$USER" --env POSTGRES_HOST_AUTH_METHOD=trust --publish 5432:5432 docker.io/library/postgres:15
```
With that running in the background, `sql_integration` tests can be triggered from IDE or command-line.

</details>

#### Depuración

<details><summary>Haz clic para expandir</summary>

**Configuración del depurador de Kubernetes**

Con GoLand, puedes usar naturalmente puntos de interrupción y el depurador al ejecutar pruebas unitarias en el IDE.

Si deseas depurar una implementación local o incluso remota, sigue el procedimiento a continuación.

1. Crea una compilación de depuración local exportando `DEBUG_BUILD=yes`:   ```bash
   $ DEBUG_BUILD=yes make image
   ```
Alternativamente, también se creará una compilación de depuración cuando el nombre de la rama contenga la subcadena `-debug`. Esto funciona localmente con `make image` y en CI.
2. Despliegue la imagen usando las instrucciones de este archivo README. Funciona tanto con `deploy-local.sh` como con `deploy.sh`.
3. Inicie el depurador (y el reenvío de puertos) en el pod objetivo usando el comando `roxdebug` del repositorio `workflow`.   ```bash
   # For Central
   $ roxdebug
   # For Sensor
   $ roxdebug deploy/sensor
   # See usage help
   $ roxdebug --help
   ```
4. Configure GoLand para la depuración remota (debe hacerse solo una vez):
    1. Abra `Run | Edit Configurations …`, haga clic en el icono `+` para agregar una nueva configuración, elija la plantilla `Go Remote`.
    2. Elija `Host:` `localhost` y `Port:` `40000`. Asigne a esta configuración un nombre.
    3. Seleccione `On disconnect:` `Leave it running` (esto evita que GoLand olvide los puntos de interrupción al reconectarse).
5. Adjunte GoLand al puerto de depuración: seleccione `Run | Debug…` y elija la configuración que ha creado.
   Si todo se ha hecho correctamente, debería ver el mensaje `Connected` en la ventana `Debug | Debugger | Variables` en la parte inferior
   de la pantalla.
6. Establezca algunos puntos de interrupción en el código, active las acciones correspondientes y ¡feliz depuración!

Consulte [Depuración de código Go ejecutándose en Kubernetes](https://github.com/stackrox/dev-docs/blob/main/docs/knowledge-base/%5BBE%5D%20Debugging-go-code-running-in-Kubernetes.md) para
más información.
</details>

## Generando Instaladores Portátiles

<details><summary>Kubernetes</summary>```bash
docker run -i --rm quay.io/stackrox-io/main:<tag> central generate interactive > k8s.zip
```
Esto te guiará a través de un instalador y generará un `k8s.zip`.```bash
unzip k8s.zip -d k8s
```
[![Anchore Enterprise](https://raw.githubusercontent.com/stackrox/stackrox/HEAD/.gitbook/assets/AnchoreEnterprise-384x90-2024.png)](https://anchore.com/enterprise/?utm_source=kitploit&utm_medium=referral&utm_campaign=anchore-enterprise-ad)

**Anchore Enterprise**

La plataforma de seguridad de contenedores y cadena de suministro de software de nivel empresarial. Vaya más allá del escaneo de vulnerabilidades conocidas y automatice sus barreras de seguridad y cumplimiento en la construcción e implementación.  
[Más información y programar una demostración](https://anchore.com/enterprise/?utm_source=kitploit&utm_medium=referral&utm_campaign=anchore-enterprise-ad)```bash
bash k8s/central.sh
```
Ahora Central ha sido desplegado. Use la interfaz de usuario para desplegar Sensor.

</details>

<details><summary>OpenShift</summary>

> **Nota:**
> Si se usa un montaje de host, debe permitir que el contenedor acceda a él usando
> `sudo chcon -Rt svirt_sandbox_file_t <full volume path>`

Tome el script image-setup.sh de este repositorio y ejecútelo para realizar el pull/push al registro local de OpenShift. Este es un requisito previo para cada nuevo clúster.```bash
bash image-setup.sh
```
**A10 Network, Acalvio ShadowPlex, Acquia Cloud Platform, ADTRAN, Advantech, Airbus, Akamai, Apple, ArmorText, ArmorCode, Armorblox, Armis, Artic Wolf, Aujas, AutoRABIT, Aviatrix, Avanan, Axis Security, Barracuda Networks, Beyond Identity, BigID, Bitdefender, Black Kite, Blancco, BlueCat, Bluefin Payment Systems, BMC, Box, Britive, Broadridge, Bromium, Bugcrowd, C2SEC, Capsule8, Carbon Black, Cavelo, Cequence Security, Chainalysis, Check Point, CipherCloud, Cisco Meraki, Cisco Systems, Citrix, Claroty, ClearDATA, CloudBees, CloudPassage, Cloudflare, Cloudian, CloudKnox, CloudLock, CloudVector, Cobalt, Code42, Codefresh, Cohesity, Comforte AG, Contrast Security, CrowdStrike, CyberArk, CyberMDX, CyberSaint, CyCognito, Cymulate, Cyren, Cyxtera, Darktrace, Deepwatch, Devo, Digital Guardian, DigitalOcean, DivvyCloud, Dtex, Egnyte, Elastic, Endgame, Entrust, Ermetic, ESET, Evident.io, Exabeam, Expel, F5, FileCloud, FireEye, Forcepoint, ForgeRock, Forter, Fortinet, Fugue, Gigamon, GitGuardian, GitHub, GitLab, Google Cloud Platform, Graylog, Guidewire, HashiCorp, Heroku, HID Global, Horangi, HyTrust, iboss, ID Agent, Illumio, Imperva, Incapsula, InCountry, Infoblox, Intacct, Integris, IntSights, IS Decisions, Ivanti, JAMF, JASK, JumpCloud, Juniper Networks, Kenna Security, Kryptowire, Kudelski Security, Lacework, Lastline, LaunchDarkly, LineageOS, LookingGlass Cyber Solutions, LogRhythm, LogicGate, Lookout, MariaDB, McAfee, Menlo Security, Mimecast, MobileIron, MongoDB, Mozilla, MuleSoft, myDevices, nCipher, NetDocuments, NetFoundry, Netskope, Neustar, Nexthink, NFR Security, nGenx, NICE, NortonLifeLock, Nozomi Networks, NTT Security, Nutanix, Obrela, Okta, OneTrust, Onfido, Optiv, Oracle, Palantir, Palo Alto Networks, PerimeterX, Ping Identity, Pixm, Pivot Point Security, Plurilock, Portnox, Preempt, Proofpoint, ProtectWise, Protegrity, Prove, Pure Storage, Qualys, Radware, Rapid7, Recorded Future, Red Canary, RedLock, RedSeal, ReliaQuest, Resolver, Reveal(x), RSA Security, Rubrik, SAI Global, SailPoint, Samsara, SAP, SAS, Sauce Labs, Saviynt, SecureAuth, SecureWorks, SecurityScorecard, SentinelOne, ServiceNow, ShiftLeft, ShieldX, Skybox Security, Skyhigh Networks, Snowflake, Socure, SolarWinds, Sonatype, Sophos, Splunk, StackRox, Sumo Logic, Swimlane, Symantec, Synack, Sysdig, TaaSera, Tanium, Telefonica, Tenable, Tessian, ThreatConnect, ThreatMetrix, Thycotic, TIBCO, TitanFile, Trend Micro, Tripwire, TruSTAR, TrustArc, Turbonomic, Twilio, Twistlock, uniken, Vanta, Varonis, Vectra, Vera, Veracode, Verodin, Verizon, Versa Networks, Vormetric, Wiz, Whatfix, WhiteSource, WinMagic, Wipro, Wolters Kluwer, Workato, Workspace ONE, Xage, xMatters, Yubico, Zafesoft, ZeroFox, Zscaler, Zylo**```bash
docker run -i --rm quay.io/stackrox-io/main:<tag> central generate interactive > openshift.zip
```
Esto te guiará a través de un instalador y generará un archivo `openshift.zip`.```bash
unzip openshift.zip -d openshift
```
[![](https://img.shields.io/badge/Type-Hacking_Tools-green)]()

Como nmap para mapear redes wifi a las que no estás conectado. Mapea y rastrea redes y dispositivos wifi mediante monitorización de tramas 802.11 en bruto.

Características
--------------
* mapea redes wifi cercanas y dispositivos escuchando el tráfico 802.11 en bruto (como nmap para wifi, pero pasivo)
* rastrea la intensidad de la señal del dispositivo a lo largo del tiempo, que puede utilizarse para aproximar la distancia, el movimiento y la dirección
* obtiene una lista de puntos de acceso y estaciones (mediante la opción --list)
* monitoriza el tráfico de una estación o SSID específicos con captura de paquetes
* descubre puertas de enlace y dispositivos en otras subredes
* descubre pasivamente dispositivos que no están en la red wifi (haciendo ARP a direcciones IP de puertas de enlace comunes)

Instalación
--------------
Trackerjacker solo es compatible con Linux.

**NOTA**: trackerjacker *no* es una biblioteca. No lo instales como dependencia de biblioteca para tu proyecto. Puedes usarlo como una herramienta que tu código invoca o puedes usar la opción `--map-file` para generar datos JSON.

Necesitarás instalar algunas bibliotecas del sistema:
* libpcap-dev
* python3.6+
* python3-dev
* libiw-dev
* pip3

### Instalar trackerjacker

```bash
# Install latest stable version from PyPi
pip3 install trackerjacker

# OR install from source
git clone [email protected]:alechulce/trackerjacker.git
cd trackerjacker
pip3 install -r requirements.txt
pip3 install wheel
python3 setup.py install
```

### Configurar trackerjacker

Trackerjacker necesita ejecutarse como root (ya que necesita capturar tramas 802.11 en bruto).
Puedes ejecutarlo como root o configurar el archivo de captura para permitir usuarios no root.
Para ello, instala la biblioteca de capacidades setcap y configura cap_net_raw,cap_net_admin+eip en el binario de Python o en el binario de un solo archivo generado con PyInstaller.

Pasos para instalar setcap
[consulta aquí para más detalles](https://github.com/alechulce/trackerjacker#install-setcap)

1. Instalar libcap
```bash
# Debian-based distros
sudo apt-get install libcap2-bin
```
2. Encontrar el binario de Python
```bash
readlink -f $(which python3) | xargs -i sudo setcap cap_net_raw,cap_net_admin=eip {}
``````bash
bash openshift/central.sh
```
</details>


## Dependencias y Recomendaciones para Ejecutar StackRox

<details><summary>Haga clic para expandir</summary>

La siguiente información se ha recopilado para ayudar con la instalación y operación del proyecto open source StackRox. Estas recomendaciones fueron desarrolladas para el producto [Red Hat Advanced Cluster Security for Kubernetes](https://www.redhat.com/en/resources/advanced-cluster-security-for-kubernetes-datasheet) y no han sido probadas con el proyecto upstream StackRox.

**Distribuciones de Kubernetes Recomendadas**

Las plataformas de Kubernetes en las que StackRox se ha implementado con problemas mínimos se enumeran a continuación.

- Red Hat OpenShift Dedicated (OSD)
- Azure Red Hat OpenShift (ARO)
- Red Hat OpenShift Service on AWS (ROSA)
- Amazon Elastic Kubernetes Service (EKS)
- Google Kubernetes Engine (GKE)
- Microsoft Azure Kubernetes Service (AKS)

Si implementa en una distribución de Kubernetes diferente a las enumeradas anteriormente, puede encontrar problemas.

**Sistemas Operativos Recomendados**

Se sabe que StackRox funciona en las versiones recientes de los siguientes sistemas operativos.

- Ubuntu
- Debian
- Red Hat Enterprise Linux (RHEL)
- CentOS
- Fedora CoreOS
- Flatcar Container Linux
- Google COS
- Amazon Linux
- Garden Linux

**Navegadores Web Recomendados**

La siguiente tabla enumera los navegadores que pueden ver la interfaz de usuario web de StackRox.

- Google Chrome 88.0 (64-bit)
- Microsoft Internet Explorer Edge
    - Versión 44 y posteriores (Windows)
    - Versión 81 (compilación oficial) (64 bits)
- Safari en MacOS (Mojave) - Versión 14.0
- Mozilla Firefox Versión 82.0.2 (64 bits)

</details>

---