Modifica di valori di configurazione specifici nella tastiera su schermo di Windows 7

Devo usare la tastiera su schermo di Windows 7 per digitare:

(Se non l'hai ancora usato, puoi ottenerlo tramite: Tutti i programmi -> Accessori -> Facilità di accesso -> Tastiera su schermo

o cerca semplicemente "osk.exe")

Offre una funzione per "passare il mouse" sui pulsanti. Microsoft lo descrive come il seguente:

In modalità hovering, si utilizza un mouse o un joystick per puntare a un tasto per un periodo di tempo predefinito e il carattere selezionato viene digitato automaticamente.

C'è il mio problema specifico. Il periodo di tempo predefinito è troppo lungo per essere utile per me. Il tempo minimo è di 0,5 secondi (massimo 3 secondi).

Esiste un modo per modificare questo valore in qualcosa < 0,5? Ad esempio tramite la modifica del registro?

Modifica: la voce HKEY_CURRENT_USER\Software\Microsoft\Osk\HoverPeriodnon può essere impostata su un valore inferiore a 500 ms.

Modifica (2): penso che l'unico modo per risolvere il mio problema sia quello di decompilare il file .exe (suppongo sia scritto in C, o?) E modificare il tempo minimo. Quindi devo compilarlo di nuovo. Questa procedura è praticabile? Quali cose potrebbero fallire?

Qualsiasi consiglio utile sarebbe fantastico!

Dove trova il codice la nostra chiave?

Usando Process Monitor, scavando nel per l'evento ETL leggendo che la traccia dello stack di valori ci dà:

"Frame","Module","Location","Address","Path"
...
"3","ntdll.dll","NtQueryValueKey + 0xa","0x7fbce17344a","C:\Windows\SYSTEM32\ntdll.dll"
"4","KERNELBASE.dll","LocalBaseRegQueryValue + 0x15d","0x7fbcb1a3e1d","C:\Windows\system32\KERNELBASE.dll"
"5","KERNELBASE.dll","RegQueryValueExW + 0xe9","0x7fbcb1a3c19","C:\Windows\system32\KERNELBASE.dll"
"6","ADVAPI32.dll","RegQueryValueExWStub + 0x1e","0x7fbcba412fe","C:\Windows\system32\ADVAPI32.dll"
"7","osk.exe","OSKSettingsManager::GetOskSetting + 0xc7","0x7f72356057f","C:\Windows\System32\osk.exe"
"8","osk.exe","OSKSettingsManager::Initialize + 0x6e","0x7f72355ffe2","C:\Windows\System32\osk.exe"
"9","osk.exe","OSKSettingsManager::GetOSKSettingsManager + 0x64","0x7f72355fee4","C:\Windows\System32\osk.exe"
"10","osk.exe","COskNativeHWNDHost::DetermineOSKWindowSizeAndLimits + 0x5a","0x7f72355d4fa","C:\Windows\System32\osk.exe"
"11","osk.exe","COskNativeHWNDHost::Initialize + 0xaa","0x7f72355d28e","C:\Windows\System32\osk.exe"
"12","osk.exe","PresentOSK + 0x112","0x7f723557882","C:\Windows\System32\osk.exe"
"13","osk.exe","wWinMain + 0x356","0x7f723557f16","C:\Windows\System32\osk.exe"
"14","osk.exe","operator new[] + 0x37a","0x7f723564b12","C:\Windows\System32\osk.exe"
"15","KERNEL32.DLL","BaseThreadInitThunk + 0x1a","0x7fbcd24298e","C:\Windows\system32\KERNEL32.DLL"
"16","ntdll.dll","RtlUserThreadStart + 0x1d","0x7fbce19e229","C:\Windows\SYSTEM32\ntdll.dll"

Possiamo vedere che OSKSettingsManager::GetOskSettinglegge il valore.

Quindi, che aspetto ha quella porzione? Possiamo eseguire il debug?

Esaminando quella funzione con WinDBG, accede subito a quella chiave di registro 000007f7 23560517.

