Use of Inner Class Containing Sensitive Data

Draft Variant

Structure: Simple

Description

Using inner classes to handle sensitive data can unintentionally expose that data because of how Java compiles them. The compiler transforms inner classes into separate, package-visible classes, which can bypass the intended private access restrictions.

Extended Description

Inner classes in Java create hidden security risks due to their compilation process. While your source code might declare an inner class as private to its enclosing class, the Java bytecode has no built-in support for this relationship. To make it work, the compiler converts the inner class into a separate peer class with package-level access. This means code you intended to keep private within a single class becomes accessible to all other classes in the same package. This becomes especially dangerous because inner classes can access private fields of their outer class. To allow this access in the transformed bytecode, the compiler silently changes those private fields to protected scope. As a result, sensitive data you marked as private can be exposed through the newly created peer class, breaking your intended encapsulation and creating a potential data leak.

Common Consequences 1

Scope: Confidentiality

Impact: Read Application Data

"Inner Classes" data confidentiality aspects can often be overcome.

Detection Methods 1

Automated Static AnalysisHigh

Automated static analysis, commonly referred to as Static Application Security Testing (SAST), can find some instances of this weakness by analyzing source code (or binary/compiled code) without having to execute it. Typically, this is done by building a model of data flow and control flow, then searching for potentially-vulnerable patterns that connect "sources" (origins of input) with "sinks" (destinations where the data interacts with external components, a lower layer such as the OS, etc.)

Potential Mitigations 2

Phase: Implementation

Using sealed classes protects object-oriented encapsulation paradigms and therefore protects code from being extended in unforeseen ways.

Phase: Implementation

Inner Classes do not provide security. Warning: Never reduce the security of the object from an outer class, going to an inner class. If an outer class is final or private, ensure that its inner class is private as well.

Demonstrative Examples 4

The following Java Applet code mistakenly makes use of an inner class.

Code Example:Bad
Java
java

The following example shows a basic use of inner classes. The class OuterClass contains the private member inner class InnerClass. The private inner class InnerClass includes the method concat that accesses the private member variables of the class OuterClass to output the value of one of the private member variables of the class OuterClass and returns a string that is a concatenation of one of the private member variables of the class OuterClass, the separator input parameter of the method and the private member variable of the class InnerClass.

Code Example:

Bad

Java

java

// private member variables of OuterClass* private String memberOne; private String memberTwo;

java

java

// InnerClass has access to private member variables of OuterClass* System.out.println("Value of memberOne is: " + memberOne); return OuterClass.this.memberTwo + separator + this.innerMemberOne;}}}

Although this is an acceptable use of inner classes it demonstrates one of the weaknesses of inner classes that inner classes have complete access to all member variables and methods of the enclosing class even those that are declared private and protected. When inner classes are compiled and translated into Java bytecode the JVM treats the inner class as a peer class with package level access to the enclosing class.

To avoid this weakness of inner classes, consider using either static inner classes, local inner classes, or anonymous inner classes.

The following Java example demonstrates the use of static inner classes using the previous example. The inner class InnerClass is declared using the static modifier that signifies that InnerClass is a static member of the enclosing class OuterClass. By declaring an inner class as a static member of the enclosing class, the inner class can only access other static members and methods of the enclosing class and prevents the inner class from accessing nonstatic member variables and methods of the enclosing class. In this case the inner class InnerClass can only access the static member variable memberTwo of the enclosing class OuterClass but cannot access the nonstatic member variable memberOne.

Code Example:

Good

Java

java

// private member variables of OuterClass* private String memberOne; private static String memberTwo;

java

java

// InnerClass only has access to static member variables of OuterClass* return memberTwo + separator + this.innerMemberOne;}}}

The only limitation with using a static inner class is that as a static member of the enclosing class the inner class does not have a reference to instances of the enclosing class. For many situations this may not be ideal. An alternative is to use a local inner class or an anonymous inner class as shown in the next examples.

In the following example the BankAccount class contains the private member inner class InterestAdder that adds interest to the bank account balance. The start method of the BankAccount class creates an object of the inner class InterestAdder, the InterestAdder inner class implements the ActionListener interface with the method actionPerformed. A Timer object created within the start method of the BankAccount class invokes the actionPerformed method of the InterestAdder class every 30 days to add the interest to the bank account balance based on the interest rate passed to the start method as an input parameter. The inner class InterestAdder needs access to the private member variable balance of the BankAccount class in order to add the interest to the bank account balance.

