Mit Java Textfeld einer externen Anwendung auslesen

[Chry007]

Hey,
habe die Frage eigentlich schon im Titel gestellt. Wie kann ich aus eine Java-Applikation das Textfeld einer anderen Anwendung auslesen? Möglichst auch noch herausfinden, wann sich der Inhalt ändert. Später möchte ich auch herausfinden, wann diese Anweisung etwas in ihr logfile schreibt, aber ein Problem nach dem anderen.:toll:

Ich erwarte natürlich keine ausformulierte Lösung. Ich wäre schon für einen Hinweis sehr dankbar.. Name einer Klasse, Bibliothek etc.

Danke schonmal im Voraus für eure Hilfe
Gruß,
Chry

 

[faetzminator]

Gar nicht.
Höchstens mit JNI/JNA betriebssystemabhängig.
Java ist dafür die falsche Sprache!

 

[alcedo707]

Beitrag kann gelöscht werden, verdrückt, sorry

 

[Gast2]

Später möchte ich auch herausfinden, wann diese Anweisung etwas in ihr logfile schreibt, aber ein Problem nach dem anderen.

Das bekommst du aber relativ einfach mit der neuen File API von Java 7 hin.

 

[Chry007]

Ok. File API für logfile. Ist notiert Wo wäre ich denn für das auslesen des Textfensters an der richtigen Adresse?

 

[Gast2]

Wenn das überhaupt irgendwie gehen sollte (was ich stark bezweifel), dann solltest du dich mal über JNI und C schlau machen.

 

[Chry007]

Danke, das werde ich mal machen. Ich meine aber mal gelesen zu haben, dass so etwas möglich ist. Über das Umleiten der calls zur Windows-System API. Ich kann aber nichts mehr darüber finden...

 

[destiny]

Ich denke im allgemeinen wäre eine ausführlichere Beschreibung deinerseits gefragt Was meinst du mit "anderer" Anwendung?

Woher kommt dieses Problem? (aufgabe anner schule / Uni..? wenn ja, was war die korrekte aufgabenstellung?).

Wenn du dein problem konkreter beschreiben könntest, können dir sicher mehrere leute helfen

 

[Marcinek]

Vieleicht probierst du "AutoIt"

Ich selber habe es nie benutzt, aber damit kann man schon mal andere Anwendungen steuern.

Gruß,

Martin

 

[Cola_Colin]

Ich hab mal einen Bot für ein Spiel geschrieben (naja, es zumindest versucht, über das auslesen von Zahlenwerten bin ich nicht rausgekommen...), da hab ich Werte aus dem Speicherbereich des Spieles mit JNA (Gebraucht wird die JNA.jar und eventuell die plattform.jar) und der Windowsapi ausgelesen, wenn man die Speicheraddresse hat, dann kann man damit sicher auch auf Strings zugreifen. Um die zu finden, würde ich einen Debugger empfehlen, oder eventuell Cheat Engine letzteres hatte mir bei meinem vorhaben exorbitant geholfen.
Hier der Code, läuft mit JNA, man müsste eben noch eine Methode hinzufügen, die die eingelesenen bytes als String interpretiert, bzw. einen String in byte-Form rausschreibt.

import com.sun.jna.Memory;
import com.sun.jna.Native;
import com.sun.jna.Platform;
import com.sun.jna.Pointer;
import com.sun.jna.platform.win32.WinNT.HANDLE;
import com.sun.jna.ptr.IntByReference;
import com.sun.jna.win32.StdCallLibrary;
import java.io.Closeable;

/**
 *
 * @author Colin Clausen
 */
public class ProcessAPI implements Closeable{
    
    static {
        if (!Platform.isWindows()) {
            throw new RuntimeException("This works only with windows!");
        }
    }
    
    private HANDLE process = null;
    
    private HANDLE window = null;
    
    public boolean processWindowHasFocus() {
        return window.equals(User32.INSTANCE.GetForegroundWindow());
    }
    
    public boolean openProcessByWindow(String windowClass, String windowName) {
        if (process != null) {
            close();
        }
        
        IntByReference pid = new IntByReference();
        User32.INSTANCE.GetWindowThreadProcessId(window = User32.INSTANCE.FindWindowA(windowClass, windowName), pid);
        
        int accessCode = Kernel32.PROCESS_VM_OPERATION | Kernel32.PROCESS_VM_READ | Kernel32.PROCESS_VM_WRITE;
        
        process = Kernel32.INSTANCE.OpenProcess(accessCode, false, pid.getValue());
        
        return process != null;
    }
    
