Open Source Intelligence (OSINT) Reconnaissance Framework & Intelligence Lifecycle (v3.8.0-Enterprise)

Dokumentasi Standar Operasional Pengumpulan Intelijen Sumber Terbuka, Analisis Jejak Digital, dan Automasi Investigasi Multi-Vektor

1. Ikhtisar & Arsitektur Sistem

Open Source Intelligence (OSINT) Framework v3.8.0 dirancang sebagai arsitektur intelijen terintegrasi untuk mengotomatisasi pengumpulan data, profiling target, pemetaan permukaan serangan (attack surface mapping), dan investigasi jejak digital secara etis dan terstruktur. Kerangka kerja ini mengadopsi Siklus Intelijen Formal (Intelligence Cycle) yang terdiri dari lima fase utama guna memastikan transformasi data mentah (raw data) menjadi intelijen yang dapat ditindaklanjuti (actionable intelligence).

Siklus Intelijen OSINT (5 Tahapan Inti)

Perencanaan dan Pengarahan (Planning & Direction): Perumusan tujuan investigasi, penetapan Essential Elements of Information (EEI), pembatasan ruang lingkup target, dan mitigasi risiko operasional (Operational Security / OPSEC).
Pengumpulan (Collection): Akuisisi data mentah dari berbagai domain publik—termasuk social media platforms, repositori kode, arsip metadata berkas, DNS records, mesin pencari terindeks, dan basis data identitas.
Pengolahan (Processing): Normalisasi data, pembersihan format (data parsing/sanitization), metadata stripping, pemecahan enkripsi/hashing satu arah, dan strukturisasi berkas ke format standar (JSON/Graph Nodes).
Analisis dan Produksi (Analysis & Production): Korelasi silang data antar entitas (cross-referencing), pengelompokan pola (pattern clustering), geolokasi spasial visual, dan atribusi digital untuk menghasilkan laporan intelijen komprehensif.
Diseminasi dan Pengintegrasian (Dissemination & Integration): Penyajian visual intelijen grafis via node link analysis, integrasi ke platform SIEM/SOC, dan penyerahan laporan eksekutif kepada pemangku kepentingan.

Diagram Alur Siklus Intelijen & Arsitektur Pipeline (ASCII)

+----------------------------------------------------------------------------------------------------+
|                                    OSINT RECONNAISSANCE PIPELINE                                   |
+----------------------------------------------------------------------------------------------------+

 [ FASE 1: Perencanaan & Pengarahan ]
   |-- Penentuan Target (Username, Email, Domain, Citra Visual, Akun Media Sosial)
   +-- Pengaturan Profil Isolasi OPSEC (VPN / Tor Chaining / Ephemeral Browser)
        |
        v
 [ FASE 2: Pengumpulan Data Multi-Vektor ]
   |
   +---> [ Vector A: Identitas & Username ] ---> (Sherlock, Maigret, WhatsMyName, GoSearch, Tookie)
   +---> [ Vector B: Email & Credential Pivoting ] -> (Holehe, theHarvester, Slash)
   +---> [ Vector C: Citra & Geospasial ] -------> (PimEyes, Search4Faces, Picarta, GeoEstimation)
   +---> [ Vector D: Search Engine & Dorks ] -----> (Google Dorks, Webmii, OSINT Framework)
   +---> [ Vector E: Fediverse & Microblog ] -----> (Masto, TweetDeck)
        |
        v
 [ FASE 3: Pengolahan & Normalisasi ]
   |-- Deduplikasi Entitas & Parsing Respon HTTP Status (200 OK, 404, WAF Challenge)
   |-- Ekstraksi Metadata EXIF / IPTC / XMP dari Objek Citra
   +-- Konversi Format Log Mentah ke Skema Terstruktur (Graph Model / Relational JSON)
        |
        v
 [ FASE 4: Analisis & Produksi ]
   |-- Pemetaan Korelasi Node Relasional (Maltego Transform Engine)
   |-- Verifikasi Kecocokan Wajah Biometrik & Estimasi Titik Koordinat GPS
   +-- Pembuatan Timeline Aktivitas Digital & Penilaian Atribusi Target
        |
        v
 [ FASE 5: Diseminasi & Pengintegrasian ]
   |-- Visualisasi Graph Matrix (.mtz / .gephi)
   +-- Distribusi Laporan Intelijen & Integrasi API ke Threat Intelligence Platform (TIP)

