【逃课教程】1小时火速拿下华为云600代金卷的快捷流程

frankxxx · 2025 年9 月 23 日 08:54

主要思路就是通过油猴脚本屏蔽切屏，截图下来考试题目汇总，再让gemini批量答题（答题65-85%的正确率），基本上一次考试6分钟左右

我会把脚本，选课指南，领卷链接都列出来，方便直接用。正常的手速，可以在1小时以内，考完提交领600卷申请，卷可以开小鸡和续费 xhj015

具体操作如下：

1.先报名（25号活动结束）：
报名链接(含AFF)：Developer Events_Developer Alliance-Huawei Cloud

2.领卷链接：
27元三张，需要分别打开三次领取
https://account.huaweicloud.com/usercenter/#/getCoupons?activityID=P25082506274639016RQUHE1HGEBW3&contentID=PCP2508250616435961MDQQ4917UC2YS
37元两张，需要分别打开两次领取
https://account.huaweicloud.com/usercenter/#/getCoupons?activityID=P25082506292772514R5O1M0I0I0UH&contentID=PCP2508250617550470QMI6HL1FCTZ2C
47元1张，打开一次领取
https://account.huaweicloud.com/usercenter/#/getCoupons?activityID=P2508250630548551IIO5A50Z3AF2X&contentID=PCP2508250618321451VGV1HD086TWOT

3.选课和买课
这里是大佬整理好的可用的课程，点进去购买，如果没有提示已购买，则可以买。
27的课买3门，37的买2门，47的买1门。

具体选课参考NS大佬的帖子：https://www.■■■■■■■■.com/post-432901-1

