H5开发工具 - 网页打包, 全景VR, AI助手, APK加固混淆, JS加密混淆保护技术分享

HTML打包APK实现视频全屏播放教程

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

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

如果你不了解HTML打包APK工具，可以访问官网查看详情：

HTML一键打包APK工具官网

创建视频播放页面

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

视频播放：使用 video 标签加载网络或本地视频，并添加 playsinline 系列属性保证在APP内联播放。
最大化按钮：调用浏览器全屏接口，将播放器切换到全屏状态，兼容打包后APP的WebView环境。
横屏锁定：进入全屏时自动锁定为横屏，退出全屏时恢复竖屏。
地址加载：支持输入视频直链地址，加载不同的视频进行测试。

视频标签需要添加 playsinline、webkit-playsinline 和 x5-playsinline 属性，避免在部分WebView中点击播放时强制跳转系统播放器：

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

最大化按钮通过全屏接口把播放器容器切换到全屏，并同时处理标准接口和 webkit 前缀接口，保证在打包后的WebView中正常工作：

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

打包成APK

复制上述HTML代码, 保存到video-test.html文件中, 然后HTML一键打包APK工具中载入该文件, 然后点击打包生成APP即可

安装并测试功能

将生成的APK安装到安卓手机，依次测试页面中的各项功能：

打开APP，确认默认视频可以正常加载，点击“播放 / 暂停”按钮可以控制播放。
点击右上角的最大化按钮，确认播放器进入全屏状态，按钮图标切换为还原样式。
在全屏状态下旋转手机，确认画面锁定为横屏；退出全屏后确认恢复竖屏显示。
在地址栏中输入其他mp4直链地址并点击“加载”，确认可以切换播放不同的视频。
拖动进度条，确认视频可以从指定位置继续播放。

为了获得最好的兼容性，视频建议使用H.264视频编码和AAC音频编码的mp4文件。部分WebView版本对HEVC、VP9等编码的支持不一致，可能出现只有声音没有画面的情况。

如果点击最大化按钮没有进入全屏，请先确认APP系统设置中没有限制横屏，并检查手机是否开启了方向锁定；如果在线视频一直无法加载，请检查打包时是否勾选了网络权限，以及视频地址是否可以通过手机浏览器直接打开。网页中的自动播放在WebView里通常需要先有一次用户交互，因此建议像示例一样提供明确的播放按钮，而不是依赖页面打开后自动播放。

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

<!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:03 +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:15:01 +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:34 +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。防篡改适合需保证文件完整性的桌面程序；加壳适合希望隐藏原始程序集的应用。处理后需重新检查数字签名、杀毒软件兼容性、更新程序和安装包流程。

防虚拟机

防虚拟机会检测程序是否运行在虚拟机中，检测到后停止运行。该功能适合明确禁止虚拟机运行的应用，但不适合在云桌面、虚拟化服务器、自动化测试机或沙箱中使用的软件。启用前需确认用户部署环境。

注入功能选项

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

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

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

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

垃圾空指令与垃圾字符串

垃圾空指令：在 IL 指令中注入无用指令，增加反编译代码阅读难度。
垃圾字符串：加入无用字符串，干扰通过字符串搜索定位关键逻辑。

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

混淆功能选项

混淆功能处理程序集信息、代码流程、常量、调用关系、函数体和资源等。部分选项改变范围大，建议从常用选项开始逐步增加保护强度。

程序集与文件结构混淆

文件信息混淆：修改程序内部名称和 Assembly 信息。
文件时间混淆：修改加密文件的时间戳。
DOS头混淆：修改 EXE 的 DOS 头内容。
混淆引用列表：处理程序集引用列表，使依赖关系难理解。
加密资源文件：加密资源，防止直接查看。

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

流程与函数调用混淆

流程混淆：打乱函数内部指令并增加跳转，使反编译后控制流程难理解。
函数调用混淆：通过函数 token 调用目标函数，降低调用关系可读性。
链式函数混淆：把一次函数调用转换为多层嵌套调用。
异步混淆：把部分代码转换为异步调用形式。
错误函数体混淆：加入错误指令干扰静态分析。