2. Prasyarat Sistem & Dependensi

Spesifikasi Lingkungan Minimal

Operating System: Debian 12 (Bookworm) / Ubuntu 22.04 LTS / Kali Linux Rolling (x86_64).
Kernel: Linux Kernel 5.15+ (LTS).
Runtime Environment: Python 3.10+, Go (Golang) 1.21+, Node.js 18.x LTS, OpenJDK 17/21 (untuk Maltego Desktop).
Jaringan & Routing: Akses internet tanpa filtering DNS; mendukung binding proxy SOCKS5/Tor lokal (127.0.0.1:9050).
Storage: Minimal 20 GB SSD/NVMe (direkomendasikan partisi tmpfs untuk isolasi berkas sensitif).

Matriks Dependensi Alat & Repositori

Nama Alat / Komponen	Kategori & Runtime	Repositori / Sumber Endpoint	Fungsi Operasional Spesifik
Maltego	Visual Graph / Java GUI	`[https://www.maltego.com/](https://www.maltego.com/)`	Analisis link node interaktif, visualisasi relasi entitas, transformasi data OSINT visual.
TweetDeck / X Pro	Social Monitoring / Web	`[https://tweetdeck.twitter.com/](https://tweetdeck.twitter.com/)`	Monitoring real-time aliran data kata kunci, tagar, dan mention akun mikroblogging.
Google Dorks Engine	Search Query Recon / Web	Mesin Pencari Google	Pencarian spesifik direktori terbuka, file konfigurasi, kebocoran basis data via dorking syntax.
OSINT Framework	Metodologi & Indeks	`[https://osintframework.com/](https://osintframework.com/)`	Panduan direktori taksonomi alat intelijen berbasis web.
theHarvester	Reconnaissance / Python	`[https://git.mnytc.eu/laramies/theHarvester](https://git.mnytc.eu/laramies/theHarvester)`	Pemanenan subdomain, email pengelola, port terbuka, dan virtual host secara pasif.
WhatsMyName	Web Recon Platform	`[https://whatsmyname.app/](https://whatsmyname.app/)`	Deteksi eksistensi username di ratusan situs web berbasis repositori JSON signature.
Webmii	People Search / Web	`[https://webmii.com/](https://webmii.com/)`	Agregasi jejak figur publik, skor visibilitas digital, dan keterkaitan profil web.
Masto	Fediverse Recon / Python	`[https://git.mnytc.eu/C3n7ral051nt4g3ncy/Masto](https://git.mnytc.eu/C3n7ral051nt4g3ncy/Masto)`	Ekstraksi intelijen pengguna, status, dan instans pada jaringan terdesentralisasi Mastodon.
Slash	Target Recon / Python	`[https://git.mnytc.eu/theahmadov/slash](https://git.mnytc.eu/theahmadov/slash)`	Pengumpulan informasi cepat terhadap input target spesifik (username/email).
Tookie OSINT	Social Enumeration / Python	`[https://git.mnytc.eu/Alfredredbird/tookie-osint](https://git.mnytc.eu/Alfredredbird/tookie-osint)`	Otomasi pelacakan akun media sosial tingkat lanjut berbasis username.
GoSearch	Fast Footprinting / Go	`[https://git.mnytc.eu/ibnaleem/gosearch](https://git.mnytc.eu/ibnaleem/gosearch)`	Identifikasi username berkecepatan tinggi dengan konkurensi native Golang.
Maigret	Deep Footprinting / Python	`[https://git.mnytc.eu/krishpranav/maigret](https://git.mnytc.eu/krishpranav/maigret)`	Analisis rekursif profil akun berdasarkan username dan ekstraksi metadata ID/nama lengkap.
Sherlock	Social Recon / Python	`[https://git.mnytc.eu/sherlock-project/sherlock](https://git.mnytc.eu/sherlock-project/sherlock)`	Pemindaian masif username pada 400+ platform jejaring sosial secara simultan.
Holehe	Account Pivot / Python	`[https://git.mnytc.eu/megadose/holehe](https://git.mnytc.eu/megadose/holehe)`	Deteksi pendaftaran alamat email pada 120+ layanan tanpa mengirimkan notifikasi.
PimEyes & Search4Faces	Facial Biometric Search	`[https://pimeyes.com/](https://pimeyes.com/)`, `[https://search4faces.com/](https://search4faces.com/)`	Pencarian wajah berbasis model neural network untuk mendeteksi kemunculan citra di web/medsos.
Picarta & GeoEstimation	Visual Geolocation AI	`[https://picarta.ai/](https://picarta.ai/)`, `[https://labs.tib.eu/geoestimation/](https://labs.tib.eu/geoestimation/)`	Prediksi koordinat lokasi geografis suatu gambar menggunakan model AI/Computer Vision.

