Parent : [[INDEX-CYBERSECU]]

CardsShield - Infrastructure de paiement proxy, rotation de domaines, anti-investigation

Problème

Le cœur du système de paiement de YGG est CardsShield, un plugin WooCommerce vendu par Nguyen Huu Tien ($800/mois, Telegram @tiennh). Il automatise la rotation entre des dizaines de domaines proxy déguisés en boutiques e-commerce. Le flux : clic "Faire un don" → token jetable (15 min, usage unique) → redirection vers un domaine aléatoire (calcilux.shop, pocarilux.shop, techcomtee.shop...) → PayPal ou Stripe voit un achat dans une boutique de t-shirts, pas un paiement à YGG.

Contexte archive Ygg

Source : https://yggleak.top/fr/home/ygg-dossier
Plugin : CardsShield WooCommerce
Prix : $800/mois
Vendeur : Nguyen Huu Tien, Telegram @tiennh
Domaines proxy : 36+ identifiés (70+ en comptant les réserves)
Domaines exemples : calcilux.shop, pocarilux.shop, techcomtee.shop
Processeurs : CardsShield PayPal, CardsShield Stripe, PayGate.to (22 sous-passerelles), OxaPay, NowPayments, Malum, Sellix, Snappy Payment, ObliqPay
Passerelle CB : enigmastocks.com (enregistré à Charlestown, Saint-Kitts-et-Nevis)
Statut WooCommerce : wc-cs-hidden pour masquer les commandes

Technique de l'attaquant

1. Rotation automatique de domaines

Clic "Faire un don" → token jetable (15 min, usage unique)
→ redirection vers un domaine aléatoire (calcilux.shop, pocarilux.shop, techcomtee.shop...)
→ PayPal ou Stripe voit un achat dans une boutique de t-shirts

2. Mecanisme de force rotate

En cas de blocage PayPal, un mécanisme de force rotate bascule instantanément
vers un autre domaine proxy

3. Masquage des commandes WooCommerce

// CardsShield enregistre un statut WooCommerce wc-cs-hidden
// pour masquer les commandes du tableau de bord standard

4. Table payment_blacklist (1 437 entrées)

- 894 entrées bloquent les fuseaux horaires non-européens → paiement crypto uniquement (avec KYC)
- 11 entrées détectent l'extension Chrome link-redirect-trace (outil pour tracer les redirections de paiement)
  et blacklistent ses utilisateurs
- 10 entrées bloquent les comptes admin/mod pour éviter des traces financières internes

5. Multi-processeurs

8 processeurs de paiement coexistent :
1. CardsShield PayPal
2. CardsShield Stripe
3. PayGate.to (22 sous-passerelles, "all high risk business models accepted, merchants stay anonymous")
4. OxaPay
5. NowPayments
6. Malum
7. Sellix
8. Snappy Payment
9. ObliqPay

6. Blanchiment

Les paiements transitent par des faux sites e-commerce (shields)
→ convertis en crypto via PayGate.to
→ mélangés via Tornado Cash
→ retirés vers des wallets anonymes

Solution protectif — Détection d'infrastructure de paiement proxy

1. Détecter la rotation de domaines

# detect_payment_rotation.py
import requests
import re
from collections import defaultdict

class PaymentRotationDetector:
    def __init__(self):
        self.domains = defaultdict(int)
        self.patterns = [
            r'https?://[a-z0-9-]+\.shop/pay/',
            r'https?://[a-z0-9-]+\.store/checkout/',
            r'https?://[a-z0-9-]+\.site/donate/',
        ]
    
    def track_redirects(self, start_url):
        """Suivre les redirections d'un lien de paiement"""
        try:
            response = requests.get(start_url, allow_redirects=True, timeout=30)
            history = response.history + [response]
            
            domains = [r.url.split('/')[2] for r in history]
            
            for domain in domains:
                self.domains[domain] += 1
            
            return domains
        except Exception as e:
            print(f"Error tracking {start_url}: {e}")
            return []
    
    def detect_rotation(self, threshold=5):
        """Détecter si plus de N domaines différents sont utilisés"""
        unique_domains = len(self.domains)
        
        if unique_domains > threshold:
            return {
                'alert': 'PAYMENT_DOMAIN_ROTATION',
                'unique_domains': unique_domains,
                'domains': dict(self.domains),
                'suspicious': True
            }
        
        return {'suspicious': False}
    
    def detect_proxy_shop(self, html_content):
        """Détecter si le site est une boutique proxy (façade)"""
        suspicious_indicators = [
            # Descriptions génériques
            r'premium quality',
            r'best seller',
            r'free shipping',
            # Pas de contact réel
            r'contact@\w+\.\w+',  # Email générique
            # Pas d'adresse physique
            r'no physical store',
            # Templates WooCommerce standard
            r'woocommerce',
            r'wp-content/themes/storefront',
        ]
        
        score = 0
        for pattern in suspicious_indicators:
            if re.search(pattern, html_content, re.I):
                score += 10
        
        return score >= 30

