devbox
我家自动化
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

使用360加固宝命令行方式加固_java11 360加固

作者：我家自动化 | 2024-04-06 10:04:16

赞

踩

java11 360加固

使用360加固宝命令行方式加固

将360加固宝安装程序下载之后，解压，然后通过winodws 的dos命令来调用360加固程序，完成登录，设置，加固应用的操作。

优点：可以使用程序控制加固工作，将生成的release包在java工程中进行加固，签名，生成多渠道包等工作，不再使用客户端手动加固应用，防止出错，方便快捷。而且可以将我们创建的一个Release包在java工程中完成一系列操作，直致生成多渠道包。可谓是一键完成线上多个渠道包的创建，不再依赖手动选择加固，签名等，大大节约了我们的时间。

 

360加固宝官网： http://jiagu.360.cn/#/global/index

步骤一：下载加固宝应用，并解压，如下图。

解压后是一个360jiagubao_windows_64文件夹，进入jiagu文件夹如下图。请注意下面两个红框的文件。help.txt和jiagu.jar

 

 

help.txt文件内容如下

    -login <username>             首次使用必须先登录 <360用户名>

        <password>                <登录密码>

    -importsign <keystore_path>         导入签名信息 <密钥路径>

        <keystore_password>             <密钥密码>

        <alias>                 <别名>

        <alias_password>            <别名密码>

    -importmulpkg <mulpkg_filepath>        导入多渠道配置信息，txt格式

    -showsign                查看已配置的签名信息

    -showmulpkg                查看已配置的多渠道信息

    -help                    显示帮助信息

    -config                 配置加固可选项

    ----------------------可选增强服务-------------------------------

        [-crashlog]                【崩溃日志分析】

        [-x86]                    【x86支持】

        [-analyse]                【加固数据分析】

        [-nocert]                【跳过签名校验】

    ----------------------高级加固选项-------------------------------

        [-vmp]                    【全VMP保护】

        [-data]                    【本地数据文件保护】

        [-assets]                【资源文件保护】

        [-filecheck]                【文件完整性校验】

        [-ptrace]                【Ptrace防注入】

        [-so]                    【SO文件保护】

        [-dex2c]                【dex2C保护】

        [-string_obfus]                【字符串加密】

        [-dex_shadow]                【DexShadow】

        [-so_private]                【SO防盗用】

    -----------------------------------------------------------------

    -config_so            配置需要加固的SO文件，以空格分隔

    -config_assets            配置需要忽略的资源文件，以空格分隔

    -config_so_private        配置防盗用的SO文件，以空格分隔

    

    -showconfig                显示已配置加固项

    -version                显示当前版本号

    -update                    升级到最新版本

    -jiagu <inputAPKpath>             加固命令 <APK路径>

        <outputPath>                 <输出路径>

        [-autosign]                 【自动签名】

        [-automulpkg]                 【自动多渠道】

        [-pkgparam mulpkg_filepath]        【自定义文件生成多渠道】

 

 

步骤二： 在windows环境下执行dos命令

2.1 ：进入该目录下

 

 

 

2.2 执行登录命令  :  java -jar jiagu.jar -login 用户名 密码 

登录成功会返回 login success字符串。

 

2.3 配置

登录成功后可设置360加固宝。设置一次后，可不再修改，设置保存至本地的。也可以登录客户端手动设置，都是一样的。、

个人建议不使用它的“启用自动签名”和 使用“跳过签名校验”功能。

 

2.4 加固apk

执行加固命令： java -jar jiagu.jar -jiagu input\input.apk output

java -jar jiagu.jar -jiagu 要加固的apk文件路径 输出apk路径

注：我使用的是相对路径， 也可以使用绝对路径。

        输出的文件名规则为 源文件名 + “_版本号_” + "jiagu.apk" .如上加固输出文件为 input_6130_jiagu.apk ， 其源文件为input.apk

 

 

使用程序进行加固。

加固先开始上传（上传至360加固服务器那边，应该是这样的）

 