流程混淆通常是核心算法的首选。对于 UI 线程、启动入口、COM 调用、反射调用等敏感函数，应逐项启用并测试。

字符串保护

字符串加密：加密字符串，避免静态分析找到关键文本。
字符串拆分：把一个字符串拆分为多个组合，降低直接搜索效果。
字符串隐藏：加密存放到原生函数中，反编译工具无法直接获取。

字符串加密适合保护接口地址、协议字段等；字符串拆分干扰简单检索；字符串隐藏保护强度更高。配置文件中的密码、令牌等敏感凭据不应仅依赖混淆。

数字、布尔值与小数保护

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

适合保护算法常量、状态标识等。涉及浮点精度、边界值或高频计算的代码需重点验证。

函数体隐藏与原生化EXE

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

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

重命名选项解析

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

重命名模式选择

软件提供五种模式：

字母数字模式：常规字母数字组合，适合大多数项目。
UUID模式：类似 UUID 的长名称，增加阅读难度。
特殊字符模式：使用特殊字符，追求更高阅读干扰。
Base64模式：Base64 风格字符串。
英文单词模式：英文单词替换，表面可读但不保留真实含义。

日常可从字母数字模式开始；若外部工具对字符有限制，应避免特殊字符模式。

可重命名的对象

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

普通内部代码可优先启用字段、函数、参数和类型重命名。涉及反射、序列化、XAML 等时，名称可能是运行时契约，需确认框架是否按字符串查找成员。Assembly 重命名可能影响依赖程序集和插件加载。

不同项目的组合策略

普通桌面程序

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

供第三方调用的类库

优先保护内部类型和实现。公开 API、反射入口、序列化模型等需谨慎重命名。字符串加密、流程混淆和函数体隐藏可用于保护不对外暴露的核心逻辑。

包含重要算法的EXE

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

使用注意事项

保护强度越高不意味着越适合所有项目，应以稳定运行为前提。
依赖反射、序列化、XAML 等时，重点测试重命名兼容性。
防篡改、加壳和原生化EXE仅适用于 EXE。
防虚拟机可能影响云桌面和虚拟化环境中的正常用户。
处理后应在目标操作系统、架构和不同性能设备上验证。
混淆用于提高逆向成本，不能替代权限控制、签名校验等服务端安全措施。

总结

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

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

C#混淆随机种子有什么用？恒盾C#混淆加密大师使用教程

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

在使用恒盾C#混淆加密大师处理 C# DLL 或 EXE 时，即使输入文件和保护选项相同，多次处理得到的结果也可能有所不同。这种随机性有助于避免不同构建始终呈现完全相同的混淆结果，但在问题排查、版本回归和自动化发布等场景中，有时也需要让结果更容易复现。

随机种子就是用于控制这种随机性的配置项。填写固定的随机种子后，对于同一个 EXE 或 DLL，在配置保持一致的情况下重复处理，可以获得更稳定、便于对比的混淆结果；留空时，软件会自动采用随机方式处理，让每次构建保持差异。

随机种子有什么作用

随机种子主要用于在“结果可复现”和“每次结果随机”之间进行选择。

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

随机种子不会改变你选择了哪些保护功能，也不会替代字符串加密、流程混淆、重命名或其他保护选项。它只用于控制混淆过程中的随机结果是否便于再次复现。

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

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

如果程序在混淆后出现异常，可以保留当前输入文件、混淆配置和随机种子，再次执行处理。固定种子能够减少重复测试时的结果差异，让开发者更容易判断问题是否与某项配置或程序改动有关。

2. 进行版本回归测试

在同一版本上多次验证启动、登录、授权、数据读写或其他核心功能时，使用固定种子可以让测试条件更加稳定。这样更适合比较不同保护选项启用前后的运行表现。

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

将混淆步骤加入构建脚本或持续集成流程后，可以为同一项目配置固定种子。开发机、构建机和发布流水线使用统一配置时，更容易复现某次构建并定位发布问题。

4. 团队共享混淆配置

