Ciao community! Appena registrato e prima discussione.
Vi spiego cosa sto cercando:
Mio nipote possiede un tablet Huawei, in questo momento non so dire il modello preciso.
Questo tablet ha un pin di protezione a 4 cifre numeriche, dopo un paio di anni mio nipote ha deciso di cambiare la sequenza ma stupidamente non l'ha annotata da nessuna parte. Poco dopo averla cambiata ha smesso di usare il tablet per un certo periodo e quando lo ha ripreso in mano non la ricordava più.
Prima che qualcuno intervenga per consigliarmi di resettare il sistema vi dico che non è quello l'argomento della discussione.
Resettare il sistema è il piano B e se deciderò di farlo non avrò bisogno di un forum di hacker, lo dico ora e non ci torno più.
Quello che voglio, sia per preservare il contenuto dell'SSD, che per fare un esperimento interessante, è tentare di recuperare la sequenza che sblocca il tablet. Se siete veri hacker l'idea dovrebbe intrigarvi.
In origine volevo scrivere su un forum per programmatori ma poi ho pensato che sia più un lavoro da hacker anche se bisogna distinguere tra fanatici dell'argomento e hacker veri. Spero di non offendere nessuno se affermo che le scelte grafiche del sito fanno pensare più alla prima categoria, ma fate sempre in tempo a smentirmi.
VENIAMO AL PUNTO
L'interfaccia di inserimento del pin su tablet è grafica e tramite touchscreen. Questo è un primo grande limite che impedisce l'uso di sistemi automatizzati per individuare la sequenza. Il secondo grande limite è che consente solo 3 tentativi all'ora.
Inizialmente ho provato a basarmi sulle memoria di mio nipote, lui sembra ricordare la sequenza originale, quella che poi è stata sostituita (3684), ha un ricordo anche della nuova sequenza ma questo ricordo si è rivelato sbagliato (3752).
Il mio primo tentativo è stato di segnarmi le 24 combinazioni che si ottengono con le cifre 2,3,5 e 7 e le ho provate tutte ma senza successo.
Poi ho deciso di interpellare ChatGPT e le ho chiesto di cerare sequenze in base a certe considerazioni, come ad esempio il principio secondo il quale nessuno sceglie una sequenza tipo 1234 oppure 1111 ma nemmeno 2580 (perché una linea retta) oppure 1397 (perché è il giro degli angoli in senso orario).
Inizialmente comunque speravo di sfruttare le memorie inconsce di mio nipote e cosi ho provato anche a disegnare un tastierino su carta e gli ho chiesto di comporre delle sequenze dicendole ad alta voce mentre io prendevo nota.
L'idea alla base di questo è che una persona tende ad usare dei criteri personali quando sceglie una sequenza da usare come combinazione anche se non ne è consapevole. Quindi secondo me se fossi riuscito a far comporre un discreto numero di combinazioni a mio nipote, prima o poi lui avrebbe finito per digitare quella già usata.
Purtroppo il ragazzo non è affatto collaborativo e pensa che io stia solo perdendo tempo. La prima volta ha accettato di farlo ma mi sono accorto subito che lo faceva in modo totalmente casuale e quindi non come se stesse cercando di scegliere una combinazione da utilizzare.
Allora sono tornato da GPT e gli ho chiesto di crearmi una web app che simuli un tastierino e memorizzi le sequenze digitate, l'idea era di fargli digitare solo poche sequenze al giorno, diciamo 5 ma chiedendogli di scegliere sequenze che a suo parere fossero valide da usare in modo fisso.
Ma anche in questo caso lui si è dimostrato poco collaborativo e cosi ho deciso che è meglio fare diversamente.
Ho chiesto a GPT di crearmi uno script che generi sequenze tenendo conto di alcuni criteri, io avrei poi salvato queste sequenze su file che avrei messo in una cartella a fianco dello script. Ogni volta che lo script viene invocato prima di tutto prende nota delle sequenze presenti nella cartella menzionata e le esclude come possibilità per la nuova sequenza. In questo modo evito di perdere tempo con eventuali doppi.
Ho chiesto a GPT di crearlo in Python, in Perl e in GAWK, ma più che altro per vedere se la cosa funzionava. La cosa funziona ma Python e Perl sono decisamente più adatti.
PERCHÉ HO APERTO QUESTA DISCUSSIONE
Io non sono un programmatore nemmeno di quelli alle prime armi, ho fatto solo qualche esperimento di tanto in tanto ma roba da nulla, quindi sono stato costretto a ricorrere a GPT e secondo me il suo lavoro non è male.
Usando le sue sequenze però mi sono accorto che alcune violano le regole che io avevo richiesto, anche se devo precisare che con GPT avevo fatto più un discorso di priorità che di esclusione.
Comunque per quanto GPT sia uno strumento stupefacente penso che par il momento ci siano ancora persone che su un compito simile possano superarla.
Quindi sono venuto qui per vedere se qualcuno è capace di creare uno script in grado di generare sequenze con maggiore possibilità di successo rispetto allo script attuale.
Eventualmente possiamo discutere le caratteristiche che dovrebbe avere questo script, ci sono molte cosa che possono restringere le possibilità anche se si tratta sempre di un discorso di probabilità.
Non so che tipo di gente ci sia in questo forum, magari siete più che altro ragazzi che si esaltando a lanciare attacchi DDOS contro il profilo Facebook del Papa (e già mi aspetto obiezioni sul fatto che si possa fare una cosa simile).
Capirò dalle risposte se qui ci sono persone adatte a questo compito e questo è ovviamente solo un invito, non pretendo nulla da nessuno, se l'idea vi interessa per qualche motivo bene, altrimenti nessun problema.
Penso sia chiaro che qui non sia sufficiente essere esperti di tecnologia, occorre avere anche un certo livello di conoscenze delle dinamiche psicologiche, cosa che i veri hacker possiedono.
A scanso di equivoci, non sono disposto a pagare per una cosa simile.
Ringrazio in anticipo tutti quelli che risponderanno in qualsiasi modo. Di seguito il codice Python creato da GPT:
------------------
import os
import random
from pathlib import Path
# Definizione del tastierino come matrice per coordinate
keypad = { '1': (0, 0), '2': (0, 1), '3': (0, 2), '4': (1, 0), '5': (1, 1), '6': (1, 2), '7': (2, 0), '8': (2, 1), '9': (2, 2), '0': (3, 1) }
# PIN da escludere perché banali
banal_pins = { "1234", "4321", "1111", "0000", "1122", "1212", "2468", "1357", "2580", "1478", "3690" }
# Funzione per determinare se una sequenza è lineare (retta o diagonale)
def is_linear(pin):
coords = [keypad[d] for d in pin if d in keypad]
if len(coords) < 2:
return False
dx = coords[1][0] - coords[0][0]
dy = coords[1][1] - coords[0][1]
for i in range(1, len(coords)):
nx = coords[i][0] - coords[i - 1][0]
ny = coords[i][1] - coords[i - 1][1]
if (nx, ny) != (dx, dy):
return False
return True
# Carica tutti i PIN già usati dai file nella cartella liste/
def load_existing_pins(directory):
existing = set()
for file in Path(directory).glob("*.txt"):
with open(file, 'r') as f:
for line in f:
existing.add(line.strip())
return existing
# Generazione dei PIN validi
def generate_pins(n=10):
existing_pins = load_existing_pins("liste")
valid_pins = []
while len(valid_pins) < n:
pin = ''.join(random.sample("0123456789", 4))
if pin in existing_pins:
continue
if pin in banal_pins:
continue
if any(pin.count(d) > 1 for d in pin):
continue
if is_linear(pin):
continue
if pin[0] in {'0', '9'} or pin[-1] in {'0', '9'}:
continue # penalizzazione: escludiamo direttamente # priorizzazione: opzionale se si vuole migliorare ulteriormente
valid_pins.append(pin)
return valid_pins
# Esecuzione e output
if __name__ == "__main__":
pins = generate_pins()
print("PIN generati:")
for p in pins:
print(p)
# Salvataggio opzionale
#save = input("Vuoi salvare i PIN in un file? (s/n): ")
# if save.lower() == 's':
# filename = input("Nome del file (senza estensione): ")
# path = Path("liste") / f"{filename}.txt"
# with open(path, 'w') as f:
# for p in pins:
# f.write(p + "\n")
# print(f"Salvato in {path}")
------------------
