#include <stdio.h>

#include <string.h>

#include <stdlib.h>

#include "xxtea.h"

#define SIZE 1024*1024*10

void main() //命令行参数

{

    FILE *infp = 0;//判断命令行是否正确

    if((infp=fopen("Assembly-CSharp.dll","rb"))==NULL)

    {

        printf("Assembly-CSharp.dll Read Error\n");//打开操作不成功

        return;//结束程序的执行

    }

    //char buffer[SIZE];

    char* buffer = (char*)malloc(sizeof(char)*SIZE);

    memset(buffer,0,sizeof(char)*SIZE);

    int rc = 0;

    int total_len = 0;

    total_len = fread(buffer , sizeof(unsigned char) , SIZE , infp);

    printf("Read Assembly-CSharp Successfully and total_len : %d \n" , total_len);

    //加密DLL

    size_t len;

    char* key = "123456";

    char *encrypt_data = xxtea_encrypt(buffer,total_len, key, &len);

    printf("Encrypt Dll Successfully and len : %d\n" , len);

    //写Dll

    FILE* outfp = 0;

    if((outfp=fopen("Assembly-CSharp_encrypt.dll","wb+"))==NULL)

    {

        printf("Assembly-CSharp_encrypt.dll Read Error\n");//打开操作不成功

        return;//结束程序的执行

    }

    int rstCount = fwrite(encrypt_data , sizeof(unsigned char) , len , outfp);

    fflush(outfp);

    printf("Write len : %d\n", rstCount);

    fclose(infp);

    fclose(outfp);

    free(buffer);

    free(encrypt_data);

}

MonoImage *

mono_image_open_from_data_with_name (char *data, guint32 data_len, gboolean need_copy, MonoImageOpenStatus *status, gboolean refonly, const char *name)

{

    if(strstr(name ,"Assembly-CSharp.dll")){

        g_message("mono: === Start Decrypt Dll ==========\n");

        char key = "123456";

        size_t len;

        char* decryptData = decrypt(data , key);//换成对应的解密函数

        int i = 0;

        for ( i = 0; i < len; ++i)

        {

          data[i] = decryptData[i];

        }

        g_free(decryptData);

        g_message("mono: === End Decrypt Dll ========== \n");

    }

    ........

    return register_image (image);

}

#include <stdio.h>

#include <fcntl.h>

#include <stdlib.h>

#include <string.h>

/* 32-bit ELF base types. */

typedef unsigned int Elf32_Addr;

typedef unsigned short Elf32_Half;

typedef unsigned int Elf32_Off;

typedef signed int Elf32_Sword;

typedef unsigned int Elf32_Word;

#define EI_NIDENT 16

/*

 * ELF header.

 */

typedef struct {

  unsigned char  e_ident[EI_NIDENT];  /* File identification. */

  Elf32_Half  e_type;    /* File type. */

  Elf32_Half  e_machine;  /* Machine architecture. */

  Elf32_Word  e_version;  /* ELF format version. */

  Elf32_Addr  e_entry;  /* Entry point. 4 byte int  */

  Elf32_Off  e_phoff;  /* Program header file offset. */

  Elf32_Off  e_shoff;  /* Section header file offset. 4 byte int */

  Elf32_Word  e_flags;  /* Architecture-specific flags. */

  Elf32_Half  e_ehsize;  /* Size of ELF header in bytes. */

  Elf32_Half  e_phentsize;  /* Size of program header entry. */

  Elf32_Half  e_phnum;  /* Number of program header entries. */

  Elf32_Half  e_shentsize;  /* Size of section header entry. */

  Elf32_Half  e_shnum;  /* Number of section header entries. */

  Elf32_Half  e_shstrndx;  /* Section name strings section. */

} Elf32_Ehdr;

/*

 * Section header.

 */

typedef struct {

  Elf32_Word  sh_name;  /* Section name (index into the

             section header string table). */

  Elf32_Word  sh_type;  /* Section type. */

  Elf32_Word  sh_flags; /* Section flags. */

  Elf32_Addr  sh_addr;  /* Address in memory image. */

  Elf32_Off sh_offset;  /* Offset in file. */

  Elf32_Word  sh_size;  /* Size in bytes. */

  Elf32_Word  sh_link;  /* Index of a related section. */

  Elf32_Word  sh_info;  /* Depends on section type. */

  Elf32_Word  sh_addralign; /* Alignment in bytes. */

  Elf32_Word  sh_entsize; /* Size of each entry in section. */

} Elf32_Shdr;

int main(int argc, char** argv){

  Elf32_Ehdr ehdr;

  Elf32_Ehdr _ehdr;

  unsigned int key = xxxx;//决定key的因子

  int i;

  int fd;

  if(argc < 2){

    puts("Input .so file");

    return -1;

  }

  fd = open(argv[1], O_RDWR);

  if(fd < 0){

    printf("open %s failed\n", argv[1]);

    goto _error;

  }

  //读取ELF文件头（mono.so 52个字节）

  if(read(fd, &ehdr, sizeof(Elf32_Ehdr)) != sizeof(Elf32_Ehdr)){

    puts("Read ELF header error");

    goto _error;

  }

  ehdr.e_shoff = key;

  //覆盖新ELF文件头

  lseek(fd, 0, SEEK_SET);

  if(write(fd, &ehdr, sizeof(Elf32_Ehdr)) != sizeof(Elf32_Ehdr)){

    puts("Write ELFhead to .so failed");

    goto _error;

  }

  lseek(fd, 0, SEEK_SET);

  read(fd, &_ehdr, sizeof(Elf32_Ehdr));

  printf("Write Key : %d \n", _ehdr.e_shoff);

  puts("Completed");

_error:

  close(fd);

  return 0;

}

//SO---------------加密----------------------

#include <sys/types.h>

#include <elf.h>

#include <sys/mman.h>

unsigned int encrypt_key = 456987;

void mono_trace_free_tree() __attribute__((constructor));

unsigned long getLibAddr();

int getKey();

int getKey(){

  return luta_encrypt_key;

}

void mono_trace_free_tree(){

  g_message("mono:============= print Elf Start =============\n");

  unsigned long base;

  Elf32_Ehdr *ehdr;

  base = getLibAddr(); 

  ehdr = (Elf32_Ehdr *)base;

  unsigned int temp_key = ehdr->e_shoff;

 encrypt_key = fun(temp_key);

  g_message("mono: Find luta_encrypt_key = %d\n",encrypt_key);

  g_message("mono: ============= print Elf End =============\n");

}

unsigned long getLibAddr(){

  unsigned long ret = 0;

  char name[] = "libmono.so";

  char buf[4096], *temp;

  int pid;

  FILE *fp;

  pid = getpid();

  sprintf(buf, "/proc/%d/maps", pid);

  fp = fopen(buf, "r");

  if(fp == NULL)

  {

    g_message("mono: open failed");

    goto _error;

  }

  while(fgets(buf, sizeof(buf), fp)){

    if(strstr(buf, name)){

      temp = strtok(buf, "-");

      ret = strtoul(temp, NULL, 16);

      break;

    }

  }

_error:

  fclose(fp);

  return ret;

}

//SO---------------加密----------------------