3. Panduan Unduh & Instalasi Langkah demi Langkah

Jalankan perintah berikut pada terminal konsol Linux untuk memasang seluruh repositori dan paket dependensi inti:

# 1. Update repositori sistem dan instal dependensi compiler/runtime
sudo apt-get update -y && sudo apt-get install -y \
    python3 \
    python3-pip \
    python3-venv \
    golang-go \
    git \
    curl \
    wget \
    jq \
    tor \
    proxychains4 \
    libxml2-dev \
    libxslt1-dev \
    zlib1g-dev

# 2. Buat direktori kerja terpadu
sudo mkdir -p /opt/osint-suite
sudo chown -R $USER:$USER /opt/osint-suite
cd /opt/osint-suite

# 3. Kloning dependensi modul repositori inti dari mirror internal
git clone https://git.mnytc.eu/laramies/theHarvester.git
git clone https://git.mnytc.eu/sherlock-project/sherlock.git
git clone https://git.mnytc.eu/krishpranav/maigret.git
git clone https://git.mnytc.eu/megadose/holehe.git
git clone https://git.mnytc.eu/Alfredredbird/tookie-osint.git
git clone https://git.mnytc.eu/C3n7ral051nt4g3ncy/Masto.git
git clone https://git.mnytc.eu/theahmadov/slash.git
git clone https://git.mnytc.eu/ibnaleem/gosearch.git

# 4. Inisialisasi Virtual Environment Python terisolasi
python3 -m venv /opt/osint-suite/venv
source /opt/osint-suite/venv/bin/activate

# 5. Instalasi dependensi Python untuk tiap modul
cd /opt/osint-suite/theHarvester && pip install --no-cache-dir -r requirements/base.txt
cd /opt/osint-suite/sherlock && pip install --no-cache-dir -r requirements.txt
cd /opt/osint-suite/maigret && pip install --no-cache-dir -r requirements.txt
cd /opt/osint-suite/holehe && pip install --no-cache-dir .
cd /opt/osint-suite/tookie-osint && pip install --no-cache-dir -r requirements.txt
cd /opt/osint-suite/Masto && pip install --no-cache-dir -r requirements.txt
cd /opt/osint-suite/slash && pip install --no-cache-dir -r requirements.txt

# 6. Kompilasi tool GoSearch berbasis Golang
cd /opt/osint-suite/gosearch
go build -o /opt/osint-suite/bin/gosearch main.go

# 7. Verifikasi symlink biner ke path sistem
mkdir -p /opt/osint-suite/bin
export PATH=$PATH:/opt/osint-suite/bin
echo 'export PATH=$PATH:/opt/osint-suite/bin' >> ~/.bashrc

4. Bedah File Konfigurasi / Kode Sumber Penuh

Di bawah ini adalah implementasi engine orkestrator OSINT terintegrasi (osint_orchestrator.py) yang menggabungkan verifikasi username multithreaded, pemeriksaan kebocoran email tanpa notifikasi (Holehe integration logic), pembuatan dork otomatis, dan ekstraksi metadata:

#!/usr/bin/env python3
"""
OSINT Unified Reconnaissance & Investigation Orchestrator
File: /opt/osint-suite/osint_orchestrator.py
"""

import argparse
import asyncio
import json
import logging
import os
import re
import sys
import time
from typing import Dict, List, Any
import aiohttp
from bs4 import BeautifulSoup

# Konfigurasi Logging Engine
logging.basicConfig(
    level=logging.INFO,
    format='[%(asctime)s] [%(levelname)s] [OSINT-CORE] %(message)s',
    handlers=[logging.StreamHandler(sys.stdout)]
)

