¿Cómo usar las anotaciones Java para modificar el código fuente antes de la compilación final?

Question

que he leído de la página de la herramienta apta que uno puede crear AnnotationProcessors a generate new derived files (source files, class files, deployment descriptors, etc.). Estoy buscando por ejemplo para hacerlo.

Mi necesidad es codificar todas las cadenas anotados en tiempo de compilación, por lo que la lectura del archivo de clase no permite la lectura de las cadenas estáticas:

código Base:

String message = (@Obfuscated "a string that should not be readable in class file"); 

deberán ser reciclados como:

String message = new ObfuscatedString(new long[] {0x86DD4DBB5166C13DL, 0x4C79B1CDC313AE09L, 0x1A353051DAF6463BL}).toString(); 

Basado en el ObfuscatedString.obfuscate(String) method of the TrueLicense framework estático, el procesador puede generar el código para reemplazar la cadena anotada. De hecho, este método genera la cadena "new ObfuscatedString ([numeric_code]). ToString()". En tiempo de ejecución el método toString() de ObfuscatedString es capaz de devolver la cadena codificada en el código numérico.

Alguna idea sobre cómo escribir el método() de la AnnotationProcessor para editar el código anotado proceso?

Gracias de antemano,

Answer 1

usted podría tener

String message = Obfuscated.decode("a string that should not be readable in class file"); 

que compila normalmente, sin embargo después de la compilación tiene una herramienta que analiza el código de bytes, por ejemplo, mediante ASM de ObjectWeb, cambia la cadena literal lo que parece que

String message = Obfuscated.decode("\u86DD\u4DBB\u5166\uC13D\u4C79\uB1CD\uC313\uAE09\u1A35\u3051\uDAF6\u463B"); 

Para hacer mas fácil la identificación de cadenas que hay que cambiar, se puede añadir un prefijo a ellos, y se podía garantizar este prefijo no aparecerá después de la el código ha sido ofuscado

String s = "Obfuscate: a string that should not be readable in class file"; 
// later 
String message = Obfuscated.decode(s); 

Answer 2

Apuesto spoon puede ser lo que estás buscando. Pero, ¿por qué quieres ofuscar cadenas estáticas?

Answer 3

Zelix KlassMaster ofrece esta capacidad. Si la memoria sirve, solía ser gratuita para las empresas de menos de 3 desarrolladores, pero acabo de comprobar su página de compra, y parece que ahora cobran una tarifa de pequeños desarrolladores para pequeñas empresas. Yo no lo he utilizado en varios años (por lo menos 5 o 7), pero hizo un trabajo fantástico ofuscar cuerdas, y el código en general.

Answer 4

Cuando voy a generar la versión para la distribución, tengo una clase que invalidan todas las constantes con la llamada Ofuscated Cadena:

Este es el proceso:

1. dirigir mi ANT , que copia todo el código en otro lugar.
2. La llamada ANT a OfuscateJavaConstant.
3. que compilar el código.

La ANT:

<java classname="de.schlichtherle.util.ObfuscatedString"> 
    <arg value="${of.constant}" /> 
    <classpath> 
     <pathelement location="${exit.path}/${buildDir}" /> 
     <path refid="myclasspath" /> 
    </classpath> 
    </java> 

El código Java Ofuscate (ObfuscatedString):

public static void main(String[] args) { 
    if (args!=null){ 
     String[] ficheros = args[0].split(";"); 

     if (args!=ficheros) 
      for (String ruta:ficheros) 
       ofuscateConstantClass(ruta); 
    } 
} 

private static void ofuscateConstantClass(String fileName){ 

    File archivo = null; 
    FileReader fr = null; 
    BufferedReader br = null; 
    List<String> sb = new ArrayList<String>(); 
    FileWriter fichero = null; 
    PrintWriter pw = null; 

    try{ 
     archivo = new File(fileName); 
     fr = new FileReader (archivo); 
     br = new BufferedReader(fr); 
     String linea; 
     while((linea=br.readLine())!=null){ 

      String noWhite = linea.trim().replaceAll(" +", " "); 

      if (noWhite.toLowerCase().startsWith("public static final string") && noWhite.endsWith("\";")){ 

       String firstPart = noWhite.substring(0, noWhite.indexOf("\"")); 
       String constant = noWhite.substring(noWhite.indexOf("\"")+1, noWhite.lastIndexOf("\"")); 
       String ofuscatedConstant = obfuscate(constant); 
       String secondPart = noWhite.substring(noWhite.lastIndexOf("\"")+1); 
       sb.add(firstPart + ofuscatedConstant + secondPart); 
       System.out.println(constant + "-->" + ofuscatedConstant); 
      } else 
       sb.add(linea); 
     } 

     fichero = new FileWriter(fileName); 
     pw = new PrintWriter(fichero); 
     for (String s:sb) 
      pw.println(s); 

    } catch (Exception e){ 

    } finally { 
     try{ 
      if(null != fr) 
       fr.close(); 
      if(null != pw) 
       pw.close(); 
      if(null != fichero) 
       fichero.close(); 
     }catch (Exception e2){ 
      e2.printStackTrace(); 
     } 
    } 

} 

espero que ayude :)