    @Override
    public void close() {
        if (process != null) {
            Kernel32.INSTANCE.CloseHandle(process);
        }
    }
    
    public byte readByte(int adr) {
        return readMemory(adr, 1)[0];
    }
    
    public int readInt(int adr) {
        return bytesToInt(readMemory(adr, 4));
    }
    
    public float readFloat(int adr) {
        return Float.intBitsToFloat(bytesToInt(readMemory(adr, 4)));
    }
    
    public void writeByte(int adr, byte b) {
        writeMemory(adr, new byte[] {b});
    }
    
    public void writeInt(int adr, int i) {
        writeMemory(adr, intToBytes(i));
    }
    
    public void writeFloat(int adr, float f) {
        writeMemory(adr, intToBytes(Float.floatToIntBits(f)));
    }
    
    private static byte[] intToBytes(int i) {
        byte[] dest = new byte[4];
        dest[3] = (byte) (i >>> 24);
        dest[2] = (byte) (i >>> 16);
        dest[1] = (byte) (i >>> 8);
        dest[0] = (byte) (i);

        return dest;
    }

    private static int bytesToInt(byte[] b) {
        int result = 0;

        result |= (0xFF & b[3]) << 24;
        result |= (0xFF & b[2]) << 16;
        result |= (0xFF & b[1]) << 8;
        result |= (0xFF & b[0]);

        return result;   
    }
    
    public byte[] readMemory(int adr, int count) {
        IntByReference bytesRead = new IntByReference();
        
        byte[] output = new byte[count];
        
        Memory mem = new Memory(output.length);
        Kernel32.INSTANCE.ReadProcessMemory(process, adr, mem, output.length, bytesRead);
        
        System.arraycopy(mem.getByteArray(0, bytesRead.getValue()), 0, output, 0, bytesRead.getValue());
        
        return output;
    }
    
    public int writeMemory(int adr, byte[] bytesToWrite) {
        IntByReference bytesWritten = new IntByReference();
        
        Memory mem = new Memory(bytesToWrite.length);
        mem.write(0, bytesToWrite, 0, bytesToWrite.length);
        
        Kernel32.INSTANCE.WriteProcessMemory(process, adr, mem, bytesToWrite.length, bytesWritten);
        
        return bytesWritten.getValue();
    }
    
    private static interface Kernel32 extends StdCallLibrary {
        public static int PROCESS_VM_OPERATION = 0x0008;
        public static int PROCESS_VM_READ = 0x0010;
        public static int PROCESS_VM_WRITE = 0x0020;
        
        Kernel32 INSTANCE = (Kernel32) Native.loadLibrary("kernel32.dll", Kernel32.class);

        public HANDLE OpenProcess(int dwDesiredAccess, boolean bInheritHandle, int dwProcessId);

        public boolean CloseHandle(HANDLE handle);

        public boolean ReadProcessMemory(HANDLE hProcess, int inBaseAddress, Pointer outputBuffer, int nSize,
                IntByReference outNumberOfBytesRead);      
        
        public boolean WriteProcessMemory(HANDLE hProcess, int inBaseAddress, Pointer inpputBuffer, int size,
                IntByReference outNumberOfBytesRead);
    }
    
    private static interface User32 extends StdCallLibrary {
        User32 INSTANCE = (User32) Native.loadLibrary("user32.dll", User32.class);
        
        public HANDLE FindWindowA(String ClassName, String WindowName);
        
        public HANDLE GetForegroundWindow();
        
        public int GetWindowThreadProcessId(HANDLE hWnd, IntByReference lpdwProcessId);
    }
}

EDIT:
Um den kompletten Namen und die Klasse des Fensters vom Zielprogramm zu bestimmen kann man z.B. Winspy verwenden.

Die Verwendung des Codes sieht dann z.B. so aus:

    public static void main(String[] args) {
	ProcessAPI accessor = new ProcessAPI();
	//Bestimmt mit WinSpy
	accessor.openProcessByWindow("BASE", "Touhou koumakyou ~ the Embodiment of Scarlet Devil"); 
	
	// Die Addresse muss ertüffelt(Cheatengine, debugger) werden,
	// diese hier z.B. setzte im betreffenen Spiel die Anzahl von Bomben
	accessor.writeByte(0x69D4BB, (byte)10);
	
	accessor.close();
    }