YLong软件

HTML打包APK：页面打印功能实现方法

Mon, 24 Aug 2026 20:34:58 +0800

在网页中，一行 window.print() 就能调起浏览器的打印功能。在HTML一键打包APK工具生成的APP中，这行代码同样有效：工具会拦截 window.print() 调用，并转交给安卓系统打印服务。用户可以直接选择打印机打印，也可以"另存为PDF"把页面保存成PDF文件。

如果你不了解HTML打包APK工具, 想要进一步了解, 可以查看官网:

HTML一键打包APK工具官网

创建打印页面

在HTML项目入口目录中创建 index.html，写入以下代码。页面展示一张简单的单据，点击"打印"按钮后调用 window.print() 触发打印。通过 @media print 样式，打印时会自动隐藏按钮等屏幕元素，只保留单据内容。

<!doctype html>
<html lang="zh-CN">
    <head>
        <meta charset="UTF-8" />
        <meta name="viewport" content="width=device-width, initial-scale=1, viewport-fit=cover" />
        <title>单据打印</title>
        <style>
            * {
                box-sizing: border-box;
            }

            body {
                min-height: 100vh;
                margin: 0;
                padding: 20px;
                display: grid;
                place-items: center;
                font-family: 'Microsoft YaHei', sans-serif;
                background: #f4f7f5;
                color: #17221c;
            }

            main {
                width: min(100%, 440px);
            }

            .sheet {
                padding: 24px;
                border: 1px solid #cad4ce;
                border-radius: 8px;
                background: #fff;
            }

            h1 {
                margin: 0 0 4px;
                font-size: 24px;
                text-align: center;
            }

            .sheet-meta {
                margin: 0 0 16px;
                font-size: 13px;
                color: #526159;
                text-align: center;
            }

            table {
                width: 100%;
                border-collapse: collapse;
                font-size: 14px;
            }

            th,
            td {
                padding: 8px 6px;
                border-bottom: 1px solid #e2e8e4;
                text-align: left;
            }

            th {
                background: #eef2f0;
            }

            .total {
                margin-top: 12px;
                text-align: right;
                font-size: 16px;
                font-weight: 700;
            }

            button {
                width: 100%;
                min-height: 48px;
                margin-top: 14px;
                border: 0;
                border-radius: 6px;
                background: #197447;
                color: white;
                font: inherit;
                font-weight: 700;
            }

            /* 打印相关样式 */
            @media print {
                body {
                    padding: 0;
                    background: #fff;
                }

                /* 打印时隐藏按钮，只保留单据 */
                .no-print {
                    display: none;
                }

                .sheet {
                    width: 100%;
                    border: 0;
                    border-radius: 0;
                }
            }
        </style>
    </head>
    <body>
        <main>
            <div class="sheet">
                <h1>购物清单</h1>
                <p class="sheet-meta">单号：20260824001　日期：2026-08-24</p>
                <table>
                    <thead>
                        <tr>
                            <th>品名</th>
                            <th>数量</th>
                            <th>金额</th>
                        </tr>
                    </thead>
                    <tbody>
                        <tr>
                            <td>无线鼠标</td>
                            <td>1</td>
                            <td>79.00</td>
                        </tr>
                        <tr>
                            <td>机械键盘</td>
                            <td>1</td>
                            <td>299.00</td>
                        </tr>
                        <tr>
                            <td>USB数据线</td>
                            <td>2</td>
                            <td>30.00</td>
                        </tr>
                    </tbody>
                </table>
                <p class="total">合计：408.00 元</p>
            </div>
            <button class="no-print" type="button" onclick="window.print()">打印</button>
        </main>
    </body>
</html>

代码说明：

点击"打印"按钮执行 window.print()，这是整个打印功能的核心，不需要引入任何第三方库。
@media print 中定义了打印时的样式，display: none 的 .no-print 元素（按钮等）不会出现在打印内容中。
单据表格、金额等内容在屏幕和打印中都会完整保留。

打包APK

打开HTML一键打包APK工具，选择包含 index.html 的项目目录，填写应用名称、包名等打包信息。打印功能依赖安卓系统打印服务，无需额外勾选权限，按默认配置打包即可。

确认配置后开始打包，等待工具生成APK文件。

安装并测试打印

将生成的APK安装到安卓手机，打开APP点击"打印"按钮，系统会弹出打印预览界面。在这里可以：

选择已连接的打印机（云打印机、局域网打印机等）直接打印；
在打印机列表中选择"另存为PDF"，把页面保存成PDF文件。

保存的PDF文件可以在手机的"文件"应用或相册中找到，方便发送给客户或存档。

常见问题

点击打印没有反应？ 请确认手机系统为Android 5.0及以上，旧系统没有内置打印服务。

列表中找不到打印机？ 安卓打印服务需要打印机与手机处于同一网络，或打印机已接入云打印服务。也可以直接使用"另存为PDF"，不依赖任何打印机。

打印内容不完整或分页异常？ 在 @media print 中适当调整宽度、字号和间距，避免内容超出纸张范围；需要强制分页时，可以在指定元素上添加 page-break-after: always 样式。

HTML打包EXE退出密码设置指南

Wed, 19 Aug 2026 21:10:33 +0800

HTML打包EXE工具提供了退出密码功能。启用后，打包生成的 EXE 在用户点击关闭按钮时，不会直接退出，而是先弹出密码输入窗口，只有输入正确的退出密码才能真正关闭程序。

对于放置在公共场所的展示机、教学机房的课件程序、无人值守的查询设备等场景，这个功能可以有效防止程序被误操作或他人随意关闭，保证内容持续稳定地展示和运行。

下载最新版本

适用场景

退出密码功能适合需要让程序保持长时间运行、不希望被随意关闭的使用方式：

展厅展示机：触摸屏一体机循环播放展示内容，防止参观者误触关闭按钮退出程序。
教学机房：学生机上的课件程序保持打开状态，避免学生上课途中关闭课件。
无人值守设备：自助查询机、叫号机等设备需要程序持续运行，只有管理人员输入密码才能退出维护。
儿童使用场景：孩子使用电脑学习时，防止其随手关闭学习软件去做其他操作。
会议和活动现场：现场大屏播放的程序避免被工作人员误关，影响活动流程。

简单来说，只要你的程序需要"一直开着"，退出密码就能帮上忙。

配置步骤

退出密码位于打包工具的静态密码标签页中，配置步骤如下：

打开 HTML打包EXE 工具，切换到静态密码标签页。
勾选启用退出密码功能。
勾选后，下方的退出密码输入框会变为可编辑状态，输入 1-16 位字母或数字作为退出密码。
正常执行打包操作，生成 EXE。

需要注意的是，未勾选"启用退出密码功能"时，退出密码输入框为灰色不可编辑状态。只有先勾选启用，才能填写和修改密码，避免误填了密码却没有实际启用功能的情况。

用户看到的效果

打包生成的 EXE 运行后，用户点击窗口关闭按钮时，会弹出"需要退出密码"的提示窗口，要求输入退出密码。

用户可以选择：

输入正确的退出密码并确认，程序正常退出。
输入错误密码，程序不会退出，需要重新输入。
点击取消，放弃退出操作，程序继续运行。

也就是说，不知道密码的用户无法通过常规方式关闭程序，只有掌握密码的管理人员才能退出。

和静态密码的区别

静态密码和退出密码位于同一个标签页，但作用阶段不同：

对比项	静态密码	退出密码
作用时机	打开程序时	关闭程序时
作用	输入正确密码才能进入软件	输入正确密码才能退出软件
适合场景	限制谁可以使用软件	防止软件被随意关闭
自定义信息	支持配置激活弹窗显示的信息	使用固定的提示信息

两者可以单独使用，也可以同时启用。例如一个付费展示项目，可以设置静态密码限制只有付费用户才能打开，再设置退出密码防止展示过程中被关闭，实现"进得来就出不去"的双重保护。

使用建议

妥善保管密码：退出密码设置后只有自己知道，请务必记录保存。如果忘记密码，程序将无法正常退出。
使用容易输入的密码：密码支持 1-16 位字母和数字，建议使用便于记忆和快速输入的组合，方便现场维护人员操作。
配合全屏使用效果更好：对于展示机场景，建议同时勾选全屏选项，隐藏窗口的放大、缩小、关闭按钮，配合退出密码形成更完整的防关闭方案。
注意内核支持：退出密码功能仅 Chrome 内核支持，打包时请确认内核选择为 Chrome 内核。
定期更换密码：如果程序长期放置在公共场所，建议定期更换退出密码并重新打包，避免密码泄露。

总结

HTML打包EXE工具的退出密码功能，配置简单但非常实用：勾选启用、填写密码、重新打包，三步即可让生成的 EXE 具备防关闭能力。

对于展厅展示、教学机房、无人值守设备等需要程序持续运行的场景，退出密码可以有效避免误操作和恶意关闭。如果再配合静态密码、全屏等选项一起使用，就能让打包出来的程序既安全又稳定。

用HTML打包APK制作视频播放器

Mon, 10 Aug 2026 19:32:34 +0800

HTML页面可以通过 video 标签播放网络和本地视频，结合浏览器全屏接口实现最大化播放，并在全屏时锁定横屏获得更好的观看体验。完成页面代码后，再通过HTML一键打包APK工具配置网络权限，即可生成支持视频播放和全屏播放的安卓APP。

工具官网：HTML一键打包APK工具官网

创建视频播放页面

在项目入口目录创建 index.html，包含视频播放区、最大化按钮和地址输入。

视频播放：使用 video 标签加载视频，添加 playsinline 属性保证内联播放。
最大化按钮：调用全屏接口，兼容WebView。
横屏锁定：全屏时自动横屏，退出竖屏。
地址加载：输入视频直链，切换测试视频。

