Greasy Fork

Greasy Fork is available in English.

[Premium] Captcha Solver

90% succes rate on Firefaucet and Viefaucet helper

当前为 2024-03-12 提交的版本,查看 最新版本

您需要先安装一款用户脚本管理器扩展,例如 Tampermonkey 篡改猴Greasemonkey 油猴子Violentmonkey 暴力猴,才能安装此脚本。

您需要先安装一款用户脚本管理器扩展,例如 Tampermonkey 篡改猴,才能安装此脚本。

您需要先安装一款用户脚本管理器扩展,例如 Tampermonkey 篡改猴Violentmonkey 暴力猴,才能安装此脚本。

您需要先安装一款用户脚本管理器扩展,例如 Tampermonkey 篡改猴Userscripts ,才能安装此脚本。

您需要先安装一款用户脚本管理器扩展,例如 Tampermonkey 篡改猴,才能安装此脚本。

您需要先安装一款用户脚本管理器扩展后才能安装此脚本。

(我已经安装了用户脚本管理器,让我安装!)

您需要先安装一款用户样式管理器扩展,比如 Stylus,才能安装此样式。

您需要先安装一款用户样式管理器扩展,比如 Stylus,才能安装此样式。

您需要先安装一款用户样式管理器扩展,比如 Stylus,才能安装此样式。

您需要先安装一款用户样式管理器扩展后才能安装此样式。

您需要先安装一款用户样式管理器扩展后才能安装此样式。

您需要先安装一款用户样式管理器扩展后才能安装此样式。

(我已经安装了用户样式管理器,让我安装!)

// ==UserScript==
// @name         [Premium] Captcha Solver
// @namespace    http://greasyfork.icu/users/1162863
// @version      1.0
// @description  90% succes rate on Firefaucet and Viefaucet helper
// @author       Andrewblood
// @icon         https://coinfinity.top/favicon.ico

// @match        *://*.coinfinity.top/*

// @match        *://*.firefaucet.win/*
// @match        *://*.viefaucet.com/*

// @grant        GM_addStyle
// @license      Copyright Andrewblood
// ==/UserScript==

