content: package com.alphabugx.security;
  
  import java.io.File;
  import java.io.FileInputStream;
  import java.lang.management.ManagementFactory;
  import java.net.URL;
  import java.security.MessageDigest;
  import java.util.List;
  
  /**
   * Jawd安全管理器
   * 提供基本的反调试和完整性检查功能
   */
  public class SecurityManager {
      
      // 加密的配置信息
      private static final String ENCRYPTED_APP_NAME = "Mdze"; // "Jawd" 偏移3
      private static final String ENCRYPTED_VERSION = "4#3#4"; // "1.0.1" 偏移3
      
      /**
       * 执行安全检查
       */
      public static void performSecurityCheck() {
          try {
              // 1. 检查是否在调试环境
              if (isDebugMode()) {
                  exitGracefully("Development environment detected");
                  return;
              }
              
              // 2. 检查JVM参数
              if (hasDebugArguments()) {
                  exitGracefully("Debug arguments detected");
                  return;
              }
              
              // 3. 检查文件完整性（可选）
              if (!checkIntegrity()) {
                  exitGracefully("File integrity check failed");
                  return;
              }
              
          } catch (Exception e) {
              // 安全检查异常，默认允许运行
              // 但可以记录日志用于分析
          }
      }
      
      /**
       * 检查是否在调试模式 - 公共方法
       */
      public static boolean isDebugMode() {
          try {
              // 检查常见的调试器端口
              List<String> arguments = ManagementFactory.getRuntimeMXBean().getInputArguments();
              for (String arg : arguments) {
                  if (arg.contains("-agentlib:jdwp") || 
                      arg.contains("-Xdebug") ||
                      arg.contains("-Xrunjdwp")) {
                      return true;
                  }
              }
              return false;
          } catch (Exception e) {
              return false;
          }
      }
      
      /**
       * 检查JVM启动参数
       */
      private static boolean hasDebugArguments() {
          try {
              List<String> arguments = ManagementFactory.getRuntimeMXBean().getInputArguments();
              for (String arg : arguments) {
                  // 检查可疑的JVM参数
                  if (arg.toLowerCase().contains("javaagent") ||
                      arg.toLowerCase().contains("jdwp") ||
                      arg.toLowerCase().contains("debug")) {
                      return true;
                  }
              }
              return false;
          } catch (Exception e) {
              return false;
          }
      }
      
      /**
       * 检查文件完整性
       */
      private static boolean checkIntegrity() {
          try {
              // 获取当前jar文件路径
              URL location = SecurityManager.class.getProtectionDomain()
                  .getCodeSource().getLocation();
              
              if (location == null) {
                  return true; // 在IDE中运行时允许
              }
              
              File jarFile = new File(location.toURI());
              
              // 计算文件MD5
              String currentHash = calculateMD5(jarFile);
              
              // 这里应该与预期的hash比较
              // 实际使用时，将正确的hash值加密存储
              // String expectedHash = decrypt("your_encrypted_expected_hash");
              // return currentHash.equals(expectedHash);
              
              return true; // 暂时总是返回true
          } catch (Exception e) {
              return true; // 出错时允许运行
          }
      }
      
      /**
       * 计算文件MD5
       */
      private static String calculateMD5(File file) throws Exception {
          MessageDigest md = MessageDigest.getInstance("MD5");
          try (FileInputStream fis = new FileInputStream(file)) {
              byte[] buffer = new byte[8192];
              int bytesRead;
              while ((bytesRead = fis.read(buffer)) != -1) {
                  md.update(buffer, 0, bytesRead);
              }
          }
          
          byte[] hashBytes = md.digest();
          StringBuilder sb = new StringBuilder();
          for (byte b : hashBytes) {
              sb.append(String.format("%02x", b));
          }
          return sb.toString();
      }
      
      /**
       * 简单的字符串解密
       */
      public static String decrypt(String encrypted, int offset) {
          StringBuilder result = new StringBuilder();
          for (char c : encrypted.toCharArray()) {
              result.append((char)(c - offset));
          }
          return result.toString();
      }
      
      /**
       * 获取应用名称（解密）
       */
      public static String getAppName() {
          return decrypt(ENCRYPTED_APP_NAME, 3);
      }
      
      /**
       * 获取版本号（解密）
       */
      public static String getVersion() {
          return decrypt(ENCRYPTED_VERSION, 3);
      }
      
      /**
       * 优雅退出，不显示明显的安全错误
       */
      private static void exitGracefully(String reason) {
          // 记录到日志（如果需要）
          System.err.println("Application initialization failed: Configuration error");
          
          // 延迟一下，让错误看起来像正常的配置问题
          try {
              Thread.sleep(1000);
          } catch (InterruptedException e) {
              Thread.currentThread().interrupt();
          }
          
          // 退出应用
          System.exit(1);
      }
      
      /**
       * 检查运行环境是否安全
       */
      public static boolean isSecureEnvironment() {
          return !isDebugMode() && !hasDebugArguments() && !isModified();
      }
      
      /**
       * 检查应用是否被修改
       */
      private static boolean isModified() {
          try {
              // 获取当前运行的jar包路径
              URL location = SecurityManager.class.getProtectionDomain()
                  .getCodeSource().getLocation();
                  
              if (location == null) {
                  return false; // 在IDE中运行，允许通过
              }
              
              File jarFile = new File(location.toURI());
              if (!jarFile.exists() || !jarFile.getName().endsWith(".jar")) {
                  return false; // 不是jar包运行，允许通过
              }
              
              // 这里可以添加更复杂的完整性检查
              // 比如检查特定文件的存在性、大小等
              
              return false; // 暂时总是通过
          } catch (Exception e) {
              return false; // 出错时允许运行
          }
      }
      
      /**
       * 运行时定期安全检查
       */
      public static void performRuntimeCheck() {
          // 定期检查（可以在后台线程中调用）
          if (!isSecureEnvironment()) {
              exitGracefully("Runtime security validation failed");
          }
      }
      
      /**
       * 应用关闭时的清理操作
       */
      public static void performCleanup() {
          try {
              // 清理敏感数据
              clearSensitiveData();
              
              // 记录正常关闭
              System.out.println("Application shutdown completed");
          } catch (Exception e) {
              // 静默处理清理错误
          }
      }
      
      /**
       * 清理敏感数据
       */
      private static void clearSensitiveData() {
          // 清理可能的敏感内存数据
          System.gc(); // 建议垃圾回收
          
          // 这里可以添加更多的清理逻辑
          // 比如清理临时文件、缓存等
      }
      
      /**
       * 获取加密的错误信息
       */
      public static String getEncryptedErrorMessage(String key) {
          // 预定义的加密错误信息
          switch (key) {
              case "config_error":
                  return decrypt("Frqiljxudwlrq#iloh#qrw#irxqg", 3); // "Configuration file not found"
              case "runtime_error": 
                  return decrypt("Uxqwlph#hqylurqphqw#huuru", 3); // "Runtime environment error"
              case "permission_error":
                  return decrypt("Lqvxiilflhqw#shuplvvlrqv", 3); // "Insufficient permissions"
              default:
                  return decrypt("Xqnqrzq#huuru", 3); // "Unknown error"
          }
      }
      
      /**
       * 生成运行时验证码
       */
      public static String generateRuntimeToken() {
          try {
              long timestamp = System.currentTimeMillis();
              String baseString = ENCRYPTED_APP_NAME + timestamp;
              
              // 简单的hash生成
              int hash = baseString.hashCode();
              return Integer.toHexString(Math.abs(hash));
          } catch (Exception e) {
              return "default_token";
          }
      }
      
      /**
       * 验证运行时token
       */
      public static boolean validateRuntimeToken(String token) {
          try {
              String expectedToken = generateRuntimeToken();
              return token != null && token.equals(expectedToken);
          } catch (Exception e) {
              return false;
          }
      }
  } 