多人维护同一个项目时，可以把随机种子与其他混淆选项一起保存到配置文件中。团队成员加载同一份配置后，可以减少因随机结果不同带来的沟通和验证成本。

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

对于重要版本，可以把当次使用的输入文件、混淆配置、软件版本和随机种子一起归档。后续需要复查或重新生成该版本时，会更容易恢复当时的处理条件。

如何使用随机种子

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

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

MyProduct150
Release202608
ClientA2026

如果不需要复现处理结果，保持随机种子输入框为空即可。

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

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

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

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

使用时需要注意什么

相同种子需要配合同一个输入文件和相同混淆配置，才便于复现结果。
输入程序、保护选项或软件版本发生变化后，处理结果也可能随之变化。
随机种子不是密码或授权密钥，不要在其中填写账号、密码等敏感信息。
更换随机种子不等于提高保护强度，实际保护效果仍取决于启用的混淆和加密功能。
需要复现正式版本时，应同时保存输入文件、配置文件、软件版本和随机种子。

总结

恒盾C#混淆加密大师的随机种子功能，可以让开发者根据实际需求选择更稳定、可复现的混淆结果，或保持每次处理的随机差异。

对于问题排查、回归测试、团队协作和 CI/CD，固定随机种子能够让构建条件更容易管理；对于希望不同发布版本保持差异的场景，则可以留空或按版本更换种子。合理使用这一配置，可以让 C# DLL、EXE 的混淆加密流程更加清晰，也更适合长期维护和自动化发布。

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

Sun, 26 Jul 2026 18:55:59 +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:22 +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:23 +0800

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

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

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

什么是原生内核

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

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

适用场景

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

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

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

使用方法

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

使用建议

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

EXE一机一码加密后无法运行？兼容模式使用指南

Sat, 11 Jul 2026 20:32:53 +0800

EXE一机一码加密后无法运行？兼容模式使用指南

使用EXE一机一码打包加密大师后，如果原始EXE可以正常运行，但打包生成的程序出现点击后没有反应、启动后立即关闭、启动时报错或部分功能异常。此类情况通常与原软件自身的运行方式有关，并不一定是加密方式或授权设置有问题, 本文主要介绍如何解决一些常见的兼容性问题。如果你不了解EXE一机一码打包加密大师, 可以访问官网查看具体介绍和说明.

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

解决方案详解

在普通模式打包时，软件会使用常规方案进行打包，进行高强度加密，适合绝大多数EXE程序。如果打包后的程序可以正常启动和使用，保持默认设置即可。

而部分EXE程序带有自身完整性校验、特殊的启动流程，或者需要与其他程序文件紧密配合；一些使用较老或较少见开发环境制作的软件，也可能对打包后的运行方式比较敏感。遇到这些情况时，开启兼容模式通常可以提高打包后程序的适应性，改善无法启动、意外退出或功能运行异常等问题。

使用时，在快速打包页面的设置区域找到兼容模式，勾选“使用兼容加密模式”，然后重新打包并测试生成的程序。开启兼容模式不会改变您选择的一机一码、静态密码或网络验证方式，也不需要修改原始EXE。

建议先使用默认模式打包；如果默认模式运行正常，就继续使用默认方案。如果默认模式生成的程序无法正常运行，再开启兼容模式重新打包，并在实际使用的电脑上测试。兼容模式主要用于解决原始EXE本身可以运行、加密后才出现异常的情况；如果原始EXE也无法运行，则需要先检查原程序自身的运行条件。

多实例共享进程：让HTML打包的EXE更快多开并共享登录

Tue, 07 Jul 2026 21:12:57 +0800

在一些网页应用打包成EXE后，用户可能会习惯同时打开多个窗口。例如后台系统需要一边查看订单列表，一边打开客户详情；运营工具需要同时对比多个页面；或者同一个网站需要频繁打开多个独立窗口。

如果每次双击EXE都完整启动一个新的程序实例，第二个、第三个窗口有时会明显变慢，甚至出现短暂白屏。多实例共享进程就是为这类场景准备的功能：在同一个EXE已经运行时，再次打开它，可以更快显示新窗口，并共享同一套登录状态。

