Quale strumento di analisi statica utilizzare per la scansione del flusso di dati da un metodo all'altro?

Question

dicono che ci sono due metodi della mia biblioteca:

void com.somepackage.SomeClass.someSink(String s)

e

int com.someotherpackage.SomeOtherClass.someSource(int i)

Il primo metodo è utilizzato come dissipatore di dati, mentre il secondo come fonte di dati nel mio codice . I parametri di tipo int, String vengono forniti a titolo di esempio e potrebbero cambiare nella situazione attuale.

voglio rilevare l'utilizzo di questi metodi in un codice che soddisfano un certo modello indicato di seguito:

1. alcuni dati (diciamo x) viene generato dalla sorgente
2. alcuni dati (diciamo y) viene generato utilizzando una serie di trasformazioni f1(f2(... fn(x))
3. viene assegnato al sink.

Le trasformazioni possono essere qualsiasi funzioni arbitrarie finché v'è una sequenza di chiamate dalla funzione che genera i dati per il lavandino per una funzione che prende in dati dall'origine. Le funzioni possono assumere anche altri parametri e devono essere utilizzate come black-box.

La scansione può essere al livello sorgente o codice byte. Quali sono gli strumenti disponibili là fuori per questo tipo di analisi?

Preferisci strumenti non IDE con API Java.

[EDIT:] chiarire più, someSink e someSource sono metodi arbitrari nomi delle classi SomeSome e SomeOtherClass rispettivamente. Possono o non possono essere static e possono assumere un numero arbitrario di parametri (che dovrei essere in grado di definire). Anche il tipo dei parametri non è arbitrario. L'unico requisito è che lo strumento esegua la scansione del codice e dei numeri di riga di output in cui si verifica il modello. Quindi lo strumento potrebbe funzionare in questo modo:

• Ottenere i nomi di sink e origine (nome completo della classe e nome del metodo) dall'utente.
• staticamente la scansione del codice e trovare tutti i luoghi dove il lavandino data e la fonte siano utilizzati
• Verificare se un percorso esiste in cui viene dato un po 'di dati in uscita dal fonte di affondare, direttamente o indirettamente, tramite una serie di operazioni (operatori, metodi).
• Ignora le sorgenti/i sink in cui non esiste un percorso di questo tipo e restituisce i restanti (se presenti).

uscita Esempio:

MyClass1.java:12: value1 = com.someotherpackage.SomeOtherClass.someSource(...) 
MyClass2.java:23: value2 = foo(value1, ...) 
MyClass3.java:3: value3 = bar(value2) 
MyClass4.java:22: com.somepackage.SomeClass.someSink(value3, ...) 

Nota: Se una funzione non prende parametri ma ha alcuni effetti collaterali sui dati deve anche essere considerato. (L'esempio a = source(); void foo(){ c = a+b }; foo(); sink(c) è uno schema che deve essere catturato.)

Answer 1

Dopo aver fatto qualche ricerca, ho trovato che soot è il più adatto per questo tipo di attività. La fuliggine è più matura di altre alternative open source come PQL.

Answer 2

Quindi il ruolo dei metodi source e sink è semplicemente che x ha origine nel metodo source (da qualche parte) e viene consumato (da qualche parte) nel metodo target? Come si caratterizza "x", o vuoi semplicemente tutti x che hanno questa proprietà?

Supponendo di aver identificato una specifica x nel metodo di origine, si fa a) insistere sul fatto che x essere passati al metodo di destinazione solo da chiamate di metodo [che renderebbe il metodo di destinazione l'ultima chiamata nella catena di chiamate ], oppure è possibile copiare uno dei valori intermedi? b) insistere sul fatto che ogni chiamata di funzione ha esattamente un argomento?

Abbiamo fatto qualcosa di simile per sistemi C di grandi dimensioni. Il problema era di tracciare una variabile assegnata in un uso in altre funzioni dovunque potessero essere, inclusi valori non identici nella rappresentazione ma identici nell'intento ("copia astratta"; la stringa "1.0" è astratta- mente equivalente al numero intero 1 se io uso la stringa alla fine come numero; "int_to_string" è una funzione di "copia astratta" che converte un valore in una rappresentazione in un valore equivalente in un'altra.).

Ciò di cui abbiamo bisogno è un'analisi delle definizioni di raggiungimento per ogni funzione ("dove va il valore di un compito specifico?") E una "copia astratta" che raggiunge un'analisi che determina dove un valore di raggiungimento viene consumato da uno speciale funzioni contrassegnate come "copie astratte" e dove raggiunge il risultato di tale funzione di copia abstact. Quindi una chiusura transitiva di "x raggiunge z" e "x raggiunge f (x) raggiunge z" calcolata dove x può andare.

L'abbiamo fatto utilizzando il nostro DMS Software Reengineering Toolkit, che fornisce analisi generiche e il flusso macchinari di analisi, e DMS di C Front End, che implementa la specifica raggiungere e calcoli per C. DMS raggiungere astratto-copia-ha un Java Front End che calcola le definizioni portata; uno avrebbe aggiunto la logica di raggiungimento della copia abstact e reimplementare il codice di chiusura transitiva.