class TargetProfiler:
    def __init__(self, target_identifier: str, is_email: bool = False):
        self.target = target_identifier
        self.is_email = is_email
        self.results: Dict[str, Any] = {
            "target": target_identifier,
            "timestamp": int(time.time()),
            "footprint": {},
            "email_associations": [],
            "generated_dorks": [],
            "status": "INITIALIZED"
        }

    def generate_dork_matrix(self) -> List[str]:
        """Menghasilkan sekumpulan query Google Dorks target spesifik."""
        t = self.target
        dorks = [
            f'site:pastebin.com "{t}"',
            f'site:github.com "{t}"',
            f'site:linkedin.com/in/ "{t}"',
            f'intitle:"index of" "{t}"',
            f'filetype:pdf OR filetype:docx OR filetype:xlsx "{t}"',
            f'inurl:profile OR inurl:user "{t}"',
            f'"{t}" ext:env OR ext:sql OR ext:log'
        ]
        self.results["generated_dorks"] = dorks
        return dorks

    async def scan_common_social_endpoints(self, session: aiohttp.ClientSession) -> Dict[str, str]:
        """Melakukan probing asinkron terhadap signature platform sosial umum."""
        endpoints = {
            "GitHub": f"https://api.github.com/users/{self.target}",
            "Reddit": f"https://www.reddit.com/user/{self.target}/about.json",
            "Mastodon Social": f"https://mastodon.social/@{self.target}.json",
            "GitLab": f"https://gitlab.com/api/v4/users?username={self.target}"
        }

        headers = {
            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:109.0) Gecko/20100101 Firefox/115.0"
        }

        async def probe(platform: str, url: str):
            try:
                async with session.get(url, headers=headers, timeout=10) as response:
                    if response.status == 200:
                        logging.info(f"[HIT] Ditemukan akun aktif pada {platform}: {url}")
                        return platform, "EXISTS", url
                    elif response.status == 404:
                        return platform, "NOT_FOUND", None
                    else:
                        return platform, f"HTTP_{response.status}", None
            except Exception as ex:
                return platform, f"ERROR_{str(ex)}", None

        tasks = [probe(platform, url) for platform, url in endpoints.items()]
        completed_probes = await asyncio.gather(*tasks)

        for platform, status, resolved_url in completed_probes:
            if status == "EXISTS":
                self.results["footprint"][platform] = {
                    "status": "FOUND",
                    "url": resolved_url
                }
            else:
                self.results["footprint"][platform] = {
                    "status": status
                }

        return self.results["footprint"]

    async def scan_email_pivot_services(self, session: aiohttp.ClientSession):
        """Memeriksa keberadaan email pada layanan web tanpa password trigger."""
        if not self.is_email:
            return

        logging.info(f"Memulai pivoting akun untuk email target: {self.target}")

        # Contoh simulasi probing layanan Twitter / Office365 credential discriminator
        # Pada lingkungan riil, memanggil wrapper API Holehe
        self.results["email_associations"].append({
            "service": "Simulated_Recovery_Query",
            "registered": True,
            "metadata": "Dispatched to Holehe Subprocess Engine"
        })

    def export_report(self, output_dir: str = "/tmp"):
        """Menyimpan hasil intelijen ke format JSON terstruktur."""
        filename = f"{output_dir}/osint_report_{self.target}_{int(time.time())}.json"
        with open(filename, "w", encoding="utf-8") as f:
            json.dump(self.results, f, indent=4)
        logging.info(f"Laporan intelijen lengkap berhasil ditulis ke: {filename}")


async def main():
    parser = argparse.ArgumentParser(description="OSINT Multi-Vector Reconnaissance Orchestrator")
    parser.add_argument("-t", "--target", required=True, help="Target identitas (username, handle, atau email)")
    parser.add_argument("--email", action="store_true", help="Set flag jika target merupakan alamat email")
    parser.add_argument("-o", "--output", default="/tmp", help="Direktori penyimpanan laporan JSON")

    args = parser.parse_args()

    profiler = TargetProfiler(target_identifier=args.target, is_email=args.email)
    profiler.generate_dork_matrix()

    connector = aiohttp.TCPConnector(limit=20, ssl=False)
    async with aiohttp.ClientSession(connector=connector) as session:
        logging.info(f"Menjalankan enumerasi aktif untuk target: {args.target}")
        await profiler.scan_common_social_endpoints(session)
        if args.email:
            await profiler.scan_email_pivot_services(session)

    profiler.results["status"] = "COMPLETED"
    profiler.export_report(args.output)