视频标签需要添加 playsinline、webkit-playsinline 和 x5-playsinline 属性，避免跳转系统播放器：

<video playsinline webkit-playsinline x5-playsinline src="video.mp4"></video>

最大化按钮通过全屏接口处理标准接口和 webkit 前缀接口：

if (shell.requestFullscreen) shell.requestFullscreen();
else if (shell.webkitRequestFullscreen) shell.webkitRequestFullscreen();

打包成APK

保存代码到video-test.html，用工具载入并点击打包：

测试功能

安装APK后测试：

默认视频加载，播放暂停正常。
点最大化按钮进入全屏。
全屏时横屏锁定，退出恢复竖屏。
输入其他mp4链接，切换加载。
拖动进度条，从指定位置播放。

推荐H.264+AAC编码的mp4，避免HEVC等兼容问题。

如果全屏失效，检查系统横屏限制；视频加载失败，确认网络权限和地址可用。自动播放需要用户交互。

完整示例：

<!DOCTYPE html>
<html lang="zh-CN">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=no">
<title>视频播放测试</title>
<style>
  * { margin: 0; padding: 0; box-sizing: border-box; }
  html, body {
    width: 100%; height: 100%;
    background: #000;
    font-family: -apple-system, "PingFang SC", "Microsoft YaHei", sans-serif;
    overflow: hidden;
  }

  #player-wrap {
    position: relative;
    width: 100%;
    height: 100%;
    display: flex;
    flex-direction: column;
  }

  /* 视频区域 */
  #video-box {
    position: relative;
    flex: 1;
    background: #000;
    display: flex;
    align-items: center;
    justify-content: center;
    overflow: hidden;
  }
  video {
    width: 100%;
    height: 100%;
    object-fit: contain;
    background: #000;
  }

  /* 最大化按钮（悬浮在视频右上角） */
  #btn-fullscreen {
    position: absolute;
    top: 12px;
    right: 12px;
    z-index: 20;
    width: 44px;
    height: 44px;
    border: none;
    border-radius: 8px;
    background: rgba(0, 0, 0, 0.55);
    color: #fff;
    display: flex;
    align-items: center;
    justify-content: center;
    cursor: pointer;
    -webkit-tap-highlight-color: transparent;
  }
  #btn-fullscreen:active { background: rgba(255, 255, 255, 0.25); }
  #btn-fullscreen svg { width: 24px; height: 24px; }

  /* 底部控制栏 */
  #controls {
    position: relative;
    z-index: 10;
    background: #111;
    padding: 10px 12px calc(10px + env(safe-area-inset-bottom));
    display: flex;
    flex-direction: column;
    gap: 10px;
  }

  #btn-play {
    width: 100%;
    padding: 14px;
    font-size: 17px;
    color: #fff;
    background: #1f80ff;
    border: none;
    border-radius: 10px;
    -webkit-tap-highlight-color: transparent;
  }
  #btn-play:active { opacity: 0.8; }

  .url-row { display: flex; gap: 8px; }
  #url-input {
    flex: 1;
    min-width: 0;
    padding: 12px;
    font-size: 14px;
    color: #fff;
    background: #222;
    border: 1px solid #333;
    border-radius: 8px;
    outline: none;
  }
  #btn-load {
    padding: 0 16px;
    font-size: 14px;
    color: #fff;
    background: #333;
    border: none;
    border-radius: 8px;
    white-space: nowrap;
  }

  #status {
    font-size: 12px;
    color: #888;
    word-break: break-all;
  }

  /* 全屏时隐藏控制栏 */
  :fullscreen #controls { display: none; }
  :-webkit-full-screen #controls { display: none; }
</style>
</head>
<body>

<div id="player-wrap">
  <div id="video-box">
    <video id="video" playsinline webkit-playsinline x5-playsinline preload="metadata"
      src="./BigBuckBunny.mp4"></video>

    <!-- 最大化按钮 -->
    <button id="btn-fullscreen" aria-label="最大化">
      <svg id="icon-max" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
        <path d="M8 3H5a2 2 0 0 0-2 2v3"/><path d="M16 3h3a2 2 0 0 1 2 2v3"/>
        <path d="M8 21H5a2 2 0 0 1-2-2v-3"/><path d="M16 21h3a2 2 0 0 0 2-2v-3"/>
      </svg>
      <svg id="icon-min" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" style="display:none">
        <path d="M8 3v3a2 2 0 0 1-2 2H3"/><path d="M21 8h-3a2 2 0 0 1-2-2V3"/>
        <path d="M3 16h3a2 2 0 0 1 2 2v3"/><path d="M16 21v-3a2 2 0 0 1 2-2h3"/>
      </svg>
    </button>
  </div>

  <div id="controls">
    <button id="btn-play">播放 / 暂停</button>
    <div class="url-row">
      <input id="url-input" type="url" placeholder="输入视频地址 (mp4/m3u8直链)">
      <button id="btn-load">加载</button>
    </div>
    <div id="status">就绪</div>
  </div>
</div>

<script>
(function () {
  var wrap = document.getElementById('player-wrap');
  var video = document.getElementById('video');
  var btnFs = document.getElementById('btn-fullscreen');
  var btnPlay = document.getElementById('btn-play');
  var btnLoad = document.getElementById('btn-load');
  var urlInput = document.getElementById('url-input');
  var status = document.getElementById('status');
  var iconMax = document.getElementById('icon-max');
  var iconMin = document.getElementById('icon-min');

  function setStatus(msg) { status.textContent = msg; }

  function isFullscreen() {
    return !!(document.fullscreenElement || document.webkitFullscreenElement ||
              document.webkitCurrentFullScreenElement);
  }

  function updateIcon() {
    var fs = isFullscreen();
    iconMax.style.display = fs ? 'none' : '';
    iconMin.style.display = fs ? '' : 'none';
  }

  // 最大化 / 退出全屏（兼容 iOS Safari 的 video 原生全屏）
  btnFs.addEventListener('click', function () {
    if (isFullscreen()) {
      if (document.exitFullscreen) document.exitFullscreen();
      else if (document.webkitExitFullscreen) document.webkitExitFullscreen();
      else if (video.webkitExitFullscreen) video.webkitExitFullscreen();
      return;
    }
    if (wrap.requestFullscreen) {
      wrap.requestFullscreen();
    } else if (wrap.webkitRequestFullscreen) {
      wrap.webkitRequestFullscreen();
    } else if (video.webkitEnterFullscreen) {
      // iOS Safari: 只对 video 元素有效
      video.webkitEnterFullscreen();
    } else {
      setStatus('当前环境不支持全屏 API');
    }
  });

  ['fullscreenchange', 'webkitfullscreenchange'].forEach(function (ev) {
    document.addEventListener(ev, updateIcon);
  });
  video.addEventListener('webkitendfullscreen', updateIcon);

  // 播放 / 暂停
  btnPlay.addEventListener('click', function () {
    if (video.paused) video.play().catch(function (e) { setStatus('播放失败: ' + e.message); });
    else video.pause();
  });

  // 加载自定义地址
  btnLoad.addEventListener('click', function () {
    var url = urlInput.value.trim();
    if (!url) { setStatus('请输入视频地址'); return; }
    video.src = url;
    video.load();
    video.play().catch(function () {});
    setStatus('已加载: ' + url);
  });

  // 状态反馈
  video.addEventListener('playing', function () { setStatus('播放中 ' + video.videoWidth + 'x' + video.videoHeight); });
  video.addEventListener('pause', function () { setStatus('已暂停'); });
  video.addEventListener('error', function () {
    var err = video.error;
    setStatus('加载出错: ' + (err ? 'code ' + err.code : '未知错误'));
  });
  video.addEventListener('ended', function () { setStatus('播放结束'); });
})();
</script>
</body>
</html>

HTML打包APK实现拍照、录像、录音和文件选择

Sat, 08 Aug 2026 20:44:05 +0800

HTML页面可以通过文件选择控件和浏览器媒体接口调用安卓设备的相机、摄像头、麦克风及文件选择器。完成页面代码后，再通过HTML一键打包APK工具配置相机和麦克风权限，即可生成支持拍照、录像、录音和文件选择的安卓APP。

如果你不了解HTML打包APK工具，想要进一步了解，可以查看官网：

HTML一键打包APK工具官网

创建文件采集页面

在HTML项目入口目录中创建 index.html，加入拍摄照片、录制视频、录制音频和选择文件四个入口。

拍摄照片：调用设备相机并优先进入后置摄像头拍照页面。
录制视频：调用设备摄像头并进入视频录制页面。
录制音频：申请麦克风权限，在网页内录制音频并生成可下载的音频文件。
选择文件：打开系统文件选择界面，并支持一次选择多个文件。也可以选择相机进行拍照或者录频

一个完整的html示例代码如下：