However as demonstrated in the previous example, because InterestAdder is a non-static member inner class of the BankAccount class, InterestAdder also has access to the private member variables of the BankAccount class - including the sensitive data contained in the private member variables for the bank account owner's name, Social Security number, and the bank account number.

Code Example:

Bad

Java

java

// private member variables of BankAccount class* private String accountOwnerName; private String accountOwnerSSN; private int accountNumber; private double balance;

java

java

// InterestAdder is an inner class of BankAccount class*

java

java

In the following example the InterestAdder class from the above example is declared locally within the start method of the BankAccount class. As a local inner class InterestAdder has its scope restricted to the method (or enclosing block) where it is declared, in this case only the start method has access to the inner class InterestAdder, no other classes including the enclosing class has knowledge of the inner class outside of the start method. This allows the inner class to access private member variables of the enclosing class but only within the scope of the enclosing method or block.

Code Example:

Good

Java

java

// private member variables of BankAccount class* private String accountOwnerName; private String accountOwnerSSN; private int accountNumber; private double balance;

java

java

// InterestAdder is a local inner class*

java

java

A similar approach would be to use an anonymous inner class as demonstrated in the next example. An anonymous inner class is declared without a name and creates only a single instance of the inner class object. As in the previous example the anonymous inner class has its scope restricted to the start method of the BankAccount class.

Code Example:

Good

Java

java

// private member variables of BankAccount class* private String accountOwnerName; private String accountOwnerSSN; private int accountNumber; private double balance;

java

java

// anonymous inner class that implements the ActionListener interface* ActionListener adder = new ActionListener() { ``` public void actionPerformed(ActionEvent event) { double interest = BankAccount.this.balance * rate / 100; BankAccount.this.balance += interest; } }; Timer t = new Timer(1000 * 3600 * 24 * 30, adder); t.start(); } }

In the following Java example a simple applet provides the capability for a user to input a URL into a text field and have the URL opened in a new browser window. The applet contains an inner class that is an action listener for the submit button, when the user clicks the submit button the inner class action listener's actionPerformed method will open the URL entered into the text field in a new browser window. As with the previous examples using inner classes in this manner creates a security risk by exposing private variables and methods. Inner classes create an additional security risk with applets as applets are executed on a remote machine through a web browser within the same JVM and therefore may run side-by-side with other potentially malicious code.

Code Example:

Bad

Java

java

// private member variables for applet components* private Label enterUrlLabel; private TextField enterUrlTextField; private Button submitButton;

java

java

As with the previous examples a solution to this problem would be to use a static inner class, a local inner class or an anonymous inner class. An alternative solution would be to have the applet implement the action listener rather than using it as an inner class as shown in the following example.

Code Example:

Good

Java

java

// private member variables for applet components* private Label enterUrlLabel; private TextField enterUrlTextField; private Button submitButton;

java

java

References 1

Seven Pernicious Kingdoms: A Taxonomy of Software Security Errors

Katrina Tsipenyuk, Brian Chess, and Gary McGraw

NIST Workshop on Software Security Assurance Tools Techniques and Metrics • NIST

07-11-2005

https://samate.nist.gov/SSATTM_Content/papers/Seven%20Pernicious%20Kingdoms%20-%20Taxonomy%20of%20Sw%20Security%20Errors%20-%20Tsipenyuk%20-%20Chess%20-%20McGraw.pdf

ID: REF-6

Likelihood of Exploit

Medium

Applicable Platforms

Languages:

Java : Undetermined

Modes of Introduction

Implementation

Related Weaknesses

ChildOf:

Exposure of Resource to Wrong Sphere (CWE-668)

Taxonomy Mapping

7 Pernicious Kingdoms
CLASP
The CERT Oracle Secure Coding Standard for Java (2011)

Notes

OtherMobile code, in this case a Java Applet, is code that is transmitted across a network and executed on a remote machine. Because mobile code developers have little if any control of the environment in which their code will execute, special security concerns become relevant. One of the biggest environmental threats results from the risk that the mobile code will run side-by-side with other, potentially malicious, mobile code. Because all of the popular web browsers execute code from multiple sources together in the same JVM, many of the security guidelines for mobile code are focused on preventing manipulation of your objects' state and behavior by adversaries who have access to the same virtual machine where your program is running.