上传完成开始加固

 

加固完成。即加固程序运行结束

 

 

三、使用脚本工具进行加固

脚本工具下载地址：https://download.csdn.net/download/liuyu0915/11197032

实现功能：

脚本加固apk工具，可以通过该工具批量加固apk,  并支持加固api，加固apk不再需要手动操作加固客户端。内部封装的是360加固宝工具。该工具可以与签名、生成渠道包工具组合起来，达到一键生成线上渠道包的功能（studio生成release包，使用该工具加固，再调用程序进行签名，最后通过创建渠道包工具生成对应的渠道包，整个流程不需要手动操作，使用简单稳定。）。
准备工作：在360加固宝官网上下载360加固宝程序并解压，找到jiagu.jar文件，并记录它的路径。360加固宝下载地址

 

 

使用方法：


命令行方式： java -jar 360jiagu.jar kaixin -login 360加固宝用户名 360加固宝登录密码  -input input.apk -output 输出apk路径 -jiaguJar 360加固宝中jiagu.jar的路径

示例：java -jar 360jiagu.jar kaixin -login 153****8060  mima -input C:\Users\ttkx\Desktop\input.apk -output f:\ouput -jiaguJar D:\github_\AutoCreateApk\jiagu\jiagu.jar


API调用方式： 直接调用360jiagu.jar中的api .

调用方法：  JiaGuMain.runJiaGu(JiaGuConfig config).    JiaGuConfig类中设置登录用户名和密码，输入apk和加固完成后输出路径，还需要传360加宝程序解压后jiagu.jar的路径。

  1. JiaGuConfig config = JiaGuConfig.build()
  2.  
  3.  .setJarFile(new File("....\jiagu.jar"))
  4.  
  5. .login("用户名****", "密码****")
  6.  
  7. .addInputApkPath(getInputApkPath("htg_input.apk"))
  8.  
  9. .addInputApkPath(getInputApkPath("app-anzhi_oas-debug.apk"))
  10.  
  11. .outputPath(mOutputPath);
  12.  
  13. JiaGuMain.runJiaGu(config);

备注：该工具没有设置360加固宝相关设置的功能，如果需要修改加固宝默认设置，可以打开客户端手动设置后关闭再使用该工具进行加固，设置一次之后就不用再设置了。建议大家不使用360加固宝的自动签名和签名校验功能。

 

 

 

四、脚本工具源码解析

 

目的： 用程序调用加固apk， 与后续签名和生成多渠道包功能连贯至一起。实现一键生成多渠道线上包的功能。

创建java工程， 然后使用java api执行windows 的dos命令，调用360加固宝程序 。最终实现加固apk.

步骤一 ： 创建java工程 或是java lib 工程。

步骤二： 将360加固宝解压文件入至工程中（方便管理）。

我的目录结构如下：

 

步骤三： 使用java api 调用dos命令，执行加固程序

3.1 设置登录用户名和密码 ， 输入文件路径 和 输出文件夹路径

3.4 检查是否登录完成 。 

检查返回的字符串是否包含login success 字符串即可。

3.5检查加固是否完成

检查返回字符串是否包含 “已加固”。

备注： dos命令在程序中执行是在当前线程，当加固程序完成之后才会走下一行代码。所以当加固程序走完的时候，就能够在输出文件夹内找到对应的已加固apk文件。本人dos命令玩的太差，上面检查360加固登录和加固状态的代码写的稀烂，对返回的字符串处理很low，欢迎大神指点。

上述三的思想是创建java工程，然后调用360加固宝工具进行加固。我对其进行了二次封装。