<!doctype html>
<html lang="zh-CN">
<head>
  <meta charset="utf-8">
  <meta name="viewport" content="width=device-width, initial-scale=1, viewport-fit=cover">
  <meta name="theme-color" content="#f4f1ea">
  <title>移动端文件采集</title>
  <style>
    :root {
      color-scheme: light;
      --ink: #18201d;
      --muted: #65706b;
      --paper: #f4f1ea;
      --surface: #fffdf8;
      --line: #d8d5cd;
      --green: #18634b;
      --green-dark: #104b39;
      --coral: #e56f51;
      --shadow: 0 12px 32px rgba(24, 32, 29, 0.09);
    }

    * {
      box-sizing: border-box;
      letter-spacing: 0;
    }

    body {
      min-width: 320px;
      min-height: 100vh;
      margin: 0;
      color: var(--ink);
      background:
        linear-gradient(rgba(24, 99, 75, 0.055) 1px, transparent 1px),
        linear-gradient(90deg, rgba(24, 99, 75, 0.055) 1px, transparent 1px),
        var(--paper);
      background-size: 24px 24px;
      font-family: "Noto Sans SC", "Microsoft YaHei UI", sans-serif;
    }

    button,
    input {
      font: inherit;
    }

    [hidden] {
      display: none !important;
    }

    .shell {
      width: min(100%, 560px);
      min-height: 100vh;
      margin: 0 auto;
      padding: max(24px, env(safe-area-inset-top)) 18px max(32px, env(safe-area-inset-bottom));
    }

    header {
      position: relative;
      padding: 12px 4px 25px;
    }

    header::after {
      position: absolute;
      right: 4px;
      bottom: 18px;
      width: 52px;
      height: 5px;
      background: var(--coral);
      content: "";
      transform: rotate(-3deg);
    }

    .eyebrow {
      margin: 0 0 8px;
      color: var(--green);
      font-size: 12px;
      font-weight: 800;
      text-transform: uppercase;
    }

    h1 {
      margin: 0;
      font-family: "STSong", "SimSun", serif;
      font-size: clamp(32px, 10vw, 48px);
      font-weight: 700;
      line-height: 1.08;
    }

    .subtitle {
      max-width: 360px;
      margin: 12px 0 0;
      color: var(--muted);
      font-size: 14px;
      line-height: 1.7;
    }

    .actions {
      display: grid;
      grid-template-columns: repeat(2, minmax(0, 1fr));
      gap: 10px;
    }

    .picker {
      position: relative;
      min-width: 0;
      min-height: 132px;
      overflow: hidden;
      border: 1px solid var(--line);
      border-radius: 8px;
      background: var(--surface);
      box-shadow: 0 4px 12px rgba(24, 32, 29, 0.035);
    }

    .picker:focus-within {
      outline: 3px solid rgba(24, 99, 75, 0.2);
      outline-offset: 2px;
    }

    .picker input {
      position: absolute;
      width: 1px;
      height: 1px;
      opacity: 0;
      pointer-events: none;
    }

    .picker label {
      display: flex;
      width: 100%;
      min-height: 132px;
      padding: 17px;
      cursor: pointer;
      flex-direction: column;
      justify-content: space-between;
      -webkit-tap-highlight-color: transparent;
    }

    .picker-button {
      display: flex;
      width: 100%;
      min-height: 132px;
      padding: 17px;
      border: 0;
      color: inherit;
      background: transparent;
      cursor: pointer;
      flex-direction: column;
      justify-content: space-between;
      text-align: left;
      -webkit-tap-highlight-color: transparent;
    }

    .picker label:active,
    .picker-button:active {
      background: #f2f7f3;
    }

    .icon {
      display: grid;
      width: 42px;
      height: 42px;
      border-radius: 50%;
      color: #fff;
      background: var(--green);
      font-size: 20px;
      place-items: center;
    }

    .picker:nth-child(2) .icon,
    .picker:nth-child(4) .icon {
      background: var(--coral);
    }

    .label-title {
      display: block;
      margin-bottom: 4px;
      font-size: 16px;
      font-weight: 800;
    }

    .label-meta {
      display: block;
      overflow: hidden;
      color: var(--muted);
      font-size: 11px;
      text-overflow: ellipsis;
      white-space: nowrap;
    }

    .result {
      margin-top: 18px;
      overflow: hidden;
      border: 1px solid var(--line);
      border-radius: 8px;
      background: var(--surface);
      box-shadow: var(--shadow);
      animation: rise 240ms ease-out;
    }

    .result-header {
      display: flex;
      min-height: 52px;
      padding: 12px 14px;
      border-bottom: 1px solid var(--line);
      align-items: center;
      justify-content: space-between;
      gap: 12px;
    }

    .result-header h2 {
      margin: 0;
      font-size: 15px;
    }

    .clear {
      width: 34px;
      height: 34px;
      padding: 0;
      border: 1px solid var(--line);
      border-radius: 50%;
      color: var(--ink);
      background: transparent;
      cursor: pointer;
      font-size: 20px;
      line-height: 1;
    }

    .file-list {
      margin: 0;
      padding: 0;
      list-style: none;
    }

    .file-list li {
      display: flex;
      gap: 8px;
      min-height: 68px;
      padding: 10px 14px;
      border-top: 1px solid var(--line);
      align-items: center;
      font-size: 12px;
    }

    .file-list li:first-child {
      border-top: 0;
    }

    .file-info {
      min-width: 0;
      flex: 1;
    }

    .file-name {
      display: block;
      overflow: hidden;
      font-weight: 700;
      text-overflow: ellipsis;
      white-space: nowrap;
    }

    .file-size {
      display: block;
      margin-top: 4px;
      color: var(--muted);
    }

    .download-button {
      min-width: 76px;
      min-height: 40px;
      padding: 0 12px;
      border: 1px solid var(--green);
      border-radius: 6px;
      color: #fff;
      background: var(--green);
      cursor: pointer;
      font-weight: 800;
      flex-shrink: 0;
    }

    .recorder {
      margin-top: 18px;
      padding: 18px;
      border: 1px solid var(--line);
      border-radius: 8px;
      background: var(--surface);
      box-shadow: var(--shadow);
    }

    .recorder h2 {
      margin: 0 0 6px;
      font-size: 18px;
    }

    .recorder-status {
      min-height: 42px;
      margin: 0 0 14px;
      color: var(--muted);
      font-size: 13px;
      line-height: 1.6;
    }

    .recorder-controls {
      display: grid;
      grid-template-columns: 1fr 1fr;
      gap: 10px;
    }

    .recorder-controls button,
    .audio-fallback {
      min-height: 46px;
      border: 1px solid var(--green);
      border-radius: 6px;
      color: #fff;
      background: var(--green);
      cursor: pointer;
      font-weight: 800;
    }

    .recorder-controls button:disabled {
      cursor: not-allowed;
      opacity: 0.45;
    }

    .audio-fallback {
      display: grid;
      margin-top: 10px;
      border-color: var(--line);
      color: var(--ink);
      background: transparent;
      font-size: 13px;
      place-items: center;
    }

    @keyframes rise {
      from { opacity: 0; transform: translateY(8px); }
      to { opacity: 1; transform: translateY(0); }
    }

    @media (min-width: 480px) {
      .shell { padding-inline: 26px; }
      .picker label { min-height: 144px; }
    }

    @media (prefers-reduced-motion: reduce) {
      .result { animation: none; }
    }
  </style>
