Datasets:
Devilishcode
/
hacking

Dataset card Data Studio Files
xet
 Community
text
stringlengths
0
1.99k
[2] Getting around non-executable stack (and fix)
Solar Designer
ERROR: type should be string, got " https://seclists.org/bugtraq/1997/Aug/63"
[3] one_gadget
david942j
ERROR: type should be string, got " https://github.com/david942j/one_gadget"
[4] ASLRn't: How memory alignment broke library ASLR
zolutal
ERROR: type should be string, got " https://blog.zolutal.io/aslrnt/"
[5] ASLR test fails in Ubuntu 22.10
ERROR: type should be string, got " https://bugs.launchpad.net/ubuntu-kernel-tests/+bug/1983357"
[6] The never ending problems of local ASLR holes in Linux
Blaze Labs
ERROR: type should be string, got " https://www.blazeinfosec.com/post/never-ending-problems-aslr-linux/"
Co-written with Yahav Rahom (yahavrahom1@gmail.com).
|=------------------------------------------------------------------------=|
|=---=[ Back to the Binary: Revisiting Similarities of Android Apps ]=----=|
|=------------------------------------------------------------------------=|
|=-----------------=[ Jakob Bleier & Martina Lindorfer ]=-----------------=|
|=------------------------------------------------------------------------=|
--[ Table of Contents
0. A Bit of Context
1. A Bit of History
2. A Bit of the Current State
3. A Bit of Examples
4. A Bit of Putting the Bits Together
5. A Bit of an Outlook
6. A Bit of Summary and Thanks
7. A Bit of References
8. And That Makes a Byte (code)
--[ 0 - A Bit of Context
> The sky above the port was the color of a mobile phone,
> stuck in a boot loop.
It's been 13 years since "Similarities for Fun and Profit [0]," aka Elsim,
was published in April 2012. Python 2.7 was still supported, Android 4.1
wasn't released yet, and it would take another 2 years until a
libstagefright bug would get its very own shiny logo. Heck, even Google
Code was still around!
Things changed, and herein lies our challenge: Code-based Android app
similarity is not working (in 2025). The original Elsim code presented by
Pouik and G0rfi3ld has seen major changes and improvements over the years,
but unfortunately the updated version vanished (worry not, we saved a copy
[1], tho we're still tracking down some dependencies). Alternative
approaches were developed, but even if they have public descriptions and
published code, they lack the generality of Elsim.
Similarities between apps are still interesting: Detecting malware is one
use case. Finding suspicious copies of apps is another. A fast similarity
tool can help you find cloned apps and get you started on finding license
violations, impostors, or trojans. With similarities there's also the
possibility of clustering apps to find "families". Allegedly the biggest
app store for Android uses machine learning to detect outliers [2]: Apps
that should be similar are compared, and outliers investigated. For
example, if most apps providing control over the Flashlight don't request
access to your contact list, the few that do are worth taking a closer look
at.
But what is similarity anyway? Android apps can be easily downloaded [3],
unpacked, changed, and repackaged. The presentation of an app, its icon and
styling, are easy to change. So instead of relying on these properties, we
want to use the code to reason whether apps are similar, ideally based on
what they do, but this leads us very close to unsolvable problems. Imagine
we want to be exact and see how many properties are shared between two
apps: We'd need to define those properties and check if an app has them.
For declared permissions, this is trivial. An app should not be able to
access contact information without declaring the permission. If it actually
has a particular property, it is, generally speaking, undecidable: Imagine
we replace the call to get contact information with an infinite loop.
Voila, we are trying to solve the Halting problem.
So, instead of requiring similarity to represent what exactly apps do, we
want to have an approximation of whether their code is similar. And while
Android changed in ways that threw some convenient assumptions overboard,
it also provided us with new opportunities.
To understand why Android works the way it does in 2025, we'll travel a bit
back in time and see how it used to work, what problems it had, and how
they were solved. With this, we'll revisit the state of the art for
similarities and then present a new approach to working with apps, treating
them as binaries instead of bytecode. A good PoC can't be missing, so we
show how to do what Elsim did by using our binary trickery: scoring the
similarity of an app from zero to one based on code.
TL;DR: We'll show how to turn APKs into binary ELF files and use those to
calculate similarities between apps, such as Signal and TM SGNL, using
BinDiff. Since this requires BinExport files and disassembly, it can take
hours to analyze modern apps. We also provide a PoC to bring this down to
minutes, which, for now, has a side effect of making BinDiff slower than it
should be.