Ressource + Tool

[KrT]

Guten Tag,

Knuddels verwaltet seine Ressourcen in einer als Klasse getarnten Datei (aktuell za.class). Diese Datei ist allerdings keine Klasse, sondern eine verschlüsselte Textdatei.
Ihr kennt es sicherlich aus dem Applet, wenn ein String als xx.a(1234) dargestellt ist.

Die Datei ist in zwei Teile aufgebaut. Einmal in den kodierten Teil, der erste dekodiert werden muss und dann in den Raw-Teil, zu dem wir später kommen.
Teil 1 besteht aus 2 Teilen, dem Header und dem Content.

Header (3 bytes)
Die ersten drei Bytes ergeben als 24bit-Integer die Länge des Contents, also:

int len = buffer[0] << 16 | buffer[1] << 8 | buffer[2];

Die Länge ist die Länge der Datei minus drei, da die ersten drei Bytes nicht mehr gebraucht werden.
Das dritte Byte hat noch eine Sonderfunktion, es stellt das Decodebyte der Datei da, welche mit einer sehr simplen xor-Kodierung verschlüsselt ist.

Content (len bytes)
Der Content setzt sich auch sehr einfach zusammen.
rLen (1 byte)
res (n bytes)

Also zB:

00000000  09 4b 45 59 5f 56 41 4c  55 45                    .KEY_VALUE

Die 0x09 gibt die Länge des Strings an. In diesem Fall halt 9. Um nun an einen String zu kommen gibt man der Funktion die Stelle, an der der String anfängt. Die Funktion geht dann zu Position - 1 und liest die Länge aus, und erhält so den String.

import java.io.InputStream;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.FileOutputStream;

class kRes {

     public static void main(String[] args) throws Exception {
          if(args.length == 0) {
               System.out.println("kRes-Analysor v1.0 by KrT @ banana-coding / k-script");
               return;
          }
          String resFile = args[0];
          try { 
               if(!load(resFile)) System.err.println("[ERROR] unknown i/o error");
          } catch(IOException ioe) {
               System.err.println("[ERROR] resfile isn't there");
          }
          
          if(args[1].equals("get")) {
               System.out.println(getRes(Integer.parseInt(args[2])));
          } else if(args[1].equals("put")) {
               System.out.println(setRes(resFile, args[2]));
          }
     }
     
     static byte[] buffer;
     static String[] stringBuffer = new String[256];
     static int[] posBuffer = new int[256]; 
     
     static String getRes(int pos) {
          int posByte = pos & 0xFF; // Auf 8 Bit trimmen
          // Wenns im buffer noch nicht vorhanden ist, adden.
          if(posBuffer[posByte] != pos) {
               posBuffer[posByte] = pos;
               pos = pos < 0 ? pos & 0xFFFF : pos;
               String returnStr = new String(buffer, 0, pos, buffer[pos - 1] & 0xFF).intern();
               stringBuffer[posByte] = returnStr;
          }
          return stringBuffer[posByte];
     }
     
     static int setRes(String fileName, String res) throws IOException{
          FileOutputStream out = new FileOutputStream(fileName, false);
          int nLen = buffer.length + res.length() + 1;
          byte[] bLen = new byte[3];
          bLen[2] = (byte) nLen;
          bLen[1] = (byte) (nLen >> 8);
          bLen[0] = (byte) (nLen >> 16);
          out.write(bLen);
                             
          byte[] newBuffer = new byte[nLen];
          System.arraycopy(buffer, 0, newBuffer, 0, buffer.length);
          System.arraycopy(new byte[] { (byte) res.length() }, 0, newBuffer, buffer.length, 1);
          System.arraycopy(res.getBytes(), 0, newBuffer, buffer.length + 1, res.length());
          
          for(int i = 0; i < newBuffer.length; newBuffer[i] = (byte) (newBuffer[i++] ^ bLen[2]));
          out.write(newBuffer);
          out.flush();
          out.close();
          return buffer.length + 1;
     }
     
     static boolean load(String resFile) throws IOException {
          InputStream resourceStream = new FileInputStream(resFile);
          if(resourceStream != null) {
               // Die ersten drei Bytes geben die Länge des Puffers an (Puffergröße = Dateigröße)
               byte decodeByte;
               int len = resourceStream.read() << 16 |  resourceStream.read() << 8 | (decodeByte = (byte)  resourceStream.read());
               len = len < 0 ? len & 0xFFFF : len; // signed fix
               buffer = new byte[len];
               
               int offset = 0;
               while(len > 0) {
                    int res;
                    if((res = resourceStream.read(buffer, offset, len))  < 0) break; // Liest len bytes aus dem Stream (angefangen bei i)
                    len -= res; 
                    res += offset;
                    
                    while(offset < res) {
                         buffer[offset] = (byte) (buffer[offset++] ^ decodeByte); // simple xor
                    }
               } 
               return true;
          }
          return false;
     }
}

Diese Klasse kann diese Datei dekodieren und einkodieren, also Einträge entfernen und neue hinzufügen. Ist natürlich nur ein Beispielprojekt und erweiterbar.

MfG