</head>
<body>
  <main class="shell">
    <header>
      <p class="eyebrow">Mobile capture lab</p>
      <h1>从设备中采集文件</h1>
      <p class="subtitle">点击一种方式，系统会打开对应的拍摄、录制或文件选择界面。</p>
    </header>

    <section class="actions" aria-label="文件采集方式">
      <div class="picker">
        <input id="camera" type="file" accept="image/*" capture="environment">
        <label for="camera">
          <span class="icon" aria-hidden="true">●</span>
          <span><span class="label-title">拍摄照片</span><span class="label-meta">设备后置相机</span></span>
        </label>
      </div>

      <div class="picker">
        <input id="video" type="file" accept="video/*" capture="environment">
        <label for="video">
          <span class="icon" aria-hidden="true">▶</span>
          <span><span class="label-title">录制视频</span><span class="label-meta">设备摄像头</span></span>
        </label>
      </div>

      <div class="picker">
        <button id="openRecorder" class="picker-button" type="button">
          <span class="icon" aria-hidden="true">♪</span>
          <span><span class="label-title">录制音频</span><span class="label-meta">设备麦克风</span></span>
        </button>
      </div>

      <div class="picker">
        <input id="files" type="file" multiple>
        <label for="files">
          <span class="icon" aria-hidden="true">＋</span>
          <span><span class="label-title">选择文件</span><span class="label-meta">支持多选</span></span>
        </label>
      </div>
    </section>

    <section id="recorder" class="recorder" aria-live="polite" hidden>
      <h2>麦克风录音</h2>
      <p id="recorderStatus" class="recorder-status">点击“开始录音”，并允许浏览器使用麦克风。</p>
      <div class="recorder-controls">
        <button id="startRecording" type="button">开始录音</button>
        <button id="stopRecording" type="button" disabled>停止并使用</button>
      </div>
      <input id="audioFallback" type="file" accept="audio/*" hidden>
      <label class="audio-fallback" for="audioFallback">无法录音？选择已有音频</label>
    </section>

    <section id="result" class="result" aria-live="polite" hidden>
      <div class="result-header">
        <h2 id="resultTitle">处理完成</h2>
        <button id="clearButton" class="clear" type="button" aria-label="清除选择" title="清除选择">×</button>
      </div>
      <ul id="fileList" class="file-list"></ul>
    </section>
  </main>

  <script>
    const inputs = document.querySelectorAll('input[type="file"]');
    const result = document.getElementById('result');
    const resultTitle = document.getElementById('resultTitle');
    const fileList = document.getElementById('fileList');
    const clearButton = document.getElementById('clearButton');
    const openRecorder = document.getElementById('openRecorder');
    const recorderPanel = document.getElementById('recorder');
    const recorderStatus = document.getElementById('recorderStatus');
    const startRecording = document.getElementById('startRecording');
    const stopRecording = document.getElementById('stopRecording');
    let activeInput = null;
    let microphoneStream = null;
    let recordingAudioContext = null;
    let recordingSource = null;
    let recordingProcessor = null;
    let recordingGain = null;
    let pcmChunks = [];
    let pcmSampleCount = 0;
    let isRecording = false;
    let recordingTimer = null;
    let recordingStartedAt = 0;

    function formatSize(bytes) {
      if (bytes === 0) return '0 B';
      const units = ['B', 'KB', 'MB', 'GB'];
      const unitIndex = Math.min(Math.floor(Math.log(bytes) / Math.log(1024)), units.length - 1);
      return `${(bytes / (1024 ** unitIndex)).toFixed(unitIndex ? 1 : 0)} ${units[unitIndex]}`;
    }

    function clearSelection() {
      if (activeInput) activeInput.value = '';
      activeInput = null;
      fileList.replaceChildren();
      result.hidden = true;
    }

    function downloadFile(file) {
      const reader = new FileReader();
      reader.addEventListener('load', () => {
        const link = document.createElement('a');
        link.href = reader.result;
        link.download = file.name || `文件_${Date.now()}`;
        document.body.appendChild(link);
        link.click();
        document.body.removeChild(link);
      });
      reader.addEventListener('error', () => {
        resultTitle.textContent = '下载失败，请重试';
      });
      reader.readAsDataURL(file);
    }

    function displayFiles(files, input = null) {
      if (!files.length) return;
      if (activeInput && activeInput !== input) activeInput.value = '';
      activeInput = input;
      resultTitle.textContent = files.length > 1 ? `${files.length} 个文件处理完成` : '处理完成';
      fileList.replaceChildren(...files.map((file) => {
        const item = document.createElement('li');
        const info = document.createElement('span');
        const name = document.createElement('span');
        const size = document.createElement('span');
        const downloadButton = document.createElement('button');
        info.className = 'file-info';
        name.className = 'file-name';
        name.textContent = file.name;
        size.className = 'file-size';
        size.textContent = formatSize(file.size);
        downloadButton.className = 'download-button';
        downloadButton.type = 'button';
        downloadButton.textContent = '↓ 下载';
        downloadButton.addEventListener('click', () => downloadFile(file));
        info.append(name, size);
        item.append(info, downloadButton);
        return item;
      }));
      result.hidden = false;
      result.scrollIntoView({ behavior: 'smooth', block: 'nearest' });
    }

    function stopMicrophone() {
      if (recordingTimer) clearInterval(recordingTimer);
      recordingTimer = null;
      isRecording = false;
      if (recordingProcessor) recordingProcessor.disconnect();
      if (recordingSource) recordingSource.disconnect();
      if (recordingGain) recordingGain.disconnect();
      recordingProcessor = null;
      recordingSource = null;
      recordingGain = null;
      if (microphoneStream) microphoneStream.getTracks().forEach((track) => track.stop());
      microphoneStream = null;
      if (recordingAudioContext && recordingAudioContext.state !== 'closed') {
        recordingAudioContext.close().catch(() => {});
      }
      recordingAudioContext = null;
    }

    function createWavFile(chunks, sampleCount, sampleRate) {
      const buffer = new ArrayBuffer(44 + sampleCount * 2);
      const view = new DataView(buffer);

      function writeText(offset, text) {
        for (let index = 0; index < text.length; index += 1) {
          view.setUint8(offset + index, text.charCodeAt(index));
        }
      }

      writeText(0, 'RIFF');
      view.setUint32(4, 36 + sampleCount * 2, true);
      writeText(8, 'WAVE');
      writeText(12, 'fmt ');
      view.setUint32(16, 16, true);
      view.setUint16(20, 1, true);
      view.setUint16(22, 1, true);
      view.setUint32(24, sampleRate, true);
      view.setUint32(28, sampleRate * 2, true);
      view.setUint16(32, 2, true);
      view.setUint16(34, 16, true);
      writeText(36, 'data');
      view.setUint32(40, sampleCount * 2, true);

      let offset = 44;
      chunks.forEach((chunk) => {
        for (let index = 0; index < chunk.length; index += 1) {
          const sample = Math.max(-1, Math.min(1, chunk[index]));
          view.setInt16(offset, sample < 0 ? sample * 0x8000 : sample * 0x7fff, true);
          offset += 2;
        }
      });

      return new File([buffer], `recording-${Date.now()}.wav`, { type: 'audio/wav' });
    }

    inputs.forEach((input) => {
      input.addEventListener('change', () => {
        const files = Array.from(input.files || []);
        displayFiles(files, input);
      });
    });

    openRecorder.addEventListener('click', () => {
      recorderPanel.hidden = false;
      recorderPanel.scrollIntoView({ behavior: 'smooth', block: 'nearest' });
    });

    startRecording.addEventListener('click', async () => {
      const AudioContextClass = window.AudioContext || window.webkitAudioContext;
      if (!navigator.mediaDevices?.getUserMedia || !AudioContextClass) {
          recorderStatus.textContent = '当前浏览器不支持网页录音，请使用下方按钮选择已有音频。';
        return;
      }

      try {
        microphoneStream = await navigator.mediaDevices.getUserMedia({
          audio: { channelCount: 1, echoCancellation: true, noiseSuppression: true }
        });
        recordingAudioContext = new AudioContextClass();
        await recordingAudioContext.resume();
        recordingSource = recordingAudioContext.createMediaStreamSource(microphoneStream);
        recordingProcessor = recordingAudioContext.createScriptProcessor(4096, 1, 1);
        recordingGain = recordingAudioContext.createGain();
        recordingGain.gain.value = 0;
        pcmChunks = [];
        pcmSampleCount = 0;
        isRecording = true;
        recordingProcessor.onaudioprocess = (event) => {
          if (!isRecording) return;
          const samples = new Float32Array(event.inputBuffer.length);
          event.inputBuffer.copyFromChannel(samples, 0);
          pcmChunks.push(samples);
          pcmSampleCount += samples.length;
        };
        recordingSource.connect(recordingProcessor);
        recordingProcessor.connect(recordingGain);
        recordingGain.connect(recordingAudioContext.destination);
        recordingStartedAt = Date.now();
        recorderStatus.textContent = '正在录音 00:00';
        recordingTimer = setInterval(() => {
          const elapsed = Math.floor((Date.now() - recordingStartedAt) / 1000);
          const minutes = String(Math.floor(elapsed / 60)).padStart(2, '0');
          const seconds = String(elapsed % 60).padStart(2, '0');
          recorderStatus.textContent = `正在录音 ${minutes}:${seconds}`;
        }, 1000);
        startRecording.disabled = true;
        stopRecording.disabled = false;
      } catch (error) {
        stopMicrophone();
        const insecure = !window.isSecureContext;
        recorderStatus.textContent = insecure
          ? '浏览器只允许 HTTPS 页面使用麦克风，请通过 HTTPS 打开本页。'
          : '未能使用麦克风，请检查浏览器的网站麦克风权限。';
      }
    });

    stopRecording.addEventListener('click', () => {
      if (!isRecording || !recordingAudioContext || !pcmSampleCount) return;
      isRecording = false;
      const sampleRate = recordingAudioContext.sampleRate;
      const duration = pcmSampleCount / sampleRate;
      const recording = createWavFile(pcmChunks, pcmSampleCount, sampleRate);
      stopMicrophone();
      displayFiles([recording]);
      recorderStatus.textContent = `录音处理完成（${duration.toFixed(1)} 秒），可在下方下载。`;
      startRecording.disabled = false;
      stopRecording.disabled = true;
    });

    clearButton.addEventListener('click', clearSelection);
    window.addEventListener('pagehide', () => {
      stopMicrophone();
    });
  </script>
</body>
</html>

页面中的拍照和录像入口可以分别使用带有 capture 属性的文件控件。拍照入口设置 accept="image/*"，录像入口设置 accept="video/*"，安卓APP会根据文件类型打开对应的系统采集页面。

拍摄照片：

<input type="file" accept="image/*" capture="environment" />

录制视频：

<input type="file" accept="video/*" capture="environment" />

音频录制可以通过 navigator.mediaDevices.getUserMedia() 获取麦克风音频流，再使用浏览器音频接口处理并生成音频文件。普通文件入口不设置 capture，因此会保留系统提供的文件、照片和视频选择方式。

打包APK并配置权限

打开HTML一键打包APK工具，选择包含 index.html 的项目目录，填写应用名称、包名等打包信息。

在权限设置中勾选“相机权限”和“麦克风权限”：

相机权限用于拍摄照片、录制视频以及网页调用摄像头。
麦克风权限用于网页录音；录制带声音的视频时也需要该权限。
普通文件选择通过安卓系统文件选择器完成，用户只会授权当前选择的文件。

确认配置后开始打包，等待工具生成APK文件。

安装并测试功能

将生成的APK安装到安卓手机，依次测试页面中的四个入口：

点击“拍摄照片”，确认APP直接打开相机拍照页面。
点击“录制视频”，确认APP直接打开视频录制页面，并且能够正常保存视频。
点击“录制音频”，首次使用时允许APP访问麦克风，停止录音后确认页面能够显示并下载录音文件。
点击“选择文件”，确认系统文件选择界面正常打开，并且可以选择一个或多个文件。

不同品牌手机使用的相机和文件管理应用可能不同，因此系统界面的样式会有差异。capture 属性用于告诉安卓当前需要拍照还是录像，但最终的采集界面由手机系统和默认相机应用提供。

如果拍照或录像入口没有打开对应页面，请先检查APP的相机权限；如果网页无法开始录音，请检查麦克风权限。对于在线页面，网页录音通常还要求通过HTTPS加载；打包到APP内的本地页面则由WebView和APP权限共同控制。

HTML项目打包APK：二维码扫码功能实现

Fri, 07 Aug 2026 21:26:06 +0800

在HTML项目中，可以使用 html5-qrcode 调用手机摄像头并识别二维码。完成页面代码后，再通过HTML一键打包APK工具勾选相机权限，即可生成支持扫码的安卓APP。

