关于jdk中类装载器ClassLoader扩展和JNI技术(JavaNativeInterface)以及类文件的加密解密算法

1、自定义Classloader的代码如下：

package com.test.start;

import java.io.IOException;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.net.URL;
import java.net.URLClassLoader;
import java.nio.ByteBuffer;
import java.security.AccessControlContext;
import java.security.AccessController;
import java.security.CodeSigner;
import java.security.CodeSource;
import java.security.PrivilegedActionException;
import java.security.PrivilegedExceptionAction;
import java.security.ProtectionDomain;
import java.util.jar.Attributes;
import java.util.jar.Attributes.Name;
import java.util.jar.Manifest;
import sun.misc.Resource;
import sun.misc.URLClassPath;

public class CommonClassLoader extends URLClassLoader
{
  private URLClassPath ucp;
  private AccessControlContext acc;
  private Method getProtectionDomainMethod;

  public CommonClassLoader(URL[] urls)
  {
    super(urls);
  }

  public CommonClassLoader(URL[] urls, ClassLoader parent) {
    super(urls);
  }

  protected void addURL(URL arg0)
  {
    super.addURL(arg0);
  }

//系统方法

  protected Class<?> findClass(String name)
    throws ClassNotFoundException
  {
    try
    {
      check();
      return
        ((Class)AccessController.doPrivileged(new PrivilegedExceptionAction(this, name) {
        public Object run() throws ClassNotFoundException {
          String path = this.val$name.replace('.', '/').concat(".class");
Resource res = CommonClassLoader.access$0(this.this$0).getResource(path, false);
          if (res != null)
            try {
              return CommonClassLoader.access$1(this.this$0, this.val$name, res);
            } catch (IOException e) {
              throw new ClassNotFoundException(this.val$name, e);
            }

          throw new ClassNotFoundException(this.val$name);
        }
      }
      , this.acc));
    } catch (PrivilegedActionException pae) {
      throw ((ClassNotFoundException)pae.getException());
    }
  }

//修改后的系统方法

  private Class defineClass(String name, Resource res)
    throws IOException
  {
    int i = name.lastIndexOf(46);
    URL url = res.getCodeSourceURL();
    if (i != -1) {
      String pkgname = name.substring(0, i);

      Package pkg = getPackage(pkgname);
      Manifest man = res.getManifest();
      if (pkg != null)
      {
        if (pkg.isSealed())
        {
          if (pkg.isSealed(url)) break label172;
          throw new SecurityException(
            "sealing violation: package " + pkgname + " is sealed");
        }

        if ((man == null) || (!(isSealed(pkgname, man)))) break label172;
        throw new SecurityException(
          "sealing violation: can't seal package " + pkgname +
          ": already loaded");
      }

      if (man != null)
        definePackage(pkgname, man, url);
      else {
        definePackage(pkgname, null, null, null, null, null, null, null);
      }

    }

    label172: ByteBuffer bb = res.getByteBuffer();
    if (bb != null)
    {
      CodeSigner[] signers = res.getCodeSigners();
      CodeSource cs = new CodeSource(url, signers);
      byte[] b = getBytes(bb);
      return defineClassInternal(name, b, 0, b.length, cs);
    }
    byte[] b = res.getBytes();

    CodeSigner[] signers = res.getCodeSigners();
    CodeSource cs = new CodeSource(url, signers);
    return defineClassInternal(name, b, 0, b.length, cs);
  }

//系统方法

  private boolean isSealed(String name, Manifest man)
  {
    String path = name.replace('.', '/').concat("/");
    Attributes attr = man.getAttributes(path);
    String sealed = null;
    if (attr != null)
      sealed = attr.getValue(Attributes.Name.SEALED);

    if (sealed == null)
      if ((attr = man.getMainAttributes()) != null)
        sealed = attr.getValue(Attributes.Name.SEALED);

    return "true".equalsIgnoreCase(sealed);
  }

//自定义方法 检测父类的属性初始化给子类调用，使用java反射技术实现。

