soot
4.6.0
Em dezembro de 2022, lançamos oficialmente o SootUp, uma versão do Soot com uma arquitetura completamente reformulada, mais modular, testável, sustentável e utilizável. Por favor, verifique isso caso deseje iniciar um novo projeto de análise de programa.
Como houve alguma confusão: o SootUp ainda não está completo. Portanto, o "antigo" Fuligem precisa sobreviver por enquanto, especialmente para projetos que exigem recursos de instrumentação ou suporte robusto ao Android. O "antigo" Fuligem ainda está sendo mantido até que possa ser descartado com segurança para um sucessor completo.
Solicitamos regularmente financiamento para nos ajudar a manter o Fuligem. Você pode nos ajudar imensamente informando-nos sobre projetos que utilizam Fuligem , tanto comercialmente quanto na forma de ferramentas de pesquisa.
Muito obrigado também por apoiar o Soot com uma licença de código aberto de uso gratuito!
... por apoiar o desenvolvimento do Fuligem! Amazon Web Services é patrocinador Gold.
Leia mais aqui sobre como se tornar um patrocinador por conta própria.
Experimente e envolva-se no desenvolvimento de ponta do Java 9 da Soot.
ModuleScene do SootSoot é uma estrutura de otimização Java. Ele fornece quatro representações intermediárias para analisar e transformar bytecode Java:
Consulte https://soot-oss.github.io/soot para obter detalhes.
Temos alguma documentação sobre Fuligem no wiki e também uma grande variedade de tutoriais sobre Fuligem.
Para obter informações detalhadas, considere também as documentações JavaDoc e de opções da Soot.
Uma versão do Soot é atualmente construída para cada commit no branch master . Você pode incluir Soot como uma dependência via Maven, Gradle, SBT, etc. usando as seguintes coordenadas:
< dependencies >
< dependency >
< groupId >org.soot-oss</ groupId >
< artifactId >soot</ artifactId >
< version >4.3.0</ version >
</ dependency >
</ dependencies > Você também pode obter versões mais antigas do branch master . Uma lista completa de compilações pode ser encontrada no Maven Central.
Um Soot SNAPSHOT é atualmente construído para cada commit no branch develop . Você pode incluir Soot como uma dependência via Maven, Gradle, SBT, etc. usando as seguintes coordenadas:
< dependencies >
< dependency >
< groupId >org.soot-oss</ groupId >
< artifactId >soot</ artifactId >
< version >4.4.0-SNAPSHOT</ version >
</ dependency >
</ dependencies >
< repositories >
< repository >
< id >sonatype-snapshots</ id >
< url >https://oss.sonatype.org/content/repositories/snapshots</ url >
< releases >
< enabled >false</ enabled >
</ releases >
</ repository >
</ repositories > Você também pode obter versões mais antigas do branch develop . Uma lista completa de compilações pode ser encontrada no Maven Central.
Recomendamos usar o Soot com Maven. Você pode obter a versão mais recente do Soot diretamente. Você pode obter a versão mais recente do SNAPSHOT do Soot diretamente.
O arquivo soot-<RELEASE>-jar-with-dependencies.jar é um arquivo completo que também contém todas as bibliotecas necessárias.
O arquivo soot-<RELEASE>.jar contém apenas Fuligem, permitindo que você escolha manualmente as dependências conforme necessário. Se você não quiser se preocupar com dependências, recomendamos usar a primeira.
Se você não consegue trabalhar com as versões pré-construídas e precisa construir o Soot por conta própria, considere o wiki para obter etapas adicionais.
Fuligem segue a convenção git-flow. Releases e hotfixes são mantidos no branch master. O desenvolvimento acontece no ramo de desenvolvimento. Para entender o que há de mais moderno em Fuligem, dê uma olhada neste último.
Estamos felizes em aceitar melhorias arbitrárias no Soot na forma de solicitações pull do GitHub. Leia nossas diretrizes de contribuição antes de configurar uma solicitação pull.
Você está usando o Soot e gostaria de nos ajudar a apoiá-lo no futuro? Então, por favor, ajude-nos preenchendo este pequeno formulário online.
Dessa forma você pode nos ajudar de duas maneiras:
Se você deseja executar o Soot com Java> 8, está pronto. Basta executá-lo normalmente. Se você deseja executar o Soot com Java 8, mas analisar projetos Java >8 ou vice-versa, veja abaixo.
Para carregar módulos no ModuleScene do Soot a partir de java:
// configure Soot's options, refer to example configurations below
Options . v (). set_soot_modulepath ( modulePath );
// load classes from modules into Soot
// Here, getClassUnderModulePath() expects the module path to be set using the Options class as seen above
Map < String , List < String >> map = ModulePathSourceLocator . v (). getClassUnderModulePath ( modulePath );
for ( String module : map . keySet ()) {
for ( String klass : map . get ( module )) {
logger . info ( "Loaded Class: " + klass + " n " );
loadClass ( klass , false , module );
// the loadClass() method is defined below
}
}
//this must be called after all classes are loaded
Scene . v (). loadNecessaryClasses ();
public static SootClass loadClass ( String name , boolean main , String module ) {
SootClass c = ModuleScene . v (). loadClassAndSupport ( name , Optional . of ( module ));
c . setApplicationClass ();
if ( main )
Scene . v (). setMainClass ( c );
return c ;
}ModuleUtil.module_mode() ajuda a verificar se você tem módulos habilitados no Soot. Isso é feito com base no fato de o caminho do módulo ser definido usando a classe Options.
if ( java < 9 ) { // when you have a target benchmark with Java < 9 and hence no modules
Options . v (). set_prepend_classpath ( true );
Options . v (). set_process_dir ( Arrays . asList ( applicationClassPath (). split ( File . pathSeparator )));
Options . v (). set_soot_classpath ( sootClassPath ());
}
if ( java >= 9 && USE_CLASSPATH ) { // when you have a target benchmark with Java >= 9 and do not want module support
Options . v (). set_soot_classpath ( "VIRTUAL_FS_FOR_JDK" + File . pathSeparator + sootClassPath ());
Options . v (). set_process_dir ( Arrays . asList ( applicationClassPath (). split ( File . pathSeparator )));
}
if ( java >= 9 && USE_MODULEPATH ) { // when you have a target benchmark with Java >= 9 and want module support
Options . v (). set_prepend_classpath ( true );
Options . v (). set_soot_modulepath ( sootClassPath ());
Options . v (). set_process_dir ( Arrays . asList ( applicationClassPath (). split ( File . pathSeparator )));
}Nos exemplos acima, applicationClassPath() deve ser substituído pelo caminho para as classes do aplicativo para análise por Soot e sootClassPath() deve ser substituído pelo caminho de classe Soot.
Para executar o Soot usando Java 1.9, mas analisando um caminho de classe, execute, como antes: java -cp soot-trunk.jar soot.Main --process-dir directoryToAnalyse
se você deseja especificar o caminho de classe explicitamente, execute: java -cp soot-trunk.jar soot.Main -cp VIRTUAL_FS_FOR_JDK --process-dir directoryToAnalyse
o valor VIRTUAL_FS_FOR_JDK indica que Soot também deve procurar classes no sistema de arquivos virtual jrt:/ do Java (>9), embora Soot não seja executado no modo de módulo.
Para carregar módulos e classes no Soot usando java 1.8, execute:
java -cp PATH_TO_JAVA9/jrt-fs.jar:soot-trunk.jar soot.Main -pp -soot-modulepath modules/
Substitua PATH_TO_JAVA9 pelo caminho para sua instalação local do java 9. O jrt-fs.jar é um provedor NIO FileSystem integrado para o sistema de arquivos jrt:// que o java 9 usa que substitui rt.jar .