如果你不了解HTML打包APK工具, 想要进一步了解, 可以查看官网:

HTML一键打包APK工具官网

创建扫码页面

在HTML项目入口目录中创建 index.html，写入以下代码。页面点击“开始扫码”后会申请摄像头权限，识别成功时停止摄像头并显示二维码内容。

<!doctype html>
<html lang="zh-CN">
    <head>
        <meta charset="UTF-8" />
        <meta name="viewport" content="width=device-width, initial-scale=1, viewport-fit=cover" />
        <title>二维码扫码</title>
        <script src="https://unpkg.com/html5-qrcode@2.3.8/html5-qrcode.min.js"></script>
        <style>
            * {
                box-sizing: border-box;
            }

            body {
                min-height: 100vh;
                margin: 0;
                padding: 20px;
                display: grid;
                place-items: center;
                font-family: 'Microsoft YaHei', sans-serif;
                background: #f4f7f5;
                color: #17221c;
            }

            main {
                width: min(100%, 440px);
            }

            h1 {
                margin: 0 0 8px;
                font-size: 30px;
            }

            p {
                margin: 0 0 18px;
                color: #526159;
            }

            #reader {
                width: 100%;
                min-height: 280px;
                overflow: hidden;
                border: 1px solid #cad4ce;
                border-radius: 8px;
                background: #101511;
            }

            #reader video {
                object-fit: cover;
            }

            .actions {
                display: grid;
                grid-template-columns: 1fr 1fr;
                gap: 10px;
                margin-top: 14px;
            }

            button {
                min-height: 48px;
                border: 0;
                border-radius: 6px;
                padding: 0 16px;
                font: inherit;
                font-weight: 700;
            }

            #startButton {
                background: #197447;
                color: white;
            }

            #stopButton {
                background: #dfe6e2;
                color: #26352d;
            }

            button:disabled {
                opacity: 0.5;
            }

            #status {
                min-height: 24px;
                margin-top: 12px;
                font-size: 14px;
                color: #526159;
            }
        </style>
    </head>
    <body>
        <main>
            <h1>二维码扫码</h1>
            <p>点击开始后，将摄像头对准二维码。</p>
            <div id="reader" aria-label="摄像头扫码区域"></div>
            <div class="actions">
                <button id="startButton" type="button">开始扫码</button>
                <button id="stopButton" type="button" disabled>停止扫码</button>
            </div>
            <div id="status" role="status">等待开始</div>
        </main>

        <script>
            const reader = new Html5Qrcode('reader');
            const startButton = document.getElementById('startButton');
            const stopButton = document.getElementById('stopButton');
            const status = document.getElementById('status');
            let isScanning = false;
            let resultHandled = false;

            async function stopScanning() {
                if (!isScanning) return;

                await reader.stop();
                isScanning = false;
                startButton.disabled = false;
                stopButton.disabled = true;
                status.textContent = '扫码已停止';
            }

            async function startScanning() {
                startButton.disabled = true;
                status.textContent = '正在请求摄像头权限...';
                resultHandled = false;

                try {
                    await reader.start(
                        { facingMode: 'environment' },
                        { fps: 10, qrbox: { width: 240, height: 240 } },
                        async decodedText => {
                            if (resultHandled) return;
                            resultHandled = true;
                            await stopScanning();
                            alert(decodedText);
                        },
                        () => {}
                    );

                    isScanning = true;
                    stopButton.disabled = false;
                    status.textContent = '正在扫描...';
                } catch (error) {
                    startButton.disabled = false;
                    status.textContent = '无法打开摄像头，请检查相机权限。';
                    console.error(error);
                }
            }

            startButton.addEventListener('click', startScanning);
            stopButton.addEventListener('click', () => {
                stopScanning().catch(console.error);
            });

            window.addEventListener('pagehide', () => {
                if (isScanning) reader.stop().catch(() => {});
            });
        </script>
    </body>
</html>

示例通过 CDN 加载 html5-qrcode。如果APP需要完全离线运行，请提前下载 html5-qrcode.min.js 放入项目目录，并将页面中的脚本地址改为本地相对路径。

打包APK并勾选相机权限

打开HTML一键打包APK工具，选择包含 index.html 的项目目录，填写应用名称、包名等打包信息。在权限设置中勾选“相机权限”，否则APP无法调用手机摄像头。

确认配置后开始打包，等待工具生成APK文件。

安装并测试扫码

将生成的APK安装到安卓手机。首次点击“开始扫码”时，系统会弹出相机授权提示，选择允许后，将摄像头对准二维码。识别成功后，页面会停止扫描并弹出二维码中的文字或链接。

如果页面提示无法打开摄像头，请先在手机的应用权限设置中确认相机权限已经允许。扫码页面使用 CDN 脚本时，还需要确保手机能够正常访问网络；改用本地脚本后则不受此限制。

C#混淆选项选择指南：恒盾加密大师详解

Tue, 04 Aug 2026 19:56:39 +0800

恒盾C#混淆加密大师提供了基本保护、垃圾代码注入、代码混淆和重命名等多类选项。这些功能面向不同的攻击场景：部分用于阻止调试和反编译工具；另一些增加反编译代码理解难度；还有直接改变类型、函数和字段的命名。

实际选用时，无需不加区分地启用全部选项。更合理的做法是先理解每类功能的作用域，再根据项目类型（DLL、控制台程序、WinForms、WPF等）逐步启用，并在每次调整后完成启动和核心功能测试。

官方网址

四类混淆选项分别解决什么问题

软件中的选项可划分为四类：

基本保护选项：针对调试器、反编译工具、程序篡改和虚拟机运行环境进行防护。
注入功能选项：向程序集注入无用字段、指令、函数、类型或字符串，增加静态分析干扰。
混淆功能选项：改变代码、数据或程序集结构，使反编译结果更难还原。
重命名选项：修改Module、字段、函数、命名空间、参数、类型和Assembly等标识符。

这四类功能可以灵活组合：重命名负责降低代码可读性；字符串和流程类选项保护关键逻辑；基本保护针对常见分析工具和运行环境形成额外防线。

基本保护选项

基本保护主要面向调试、反编译、篡改和运行环境检测。部分功能在检测到特定行为时会终止程序，因此启用后需在目标用户真实环境中测试。

防调试、防DnSpy与防断点

防调试：检测Visual Studio或其他调试工具附加行为，发现后自动退出。
防DnSpy：针对DnSpy动态调试检测，发现后退出。
防断点：检测程序运行中异常超长停顿，防止通过断点跟踪代码。

这三个选项与运行时分析相关，适合保护授权校验、关键算法和商业逻辑。由于性能较弱的设备或特殊环境可能影响检测效果，建议先在测试版启用，再覆盖不同配置设备验证。

防ILDasm、防ILSpy与防de4dot

防ILDasm：阻止系统ILDasm正常反编译处理后的DLL或EXE。
防ILSpy：让处理后程序集无法被ILSpy正常解析。
防de4dot：干扰de4dot自动反混淆。

这组功能用于阻止常见静态分析和自动还原工具。可与重命名、流程混淆、字符串加密搭配，让分析者难以打开程序集，也难以理解已反编译代码。

防篡改与加壳

防篡改（仅限EXE）：校验EXE是否被修改，改动后无法运行。
加壳（仅限EXE）：加密原生程序到外层EXE，避免静态反编译。

仅适用于EXE。防篡改适合需保证文件完整性的桌面程序；加壳适合整体隐藏原始程序集。处理后需检查数字签名、杀毒兼容性及更新流程。

防虚拟机

防虚拟机检测程序是否运行在虚拟机中，检测到后停止运行。适合禁止虚拟机运行的应用，但不适合云桌面、虚拟化服务器、自动化测试或沙箱环境。启用前需确认用户部署环境，若正常客户可能使用VMware、Hyper-V等，建议谨慎。

注入功能选项

注入功能通过增加干扰内容，让反编译后程序集结构更复杂，而非替代关键代码加密。

垃圾域、垃圾函数与垃圾类型

垃圾域：向类型中注入大量无用字段。
垃圾函数：注入不参与业务的函数。
垃圾类型：注入额外类型。

这些选项让反编译工具显示更多成员和类型，增加定位真实业务代码的难度。对体积敏感项目需比较处理前后文件大小和加载表现。

垃圾空指令与垃圾字符串

垃圾空指令：在IL指令中注入无用指令，增加阅读难度。
垃圾字符串：注入无用字符串，干扰基于字符串搜索的定位。

垃圾空指令适合配合流程混淆；垃圾字符串干扰接口地址、提示文本或关键字检索。主要增加分析成本。

混淆功能选项

混淆功能处理程序集信息、代码流程、常量、调用关系等。一些选项影响较大，建议从常用选项开始逐步增加强度。

程序集与文件结构混淆

文件信息混淆：修改程序内部名称、Assembly信息。
文件时间混淆：修改加密文件时间戳。
DOS头混淆：修改EXE的DOS头，去除常见可识别字符串。
混淆引用列表：处理程序集引用列表，使依赖关系更模糊。
加密资源文件：加密程序集中的资源，防止直接查看。

若程序依赖程序集名称、文件版本、反射、插件扫描或资源加载路径，需重点验证。加密资源文件还需测试图片、语言资源等能否正常读取。

流程与函数调用混淆

流程混淆：打乱函数内部指令并增加跳转，使控制流程难以理解。
函数调用混淆：通过函数token调用目标函数，降低可读性。
链式函数混淆：将一次调用转为多层嵌套调用，增加分析难度。
异步混淆：将部分代码转换为异步调用形式，使静态跟踪更困难。
错误函数体混淆：加入错误指令，干扰静态分析工具解析函数体。