if __name__ == "__main__":
    asyncio.run(main())

5. Rincian Teknis Modul & Logika Operasional

A. Modul 1: Identitas & Username Footprinting

Mekanisme Kerja: Modul seperti Sherlock, Maigret, WhatsMyName, dan GoSearch bekerja dengan mengirimkan ribuan probe requests ke daftar endpoint profil situs web yang telah ditentukan sebelumnya (signature schema).
Penanganan False Positive: Sistem melakukan komparasi kode status respons HTTP (contoh: 200 OK vs 404 Not Found), validasi error message di dalam teks HTML (seperti "Pengguna tidak ditemukan" atau "User suspended"), dan pengecekan panjang respon (Content-Length).
Optimasi Konkurensi: Menggunakan event loop asynchronous berbasis asyncio/aiohttp (Python) atau goroutine (GoSearch) guna mengeksekusi ratusan validasi domain per detik tanpa memory leak.

B. Modul 2: Email Reconnaissance & Password Recovery Pivot

Mekanisme Kerja (Holehe & Slash): Modul memeriksa apakah email tertentu terdaftar pada layanan daring seperti Twitter, Instagram, GitHub, Discord, dsb.
Logika Tanpa Notifikasi (Zero-Alert Mechanism): Modul memanfaatkan perilaku API pada formulir Forgot Password atau Registration Endpoint. API merespons secara berbeda ketika email sudah terdaftar (contoh: "error": "email_already_exists") tanpa menyelesaikan proses pengiriman token pemulihan sandi, sehingga target tidak menerima notifikasi peringatan.

C. Modul 3: Visual & Geospatial Intelligence (Image OSINT)

Facial Recognition (PimEyes & Search4Faces): Citra wajah target diekstraksi ke dalam vektor matematis biometric embeddings menggunakan arsitektur deep learning Convolutional Neural Networks (CNN). Vektor ini dicocokkan dengan miliaran citra terindeks di web untuk melacak identitas lintas platform.
Visual Geolocation (Picarta & GeoEstimation): Gambar lingkungan/objek dianalisis untuk mendeteksi elemen arsitektur, vegetasi, flora/fauna, formasi geografis, dan pola infrastruktur. Sistem membandingkannya dengan model prediksi global untuk mengestimasi lintang dan bujur (GPS Coordinates) asal foto.
Metadata Inspection: Melakukan ekstraksi otomatis data tersembunyi (EXIF) termasuk kamera pemotret, aperture, tanggal/waktu asli, dan penanda lokasi GPS jika tidak dibersihkan oleh platform media sosial.

D. Modul 4: Advanced Search Engine Dorking & Defensive Countermeasures

Google Dorking Syntax: Operasi pencarian terstruktur menggunakan query lanjutan:
filetype:env DB_PASSWORD : Mendeteksi variabel konfigurasi sensitif.
site:target.com inurl:admin : Menemukan panel administrasi login tersembunyi.
intitle:"index of /" backup : Mengidentifikasi direktori direktori terbuka berisi arsip backup.
Defending Against Google Dorks (Mitigasi Defensif):
Konfigurasi robots.txt: Mencegah crawling pada direktori sensitif (Disallow: /admin/, Disallow: /private/).
Header HTTP X-Robots-Tag: Menerapkan instruksi noindex, nofollow pada berkas non-HTML (PDF, log, backup).
Web Application Firewall (WAF): Memblokir pola request crawler otomatis yang tidak wajar dan membatasi akses direktori internal menggunakan Authentication Barrier serta proteksi .htaccess / Nginx block rules.

E. Modul 5: Anti-Detection, Rate-Limit Mitigation & Proxy Chaining

Rotasi IP Dinamis: Integrasi modul jaringan dengan Tor daemon (127.0.0.1:9050) atau penyedia rotating residential proxy melalui ProxyChains.
User-Agent & Fingerprint Spoofing: Setiap request acak memanipulasi header User-Agent, Accept-Language, Sec-Ch-Ua, dan memvariasikan jeda waktu acak (jitter 2–7 detik) untuk menghindari deteksi pola bot oleh modul mitigasi Cloudflare atau Akamai.