osk!OSKSettingsManager::GetOskSetting:
...
000007f7`2356050e ff15440bfeff    call    qword ptr [osk!_imp_RegOpenKeyExW (000007f7`23541058)]
000007f7`23560514 448bd8          mov     r11d,eax
000007f7`23560517 85c0            test    eax,eax
000007f7`23560519 751f            jne     osk!OSKSettingsManager::GetOskSetting+0x82 (000007f7`2356053a)
000007f7`2356051b 488b0b          mov     rcx,qword ptr [rbx]
...

Ora, il problema qui è che quando provo a breakpoint in quella posizione non riesco più a digitare nulla perché si osk.exeaggiunge ai driver di input. Questo può essere facilmente visto tenendo premuto un tasto modificatore come Altsulla tastiera, questo si illumina osk.exe.

Guardando nel codice per aggiunte o sottrazioni, vedo solo qualcosa accadere con 40esadecimali che è 64decimale. Quindi anche questo non è correlato al numero.

Potrebbe essere in una delle quattro cmpistruzioni (confronta), ma ciò richiederebbe informazioni di debug. Oppure potrebbe accadere in una funzione di livello superiore, il che richiederebbe ulteriori indagini. Ma senza la possibilità di eseguire il debug senza perdere le capacità di input, questa è una cosa molto difficile da fare ...

Sembra che trovare la posizione giusta richiederà un cavo di debug poiché il computer su cui si esegue il debug perde le sue capacità di input o è troppo lento a causa del sovraccarico del debug. Poiché al momento non ho un laptop con una porta del 1943, non riesco a eseguire questo debug da solo. Sarebbe in grado di farlo, e sì, bloccherebbe letteralmente il tuo sistema operativo. Il debug di un sistema operativo anziché di un'applicazione è divertente ... ^^

Aspetta, abbiamo accesso ai simboli! Possiamo trovare il codice offensivo?

OSKSettingsManager::ClearTransferKey(void)
OSKSettingsManager::GetOSKSettingsManager(OSKSettingsManager * *)
OSKSettingsManager::GetOskSetting(ulong,ulong *)
OSKSettingsManager::GetOskSetting(ulong,ulong *,int)
OSKSettingsManager::Initialize(void)
OSKSettingsManager::NotifyListeners(ulong,ulong)
OSKSettingsManager::RegisterListener(void (*)(ulong,ulong))
OSKSettingsManager::SQMStartupSettings(void)
OSKSettingsManager::SetOskSetting(ulong,ulong)
OSKSettingsManager::SetOskSetting(ulong,ulong,int)
OSKSettingsManager::_HandleUpdateAllListeners(void)
OSKSettingsManager::_KeepSettingValueInBounds(ulong,ulong *,int)
OSKSettingsManager::`scalar deleting destructor'(uint)

Dando un'occhiata più da vicino, noterai la funzione offensiva:

OSKSettingsManager::_KeepSettingValueInBounds(ulong,ulong *,int)

Se passiamo attraverso quella funzione vediamo prima:

mov     edi, edi
push    ebp
mov     ebp, esp
mov     eax, [ebp+arg_4]
imul    eax, 14h
cmp     dword_4B7598[eax], 0
jz      short loc_41BC36        

Ok, questo confronta qualcosa e poi salta in un'altra posizione. Cosa c'è qui?

pop     ebp
retn    8

Quindi, se la condizione decide che deve saltare, lascerà semplicemente la funzione e non cambierà nulla.

Quindi, come facciamo a lasciare sempre la funzione?

Cambia l' jzistruzione in jmpun'istruzione che fa sempre il salto, puoi trovarla all'offset relativo 41BC10. Nel caso in cui il tuo programma calcoli offset diversi, devi sapere che usa 401000come base, quindi la sottrazione ci dà l'offset assoluto 1AC10.

Si noti che cambiando 74( JZ) nell'editor esadecimale in E9( JMP) non funzionerà. Non puoi farlo in un editor esadecimale, avrai bisogno di qualcosa che disassembla e riassembla il codice ma non è necessariamente facile da trovare (es. IDA Professional per il quale le persone effettivamente pagano, non è in grado di produrre un codice c adeguato o un eseguibile. OllyDBG, comunemente usato nella comunità delle patch, non può nemmeno aprire l'eseguibile.). E poi anche, Microsoft potrebbe proteggere il suo eseguibile da manomissioni, perché questo potrebbe essere considerato contro l'EULA; perciò buona fortuna!

Meh! È difficile, voglio solo digitare velocemente usando il mio mouse / occhi / ...

Dovresti assolutamente dare un'occhiata a Dasher, che è molto più veloce di una tastiera su schermo. Funziona semplicemente spostando il mouse verso le lettere; il movimento orizzontale determina la velocità e il movimento verticale seleziona le lettere. Con un dizionario incorporato può persino ridimensionare le lettere più probabili per essere più grandi, cerca anche di imparare dai tuoi movimenti in modo tale che la velocità e le lettere siano davvero abituate al tuo utilizzo.

Un'immagine parla più di mille parole ...

Naturalmente questo è piuttosto piccolo e non molto veloce in quanto è un esempio, ma potresti ridimensionarlo per essere sul lato destro dello schermo in modo che non interferisca con lo schermo. Ciò ti consente di digitare il più velocemente possibile ...

Ecco un buon esempio di come le previsioni ti consentono di digitare qualsiasi lingua più rapidamente:

Si noti inoltre che le lettere a destra sono ordinate in un ordine specifico, in modo tale che la direzione principale (su, metà o giù) scelga tra i diversi tipi (lettere minuscole, maiuscole, numeri e punteggiatura); e quindi all'interno di tale direzione maggiore, la direzione minore sceglierà tra AZ, az, 0-9 e così via. L'ho usato in passato e sono rimasto davvero sorpreso da quanto sia fluido rispetto ad altri concorrenti ...

Nota anche che Dasher ha una configurazione, quindi potresti essere in grado di regolare qualcosa che non ti piace.