流程混淆是核心算法保护的首选。函数调用、链式和异步混淆进一步改变结构，适合不依赖特殊调用顺序的业务代码。对UI线程、启动入口、COM调用、反射调用等需逐项测试。

字符串保护

字符串加密：加密字符串，避免静态分析直接找到关键文本。
字符串拆分：将完整字符串拆成多个组合，降低搜索效率。
字符串隐藏：加密后存放到原生函数，使反编译工具无法获取值。

字符串加密适合保护接口地址、协议字段、算法参数；拆分可干扰简单检索；隐藏强度更高，适合少量重要字符串。配置文件中的密码、令牌需用专门密钥管理方案。

数字、布尔值与小数保护

布尔混淆：将布尔值转为更难识别的基础类型表达。
数字混淆：将整型数字转化为复杂运算，隐藏常量。
数字隐藏：将整型数字加密存放到原生函数。
小数混淆：加密代码中的小数，避免直接看到原始值。

适合保护算法常量、状态标识、限制数值和业务参数。与流程混淆配合，静态分析难度更高。涉及浮点精度或高频计算的代码需重点验证。

函数体隐藏与原生化EXE

函数体隐藏：加密函数体，使反编译工具无法查看内部代码。
原生化EXE：将EXE转为原生程序，C#反编译工具无法分析IL。

适合保护核心实现。函数体隐藏可加强保护重要算法；原生化EXE从整体改变程序形态，仅适用于EXE。启用后需完整测试启动、异常处理、依赖加载等。

重命名选项

重命名是C#混淆中最直观的保护，将具有业务含义的标识符替换为难以理解的新名称，移除语义。

重命名模式怎么选

软件提供五种模式：

字母数字模式：字母数字组合，适合常规项目。
UUID模式：长名称，增加阅读和检索难度。
特殊字符模式：使用特殊字符，适合更高阅读干扰。
Base64模式：Base64风格字符串。
英文单词模式：英文单词替换，表面可读但失去真实含义。

不同模式影响外观，不改变勾选对象。日常可从字母数字模式开始；若外部工具或日志系统对字符有限制，避免使用特殊字符模式。

可以重命名哪些对象

Module重命名：修改全局Module名称。
域重命名：修改类中字段名称。
函数重命名：修改方法名称。
命名空间重命名：修改类型所在命名空间。
参数重命名：修改函数参数名称。
类型重命名：修改类、结构体等类型名称。
Assembly重命名：修改程序集名称。

普通内部代码可优先启用字段、函数、参数和类型重命名。涉及反射、依赖注入、序列化、XAML等时，名称可能是运行时契约，需先确认。Assembly重命名影响依赖程序集、插件加载等，处理多个DLL时需验证引用解析。

不同项目可以怎样组合

普通桌面程序

先启用函数、字段、参数和类型重命名，加入字符串加密、数字混淆和流程混淆。确认功能正常后，再根据需要增加防调试、防ILSpy、防DnSpy或加壳。

供第三方调用的类库

优先保护内部类型和实现。公开API、反射入口、序列化模型需谨慎重命名，否则可能导致调用方无法找到成员。字符串加密、流程混淆和函数体隐藏可保护不对外暴露的核心逻辑。

包含重要算法的EXE

组合流程混淆、字符串隐藏、数字隐藏、函数调用混淆和函数体隐藏。完成兼容性测试后，考虑加壳、防篡改或原生化EXE。高强度选项应逐项增加并保留测试结果。

使用时需要注意什么

保护强度越高并不代表越适合所有项目，稳定运行是前提。
依赖反射、序列化、XAML、插件机制等项目，需重点测试重命名兼容性。
防篡改、加壳和原生化EXE仅限EXE，不能用于DLL。
防虚拟机可能影响云桌面、虚拟化服务器中的正常用户。
处理后文件应在目标操作系统、架构和性能配置上验证。
混淆用于提高逆向成本，不能替代权限控制、签名校验、密钥管理和服务端安全。

总结

恒盾C#混淆加密大师各类选项承担不同作用：基本保护应对调试和反编译工具；注入功能增加干扰；混淆功能隐藏代码流程和关键数据；重命名移除业务语义。

对多数项目，可从重命名、字符串加密、数字混淆和流程混淆开始，再根据程序类型增加防调试、工具防护、函数体隐藏、加壳或原生化EXE。逐步启用、逐步测试，在保护强度和兼容性之间取得平衡。

C#混淆随机种子的作用与使用教程

Mon, 03 Aug 2026 21:31:19 +0800

在混淆 C# 应用时，很多开发者会发现，即使输入文件和配置一模一样，每次生成的结果也可能不同。这是因为恒盾C#混淆加密大师默认引入了随机性，避免每次构建都产生完全相同的结果。但在某些场景下——比如排查问题、做回归测试、或者对接 CI/CD 流程——我们反而希望结果是可复现的，以便对比和定位。

这时，随机种子就派上用场了。它本质上是一个控制混淆过程随机行为的开关。填上一个固定的值后，对于同一个 EXE 或 DLL，在配置完全一致的情况下，每次处理都会得到相同的结果；如果不填，软件就会自动随机处理，保持构建之间的差异。

随机种子有什么作用

随机种子让开发者可以在“可复现的结果”和“每次结果随机”之间灵活选择。

填写固定种子：适用于重复构建、对比结果、排查问题，或者需要保持发布流程一致。
留空不填：软件自动随机，适用于希望不同构建产生不同混淆结果的日常发布。

需要特别注意：随机种子不会改变你启用了哪些保护功能，也不会替代字符串加密、流程混淆或重命名。它只影响结果是否容易复现。

哪些场景适合设置固定种子

1. 排查混淆后的运行问题

如果程序在混淆后出现异常，保留输入文件、配置和随机种子，重新处理一次。固定种子能减少重复测试时的结果差异，让问题更容易定位。

2. 进行版本回归测试

在同一个版本上反复验证启动、登录、授权、读写等核心功能时，固定种子可以提供更稳定的测试条件，方便对比不同保护选项的效果。

3. 接入自动化构建和 CI/CD

将混淆步骤集成到构建脚本或持续集成流水线中后，为项目指定固定种子，可以让开发机、构建机和流水线使用相同的条件，便于复现和排错。

4. 团队共享混淆配置

多人维护同一个项目时，把随机种子和其他选项一起保存到配置文件里，团队成员加载统一配置后，就能减少因随机结果带来的额外沟通成本。

5. 保存可复现的发布记录

对于重要版本，把当次使用的输入文件、配置、软件版本和种子一起归档。以后要回溯或者重新生成该版本时，可以直接恢复当时的条件。

如何使用随机种子

打开恒盾C#混淆加密大师，选择需要处理的 DLL 或 EXE。
根据项目需求，勾选代码保护、代码混淆和重命名等选项。
在主界面下方找到“随机种子”输入框。
输入便于识别的字母或数字，例如项目名称与版本号的组合。
选择输出路径，点击“开始处理”。
如果需要保留当前设置，点击“保存配置”。

随机种子支持字母和数字。建议使用团队容易识别、能长期保存的内容，例如：

MyProduct150
Release202608
ClientA2026

如果不需要复现结果，保持输入框为空即可。

固定种子与留空随机应该怎么选

如果当前工作重点是测试、排错、回归或自动化构建，建议设置固定种子。这样多次处理的结果更容易比较，也便于其他开发者复现。

如果重点是正式发布，并且希望不同批次的混淆结果保持差异，可以留空或者每个版本使用不同的种子。

一个常见的策略是：测试阶段固定使用项目级种子，正式发布时按版本换用不同的种子。这样既方便日常验证，也能让不同版本之间保持足够的差异。

使用时需要注意什么

相同种子需要搭配相同的输入文件和配置，才能得到一致的结果。
输入程序、保护选项或软件版本变化后，结果也可能跟着变。
随机种子不是密码，不要在里面填写账号、密码等敏感信息。
换随机种子不等于提高保护强度，实际效果取决于你启用的混淆和加密功能。
需要复现正式版本时，记得同时保存输入文件、配置、版本号和种子。

总结

恒盾C#混淆加密大师的随机种子功能，让开发者可以根据实际需求决定混淆结果的稳定性。在排查问题、回归测试、团队协作和 CI/CD 场景中，固定种子可以大幅简化构建管理；而在需要不同版本保持差异的正式发布中，则可以留空或更换种子。合理使用这个配置项，可以让 C# 代码混淆的流程更加清晰、可控，也更适合长期的维护和自动化发布。

在.NET项目集成混淆加密：自动化保护DLL和EXE

Sun, 26 Jul 2026 18:56:01 +0800

为了保护C#程序, 在.NET项目交付DLL或EXE之前，通常需要先编译，再手动打开混淆工具、选择程序集、加载配置并导出结果。对于经常发布的项目，这套操作不仅重复，还容易漏选文件或使用错误配置。

更稳定的方式是把恒盾C#混淆加密大师的CLI接入MSBuild：Release构建完成后自动获取当前项目的真实输出路径，调用CLI生成保护版本。由于Visual Studio、Rider、dotnet build和多数CI平台最终都会调用MSBuild，因此只需在项目文件中维护一套规则。

集成后的构建流程

本文实现的流程如下：

正常编译.NET项目，不修改原始构建产物。
仅在Release配置且已经配置CLI路径时执行混淆。
将.deps.json、.runtimeconfig.json和依赖DLL复制到protected目录。
使用--input和--output覆盖配置文件中的路径，由CLI生成受保护的主程序集。
CLI返回非零退出码或未生成目标文件时让构建失败，避免误发布未保护的程序。

最终目录类似下面这样：