(function() {
    'use strict';



    var CaptchaSolverStatus = document.createElement('div');
    document.body.appendChild(CaptchaSolverStatus);

    CaptchaSolverStatus.classList.add('captchasolver-status');
    GM_addStyle(`
                .captchasolver-status {
                position: fixed;
                top: 140px;
                right: 10px;
                z-index: 9999; }
                `);

    function setCaptchaSolverStatus(html, color) {
        if (color === 'green') {
            CaptchaSolverStatus.style.color = 'green';
        } else if (color === 'red') {
            CaptchaSolverStatus.style.color = 'red';
        } else {
            CaptchaSolverStatus.style.color = 'black';
        }
        CaptchaSolverStatus.innerHTML = html;
    }

    setCaptchaSolverStatus('<p><b>[Premium] Captcha Solver</b> is running.</p>', 'green');



    if (window.location.href.includes('coinfinity.top/faucetlist')) {
        var isCaptchaSolverOverlayOpened = false;
        var CaptchaSolverButton = createCaptchaSolverButton('Captcha Solver');

        function createCaptchaSolverButton(text) {
            var CaptchaSolverButton = document.createElement('button');
            CaptchaSolverButton.innerHTML = text;
            CaptchaSolverButton.classList.add('captchasolver-button');
            CaptchaSolverButton.addEventListener('click', function() {
                if (!isCaptchaSolverOverlayOpened) {
                    openCaptchaSolverOverlay();
                    isCaptchaSolverOverlayOpened = true;
                }
            });
            return CaptchaSolverButton;
        }

        function openCaptchaSolverOverlay() {
            var CaptchaSolverOverlay = createCaptchaSolverOverlay();
            var CaptchaSolverOverlayContent = createCaptchaSolverOverlayContent();
            CaptchaSolverOverlay.appendChild(CaptchaSolverOverlayContent);
            document.body.appendChild(CaptchaSolverOverlay);
            CaptchaSolverOverlay.addEventListener('click', function(event) {
                if (event.target === CaptchaSolverOverlay) {
                    CaptchaSolverOverlay.remove();
                    isCaptchaSolverOverlayOpened = false;
                }
            });
        }

        function createCaptchaSolverOverlay() {
            var CaptchaSolverOverlay = document.createElement('div');
            CaptchaSolverOverlay.classList.add('captchasolver-overlay');
            return CaptchaSolverOverlay;
        }

        function createCaptchaSolverOverlayContent() {
            var CaptchaSolverOverlayContent = document.createElement('div');
            CaptchaSolverOverlayContent.classList.add('captchasolver-overlay-content');
            CaptchaSolverOverlayContent.innerHTML = `
                <h2>Captcha Solver Overlay Content</h2>
                <p>This is the content of the overlay. You can put any HTML content here.</p>
            `;
            return CaptchaSolverOverlayContent;
        }

        document.body.appendChild(CaptchaSolverButton);

        GM_addStyle(`
            .captchasolver-button {
                position: fixed;
                bottom: 20px;
                left: calc(65%);
                transform: translateX(50%);
                padding: 10px;
                background: blue;
                color: white;
                border: none;
                border-radius: 5px;
                cursor: pointer;
                z-index: 9999;
            }

            .captchasolver-overlay {
                position: fixed;
                top: 0;
                left: 0;
                width: 100%;
                height: 100%;
                background: rgba(0, 0, 0, 0.7);
                z-index: 9998;
                display: flex;
                align-items: center;
                justify-content: center;
            }

            .captchasolver-overlay-content {
                width: 95%;
                height: 80%;
                background: white;
                padding: 20px;
                overflow: auto;
                text-align: center;
            }
        `);
    }



    if (window.location.href.includes("firefaucet.win/viewptc")) {

        GM_addStyle(`
    .imageOverlay {
        position: fixed;
        z-index: 9999;
        padding: 10px;
        border-radius: 5px;
    }
    .imageOverlay.original {
        top: 150px;
        left: 10px;
        background-color: rgba(0, 0, 0, 0.8);
        color: white;
    }
    .imageOverlay.processed {
        top: 150px;
        right: 10px;
        background-color: rgba(0, 0, 0, 0.8);
        color: white;
    }
    .imageOverlay img {
        max-width: 200px;
        max-height: 200px;
        width: auto;
        height: auto;
    }
`);

        // Create the original overlay div and add it to the document
        const originalOverlayDiv = document.createElement('div');
        originalOverlayDiv.classList.add('imageOverlay', 'original');
        document.body.appendChild(originalOverlayDiv);

        // Create the processed overlay div and add it to the document
        const processedOverlayDiv = document.createElement('div');
        processedOverlayDiv.classList.add('imageOverlay', 'processed');
        document.body.appendChild(processedOverlayDiv);

        // Create img elements for the original and processed images
        const originalImgElement = document.createElement('img');
        const processedImgElement = document.createElement('img');
        originalOverlayDiv.appendChild(originalImgElement);
        processedOverlayDiv.appendChild(processedImgElement);

        // Load Tesseract.js script
        var tesseractScript = document.createElement('script');
        tesseractScript.src = 'https://cdnjs.cloudflare.com/ajax/libs/tesseract.js/5.0.4/tesseract.min.js';
        tesseractScript.onload = function() {

            // Load Tesseract worker
            var workerScript = document.createElement('script');
            workerScript.src = 'https://cdnjs.cloudflare.com/ajax/libs/tesseract.js/5.0.4/worker.min.js';
            workerScript.onload = function() {
                console.log("Tesseract.js loaded");

                // OpenCV script
                var opencvScript = document.createElement('script');
                opencvScript.src = 'https://docs.opencv.org/4.5.5/opencv.js';
                opencvScript.onload = function() {

                    // Funktion zum Polling bis das Element sichtbar ist
                    function waitForElement(selector, callback) {
                        const element = document.querySelector(selector);
                        if (element && element.offsetHeight > 1) {
                            callback(element);
                        } else {
                            setTimeout(() => waitForElement(selector, callback), 1000);
                        }
                    }

                    // Funktion zum Laden und Bearbeiten des Bildes
                    function loadAndProcessImage() {
                        console.log("Starte Überwachung des Bildes...");

                        // Überwachungsfunktion, die in bestimmten Intervallen prüft, ob das Bild vorhanden ist
                        let interval = setInterval(function() {
                            let imgElement = document.querySelector("#description > img");
                            if (imgElement) {
                                clearInterval(interval); // Stoppe das Intervall, wenn das Bild vorhanden ist
                                console.log("Bild gefunden. Starte Bearbeitung...");
                                originalImgElement.src = imgElement.src; // Zeige das Originalbild an
                                processImage(imgElement); // Lade und bearbeite das Bild
                            } else {
                                console.log("Bild nicht gefunden. Warte weiter...");
                            }
                        }, 1000); // Überprüfe alle 1 Sekunde, ob das Bild vorhanden ist
                    }

                    // Funktion zum Laden und Bearbeiten des Bildes
                    function processImage(imgElement) {
                        let src = cv.imread(imgElement);

                        // Schritt 0: Vergrößere das Bild
                        let resized = new cv.Mat();
                        let dsize = new cv.Size(src.cols * 4, src.rows * 4); // Verdreifache die Größe des Bildes
                        cv.resize(src, resized, dsize, 0, 0, cv.INTER_LINEAR);

                        let dst = new cv.Mat();
                        let M = cv.Mat.ones(5, 5, cv.CV_8U);
                        let anchor = new cv.Point(-1, -1);

                        // Schritt 1: Ändere die Schriftfarbe auf Weiß und den Hintergrund auf Schwarz
                        cv.cvtColor(resized, dst, cv.COLOR_RGB2GRAY);
                        cv.threshold(dst, dst, 0, 255, cv.THRESH_BINARY | cv.THRESH_OTSU);

                        // Schritt 2: Verwende Morphologie-Operationen, um das Bild zu bearbeiten
                        cv.dilate(dst, dst, M, anchor, 2, cv.BORDER_CONSTANT, cv.morphologyDefaultBorderValue());
                        //        cv.erode(dst, dst, M, anchor, 1, cv.BORDER_CONSTANT, cv.morphologyDefaultBorderValue());

                        // Schritt 3: Konvertiere das bearbeitete Bild zurück in ein DOM-Element
                        let canvas = document.createElement('canvas');
                        cv.imshow(canvas, dst);
                        let manipulatedImageSrc = canvas.toDataURL();

                        // Füge das bearbeitete Bild dem Overlay-DIV hinzu
                        processedImgElement.src = manipulatedImageSrc;

                        console.log("Bild erfolgreich bearbeitet und dem Overlay hinzugefügt.");

                        // Texterkennung mit Tesseract.js
                        Tesseract.recognize(
                            manipulatedImageSrc,
                            'eng',
                            {
                                logger: m => console.log("Tesseract Log:", m),
                                psm: 7,
                                oem: 3,
                                tessedit_char_whitelist: "0123456789"
                            }
                        ).then(({ data: { text } }) => {
                            console.log("Roh-Text:", text);

                            // Filtere nur Zahlen von 0 bis 9 aus dem erkannten Text
                            const filteredText = text.replace(/[^0-9]/g, '');

                            console.log("Text nach der Filterung:", filteredText);

                            // Füge den gefilterten Text dem Eingabefeld hinzu
                            var textField = document.querySelector("#description > input.captcha-input");

                            // Überprüfe, ob die Länge des Textes korrekt ist
                            if (filteredText.length === 4) {
                                textField.value = filteredText;

                                // Warte auf die Höhe des Elements #submit-button > i

                            } else {
                                // Lade die Seite neu
                                location.reload();
                            }
                        });

                        // Bereinige Ressourcen
                        src.delete();
                        dst.delete();
                        M.delete();
                        resized.delete();
                    }

                    // Starte das Laden und Bearbeiten des Bildes
                    loadAndProcessImage();
                };
                document.head.appendChild(opencvScript);
            };
            document.head.appendChild(workerScript);
        };
        document.head.appendChild(tesseractScript);
    }



    if (window.location.href.includes("viefaucet.com")){
        function VieCaptcha() {
            const targetElementSelector = '.check-box';
            const targetElement = document.querySelector(targetElementSelector);
            if (targetElement) {
                window.focus();
                targetElement.click();
            }
            const dotElement = document.querySelector('div.dot');
            if (dotElement) {
                const buttons = document.querySelectorAll('button');
                buttons.forEach(button => {
                    if (button.textContent.includes('Verify')) {
                        button.click();
                        if(window.location.href.includes("https://viefaucet.com/app/ptc/iframe/")) {
                            setInterval(function() {
                                if (document.querySelector(".el-notification__title")){
                                    window.close();
                                }
                            }, 1000);
                        }
                    }
                });
            }
        }
        setInterval(VieCaptcha, 1000);
    }



})();