  private void check()
  {
    try {
      if (this.ucp == null)
      {
        Field fieldOfucp = getClass().getSuperclass().getDeclaredField("ucp");//获取private类型的字段
        fieldOfucp.setAccessible(true);//设置private类型修饰的字段可以访问
        this.ucp = ((URLClassPath)fieldOfucp.get(this));//访问private类型修饰的字段
      }
      if (this.acc == null)
      {
        Field fieldOfacc = getClass().getSuperclass().getDeclaredField("acc");
        fieldOfacc.setAccessible(true);
        this.acc = ((AccessControlContext)fieldOfacc.get(this));
      }
      if (this.getProtectionDomainMethod != null) return;

      this.getProtectionDomainMethod = getClass().getSuperclass().getSuperclass().getDeclaredMethod("getProtectionDomain", new Class[] { CodeSource.class });
      this.getProtectionDomainMethod.setAccessible(true);
    }
    catch (Exception ex)
    {
      ex.printStackTrace();
    }
  }

//自定义方法 字节缓冲中的字节获取

  private byte[] getBytes(ByteBuffer b)
  {
    int len = b.remaining();
    byte[] tb = new byte[len];

    if (!(b.isDirect()))
      if (b.hasArray()) {
        System.arraycopy(b.array(), b.position() + b.arrayOffset(), tb, 0, len);
      }
      else
        b.get(tb);

    return tb;
  }

//自定义方法 让加密的的class文件交给解密方法来执行装载否则由系统来装载

  protected final Class<?> defineClassInternal(String name, byte[] b, int off, int len, CodeSource cs)
  {
    Class clz = null;
    try
    {
      if (cs == null) {
        clz = defineClass0(name, b, off, len); break label75:
      }
      clz = defineClass1(name, b, off, len, getProtectionDomainInternal(cs));
    }
    catch (ClassFormatError ex)
    {
      if (cs == null)
        return super.defineClass(name, b, off, len);

      return super.defineClass(name, b, off, len, getProtectionDomainInternal(cs));
    }
    if (clz == null)
    {
      if (cs == null)
        label75: return super.defineClass(name, b, off, len);

      return super.defineClass(name, b, off, len, getProtectionDomainInternal(cs));
    }
    return clz;
  }

//系统方法

  protected ProtectionDomain getProtectionDomainInternal(CodeSource cs)
  {
    try {
      return ((ProtectionDomain)this.getProtectionDomainMethod.invoke(this, new Object[] { cs }));
    }
    catch (IllegalArgumentException e) {
      e.printStackTrace();
    }
    catch (IllegalAccessException e) {
      e.printStackTrace();
    }
    catch (InvocationTargetException e) {
      e.printStackTrace();
    }
    return null;
  }

//自定义方法 调用dll文件中的解密算法来解密class文件并装载到jvm中

  private native Class<?> defineClass0(String paramString, byte[] paramArrayOfByte, int paramInt1, int paramInt2);

  private native Class<?> defineClass1(String paramString, byte[] paramArrayOfByte, int paramInt1, int paramInt2, ProtectionDomain paramProtectionDomain);
}

2、c++实现加密和解密算法以及JNI技术的应用实例：