bin/Release/net8.0/
├─ DotNetObfuscationSample.dll          # 原始构建产物
├─ DotNetObfuscationSample.deps.json
├─ DotNetObfuscationSample.runtimeconfig.json
└─ protected/
   ├─ DotNetObfuscationSample.dll       # 已混淆的主程序集
   ├─ DotNetObfuscationSample.deps.json
   └─ DotNetObfuscationSample.runtimeconfig.json

原始目录可继续用于调试和问题定位，发布时只取protected目录即可。

第一步：准备CLI和混淆配置

安装恒盾C#混淆加密大师后，在安装目录中找到CLI.exe。然后在图形界面中配置需要启用的保护功能，通过“文件 > 导出配置”得到obfuscation.csop，并把它放在.csproj同一目录。配置文件中的ModulePath和OutputPath可以保留示例值，因为构建时会通过CLI参数覆盖：

{
    "ModulePath": "bin/Release/net8.0/MyApp.dll",
    "OutputPath": "bin/Release/net8.0/protected/MyApp.dll",
    "AntiILDasm": true,
    "StringConfusor": true,
    "IntConfusor": true,
    "FieldRename": true,
    "MethodRename": true,
    "ParamRename": true,
    "TypeRename": true,
    "RenameMode": 1,
    "Seed": "my-project-release",
}

实际使用时建议保留软件导出的完整配置，不要只复制上面的精简片段。可先启用少量保护选项，验证程序正常启动和主要功能后，再逐步增加保护强度。

第二步：在项目文件中加入MSBuild目标

打开需要保护的.csproj，在</Project>之前加入下面的内容：

<PropertyGroup>
  <ObfuscatorCliPath Condition="'$(ObfuscatorCliPath)' == ''">$(OBFUSCATOR_CLI_PATH)</ObfuscatorCliPath>
  <RunObfuscator Condition="'$(RunObfuscator)' == '' and '$(Configuration)' == 'Release' and '$(ObfuscatorCliPath)' != ''">true</RunObfuscator>
  <RunObfuscator Condition="'$(RunObfuscator)' == ''">false</RunObfuscator>
  <ObfuscatorConfigPath>$(MSBuildProjectDirectory)\obfuscation.csop</ObfuscatorConfigPath>
</PropertyGroup>

<Target Name="ObfuscateReleaseOutput"
        AfterTargets="Build"
        Condition="'$(Configuration)' == 'Release' and '$(RunObfuscator)' == 'true'">
  <PropertyGroup>
    <ObfuscatedOutputDir Condition="'$(ObfuscatedOutputDir)' == ''">$(TargetDir)protected\</ObfuscatedOutputDir>
    <ObfuscatedOutputPath Condition="'$(ObfuscatedOutputPath)' == ''">$(ObfuscatedOutputDir)$(TargetFileName)</ObfuscatedOutputPath>
  </PropertyGroup>

  <Error Condition="'$(ObfuscatorCliPath)' == ''"
         Text="RunObfuscator=true, but ObfuscatorCliPath or OBFUSCATOR_CLI_PATH is not configured." />
  <Error Condition="!Exists('$(ObfuscatorCliPath)')"
         Text="Obfuscator CLI was not found: $(ObfuscatorCliPath)" />
  <Error Condition="!Exists('$(ObfuscatorConfigPath)')"
         Text="Obfuscator config was not found: $(ObfuscatorConfigPath)" />

  <RemoveDir Directories="$(ObfuscatedOutputDir)" />
  <MakeDir Directories="$(ObfuscatedOutputDir)" />
  <ItemGroup>
    <ObfuscatorCompanionFile Include="$(TargetDir)**\*"
                                                                                                   Exclude="$(ObfuscatedOutputDir)**\*;$(TargetPath)" />
  </ItemGroup>
  <Copy SourceFiles="@(ObfuscatorCompanionFile)"
        DestinationFiles="@(ObfuscatorCompanionFile->'$(ObfuscatedOutputDir)%(RecursiveDir)%(Filename)%(Extension)')"
        SkipUnchangedFiles="true" />

  <Message Importance="high" Text="Obfuscating $(TargetPath)" />
  <Exec Command="&quot;$(ObfuscatorCliPath)&quot; obf --config &quot;$(ObfuscatorConfigPath)&quot; --input &quot;$(TargetPath)&quot; --output &quot;$(ObfuscatedOutputPath)&quot;" />
  <Error Condition="!Exists('$(ObfuscatedOutputPath)')"
         Text="Obfuscator did not create the expected output: $(ObfuscatedOutputPath)" />
  <Message Importance="high" Text="Protected output: $(ObfuscatedOutputDir)" />
</Target>

这里使用的都是MSBuild内置属性，因此不需要硬编码项目名称或目标框架：

$(MSBuildProjectDirectory)是当前项目目录。
$(TargetPath)是本次构建产生的主程序集完整路径。
$(TargetFileName)会自动适配不同项目名称。
AfterTargets="Build"确保只有编译成功后才执行CLI。
Exec检查CLI退出码，随后的Error还会确认目标文件确实已经生成。

复制主程序集以外的完整输出内容，再由CLI生成受保护的主程序集，是为了保留程序运行需要的配置和依赖文件。不要只把混淆后的DLL单独交付。排除原始主程序集也能确保后续文件检查不会把未经保护的副本误判为成功结果。

第三步：配置CLI路径

不建议把个人电脑上的绝对安装路径写入.csproj。可以使用环境变量，让不同开发机和CI环境使用各自的CLI位置。

在PowerShell中为当前终端设置：

$env:OBFUSCATOR_CLI_PATH = 'C:\Tools\CSharpObfuscator\CLI.exe'

如需永久写入当前Windows用户的环境变量：

[Environment]::SetEnvironmentVariable(
    'OBFUSCATOR_CLI_PATH',
    'C:\Tools\CSharpObfuscator\CLI.exe',
    'User'
)

永久设置后需要重新打开Visual Studio、Rider或终端。也可以在单次构建中直接传入路径：

dotnet build -c Release -p:ObfuscatorCliPath='C:\Tools\CSharpObfuscator\CLI.exe'

第四步：执行Release构建

在命令行中执行：

dotnet build -c Release

在Visual Studio中将解决方案配置切换为Release后执行“生成解决方案”，或者在Rider中构建Release配置，都会触发同一个MSBuild目标。Debug构建默认不会执行混淆。

如需临时跳过混淆，可以显式关闭开关：

dotnet build -c Release -p:RunObfuscator=false

构建日志中出现下面两行，表示集成目标已执行：

Obfuscating ...\bin\Release\net8.0\MyApp.dll
Protected output: ...\bin\Release\net8.0\protected\

在CI中使用

CI使用的仍然是相同命令，只需提前安装并注册CLI，再通过环境变量或MSBuild属性传入路径：

$env:OBFUSCATOR_CLI_PATH = "$env:OBFUSCATOR_HOME\CLI.exe"
dotnet restore
dotnet build -c Release --no-restore

建议把protected目录作为发布制品，并在上传前增加一个文件存在性检查：

$protectedFile = '.\bin\Release\net8.0\protected\MyApp.dll'
if (-not (Test-Path $protectedFile)) {
    throw "未生成混淆后的程序集: $protectedFile"
}

WPF、WinForms、类库和ASP.NET Core项目

这套写法不依赖控制台项目：

WPF和WinForms项目的$(TargetPath)会指向其主程序集。
类库项目可以直接保护生成的DLL。
ASP.NET Core项目应在完整发布目录中保留依赖、配置文件和静态资源，仅替换需要保护的业务程序集。
一个解决方案包含多个项目时，只在真正需要保护的项目中加入目标，或者把公共目标提取到单独的.targets文件后按条件导入。

使用反射、依赖注入扫描、JSON序列化、XAML绑定、插件加载或P/Invoke时，重命名可能影响运行。应通过忽略列表保留外部依赖的名称，并对启动、登录、核心业务、配置加载和自动更新等流程进行回归测试。

`dotnet publish`和单文件发布注意事项

本文示例挂接在Build目标之后，适合普通DLL、EXE构建。执行dotnet publish时，发布过程还会在publish目录重新整理文件，因此不要直接把未经检查的publish目录当成混淆结果。

常规发布可先执行dotnet publish -c Release，再用CLI的--input和--output处理发布目录中的主程序集。启用PublishSingleFile时，应将发布得到的单文件EXE作为CLI输入，而不是构建阶段的DLL。建议为单文件项目单独建立发布后目标，并验证解包、混淆、重构后的程序能够在干净环境启动。

完整示例代码

可以访问GitHub获取完整项目代码: https://github.com/leapever/csharp-obfuscator-cli-integration

恒盾C#混淆加密大师1.5.0：EXE保护升级与.NET 10兼容

Sat, 25 Jul 2026 14:43:23 +0800

恒盾C#混淆加密大师 1.5.0 版本现已发布。本次更新聚焦于保护效果、运行兼容性和处理效率，增强了原生化EXE保护能力，适配最新的 .NET 10，并对多项常用混淆功能进行了集中优化。

下载最新版本

点击进入下载页面

对于需要保护 C# DLL、EXE、WPF、WinForms、控制台程序以及其他 .NET 应用的开发者来说，1.5.0 是一次以稳定性和实用性为重点的升级。无论是单独启用某项保护，还是组合使用多项混淆功能，新版本都能更好地适应复杂项目和实际发布环境。

1.5.0 版本重点更新

1. 增强原生化EXE保护效果

1.5.0 进一步增强了原生化EXE的保护效果，可以提高程序被分析和还原的难度，为需要重点保护的 Windows EXE 程序提供更强的安全保障。

