Jar-Datei splitten

[R3s1stanc3]

Hi
ich spiele zZ ein bisschen mit Java rum und möchte eine Jar-Datei splitten.
Ich habe davor 2 mal das selbe hallo_welt Programm durch einen Splitstring getrennt aneinander gehängt. Dazu der Code:

public void combineFiles ( String file1, String file2, String output, String split )
{
        
    try
    {
        RandomAccessFile data1 = new RandomAccessFile ( file1, "r" ) ;
        RandomAccessFile data2 = new RandomAccessFile ( file2, "r" ) ;
        
        byte [ ] byte1 = new byte [ ( int ) data1.length ( ) ] ;
        byte [ ] byte2 = new byte [ ( int ) data2.length ( ) ] ;
        byte [ ] splitBytes = new byte [ split . length ( ) ] ;
        byte [ ] both = new byte [ split . length ( ) + byte1 . length + byte2 . length ] ;
        
        splitBytes = split . getBytes ( ) ;
        
        data1.read ( byte1 ) ;
        data2.read ( byte2 ) ;
        data1.close ( ) ;
        data2.close ( ) ;
        
        both = concat ( byte1, splitBytes, byte2 ) ;
        
        RandomAccessFile newFile = new RandomAccessFile ( output, "rw" ) ;
        newFile . write ( both ) ;
        newFile . close ( ) ;
    }
    catch ( Exception e ) { }
    
}
    
public byte [ ] concat ( byte [ ] A, byte [ ] B, byte [ ] C ) 
{
    
    byte [ ] D = new byte [ A . length + B . length + C . length ] ;
    System . arraycopy ( A, 0, D, 0, A . length ) ;
    System . arraycopy ( B, 0, D, A . length, B . length ) ;
    System . arraycopy ( C, 0, D, A . length + B . length, C . length ) ;
    return D ;
    
}

Das hat super funktioniert. Ich habe dannach eine Datei, die ich immer noch ausführen kann (das erste hallo_welt Programm wird ausgeführt) und die Dateigröße stimmt auch (datei1+datei2+splitString)

Jetzt will ich mithilfe von split() die beiden ursprünglichen Dateien wieder herstellen:

public String [ ] getOldFile ( String file, String splitStr )
{
    
    try
    {
        StringBuffer fileData = new StringBuffer ( 1000 ) ;
        BufferedReader reader = new BufferedReader ( new FileReader ( file ) ) ;
        char [ ] buf = new char [ 1024 ] ;
        int numRead = 0 ;
        while ( ( numRead = reader . read ( buf ) ) != -1 )
        {
            String readData = String . valueOf ( buf, 0, numRead ) ;
            fileData . append ( readData ) ;
            buf = new char [ 1024 ] ;
        }
        reader.close();
        
        String data = fileData . toString ( ) ;
        String [ ] splited ;
        splited = data . split ( splitStr ) ;
        return splited ;
        
    }
    catch ( Exception e ) { return null ; }
    
}

Und die beiden Felder des String Arrays wieder in 2 neue Dateien schreiben:

public void writeFile ( String fi, String data )
{
    
    try
    {
        File file = new File ( fi ) ;
        FileWriter fw = new FileWriter ( file ) ;
        fw . write ( data ) ;
        fw . flush ( ) ;
        fw . close ( ) ;
    }
    catch ( Exception e ) { }
    
}

Die beiden neuen Dateien sind aber größer als die beiden ursprünglichen Dateien und lassen sich nicht mehr ausführen:

invalid file (bad magic number): Exec format error

Dateigrößen:
hallo_welt1.jar: 17362 byte
hallo_welt2.jar: 17362 byte
splitString: 1234567890 entspricht 10 byte
hallo_welt12.jar (beide zusammen): 34734 byte <- lässt sich problemlos ausführen
Nach dem Splitten:
file0.jar: 29473 byte
file1.jar: 29473 byte

er erkennt also den SplitString und splittet auch in 2 gleich große Dateien. Diese sind aber nicht mehr die ursprünglichen Dateien.
Woran könnte das liegen?

 

[R3s1stanc3]

Hab die Lösung:

    public byte[][] getOldFile2(String file, String splitStr) {		
		try {
			FileInputStream fis = new FileInputStream(file);
			byte[] dataByte = new byte[(int) (new File(file)).length()];
			fis.read(dataByte);
			fis.close();
			
			byte[] splitByte = splitStr.getBytes();
			
			int splitPos = -1;
			
			for(int i = 0; i < dataByte.length - splitByte.length;i++){
				for (int j = 0; j < splitByte.length; j++) {
					if (dataByte[i+j] != splitByte[j]) {
						break;
					}
					if (j == splitByte.length-1) {
						splitPos = i;					
					}
				}
				if(splitPos != -1){
					break;
				}
			}
			byte[] rByte1 = new byte[splitPos];
			byte[] rByte2 = new byte[dataByte.length - splitPos - splitByte.length];
			System.arraycopy(dataByte, 0, rByte1, 0, rByte1.length);
			System.arraycopy(dataByte, splitPos + splitByte.length, rByte2, 0, rByte2.length);
			
			byte[][] returnByte = {rByte1,rByte2};
			
			return returnByte;
		} catch (Exception e) {
			return null;
		}
	}

	public void writeFile2(String fi, byte[] data) {
		try {
	        FileOutputStream output = new FileOutputStream(fi);
	        output.write(data, 0, data.length);
	        output.flush();
	        output.close();			
		} catch (Exception e) {
		}
	}

So funktioniert es problemlos
(Sry für den Doppelpost)

 

[FileEncoding]

Hast du auch wenigstens gelernt warum das eine geht und das andere nicht ?

Als Tipp : die Reader/Writer Klassen sowie String sind nur für darstellbare Zeichen
Wenn du also Binärdateien damit bearbeiten willst kommt es zwangsläufig bei der Umwandlung byte > String > byte zu Charset-Encoding-Fehlern. Darum MUSS man für Binärdaten auch mit RAW-Streams und Byte-Arrays verwenden.