28元档:
- [微信公众号后台消息回复](https://edu.huaweicloud.com/certifications/622e6c32f54441ea8c35c998fb60c01a)
- [搭建麦进斗电子商务网站](https://edu.huaweicloud.com/certifications/7ca67e4164b64825816b54db341d522e)
- [智能声音识别](https://edu.huaweicloud.com/certifications/082c691ffb8e435ab4e3814fcd2844d4)
- [基于昇腾AI处理器的算子开发](https://edu.huaweicloud.com/certifications/a64f47428cdb425294f1dd3a8d0c9e98)
- [HarmonyOS分布式协同办公应用开发](https://edu.huaweicloud.com/certifications/24e94957537444ca974f8373a959768a)
- [基于物联网平台构建智慧路灯应用](https://edu.huaweicloud.com/certifications/77849eaa1b6045d9a2b76c58406ede82)
- [物联网智慧烟感报警系统](https://edu.huaweicloud.com/certifications/e748901f0c5243bb941be68e62cd1228)
- [使用低代码平台开发园区访客应用](https://edu.huaweicloud.com/certifications/bf00f753f078459ab3b226f28b7b07bf)
- [华为企业级JAVA编程规范](https://edu.huaweicloud.com/certifications/9eeea7c524514eb58ebc169186813cf4)

38元档:
- [区块链部署弹珠游戏模拟资产变化](https://edu.huaweicloud.com/certifications/27d614f77d6440bcb542802d06cd5db5)
- [鲲鹏计算平台软件移植初体验](https://edu.huaweicloud.com/certifications/e8b849d8b10147acab82defa5c5c4d24)
- [openGauss数据库在金融领域的使用实践](https://edu.huaweicloud.com/certifications/e0feeb4bcd484cf4a45e6583a44ac7fe)
- [基于物联网平台的自贩机销量分析](https://edu.huaweicloud.com/certifications/134f4eebbe3242a190b461b77ee1873a)
- [企业网站项目测试实战](https://edu.huaweicloud.com/certifications/0f68924c81db4356825e145f2fa53e17)
- [基于华为云CodeArts的托马斯商城](https://edu.huaweicloud.com/certifications/31d9e63e491c4a6bb910984286405efd)
- [博客网站SQL注入攻击以及防御](https://edu.huaweicloud.com/certifications/9ff8d7b057ff4268b2179f49bdae3158)

48元档:
- [华为云鲲鹏弹性云服务器高可用性架构实践](https://edu.huaweicloud.com/certifications/e82ceaa01c1c4ca58d01084999edcaa6)
- [基于Spark实现车主驾驶行为分析](https://edu.huaweicloud.com/certifications/25faaf3f72814f81ae89f70766c3d35a)
- [Ansible自动化部署LNMP](https://edu.huaweicloud.com/certifications/dad17d2f5cc24850a508f66868591f15)
- [基于分布式文件系统的人才云招聘平台实践](https://edu.huaweicloud.com/certifications/2916030d9dda4d9484740594e0896917)
- [基于应用服务网格的灰度发布](https://edu.huaweicloud.com/certifications/09893eead5ef43a89c8a8e900147accf)
- [HTTPS加密电商网站](https://edu.huaweicloud.com/certifications/8e5ea56dd49f4ee794ae3d26a48a69f2)

4.考试的流程
按照以下，基本上可以实现5-7分钟完成一门考试，答题成功率在80%左右。
考完一共3+2+1=6门，刚好满足600卷申领条件。

油猴脚本开启防切屏（脚本见文末的“其他参考”）
进入考试，将每道题截图进一个word里，可以提前将网页改成125%缩放，保证文字更清楚。
然后将包含24道题图片的word直接丢给gemini答题
告诉Gemini，你要参加一个华为网络工程师模拟考试，不需要分析题目，只告诉我答案。

效果图：

5.提交领600卷申请

代金卷申请的链接：
https://survey.huaweicloud.com/survey/#/qtn?id=83e72b9cc6e645f9954b776935064353

补充：如果你的时间充裕，可以把开发者认证也顺手搞了，虽然麻烦点，但是能多4积分，可以领800卷。

其他参考

1.如何查看考试通过结果：

在“我的微认证”查看，考试情况（结果会有几分钟延迟）

2.遇到AI答不过去的考试：
进入课程的微认证界面（第三部分选课链接进入就是），点，在线学习–报名学习，点击课件，
然后F12开启浏览器开发模式，切换到network，F5刷新，在filter搜pdf，找到哪个体积最大的文件，他的URL就是课件链接，
然后把课件下载下来，喂给AI，基本再考试就是必过了。

3.油猴（谷歌商店搜篡改猴）脚本：

// ==UserScript==
// @name         通用阻止切屏检测
// @namespace    http://tampermonkey.net/
// @version      0.1.0
// @description  尝试阻止各类网站的切屏、焦点丢失等检测
// @author       ■■■■■■■■@小号 && Gemini
// @match        http://*/*
// @match        https://*/*
// @run-at       document-start
// @grant        unsafeWindow
// @license      GPL-3.0
// ==/UserScript==

(function () {
    'use strict';
    const window = unsafeWindow; // 使用原始 window 对象

    // 黑名单事件，这些事件的监听器将被阻止
    const blackListedEvents = new Set([
        "visibilitychange", // 页面可见性改变
        "blur",             // 元素或窗口失去焦点
        "focus",            // 元素或窗口获得焦点 (某些检测可能反向利用focus)
        "pagehide",         // 页面隐藏（例如导航到其他页面）
        "freeze",           // 页面被冻结 (较新的事件)
        "resume",           // 页面从冻结状态恢复 (较新的事件)
        "mouseleave",       // 鼠标移出元素（通常是 document 或 body）
        "mouseout",         // 鼠标移出元素（更通用的移出，但要小心副作用）
        // "focusout",      // 元素将要失去焦点（与blur类似，但更通用，看情况添加）
        // "focusin",       // 元素将要获得焦点（与focus类似，看情况添加）
    ]);

    // 白名单属性，这些属性在 document 对象上将被伪造
    const spoofedDocumentProperties = {
        hidden: { value: false, configurable: true },
        mozHidden: { value: false, configurable: true }, // Firefox (旧版)
        msHidden: { value: false, configurable: true },  // Internet Explorer
        webkitHidden: { value: false, configurable: true }, // Chrome, Safari, Opera (旧版 Blink/WebKit)
        visibilityState: { value: "visible", configurable: true },
        hasFocus: { value: () => true, configurable: true }
    };

    // 需要清空/置空的事件处理器属性 (on-event handlers)
    const eventHandlersToNullifyDocument = [
        "onvisibilitychange",
        "onblur",
        "onfocus",
        "onmouseleave",
        "onmouseout",
        // "onfocusout",
        // "onfocusin",
        "onpagehide",
        "onfreeze",
        "onresume"
    ];

    const eventHandlersToNullifyWindow = [
        "onblur",
        "onfocus",
        "onpagehide",
        "onpageshow", // 有些检测可能通过 pageshow 结合 persisted 属性判断
        "onfreeze",
        "onresume",
        "onmouseleave", // window 也有 onmouseleave
        "onmouseout"
    ];

    const isDebug = false; // 设置为 true 以启用调试日志
    const scriptPrefix = "[通用阻止切屏检测]";
    const log = console.log.bind(console, `%c${scriptPrefix}`, 'color: #4CAF50; font-weight: bold;');
    const warn = console.warn.bind(console, `%c${scriptPrefix}`, 'color: #FFC107; font-weight: bold;');
    const error = console.error.bind(console, `%c${scriptPrefix}`, 'color: #F44336; font-weight: bold;');
    const debug = isDebug ? log : () => { };

    /**
     * 伪装函数的 toString 方法，使其看起来像原始函数。
     * @param {Function} modifiedFunction 被修改的函数
     * @param {Function} originalFunction 原始函数
     */
    function patchToString(modifiedFunction, originalFunction) {
        if (typeof modifiedFunction !== 'function' || typeof originalFunction !== 'function') {
            warn("patchToString: 传入的参数不是函数。", modifiedFunction, originalFunction);
            return;
        }
        try {
            const originalToStringSource = Function.prototype.toString.call(originalFunction);
            modifiedFunction.toString = () => originalToStringSource;

            // 进一步伪装 toString.toString
            const originalToStringToStringSource = Function.prototype.toString.call(originalFunction.toString);
            Object.defineProperty(modifiedFunction.toString, 'toString', {
                value: () => originalToStringToStringSource,
                enumerable: false,
                configurable: true, // 保持可配置，以防万一
                writable: false
            });
            debug(`patchToString applied for: ${originalFunction.name || 'anonymous function'}`);
        } catch (e) {
            error("patchToString failed:", e, "for function:", originalFunction.name);
        }
    }


    /**
     * 劫持并修改对象的 addEventListener 方法。
     * @param {EventTarget} targetObject 要劫持的对象 (window, document, Element)
     * @param {string} objectName 用于日志记录的对象名称
     */
    function patchAddEventListener(targetObject, objectName) {
        if (!targetObject || typeof targetObject.addEventListener !== 'function') {
            warn(`Cannot patch addEventListener for invalid target: ${objectName}`);
            return;
        }
        const originalAddEventListener = targetObject.addEventListener;

        targetObject.addEventListener = function (type, listener, optionsOrCapture) {
            if (blackListedEvents.has(type.toLowerCase())) {
                log(`BLOCKED ${objectName}.addEventListener: ${type}`);
                return undefined; // 阻止添加黑名单中的事件监听器
            }
            debug(`ALLOWED ${objectName}.addEventListener: ${type}`, listener, optionsOrCapture);
            return originalAddEventListener.call(this, type, listener, optionsOrCapture);
        };

        patchToString(targetObject.addEventListener, originalAddEventListener);
        log(`${objectName}.addEventListener patched.`);
    }

    /**
     * 劫持并修改对象的 removeEventListener 方法 (可选，但建议一起修改)。
     * @param {EventTarget} targetObject 要劫持的对象
     * @param {string} objectName 用于日志记录的对象名称
     */
    function patchRemoveEventListener(targetObject, objectName) {
        if (!targetObject || typeof targetObject.removeEventListener !== 'function') {
            warn(`Cannot patch removeEventListener for invalid target: ${objectName}`);
            return;
        }
        const originalRemoveEventListener = targetObject.removeEventListener;

        targetObject.removeEventListener = function (type, listener, optionsOrCapture) {
            if (blackListedEvents.has(type.toLowerCase())) {
                log(`Original call to ${objectName}.removeEventListener for blacklisted event '${type}' would have been ignored by our addEventListener patch anyway. Allowing native call if needed.`);
                // 即使我们阻止了 addEventListener，原始的 removeEventListener 仍然应该能安全调用
                // 因为如果监听器从未被添加，调用 remove 也无害。
            }
            debug(`PASSTHROUGH ${objectName}.removeEventListener: ${type}`, listener, optionsOrCapture);
            return originalRemoveEventListener.call(this, type, listener, optionsOrCapture);
        };
        patchToString(targetObject.removeEventListener, originalRemoveEventListener);
        log(`${objectName}.removeEventListener patched.`);
    }


    /**
     * 修改对象上的属性，使其返回伪造的值。
     * @param {object} targetObject 目标对象 (e.g., document)
     * @param {object} propertiesToSpoof 属性描述对象
     * @param {string} objectName 对象名称
     */
    function spoofProperties(targetObject, propertiesToSpoof, objectName) {
        if (!targetObject) {
            warn(`Cannot spoof properties for invalid target: ${objectName}`);
            return;
        }
        for (const prop in propertiesToSpoof) {
            if (Object.prototype.hasOwnProperty.call(propertiesToSpoof, prop)) {
                try {
                    Object.defineProperty(targetObject, prop, propertiesToSpoof[prop]);
                    debug(`Spoofed ${objectName}.${prop}`);
                } catch (e) {
                    error(`Failed to spoof ${objectName}.${prop}:`, e);
                }
            }
        }
        log(`${objectName} properties spoofed.`);
    }

    /**
     * 清空或置空对象上的事件处理器属性。
     * @param {object} targetObject 目标对象
     * @param {string[]} eventHandlerNames 事件处理器名称数组
     * @param {string} objectName 对象名称
     */
    function nullifyEventHandlers(targetObject, eventHandlerNames, objectName) {
        if (!targetObject) {
            warn(`Cannot nullify event handlers for invalid target: ${objectName}`);
            return;
        }
        eventHandlerNames.forEach(handlerName => {
            try {
                Object.defineProperty(targetObject, handlerName, {
                    get: () => {
                        debug(`Access to ${objectName}.${handlerName} (get), returning undefined.`);
                        return undefined;
                    },
                    set: (newHandler) => {
                        log(`Attempt to set ${objectName}.${handlerName} blocked.`);
                        if (typeof newHandler === 'function') {
                             // 可以选择性地调用 newHandler，或者完全阻止
                             // debug(`(Blocked) Handler function was:`, newHandler);
                        }
                    },
                    configurable: true // 保持可配置，以便脚本可以多次运行或被其他脚本修改
                });
                debug(`Nullified ${objectName}.${handlerName}`);
            } catch (e) {
                error(`Failed to nullify ${objectName}.${handlerName}:`, e);
            }
        });
        log(`${objectName} on-event handlers nullified.`);
    }

    // --- 开始执行 ---

    log("Script starting...");

    // 1. 劫持 window 和 document 的 addEventListener/removeEventListener
    patchAddEventListener(window, "window");
    patchRemoveEventListener(window, "window"); // 也 patch removeEventListener 以保持一致性
    patchAddEventListener(document, "document");
    patchRemoveEventListener(document, "document");

    // 2. 修改 document 的属性
    spoofProperties(document, spoofedDocumentProperties, "document");

    // 3. 置空 document 和 window 上的事件处理器
    nullifyEventHandlers(document, eventHandlersToNullifyDocument, "document");
    nullifyEventHandlers(window, eventHandlersToNullifyWindow, "window");

    // 4. 对于 document.body，需要等待 DOMContentLoaded
    // 使用 MutationObserver 确保 body 存在时立即 patch，比 DOMContentLoaded 更早且更可靠
    const observer = new MutationObserver((mutations, obs) => {
        if (document.body) {
            patchAddEventListener(document.body, "document.body");
            patchRemoveEventListener(document.body, "document.body");
            // 对于 document.body，也可以考虑 nullify onmouseleave, onmouseout 等
            nullifyEventHandlers(document.body, ["onmouseleave", "onmouseout", "onblur", "onfocus"], "document.body");
            log("document.body patched via MutationObserver.");
            obs.disconnect(); // 完成任务后断开观察者
        }
    });

    if (document.body) { // 如果 body 已经存在 (不太可能在 document-start，但以防万一)
        patchAddEventListener(document.body, "document.body");
        patchRemoveEventListener(document.body, "document.body");
        nullifyEventHandlers(document.body, ["onmouseleave", "onmouseout", "onblur", "onfocus"], "document.body");
        log("document.body patched directly.");
    } else {
        observer.observe(document.documentElement || document, { childList: true, subtree: true });
    }


    // 5. 调试：劫持计时器 (如果 isDebug 为 true)
    if (isDebug) {
        const originalSetInterval = window.setInterval;
        window.setInterval = function(...args) {
            const id = originalSetInterval.apply(this, args);
            debug("calling window.setInterval", id, args);
            return id;
        };
        patchToString(window.setInterval, originalSetInterval);

        const originalSetTimeout = window.setTimeout;
        window.setTimeout = function(...args) {
            const id = originalSetTimeout.apply(this, args);
            debug("calling window.setTimeout", id, args);
            return id;
        };
        patchToString(window.setTimeout, originalSetTimeout);
        log("Timer functions (setInterval, setTimeout) wrapped for debugging.");
    }

    log("Script execution finished. Monitoring active.");

})();

BearPaw · 2025 年9 月 23 日 08:57

路过

kure · 2025 年9 月 23 日 09:00

感谢大佬分享

trial · 2025 年9 月 23 日 09:00

懒得搞。实在需要的试试吧。

frankxxx · 2025 年9 月 23 日 09:09

手里有geminipro，一小时可以拿下，然后等卷就行了

chendeshen · 2025 年9 月 23 日 09:17

感谢大佬分享

azhaoyihao · 2025 年9 月 23 日 09:31

感谢楼主的分享

xybug · 2025 年9 月 23 日 09:40

华为云那是贼贵，效果不知道好不好，有用过的可以发个测评

RodickYu · 2025 年9 月 23 日 09:47

清晰明了，感谢分享

frankxxx · 2025 年9 月 23 日 09:48

其实挺一般的，就占个白嫖

国内小鸡都是2-3m，可以当个挂机宝

HK和SGP现在新开的没有三网直连了，最多2网直连，不过性能体验比国内好点，也是做挂机宝用吧，或许还能落地？我是直接DDWIN用了，没有测过解锁

xiaomiAsscan · 2025 年9 月 23 日 10:39

大佬，可以帮我代考吗？

frankxxx · 2025 年9 月 23 日 11:47

这是600保底卷，挺简单的，有geminipro全程复制粘贴了等于是

代考比较麻烦，需要你的照片好像，建议走这个教程吧，门槛就是装油猴脚本和GEminipro

tufei · 2025 年9 月 23 日 11:55

感谢楼主分享

daoyao · 2025 年9 月 23 日 13:46

感谢分享，只是我没兴趣弄

ShengZoo · 2025 年9 月 23 日 15:31

谢谢分享

kof97zip · 2025 年9 月 23 日 15:36

好复杂

Wet_Dream_Boy · 2025 年9 月 23 日 16:58

谢谢大佬分享

Jisucloud · 2025 年9 月 23 日 23:40

防切屏+gemini2.5不到5分钟一门

Zo_Ao · 2025 年9 月 24 日 00:44

其实多考几门加上开发者认证能拿1000的资源劵的

Melody · 2025 年9 月 24 日 01:18

感谢大佬，最好完善1000卷吧哈哈

话题		回复	浏览量
防切屏检测脚本，可以用于某些神秘活动，理论上是通用的科技与创作	78	521	2025 年9 月 16 日
分享之前搞得华为考试脚本数码与硬件	14	236	2025 年9 月 6 日
【重金之下可有勇夫】不限语言，解决黑五的抢鸡难题互联网服务	26	358	2024 年10 月 13 日
Nodeloc帖子增强油猴脚本标注已读隐藏高亮置顶等互联网服务	5	74	2025 年8 月 21 日
关于自制数学验证码的可靠性科技与创作	16	328	2024 年12 月 24 日

【逃课教程】1小时火速拿下华为云600代金卷的快捷流程

相关话题