ion Layer of a database system. TEAL is an implementation of a framework for secure storage and resides inside Abstraction Layer of a database (DBAL). We demonstrate how TEAL integrates transparently into existing applications. Furthermore, we explain query processing on encrypted data by re-using components of the DBAL. Finally, we visualize the impact of the processing steps of TEAL on the run-time performance of the query processing. Our demonstration shows that TEAL allows to integrate secure storage easily and with a reasonable increase of the execution times into object-relational mapping.
Outsourcing databases has become a matter of course. By hosting data from
many customers, specialized service providers can o er cost-e cient database
services with de ned service levels that adapt to exible loads. However, data
privacy laws [
While this process has been formally described, the realization of such a middleware is not obvious: First of all, the encryption must be transparent both to the database service provider and the application developer, to re-use existing services and software components. Second, in the worst case the service provider must transfer the entire database to the middleware at the client for local decryption. Thus, data management at the middleware is an issue. Third, the middleware must be able to pass transactions between client and database provider. Fourth, it is important that the middleware is interoperable with the speci c SQL dialects of di erent database vendors. Finally, the run-time overhead of the encryption is important.
This demo will feature TEAL, our approach for Transparent Encryption in
the Abstraction Layer of a database system. TEAL implements a well-researched
framework for secure storage [
Our demonstration provides insight into three aspects: We show that the integration of TEAL into existing applications is feasible with moderate e ort. To this end, we have implemented TEAL for PHP applications using Laravel, that is, we realize secure storage for object-relational mapping. We explain in detail how TEAL encrypts data, executes a certain query over encrypted data and obtains the plain-text query result. As part of our demo we show that the run-time overhead induced by the encryption is reasonable.
Paper structure: The next section introduces the foundations of our approach. Section 3 provides an overview of TEAL. Section 4 describes our demo and Section 5 concludes. 2
This section brie y describes the approach [
We have based TEAL on Hacigumus' algebraic framework [
In the following, we brie y describe [
3 Carol 3000 N.Y.
This relation would be encrypted and stored as encrypted table enc as follows: enc: etuple I1 I2 I3 I4 enc(1, Alice, 1000, N.Y.) e1 e5 e3 e2 enc(2, Bob, 2000, L.A.) e7 e5 e6 e2 enc(3, Carol, 3000, N.Y.) e7 e4 e6 e2
With e1 e7 we refer to encrypted index values. Some plain-text values are mapped to the same encrypted value. For example, Employee Id 1 has been mapped to bin e1, while the Ids 2 and 3 have been mapped to e7.
To process queries on encrypted data, the encryption middleware rewrites
plain-text queries from the client according to translation rules for relational
algebra [
Querying encrypted data always reveals some information to the service
provider [
Many Database Abstraction Layers (DBALs) have been proposed so far to overcome the heterogeneity introduced by SQL vendors, to gain independence from SQL dialects and from database vendors. Popular DBALs are objectrelational mappers such as hibernate3, the Java Persistence API4 or Laravel5.
Other DBALs provide language-level abstraction (JDBC, ODBC) or service-level abstraction (e.g., Apache SPARK6). The resulting software is vendor-agnostic, meaning that the underlying DBMS can be changed easily.
A transparent integration into a DBAL allows to migrate to secure storage without having to re-write existing applications. It also makes TEAL independent from speci c database vendors, because this is already obtained by DBAL. Furthermore, an integration into DBAL allows a seamless integration into the transaction processing between application and database server. The integration into a DBAL allows to re-use e cient libraries for query processing. Finally, DBALs focus on programming interfaces and prohibit direct access to indexes and other database-speci c features. This makes it easier to realize a secure storage approach, because no side-channels have to be considered.
To demonstrate that TEAL provides secure storage which can be integrated into existing applications seamlessly, we have implemented it in PHP using Laravel. PHP and Laravel are typical components of LAMP 7 servers that handle a wide share of today's Web load. Laravel is a DBAL that provides an objectoriented persistence interface for MySQL, Postgres, SQLite, and SQL Server. 3
TEAL provides secure storage [
avel classes. Dashed lines represent 'uses' relations between components, and continuous lines stand for 'implements' relations.
TEAL consists of four components: Con guration: This component stores all meta data that is needed for encryption, query rewriting and database access in a local database on the client. This includes the encryption and binning methods used, the encryption key, and the range and number of bins used for the encrypted indexes. It also includes the mapping from plain-text identi ers of databases, tables and columns on the client side to encrypted ones on the server side.
Installation: The installation component comes as an installation package that recon gures an existing LAMP installation for secure storage. That is, it integrates TEAL in between the PHP application and the Laravel library so that TEAL can encrypt queries and post-process encrypted query results. Furthermore, the installation provides a user interface to the con guration parameters. Builder: The TEALnBuilder obtains plain-text queries from the PHP application via the LaravelnBuilder interface. It translates them to queries over encrypted data, and passes this translation to the native Laravel library. Conversely, the Builder obtains and decrypts the encrypted intermediate results from the server side. It passes them to Post-Processing and transfers the nal result set to the PHP application. To this end, the TEALnBuilder interacts with the LaravelnBuilder component.
Post-Processing: The translated query yields an encrypted superset of the data sought. The Post-Processing computes the nal query result from the decrypted superset. This includes sorting, grouping, and ltering. In the rst step, our Post-Processing component evaluates predicates from the WHERE-condition of the query. In a second step, we put the resulting data set into a client-side database system8 and execute the original (unencrypted) query. The clientside database must have the same vendor and schema as the original database. This lets us obtain the nal query result e ciently and without having to reimplement database functionality inside the DBAL. 4
Our demonstration database for TEAL will have 100,000 rows, one column of sequential tuple IDs and two columns of uniformly distributed integers. This results in a table size of 4.3 MB and an index size of 2.2 MB for the primary key. The given data distribution allows us to demonstrate queries with a given selectivity. We use AES-256-CBC for encryption. The encrypted indexes are binned with a bucket size of 100, i.e., on average each bucket holds 1000 values. We are executing our demonstration on a machine with PostgreSQL 9.3, Intel Core i7 4770k, 16GB RAM and a Solid State Disk. Our PHP application mimics a typical dynamic web application.
First we demonstrate how TEAL integrates seamlessly and transparently into existing PHP applications. To this end, the installation component of TEAL comes with a setup wizard. Once TEAL has been installed, the setup wizard can be accessed via a web interface. We will guide the audience through the various steps of the setup. This includes the selection of the tables to be encrypted, the selection of the keys and parameters for the encryption and the binning, and the con guration of a database connection to a third-party provider storing encrypted data. Based on this information, the wizard converts the plain-text database into an encrypted one and transfers it to the database provider.
At the end of this part of the demonstration, a secure storage at the server side exists. It can be used by modifying a line in the con guration le of Laravel, i.e., without having to modify the PHP application. With our demonstration setup, the secure storage contains one table with four columns: the etuple column containing the encrypted tuples and the three columns containing encrypted and binned index values. The encrypted table has a size of 11 MB and an index of the same size. 4.2
Second, we demonstrate how TEAL rewrites queries for execution on the encrypted storage, and how it computes the result set from the encrypted answer (see Figure 2).
TEAL obtains a plain-text query over the Laravel API, i.e., all method calls to LaravelnBuilder are redirected to TEALnBuilder. In detail, Laravel allows the application developer to formulate queries using object-oriented method calls that correspond to FROM, WHERE conditions, JOIN, GROUP BY etc. The Builder constructs an internal query representation from these calls. Figure 2 subsumes these calls under specify query(). To execute a query on the database, the application eventually invokes the method get().
Once get() is invoked, TEAL translates this query representation into one
that can be executed on encrypted data [
The third part of our demo addresses the run-time penalty of TEAL. To this end, we measure the execution time of the query which we have demonstrated. 250 200 isn150 e im100 t 50 0 plain-text predicates total 100 80 % in 60 e itm40 20 00 decryption post-proc. query ex. 0 20 40 60 80 100 result size in 1,000 tuples
0,5 1 1,5 result size in 1,000 tuples 2
We show the increase of the run-time due to using secure storage rst. In particular, we vary the WHERE condition of the query to obtain query results of varying size (cf. Figure 3). First we determine the execution time of a plain-text query processing without using TEAL (continuous line in Figure 3). Second, we measure the run-time of a query processing with TEAL by ltering for the WHERE predicates, i.e., without fetching the ltered query result into a client-side database for further post-processing such as grouping and sorting (dotted line in the gure). Third, we measure the total run-times using TEAL (dashed line).
Finally, we visualize the proportions of the various processing steps of TEAL on the total run-time of a query execution (see Figure 4). Again, we vary the result size by modifying the WHERE predicates of the query. We will show the execution times of the query rewriting, query execution (dark gray in the Figure), result decryption (white) and post-processing (light gray). Query execution, which is handled by Laravel, has a share of about 30% of the execution time, while client-side decryption needs around 60% of the time. Notice that query execution and decryption are handled by a specialized DBMS and a highly optimized crypto-library. Thus, this part of the demo shows that integrating TEAL into a less performant scripting language such as PHP does not incur unreasonable costs. 5
The purpose of this demonstration is to show how a formal framework for query processing on encrypted data can be integrated into an existing software architecture. To this end, we present TEAL, our approach for Transparent Encryption in the Abstraction Layer of a database system (DBAL). TEAL implements a stateof-the-art framework for secure storage that re-uses the application programming interface of the Laravel DBAL. This allows TEAL to integrate seamlessly into PHP applications using Laravel, including object-relational mapping, transaction management, storage management and database-vendor independence.
Our demonstration reveals how our installation component achieves this integration. Furthermore, we explain how TEAL re-writes and processes a given plain-text query, and how it obtains the correct plain-text query result from the encrypted response provided by the secure storage provider. Finally, we show the increase in the execution times of a query as a result of encryption. Our demonstration visualizes which processing step of TEAL requires which share of the execution time. We demonstrate that TEAL scales linearly with the size of the query result.