#include"jni.h"
#include"com_test_start_CommonClassLoader.h"
static void arraycopy(JNIEnv *env,jbyteArray sb,int spo,jbyteArray db,int start,int len);
static jbyteArray encrypt(JNIEnv *env,jbyteArray b,jint len);
static jbyteArray getValidateCode(JNIEnv *env);
static jbyteArray getCode(JNIEnv *env);
/*
* Clasbs:     com_test_start_CommonClassLoader
* Method:    defineClass0
* Signature: (Ljava/lang/String;[BII)Ljava/lang/Class;
*/
JNIEXPORT jclass JNICALL Java_com_test_start_CommonClassLoader_defineClass0
  (JNIEnv *env, jobject loader, jstring  name, jbyteArray buffer, jint start, jint len)
{
jbyteArray temp=env->NewByteArray(len);//new一个数组，并申请一块内存
arraycopy(env,buffer,start,temp,start,len);//数组的复制相当于System.copy()方法
    jbyteArray byte0=encrypt(env,temp,len);//进行class文件的解密操作
if(byte0==NULL)
{
       env->DeleteLocalRef(temp);//释放内存
       return NULL;
}
jsize size=env->GetArrayLength(byte0);//技术数组的长度相当于Array的length属性
jclass classLoader=env->GetSuperclass(env->GetSuperclass(env->GetSuperclass(env->GetObjectClass(loader))));//获取父类装载器
jmethodID mid=env->GetMethodID(classLoader,"defineClass","(Ljava/lang/String;[BII)Ljava/lang/Class;");//获取defineClass方法

defineClass jclass cls=(jclass)env->CallObjectMethod(loader,mid,name,byte0,start,size);//调用Classloader的defineClass定义一个类到jvm中
env->DeleteLocalRef(byte0);//释放内存
return cls;
}

/*
* Class:     com_test_start_CommonClassLoader
* Method:    defineClass1
* Signature: (Ljava/lang/String;[BIILjava/security/ProtectionDomain;)Ljava/lang/Class;
*/
JNIEXPORT jclass JNICALL Java_com_test_start_CommonClassLoader_defineClass1
  (JNIEnv *env, jobject loader, jstring name, jbyteArray buffer, jint start, jint len, jobject pro)
{
    jbyteArray temp=env->NewByteArray(len);
arraycopy(env,buffer,start,temp,start,len);
    jbyteArray byte0=encrypt(env,temp,len);
if(byte0==NULL)
{
       env->DeleteLocalRef(temp);
       return NULL;
}
jsize size=env->GetArrayLength(byte0);
jclass classLoader=env->GetSuperclass(env->GetSuperclass(env->GetSuperclass(env->GetObjectClass(loader))));
jmethodID mid=env->GetMethodID(classLoader,"defineClass","(Ljava/lang/String;[BIILjava/security/ProtectionDomain;)Ljava/lang/Class;");
jclass cls=(jclass)env->CallObjectMethod(loader,mid,name,byte0,start,size,pro);
env->DeleteLocalRef(byte0);
return cls;
}
  /*
   getCode，密钥，用于加密
  */