这项更新适合用于商业桌面软件、企业内部工具、授权客户端以及包含重要业务逻辑的应用程序。通过升级后的原生化EXE功能，开发者可以在保持程序正常交付和运行的同时，进一步加强对核心代码和软件成果的保护。

2. 更新混淆内核，适配最新.NET 10

随着 .NET 平台持续更新，混淆工具也需要及时适配新的程序格式和开发环境。1.5.0 更新了混淆内核，现已适配最新的 .NET 10，为使用新版本 .NET 构建项目的开发者提供支持。

对于计划升级到 .NET 10，或已经开始使用 .NET 10 开发和发布程序的团队，新版本可以更顺畅地接入现有保护流程。同时，原有 .NET 项目仍可继续使用，便于开发者在不同版本的项目之间保持统一的混淆加密方案。

3. 提升防篡改功能的兼容性

防篡改功能可以帮助开发者降低程序文件被修改后继续运行的风险。1.5.0 提升了该功能的兼容性，使其在更多EXE程序以及多种保护功能组合使用时表现得更加稳定。

对于同时启用函数体隐藏、资源文件混淆或其他保护选项的项目，这项改进可以减少功能之间相互影响的情况，让开发者更方便地根据项目需求组合不同的保护能力。

4. 提升资源文件混淆的兼容性

.NET 程序经常会包含界面资源、文本资源、配置资源以及其他随程序集发布的内容。1.5.0 提升了资源文件混淆的兼容性，使资源保护功能能够适应更多类型的项目。

这项更新对于资源使用较多的 WPF、WinForms 和桌面应用尤其有价值。开发者可以继续保护程序中的资源内容，同时降低混淆后出现资源读取异常或程序运行异常的概率。

5. 提升隐藏函数体的兼容性

隐藏函数体是保护关键业务逻辑的重要功能之一。1.5.0 对该功能进行了兼容性优化，使其能够更稳定地应用于包含复杂调用关系和多种程序结构的项目。

如果程序中包含授权验证、业务规则、数据处理或其他不希望被直接查看的关键逻辑，可以使用隐藏函数体功能提高分析难度。新版本让这项保护能力在实际项目中更易于使用，也更适合与其他混淆选项配合启用。

6. 提升隐藏字符串和数字的兼容性

程序中的字符串和数字常常包含接口地址、业务参数、授权信息、状态标识或其他敏感内容。1.5.0 提升了隐藏字符串和数字功能的兼容性，使其可以覆盖更多使用场景，并改善与其他保护功能同时启用时的稳定性。

对于敏感常量较多，或希望减少程序静态信息暴露的项目，这项更新可以提供更完整的保护体验。开发者无需改变原有业务代码，即可继续通过统一配置保护相关内容。

7. 优化核心混淆速度

除了保护效果和兼容性提升之外，1.5.0 还优化了核心混淆速度。对于程序集较多、项目体积较大或需要频繁执行混淆的开发者，新版本可以缩短等待时间，提高日常构建和发布效率。

这项优化也更适合自动化构建、持续集成和批量处理场景。团队可以将混淆步骤继续保留在现有发布流程中，同时获得更流畅的处理体验。

多项保护功能配合使用更加稳定

真实项目通常不会只使用单一保护功能，而是会根据程序特点组合启用原生化EXE、防篡改、资源文件混淆、隐藏函数体以及隐藏字符串和数字等功能。

1.5.0 对这些常用能力进行了整体兼容性提升，重点改善多项功能同时启用时的稳定性。对于结构复杂、资源较多或保护要求较高的项目，新版本能够减少反复调整配置的成本，让混淆加密流程更容易融入日常开发和发布工作。

这次更新适合哪些用户

如果你有以下需求，建议升级到 1.5.0：

需要增强 Windows EXE 程序的原生化保护效果
正在使用或准备升级到 .NET 10
需要对 C# DLL 或 EXE 进行混淆加密
需要组合使用防篡改、资源文件混淆和函数体隐藏等功能
需要保护程序中的字符串、数字和关键业务逻辑
需要提升大型项目或自动化发布流程中的混淆处理效率

总结

恒盾C#混淆加密大师 1.5.0 是一次围绕保护强度、平台适配、功能兼容性和处理效率展开的重要更新。新版本不仅增强了原生化EXE保护效果并适配最新的 .NET 10，还集中提升了防篡改、资源文件混淆、隐藏函数体、隐藏字符串和数字等核心功能的稳定性。

对于需要在真实项目中长期使用 C# 混淆、DLL加密和EXE保护的开发者来说，1.5.0 能够提供更完整、更稳定且更高效的代码保护体验。

EXE加密原生内核使用指南：无需系统环境即可运行

Sun, 12 Jul 2026 20:14:25 +0800

EXE加密原生内核使用指南：无需系统环境即可运行

使用EXE一机一码打包加密大师时，软件默认使用普通内核进行打包，可以满足绝大多数电脑的运行需求。但少数电脑由于系统版本较旧、经过精简、处于内网隔离环境，或安装了较为严格的安全防护软件，打包后的程序可能出现双击没有反应、启动后立即关闭或运行异常的情况。遇到这类问题时，可以尝试切换为原生内核重新打包。如果你不了解EXE一机一码打包加密大师, 可以访问官网查看具体介绍和说明.

点击进入EXE一机一码打包加密大师官网

什么是原生内核

在快速打包页面的设置区域中，“加密壳”一项提供两种内核可选：普通内核和原生内核。普通内核是默认选项，需要一定的系统环境支持，适合绝大多数Windows电脑；原生内核则不依赖额外的系统环境，程序可以直接运行，通用性更好，尤其适合运行环境比较特殊的电脑。

两种内核只是加密壳的运行载体不同，不会影响你选择的一机一码、静态密码或网络验证等授权方式，也不会改变激活码的计算方式。切换内核后原有的授权设置可以继续沿用，如果已经生成过激活码，建议切换内核后重新打包并在目标电脑上测试。

适用场景

以下情况可以优先考虑切换到原生内核重新打包：

打包后的程序在部分电脑上双击没有反应、启动后一闪而过，或者提示缺少组件。
目标电脑系统版本较旧（例如仍在使用Windows 7）、是精简版系统镜像，或者是刚安装不久、组件不全的系统。
软件需要部署在完全离线、无法连接网络更新系统组件的电脑上。
目标电脑处于企业内网、政府机关等环境，安装策略较为严格，无法自由安装额外的系统组件。
已经尝试过兼容模式，问题依然存在，希望进一步提高打包程序的通用性。

如果打包后的程序在普通内核下已经可以正常运行，无需切换，保持默认设置即可。

使用方法

打开EXE一机一码打包加密大师，进入快速打包页面。
按照正常流程选择需要打包的EXE文件，设置软件名称、加密模式等选项。
在设置区域的“加密壳”一项中，选择原生内核（默认使用的是普通内核）。
点击“打包”按钮生成加密程序。
将生成的程序复制到目标电脑上测试运行效果，确认可以正常启动和使用。

使用建议

建议先使用默认的普通内核打包测试，只有在目标电脑上出现无法启动、运行异常等问题时，再切换为原生内核重新打包。
原生内核和兼容模式可以配合使用：如果单独切换原生内核后问题仍未解决，可以同时勾选兼容模式一起测试。
每次调整内核或其他打包设置后，建议在实际使用的电脑上重新测试一遍，确认无误后再正式对外分发。

YLong软件

HTML打包APK：页面打印功能实现方法

创建打印页面

打包APK

安装并测试打印

常见问题

HTML打包EXE退出密码设置指南

下载最新版本

适用场景

配置步骤

用户看到的效果

和静态密码的区别

使用建议

总结

相关阅读

用HTML打包APK制作视频播放器

创建视频播放页面

打包成APK

测试功能

HTML打包APK实现拍照、录像、录音和文件选择

创建文件采集页面

打包APK并配置权限

安装并测试功能

HTML项目打包APK：二维码扫码功能实现

创建扫码页面

打包APK并勾选相机权限

安装并测试扫码

C#混淆选项选择指南：恒盾加密大师详解

四类混淆选项分别解决什么问题

基本保护选项

防调试、防DnSpy与防断点

防ILDasm、防ILSpy与防de4dot

防篡改与加壳

防虚拟机

注入功能选项

垃圾域、垃圾函数与垃圾类型

垃圾空指令与垃圾字符串

混淆功能选项

程序集与文件结构混淆

流程与函数调用混淆

字符串保护

数字、布尔值与小数保护

函数体隐藏与原生化EXE

重命名选项

重命名模式怎么选

可以重命名哪些对象

不同项目可以怎样组合

普通桌面程序

供第三方调用的类库

包含重要算法的EXE

推荐的启用和测试顺序

使用时需要注意什么

总结

C#混淆随机种子的作用与使用教程

随机种子有什么作用

哪些场景适合设置固定种子

1. 排查混淆后的运行问题

2. 进行版本回归测试

3. 接入自动化构建和 CI/CD

4. 团队共享混淆配置

5. 保存可复现的发布记录

如何使用随机种子

固定种子与留空随机应该怎么选

使用时需要注意什么

总结

在.NET项目集成混淆加密：自动化保护DLL和EXE

集成后的构建流程

第一步：准备CLI和混淆配置

第二步：在项目文件中加入MSBuild目标

第三步：配置CLI路径

第四步：执行Release构建

在CI中使用

WPF、WinForms、类库和ASP.NET Core项目

dotnet publish和单文件发布注意事项

完整示例代码

恒盾C#混淆加密大师1.5.0：EXE保护升级与.NET 10兼容

下载最新版本

1.5.0 版本重点更新

1. 增强原生化EXE保护效果

2. 更新混淆内核，适配最新.NET 10

`dotnet publish`和单文件发布注意事项