多实例共享进程是什么？

简单来说，它可以让同一个EXE在多次打开时表现得更像一个完整的多窗口应用：

第一次打开 EXE：正常启动程序
程序已经运行时再次打开同一个 EXE：快速打开一个新窗口
新窗口与已有窗口共享登录状态、Cookie、本地存储等数据
用户可以同时使用多个窗口，而不必等待每次都完整启动

注意：这不是“单例模式”。单例模式的目标是只允许一个窗口存在，再次打开时只会回到已有窗口；多实例共享进程的目标是允许多个窗口存在，只是让后续窗口打开得更快、更稳定。

这个功能能解决什么问题？

后续窗口打开更快：对于内容较重的网站，完整启动新实例可能需要较长时间。开启后，在已有窗口运行下再次打开EXE，通常能更快显示新窗口。
减少白屏等待：第二个窗口常出现的几秒钟白屏，通过此功能可显著缩短。
多窗口共享登录状态：用户在第一个窗口登录后，再开新窗口无需重新登录，Cookie和本地数据保持一致。
更适合多窗口办公：例如一个窗口查看列表，另一个查看详情，并排对照处理。

什么时候推荐开启？

用户经常重复双击同一个EXE打开多个窗口
需要同时查看多个页面或多个业务对象
第二个窗口打开时有明显白屏或等待
应用需要保持统一登录状态
应用是后台系统、业务系统、管理系统等

什么时候不建议开启？

希望每次EXE都是完全独立的数据环境
需要同时登录多个不同账号进行测试
已开启隐身模式或禁用缓存
目标为“只能打开一个窗口”，请使用单例模式

如何开启多实例共享进程

打开 HTML打包EXE 工具
进入高级设置页面
勾选多实例共享进程
正常点击打包生成 EXE

与单例模式的区别

功能	单例模式	多实例共享进程
是否允许多个窗口	不允许	允许
再次双击EXE	回到已有窗口	打开新窗口
是否共享登录状态	共享	共享
适合场景	单窗口应用	多页面业务系统

常见问题

开启后是否每个窗口都能共享登录状态？通常可以，只要网站使用常见的Cookie、本地存储方式。

可以用来同时登录多个账号吗？不推荐。如需多账号登录，请使用默认多实例方式或不同软件ID打包。

为什么需要填写软件ID？用于区分不同的打包应用，避免数据影响。

和隐身模式/禁用缓存能一起用吗？不建议，目标相反。

总结

多实例共享进程适合需要频繁打开多个同一EXE窗口的应用，让后续窗口打开更快，减少白屏，共享登录状态。建议在打包时根据需求启用。

H5开发工具 - 网页打包, 全景VR, AI助手, APK加固混淆, JS加密混淆保护技术分享

HTML打包APK实现视频全屏播放教程

创建视频播放页面

打包成APK

安装并测试功能

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

创建文件采集页面

打包APK并配置权限

安装并测试功能

HTML打包APK实现二维码扫码功能教程

创建扫码页面

打包APK并勾选相机权限

安装并测试扫码

恒盾C#混淆加密大师选项详解

四类混淆选项的核心作用

基本保护选项详解

防调试、防DnSpy与防断点

防ILDasm、防ILSpy与防de4dot

防篡改与加壳（仅限 EXE）

防虚拟机

注入功能选项

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

垃圾空指令与垃圾字符串

混淆功能选项

程序集与文件结构混淆

流程与函数调用混淆

字符串保护

数字、布尔值与小数保护

函数体隐藏与原生化EXE

重命名选项解析

重命名模式选择

可重命名的对象

不同项目的组合策略

普通桌面程序

供第三方调用的类库

包含重要算法的EXE

推荐的启用和测试步骤

使用注意事项

总结

C#混淆随机种子有什么用？恒盾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

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

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

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

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

7. 优化核心混淆速度

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

这次更新适合哪些用户

总结

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

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

什么是原生内核

适用场景

使用方法

使用建议

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