static jbyteArray getCode(JNIEnv *env)
  {
  char char0[]={'0','1','2','3','4','5','6','7','8','9'};
  char char1[]={'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','s','y','z'};
  char char2[36];
  int i=0;
     int j=0; 
     int k=0;
     while(i<36)
  {
   
     if(i>=12&&j<10)
  {
      char2[i]=char0[j];
   j++;
  }
     else if(i>=23&&k<26)
  {
   char2[i]=char1[k];
   k++;
  }
     else
  {
      char2[i]=char1[k];
      k++;
  }
     i++;
  }
  jbyteArray code=env->NewByteArray(36);
  env->SetByteArrayRegion(code,0,36,(jbyte*)char2);
     return code;
  }
  /*
   getValidateCode，验证码用于区分是否是加密文件
  */
   static jbyteArray getValidateCode(JNIEnv *env)
   {
      char char0[]={'0','1','2','3','4','5','6','7'};
      jbyteArray char1=env->NewByteArray(8);
   env->SetByteArrayRegion(char1,0,8,(jbyte *)char0);
   return char1;
   }
   /*
   encrypt，解密操作
   */
   static jbyteArray encrypt(JNIEnv *env,jbyteArray b,jint len)
{
         int i = 0;
   jint j = 0;
   int k =len;
   jbyte* bb = (env->GetByteArrayElements(b,JNI_FALSE));
   while (i < k) {
    j = bb[i];
    if ((j >= 48) && (j <= 57)) {
     j = (((j - 48) + 5) % 10) + 48;
    } else if ((j >= 65) && (j <= 90)) {
     j = (((j - 65) + 13) % 26) + 65;
    } else if ((j >= 97) && (j <= 122)) {
     j = (((j - 97) + 13) % 26) + 97;
    }
    bb[i]=(jbyte)j;
    i++;
   }
   env->SetByteArrayRegion(b,0,k,bb);
   int length=500;//长度
   int start=0;//起始次数
   jbyteArray temp=getCode(env);//密钥
   int mode=(k-8)%(length+36);//剩余部分
   int count=(k-8)/(length+36);//总次数
         int spo=0;//源位置
         int dpo=0;//目标位置
   int size=count*length+mode;//大小
   jbyteArray byte0=env->NewByteArray(size);//密文大小
   if(count>0)
   {//进行解密
    while(start<count)
    {
     arraycopy(env,b, spo, byte0, dpo, length);
     spo=spo+length+36;
     dpo=dpo+length;
     start++;
    }
   }
   if(mode>0)
   {//复制剩余部分
    arraycopy(env,b, spo, byte0, dpo, mode);
    spo=spo+mode;
   }
   //校验码
   jbyteArray validateCode0=getValidateCode(env);
   jbyte* validateCode=env->GetByteArrayElements(validateCode0,JNI_FALSE);
   jbyteArray validate0=env->NewByteArray(8);
   arraycopy(env,b, spo, validate0, 0,8);
            jbyte* validate=env->GetByteArrayElements(validate0,JNI_FALSE);
   for(int index=0;index<8;index++)
   {//校验解码是否成功
    if(validate[index]!=validateCode[index])
    {
     return NULL;
    }
   }
   env->DeleteLocalRef(validate0);
   env->DeleteLocalRef(validateCode0);
   env->DeleteLocalRef(temp);
   return byte0;
}

    /*
    decrypt，加密操作
    */
   static jbyteArray decrypt(JNIEnv *env,jbyteArray b,jboolean end)
{
            int length=500;//长度
   int start=0;//起始次数
   int count=env->GetArrayLength(b)/length;//总次数
   jbyteArray temp=getCode(env);//密钥
         int spo=0;//源位置
         int dpo=0;//目标位置
         int mode=env->GetArrayLength(b)%length;//剩余部分
   int size=count*(length+36)+mode;//大小
   if(end==JNI_TRUE)
   {//是否结束
    size=size+8;
   }
   jbyteArray byte0=env->NewByteArray(size);//密文大小
   if(count>0)
   {//进行加密
    while(start<count)
    {
     arraycopy(env,b, spo, byte0, dpo, length);
     arraycopy(env,temp, 0, byte0, dpo+length, 36);
     spo=spo+length;
     dpo=dpo+length+36;
     start++;
    }
   }
   if(mode>0)
   {//复制剩余部分
    arraycopy(env,b, spo, byte0, dpo, mode);
    dpo=dpo+mode;
   }
   if(end==JNI_TRUE)
   {//结束位置加校验码
       jbyteArray validateCode=getValidateCode(env);
    arraycopy(env,validateCode, 0, byte0, dpo, 8);
    env->DeleteLocalRef(validateCode);
   }
   jbyte * byte1=env->GetByteArrayElements(byte0,0);
   //转换字节位置
   int i = 0;
   int j = 0;
   int k = size;
   while (i < k) {
    j = byte1[i];
   
    if ((j >= 48) && (j <= 57)) {
     j = (((j - 48) + 5) % 10) + 48;
    } else if ((j >= 65) && (j <= 90)) {
     j = (((j - 65) + 13) % 26) + 65;
    } else if ((j >= 97) && (j <= 122)) {
     j = (((j - 97) + 13) % 26) + 97;
    }
    byte1[i]=(jbyte)j;
    i++;
   }
            env->SetByteArrayRegion(byte0,0,size,byte1);
   env->DeleteLocalRef(temp);
   return byte0;
}
    /*
   arraycopy，自定义的数组赋值方法相当于System.copy()
   */
  static void arraycopy(JNIEnv *env,jbyteArray sb,int spo,jbyteArray db,int start,int len)
   {
    jbyte * t=new jbyte[len];
    env->GetByteArrayRegion(sb,spo,len,t);
    env->SetByteArrayRegion(db,start,len,t);
    delete t;
   }