Temo che la maggior parte dei decompilatori non produrrà un risultato abbastanza buono da poter essere ricompilato.

La decompilazione può solo aiutare a individuare l'area HKEY_CURRENT_USER\Software\Microsoft\Osk\HoverPeriodutilizzata, in modo da scoprire dove viene letto questo valore e dove viene applicato il limite di 500 ms.

Una volta individuato, è necessario applicare una patch al codice binario in modo da disabilitare il test e imporre che HoverPeriod sia più piccolo. Patching del binario è molto più fattibile che ricompilare.

Potrebbe essere necessario ripetere lo sforzo se osk.exe viene mai sostituito da Windows Update (cosa che non mi aspetto davvero che accada).

[MODIFICARE]

Per aiutarti di più sulla strada, ecco alcune parole sulle utility e sul loro utilizzo.

Puoi usare un decompilatore C o un disassemblatore. Il tipo successivo può essere più utile, anche se richiede una piccola conoscenza del set di istruzioni Intel. Avrai anche bisogno di un buon editor esadecimale e ce ne sono alcuni che pubblicizzano le capacità del disassemblatore (vedi link sotto).

Il progetto fenris si pubblicizza come "suite di strumenti adatti per l'analisi del codice, il debug, l'analisi dei protocolli, il reverse engineering, la medicina legale, la diagnostica, i controlli di sicurezza, la ricerca delle vulnerabilità e molti altri scopi". Sembra buono e consigliato da molti, ma non ho esperienza con esso.

REC Studio Decompiler tenta di produrre una rappresentazione simil-C del codice e dei dati utilizzati per creare il file eseguibile.

Boomerang è un decompilatore generale, open source, retargetable di programmi di codice macchina.

Molte altre di queste utilità possono essere trovate su Google, o in:

wikibooks x86 Strumenti di
smontaggio / disassemblaggio wikibooks x86 Disassemblaggio / disassemblatori e decompilatori
Open Directory: Disassemblatori

Un passaggio preliminare consiste nello smontare osk. L'elenco risultante potrebbe essere voluminoso e richiedere un buon editor di testo (normalmente notepad ++ è sufficiente).

Cerca la stringa "HoverPeriod" (senza distinzione tra maiuscole e minuscole). Se sei fortunato, il disassemblatore lo ha identificato come una stringa e puoi trovarlo così com'è. In caso contrario, dovrai cercarlo byte per byte. Come stringa Unicode sembrerà H,0,o,0,v,0...dove le lettere dovrebbero essere sostituite dai loro codici numerici.

Dopo aver trovato la stringa "HoverPeriod", il disassemblatore avrebbe dovuto posizionare un'etichetta da qualche parte prima di essa. Utilizzare il nome di questa etichetta generata per cercare dove viene utilizzato, per identificare dove viene recuperato dal registro e in quale variabile globale è archiviato il risultato.

Una volta individuata la variabile che contiene il conteggio, cerca dove viene utilizzata. Quello che farai dipende dal formato del codice che troverai. È quindi possibile decidere la patch desiderata.

Ad esempio, potresti voler usare l'editor hex per sostituire in osk.exe un comando come:

move AX,<HoverPeriod milliseconds count variable>

in

mov AX,200       (your count of 200 milliseconds)

Prestare attenzione con diverse lunghezze di comando, dove se il nuovo comando è più corto dovrà essere completato con istruzioni NOP a un byte (nessuna operazione) alla lunghezza della vecchia istruzione.

L'individuazione del comando da patchare in osk.exe potrebbe richiedere la ricerca se gli offset forniti dal disassemblatore sono nel codice anziché nel file exe. Se l'editor esadecimale non supporta la ricerca dell'assemblatore, fai lo smontaggio mentre elenca i byte delle istruzioni originali in modo da sapere quali byte binari cercare. Evita di cercare istruzioni che contengono indirizzi, poiché gli indirizzi possono essere trasferiti nell'esempio, quindi cerca una sequenza di byte vicino a tale istruzione.

È possibile creare i nuovi byte di patch direttamente nell'editor esadecimale se supporta l'assemblatore. Oppure, se non lo fa e non ti senti a tuo agio con il codice macchina Intel, trova un assemblatore per compilare il tuo nuovo codice e usa la sua lista per ottenere i byte compilati da usare per il patching.

Posso suggerire di utilizzare AutoIt per automatizzare il clic?

L'idea sarebbe quella di monitorare il mouse al minimo quando il cursore si trova all'interno della finestra sullo schermo (ad esempio in un loop di controllo, controllando a intervalli regolari se il cursore ha cambiato posizione) e fare clic automaticamente (funzione di chiamata SendClick) dopo, diciamo, 100ms di inattività.

Batte reverse engineering an .exe.

Forse non devi ricompilare tutto. Nel mondo di gioco è comune usare i trainer, che manipolano un valore in memoria quando il programma è in esecuzione. Se trovi il valore minimo in memoria (0.5) e programmi qualcosa come un caricatore per ridurre quel numero, potrebbe funzionare.