6. Panduan Penggunaan & Eksekusi Lapangan

A. Eksekusi CLI Modul Individual

1. Enumerasi Username dengan Sherlock

# Memindai username target pada seluruh platform sosial dengan proxy Tor
python3 /opt/osint-suite/sherlock/sherlock/sherlock.py target_username --tor --timeout 15 --csv

2. Deep Profile Harvesting dengan Maigret

# Menjalankan pelacakan rekursif dan menghasilkan laporan grafis HTML
python3 /opt/osint-suite/maigret/maigret.py target_username -a -T --html --pdf

3. Email Pivot Check menggunakan Holehe

# Memeriksa asosiasi email tanpa memicu notifikasi pemulihan sandi
holehe target_user@example.com --only-used --csv /tmp/holehe_report.csv

4. Pemanenan Subdomain & Email via theHarvester

# Mencari intelijen pasif domain melalui Baidu, Bing, DuckDuckGo, Yahoo
python3 /opt/osint-suite/theHarvester/theHarvester.py -d targetdomain.com -b baidu,bing,duckduckgo,yahoo -l 500 -f /tmp/theharvester_result.xml

5. Fediverse & Mastodon Intelligence via Masto

# Mengumpulkan informasi detail profil pengguna Mastodon
python3 /opt/osint-suite/Masto/masto.py -u target_username -i mastodon.social

6. Eksekusi Cepat Golang GoSearch

# Menjalankan profiling username cepat berbasis binary Go
/opt/osint-suite/bin/gosearch -u target_username -o /tmp/gosearch_output.txt

B. Eksekusi Orchestrator Otomatis (Background / Daemon)

Jalankan script orchestrator menggunakan background daemon utility (nohup atau tmux) agar investigasi jangka panjang tidak terputus saat sesi terminal ditutup:

# Menjalankan via nohup dengan direct file logging
nohup /opt/osint-suite/venv/bin/python3 /opt/osint-suite/osint_orchestrator.py \
    -t "target_investigasi" \
    -o /var/log/osint_results \
    > /var/log/osint_run.log 2>&1 &

# Memantau progres secara real-time
tail -f /var/log/osint_run.log

7. Matriks Diagnostik Masalah (Troubleshooting)

Indikasi Masalah / Error Log	Akar Penyebab Teknis	Solusi & Perintah Perbaikan
`HTTP 429 Too Many Requests`	Engine melampaui ambang batas request (rate limit) yang diterapkan oleh penyedia platform.	Tambahkan interval jitter delay pada script atau alihkan koneksi melalui Tor proxy:

tor & proxychains4 python3 /opt/osint-suite/osint_orchestrator.py -t target | | Cloudflare 403 Forbidden / CAPTCHA Challenge | IP asal teridentifikasi sebagai datacenter bot atau memiliki skor reputasi buruk. | Gunakan library undetected-chromedriver atau integrasikan API FlareSolverr untuk bypass anti-bot:

pip install undetected-chromedriver | | Tor Connection Refused (127.0.0.1:9050) | Daemon Tor lokal dalam keadaan mati atau file konfigurasi /etc/tor/torrc memblokir port SOCKS5. | Restart layanan Tor dan verifikasi status port:

sudo systemctl restart tor

sudo netstat -tlpn | |ModuleNotFoundError: No module named '...'` | Dependensi Python belum terpasang ke dalam environment global atau venv belum aktif. | Pastikan virtual environment telah diaktifkan sebelum eksekusi modul:

source /opt/osint-suite/venv/bin/activate

pip install -r requirements.txt | | Holehe / Sherlock Timeout Error on Endpoints | Resolver DNS lokal gagal menerjemahkan domain luar negeri atau koneksi diblokir oleh filtering ISP. | Ubah DNS resolver sistem ke upstream publik tepercaya (Cloudflare/Google):

echo "nameserver 1.1.1.1" | |Corrupted/Empty Image Metadata during EXIF Analysis` | Platform media sosial (misal: Twitter/Facebook/Instagram) telah menghapus EXIF tag secara otomatis saat kompresi upload. | Alihkan vektor analisis citra ke pencarian biometrik atau analisis geospasial lingkungan menggunakan PimEyes, Search4Faces, atau Picarta AI. |