Threat Modelling

An organized approach to locating, evaluating, and mitigating the security threats connected to an application is threat modelling. It entails locating potential hazards to an application, grading them according to their gravity, and applying countermeasures. The security of software apps, including those in the Android ecosystem, depends on this procedure.

In order to make sure that security risks are properly addressed, threat modelling should be a crucial component of the software development life cycle (SDLC). In the context of Android development, this article will highlight some best practices for safe coding, go over the procedures in threat modelling, and offer instances of typical threats.

Threat Modeling Process

The following steps can be used to break down the threat modelling process:

  • Identify assets: Assets are the priceless parts of a system that must be safeguarded. They might include user information, intellectual property (such as source code), application parts, and system resources when referring to Android development.
  • Create application architecture: This entails outlining the components, data flows, and trust boundaries of the application. The foundation for locating potential security holes is this architecture.
  • Identify threats: Analyze the application architecture to identify potential threats. Common threat categories include:
    • Unauthorized access (e.g., Privilege escalation, Data leakage)
    • Data tampering (e.g., Injection attacks, Parameter manipulation)
    • Eavesdropping (e.g., Network sniffing, Man-in-the-middle attacks)
    • Denial of service (e.g., Resource exhaustion, Application crash)
    • Repudiation (e.g., Lack of non-repudiation, Lack of auditing)
  • Rank threats: Prioritize threats based on a range of risk variables, such as likelihood, impact, and detection difficulty. This will assist in deciding which threats need to be handled first.
  • Create countermeasures: identify and put into action steps to lessen or eliminate the risks connected to the threats that have been identified. This may entail making adjustments to the application’s design, putting security rules in place, or employing security testing tools.
  • Verify the application’s security: Make sure that any dangers have been adequately mitigated using security testing tools and methodologies.

Examples of Threats

  • Insecure Data Storage

Sensitive user information may be accessible to third parties through insecure data storage. The usage of world-readable file permissions, which allow any application on the device to access the file, is a frequent illustration of this issue in Android applications.

For instance, the application saves sensitive user data to a file with world-readable permissions in the Java code sample below:

FileOutputStream outputStream = openFileOutput("SensitiveData.txt", Context.MODE_WORLD_READABLE);

Using private file permissions, which restrict access to the file to the application only, would be a safe substitute:

FileOutputStream outputStream = openFileOutput("SensitiveData.txt", Context.MODE_PRIVATE);
  • SQL Injection

SQL injection is a type of attack where an attacker is able to execute malicious SQL queries in the application’s database by manipulating user inputs. This can lead to unauthorized access to or manipulation of data.

Take into account the following Java code fragment, which builds a SQL query using user input:

String userInput = ... // User-supplied input
String query = "SELECT * FROM users WHERE username = '" + userInput + "'";
Cursor cursor = db.rawQuery(query, null);

An attacker could exploit this vulnerability by providing user input containing an SQL injection payload, such as admin' -- , which would result in the authentication bypass.

To prevent SQL injection, use parameterized queries, which will handle user input in a safe manner:

String userInput = ... // User-supplied input
String query = "SELECT * FROM users WHERE username = ?";
Cursor cursor = db.rawQuery(query, new String[] { userInput });
  • Buffer Overflow

Buffer overflow vulnerabilities occur when a program writes more data to a buffer than it can hold, causing data to be written to nearby memory locations. This can lead to memory corruption, application crashes, or arbitrary code execution.

In the following C code snippet, a buffer overflow vulnerability can be triggered by providing a long string as input:

void vulnerable_function(char *userInput) {
  char buffer[50];
  strcpy(buffer, userInput); // Unsafe copy of user input

int main(int argc, char **argv) {
  if (argc > 1) {
  return 0;

To prevent buffer overflow, use secure functions to limit the amount of data copied to the buffer, ensuring that it cannot exceed the buffer’s capacity.

void safe_function(char *userInput) {
  char buffer[50];
  strncpy(buffer, userInput, sizeof(buffer) - 1); // Safe copy of user input
  buffer[sizeof(buffer) - 1] = '\0'; // Ensure null termination

Best Practices for Secure Coding in Android Development

  • Follow the principle of least privilege: Make sure that applications only ask for the minimal number of permissions necessary for them to operate.
  • Use encryption for transmitting sensitive data: Use HTTPS and TLS when corresponding with distant services to secure data while it is in transit.
  • Validate user input: To avoid attacks like SQL injection and cross-site scripting (XSS), make sure to validate and sanitize user inputs at all times.
  • Use secure coding practices: Adhere to well-established security best practices, such as employing parameterized queries for database access and staying away from potentially risky functions that are prone to buffer overflow vulnerabilities.
  • Regularly update dependencies: Use the most recent versions of third-party libraries and frameworks since they can include crucial security fixes.
  • Perform security testing: To find potential security holes in your application, use static and dynamic analysis tools. You should also run regular code reviews to find and resolve any issues.
  • Stay informed: Update your knowledge of the most recent security guidelines, flaws affecting the Android ecosystem, threat modelling approaches, and tools.

Link to Book: Secure Android Development: Best Practices for Robust Apps

Leave a Comment

Your email address will not be published. Required fields are marked *