2. Détecter les statuts WooCommerce cachés

// detect-hidden-orders.php — Détecter les commandes cachées dans WooCommerce
function detect_hidden_orders() {
    global $wpdb;
    
    // Rechercher les statuts custom suspects
    $suspicious_statuses = $wpdb->get_results(
        "SELECT DISTINCT post_status FROM {$wpdb->posts} 
         WHERE post_type = 'shop_order' 
         AND post_status LIKE 'wc-%'
         AND post_status NOT IN (
             'wc-pending', 'wc-processing', 'wc-on-hold', 
             'wc-completed', 'wc-cancelled', 'wc-refunded', 'wc-failed'
         )"
    );
    
    foreach ($suspicious_statuses as $status) {
        $count = $wpdb->get_var($wpdb->prepare(
            "SELECT COUNT(*) FROM {$wpdb->posts} WHERE post_status = %s",
            $status->post_status
        ));
        
        if ($count > 0) {
            error_log("[SUSPICIOUS] Statut WooCommerce custom détecté: {$status->post_status} ($count commandes)");
        }
    }
    
    // Rechercher les méta-données suspectes
    $suspicious_meta = $wpdb->get_results(
        "SELECT post_id, meta_key, meta_value FROM {$wpdb->postmeta}
         WHERE meta_key LIKE '%card%' 
            OR meta_key LIKE '%shield%'
            OR meta_key LIKE '%proxy%'
            OR meta_key LIKE '%hidden%'"
    );
    
    return $suspicious_meta;
}

3. Détecter le tracing de paiement (link-redirect-trace)

// link-redirect-trace.js — Extension Chrome pour tracer les redirections de paiement
// (Cette extension est blacklistée par YGG)

// Version simplifiée pour la détection
async function trace_payment_redirects(donate_url) {
  const response = await fetch(donate_url, {
    redirect: 'follow',
    credentials: 'omit'
  });
  
  // Récupérer l'historique des redirections
  // (nécessite une extension avec l'API webRequest)
  
  return {
    start_url: donate_url,
    final_url: response.url,
    redirect_count: response.redirected ? 1 : 0,
    domains: [] // À remplir via l'extension
  };
}

4. Pour les plateformes de paiement (PayPal, Stripe)

# detect_proxy_payments.py — Détecter les paiements proxy
import hashlib

class ProxyPaymentDetector:
    def __init__(self):
        self.known_proxy_patterns = [
            't-shirt', 'merch', 'donation', 'support',
            'premium', 'subscription', 'membership'
        ]
    
    def analyze_paypal_transaction(self, transaction):
        """Analyser une transaction PayPal pour détecter un proxy"""
        suspicious = False
        reasons = []
        
        # 1. Montants ronds fréquents
        amounts = [14.99, 25.99, 49.99, 85.99]
        if transaction['amount'] in amounts:
            reasons.append(f"Montant standard proxy: {transaction['amount']}")
        
        # 2. Noms de boutiques génériques
        if any(pattern in transaction['merchant_name'].lower() for pattern in self.known_proxy_patterns):
            reasons.append(f"Nom de boutique générique: {transaction['merchant_name']}")
        
        # 3. Domaines .shop, .store récents
        domain = transaction['merchant_domain']
        if domain.endswith(('.shop', '.store', '.site')):
            reasons.append(f"Domaine TLD suspect: {domain}")
        
        # 4. Pas de site web fonctionnel
        # (vérifier si le site existe et vend réellement des produits)
        
        return {
            'suspicious': len(reasons) > 0,
            'reasons': reasons,
            'risk_score': len(reasons) * 25
        }

Checklist de validation

Pas de rotation de domaines pour les paiements (1 domaine = 1 marque)
Pas de statuts WooCommerce custom cachant des commandes
Pas de multiples processeurs de paiement proxy simultanés
Pas de plugin de paiement à $800/mois avec rotation automatique
Pas de masquage de la nature réelle du paiement (donation → achat t-shirt)
Pas de table payment_blacklist bloquant les fuseaux horaires
Pas de détection d'extensions de tracing de paiement
Pas de redirections vers des domaines .shop/.store génériques
Pas de formulaire caché auto-soumis avec données bancaires
Checkout hébergé par le processeur (pas de proxy)
Transparence sur l'identité du vendeur
Pas de KYC forcé uniquement pour certains fuseaux horaires

Références

Archive Ygg : Infrastructure de paiement (YGGLeak)
CardsShield : https://cardsshield.com
PCI-DSS : https://www.pcisecuritystandards.org