源码

 

  1.  
  2. package com.kaixin.jiagu360;
  3.  
  4. import java.io.BufferedReader;
  5. import java.io.File;
  6. import java.io.IOException;
  7. import java.io.InputStreamReader;
  8. import java.io.StringReader;
  9. import java.nio.charset.Charset;
  10. import java.util.Arrays;
  11. import java.util.Iterator;
  12. import java.util.List;
  13. import java.util.Map;
  14.  
  15. public class JiaGuMain {
  16.     public static final String JAR_NAME = "jiagu.jar";
  17.  
  18.     public JiaGuMain() {
  19.     }
  20.  
  21.     public static void main(String[] args) {
  22.         String cmd = args[0];
  23.         String[] params = (String[])Arrays.copyOfRange(args, 1, args.length);
  24.  
  25.         try {
  26.             if ("kaixin".equals(cmd)) {
  27.                 disposeArgs(params);
  28.             } else {
  29.                 System.err.println("请输入kaixin，不要问为什么，因为这是我写的。。。哈哈");
  30.             }
  31.         } catch (Exception var4) {
  32.             System.err.println("Error: " + var4.getMessage());
  33.         }
  34.  
  35.     }
  36.  
  37.     //处理输入参数
  38.     private static void disposeArgs(String[] params) {
  39.         if (params.length == 0) {
  40.             error("未发现有效参数");
  41.         } else {
  42.             JiaGuConfig config = JiaGuConfig.build();
  43.             Options options = new Options(params);
  44.             Map<String, List<String>> paramMap = options.builder();
  45.             List<String> loginList = (List)paramMap.get("-login");
  46.             if (loginList != null && loginList.size() == 2) {
  47.                 String userName = (String)loginList.get(0);
  48.                 String password = (String)loginList.get(1);
  49.                 config.login(userName, password);
  50.             } else {
  51.                 error("登录参数未发现或不合法");
  52.             }
  53.  
  54.             List<String> inputApkList = (List)paramMap.get("-input");
  55.             String inputApkPath;
  56.             if (inputApkList != null && inputApkList.size() > 0) {
  57.                 Iterator var11 = inputApkList.iterator();
  58.  
  59.                 label55:
  60.                 while(true) {
  61.                     while(true) {
  62.                         if (!var11.hasNext()) {
  63.                             break label55;
  64.                         }
  65.  
  66.                         inputApkPath = (String)var11.next();
  67.                         File file = new File(inputApkPath);
  68.                         if (file.exists() && file.isFile() && file.getName().endsWith(".apk")) {
  69.                             config.addInputApkPath(inputApkPath);
  70.                         } else {
  71.                             error("输入待加固apk路径不合法： " + inputApkPath);
  72.                         }
  73.                     }
  74.                 }
  75.             } else {
  76.                 error("未发现有效的待加固apk");
  77.             }
  78.  
  79.             List<String> outputDirList = (List)paramMap.get("-output");
  80.             if (outputDirList != null && outputDirList.size() > 0) {
  81.                 inputApkPath = (String)outputDirList.get(0);
  82.                 config.outputPath(inputApkPath);
  83.             } else {
  84.                 error("未发现输出apk路径");
  85.             }
  86.  
  87.             List<String> jarList = (List)paramMap.get("-jiaguJar");
  88.             if (jarList != null && jarList.size() > 0) {
  89.                 String jarPath = (String)jarList.get(0);
  90.                 File file = new File(jarPath);
  91.                 if (file.exists() && file.isFile() && "jiagu.jar".equals(file.getName())) {
  92.                     config.setJarFile(file);
  93.                 }
  94.             }
  95.  
  96.             checkJiaguJar(config);
  97.             runJiaGu(config);
  98.         }
  99.     }
  100.  
  101.     private static void checkJiaguJar(JiaGuConfig config) {
  102.         File jarFile = config.getJarFile();
  103.         if (jarFile == null || !jarFile.exists()) {
  104.             jarFile = FileHelper.searchFile(new File((new File("")).getAbsolutePath()), "jiagu.jar");
  105.             config.setJarFile(jarFile);
  106.         }
  107.  
  108.         if (jarFile == null || !jarFile.exists() || !jarFile.isFile() || !"jiagu.jar".equals(jarFile.getName())) {
  109.             error("未发现加固工具jiagu.jar");
  110.         }
  111.  
  112.     }
  113.  
  114.     private static void error(String content) {
  115.         if (content != null) {
  116.             System.err.println(content);
  117.         }
  118.  
  119.     }
  120.  
  121.     public static BufferedReader runCmd(String command) {
  122.         Runtime runtime = Runtime.getRuntime();
  123.  
  124.         try {
  125.             File jarFile = JiaGuConfig.build().getJarFile();
  126.             if (jarFile != null && jarFile.isFile()) {
  127.                 Process process = runtime.exec(command, (String[])null, jarFile.getParentFile());
  128.                 return new BufferedReader(new InputStreamReader(process.getInputStream(), Charset.forName("GBK")));
  129.             } else {
  130.                 error("未发现jiagu.jar文件");
  131.                 return null;
  132.             }
  133.         } catch (IOException var4) {
  134.             var4.printStackTrace();
  135.             return new BufferedReader(new StringReader(var4.getMessage()));
  136.         }
  137.     }
  138.  
  139.     public static boolean runJiaGu(JiaGuConfig config) {
  140.         if (config != null && config.getInputApkPath().size() > 0) {
  141.             checkJiaguJar(config);//检查360加固工具是否存在，如果不存在，在当前项目目录下搜索
  142.             boolean login_success = login360JiaGu(config);
  143.             if (login_success) {
  144.                 System.out.print("加固中。。。。\n");
  145.                 FileHelper.createNewDir(JiaGuConfig.getConfig().getOutputPath());
  146.                 List<String> inputApkPathList = config.getInputApkPath();
  147.                 Iterator var3 = inputApkPathList.iterator();
  148.  
  149.                 while(var3.hasNext()) {
  150.                     String inputApkPath = (String)var3.next();
  151.                     jiaGuOneApk(inputApkPath, config.getOutputPath());
  152.                     System.out.print("360加固完成输出路径:" + config.getOutputPath());
  153.                 }
  154.  
  155.                 return true;
  156.             }
  157.  
  158.             error("360加固宝登录不成功");
  159.         }
  160.  
  161.         return false;
  162.     }
  163.  
  164.     public static boolean jiaGuOneApk(String inputApkPath, String outputPath) {
  165.         String jarUtils = "java -jar jiagu.jar";
  166.         String command2 = jarUtils + " -jiagu " + inputApkPath + " " + outputPath;
  167.         BufferedReader bf = runCmd(command2);
  168.         String bf2Str = getBF2Str(bf);
  169.         System.out.print(bf2Str);
  170.         return true;
  171.     }
  172.  
  173.     public static boolean login360JiaGu(JiaGuConfig config) {
  174.         String jarUtils = "java -jar jiagu.jar";
  175.         String command1 = jarUtils + " -login " + config.getUserName() + " " + config.getPassword();
  176.         BufferedReader bufferedReader = runCmd(command1);
  177.         boolean login_success = checkResultInfo(bufferedReader, "login success");
  178.         return login_success;
  179.     }
  180.  
  181.     public static String getBF2Str(BufferedReader bf) {
  182.         if (bf != null) {
  183.             String line = null;
  184.             StringBuilder sb = new StringBuilder();
  185.  
  186.             try {
  187.                 while((line = bf.readLine()) != null) {
  188.                     sb.append(line + "\n");
  189.                 }
  190.  
  191.                 return sb.toString();
  192.             } catch (Exception var4) {
  193.                 var4.getMessage();
  194.             }
  195.         }
  196.  
  197.         return "";
  198.     }
  199.  
  200.     public static boolean checkResultInfo(BufferedReader bufferedReader, String tag) {
  201.         if (bufferedReader != null) {
  202.             String line = null;
  203.             StringBuilder sb = new StringBuilder();
  204.  
  205.             try {
  206.                 while((line = bufferedReader.readLine()) != null) {
  207.                     sb.append(line + "\n");
  208.                     if (line.contains(tag)) {
  209.                         System.out.println(line + "\n");
  210.                         return true;
  211.                     }
  212.                 }
  213.             } catch (Exception var5) {
  214.                 ;
  215.             }
  216.         }
  217.  
  218.         return false;
  219.     }
  220. }
  1. package com.kaixin.jiagu360;
  2.  
  3. import java.util.ArrayList;
  4. import java.util.HashMap;
  5. import java.util.List;
  6. import java.util.Map;
  7.  
  8. public class Options {
  9.     private final String[] mParams;
  10.  
  11.     public Options(String[] params) {
  12.         this.mParams = (String[])params.clone();
  13.     }
  14.  
  15.     public Map<String, List<String>> builder() {
  16.         Map<String, List<String>> map = new HashMap();
  17.         if (this.mParams != null) {
  18.             int length = this.mParams.length;
  19.             List<String> list = null;
  20.  
  21.             for(int i = 0; i < length; ++i) {
  22.                 String param = this.mParams[i];
  23.                 if (param != null && param.length() > 0) {
  24.                     if (param.startsWith("-")) {
  25.                         list = this.getList(map, param);
  26.                     } else if (list != null) {
  27.                         list.add(param);
  28.                     }
  29.                 }
  30.             }
  31.         }
  32.  
  33.         return map;
  34.     }
  35.  
  36.     private List<String> getList(Map<String, List<String>> map, String key) {
  37.         if (map.get(key) == null) {
  38.             map.put(key, new ArrayList());
  39.         }
  40.  
  41.         return (List)map.get(key);
  42.     }
  43. }
  1. //
  2. // Source code recreated from a .class file by IntelliJ IDEA
  3. // (powered by Fernflower decompiler)
  4. //
  5.  
  6. package com.kaixin.jiagu360;
  7.  
  8. import java.io.File;
  9. import java.util.ArrayList;
  10. import java.util.List;
  11.  
  12. public class JiaGuConfig {
  13.     private static JiaGuConfig mConfig;
  14.     private List<String> mInputApkPathList = new ArrayList();
  15.     private String mOutputPath;
  16.     private String mUserName;
  17.     private String mPassword;
  18.     private File mJarFile;
  19.  
  20.     public static synchronized JiaGuConfig build() {
  21.         if (mConfig == null) {
  22.             mConfig = new JiaGuConfig();
  23.         }
  24.  
  25.         return mConfig;
  26.     }
  27.  
  28.     private JiaGuConfig() {
  29.     }
  30.  
  31.     public JiaGuConfig addInputApkPath(String inputApkPath) {
  32.         this.mInputApkPathList.add(inputApkPath);
  33.         return this;
  34.     }
  35.  
  36.     public JiaGuConfig outputPath(String outputPath) {
  37.         this.mOutputPath = outputPath;
  38.         return this;
  39.     }
  40.  
  41.     public JiaGuConfig login(String userName, String password) {
  42.         this.mUserName = userName;
  43.         this.mPassword = password;
  44.         return this;
  45.     }
  46.  
  47.     public static JiaGuConfig getConfig() {
  48.         return mConfig;
  49.     }
  50.  
  51.     public List<String> getInputApkPath() {
  52.         return this.mInputApkPathList;
  53.     }
  54.  
  55.     public String getOutputPath() {
  56.         return this.mOutputPath;
  57.     }
  58.  
  59.     public String getUserName() {
  60.         return this.mUserName;
  61.     }
  62.  
  63.     public String getPassword() {
  64.         return this.mPassword;
  65.     }
  66.  
  67.     public File getJarFile() {
  68.         return this.mJarFile;
  69.     }
  70.  
  71.     public JiaGuConfig setJarFile(File mJarFile) {
  72.         this.mJarFile = mJarFile;
  73.         return this;
  74.     }
  75.  
  76.     public JiaGuConfig setInputApkPathList(List<String> inputApkPathList) {
  77.         this.mInputApkPathList = inputApkPathList;
  78.         return this;
  79.     }
  80. }

 

  1. //
  2. // Source code recreated from a .class file by IntelliJ IDEA
  3. // (powered by Fernflower decompiler)
  4. //
  5.  
  6. package com.kaixin.jiagu360;
  7.  
  8. import java.io.File;
  9.  
  10. public class FileHelper {
  11.     public FileHelper() {
  12.     }
  13.  
  14.     public static void deleteAllFiles(File root) {
  15.         if (root != null) {
  16.             File[] files = root.listFiles();
  17.             if (files != null) {
  18.                 File[] var2 = files;
  19.                 int var3 = files.length;
  20.  
  21.                 for(int var4 = 0; var4 < var3; ++var4) {
  22.                     File f = var2[var4];
  23.                     if (f.isDirectory()) {
  24.                         deleteAllFiles(f);
  25.  
  26.                         try {
  27.                             f.delete();
  28.                         } catch (Exception var8) {
  29.                             ;
  30.                         }
  31.                     } else if (f.exists()) {
  32.                         deleteAllFiles(f);
  33.  
  34.                         try {
  35.                             f.delete();
  36.                         } catch (Exception var7) {
  37.                             ;
  38.                         }
  39.                     }
  40.                 }
  41.             }
  42.  
  43.             root.delete();
  44.         }
  45.     }
  46.  
  47.     public static void deleteAllSonFiles(File root) {
  48.         if (root != null) {
  49.             File[] files = root.listFiles();
  50.             if (files != null) {
  51.                 File[] var2 = files;
  52.                 int var3 = files.length;
  53.  
  54.                 for(int var4 = 0; var4 < var3; ++var4) {
  55.                     File f = var2[var4];
  56.                     if (f.isDirectory()) {
  57.                         deleteAllFiles(f);
  58.  
  59.                         try {
  60.                             f.delete();
  61.                         } catch (Exception var8) {
  62.                             ;
  63.                         }
  64.                     } else if (f.exists()) {
  65.                         deleteAllFiles(f);
  66.  
  67.                         try {
  68.                             f.delete();
  69.                         } catch (Exception var7) {
  70.                             ;
  71.                         }
  72.                     }
  73.                 }
  74.             }
  75.  
  76.         }
  77.     }
  78.  
  79.     public static boolean createNewDir(String dirPath) {
  80.         return dirPath != null && dirPath.length() > 0 ? createNewDir(new File(dirPath)) : false;
  81.     }
  82.  
  83.     public static boolean createNewDir(File file) {
  84.         if (file != null) {
  85.             if (file.exists()) {
  86.                 deleteAllFiles(file);
  87.                 return file.mkdirs();
  88.             } else {
  89.                 return file.mkdirs();
  90.             }
  91.         } else {
  92.             return false;
  93.         }
  94.     }
  95.  
  96.     public static File searchFile(File file, String fileName) {
  97.         if (file != null && file.exists() && fileName != null && fileName.length() > 0) {
  98.             if (file.isFile() && fileName.equals(file.getName())) {
  99.                 return file;
  100.             }
  101.  
  102.             if (file.isDirectory()) {
  103.                 File[] var2 = file.listFiles();
  104.                 int var3 = var2.length;
  105.  
  106.                 for(int var4 = 0; var4 < var3; ++var4) {
  107.                     File sonFile = var2[var4];
  108.                     String absolutePath1 = sonFile.getAbsolutePath();
  109.                     if (sonFile.isFile()) {
  110.                         if (fileName.equals(sonFile.getName())) {
  111.                             return sonFile;
  112.                         }
  113.                     } else if (sonFile.isDirectory()) {
  114.                         File resultFile = searchFile(sonFile, fileName);
  115.                         if (resultFile != null && resultFile.isFile() && fileName.equals(resultFile.getName())) {
  116.                             return resultFile;
  117.                         }
  118.                     }
  119.                 }
  120.             }
  121.         }
  122.  
  123.         return null;
  124.     }
  125. }

 

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/我家自动化/article/detail/371283
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号