Client-side Computation Research Articles

Privacy-preserving outsourcing scheme of face recognition based on locally linear embedding

Face recognition is a biometric-based technology that identifies or verifies a person’s identity by analyzing and comparing patterns in their facial features. Among kinds of face recognition algorithms, Locally Linear Embedding (LLE) algorithm has the advantage of preserving the local structure of face data. However, the LLE algorithm requires some computationally intensive matrix calculations, which might introduce latency to the device. In this paper, we propose a privacy-preserving outsourcing scheme of face recognition based on LLE algorithm for the first time. By outsourcing matrix multiplication, linear equations, and eigenvalue decomposition of the LLE algorithm to a cloud server, we reduce the computational load on the client device. To ensure data security, we generate a novel type of sparse orthogonal matrix through square root application and random permutation of diagonal elements, used as secret keys to blind the client’s data. Meanwhile, due to the sparsity of key matrices, the complexity of client-side computation complexity is reduced from O(n3) to O(n2). The experimental results show that our proposed scheme reduces computational costs while maintaining almost identical face recognition accuracy as the original LLE-based algorithm.

Efficient dynamic multi-client searchable encryption supporting fuzzy search

Searchable symmetric encryption (SSE) enables the client to outsource its encrypted database to the untrusted server, while maintaining the ability to efficiently search over it. However, most of the existing solutions focus mainly on exact keyword search. That is, it will fail to fetch the desired result even though mild typos. To this end, SSE with fuzzy keyword search has attracted considerable concerns in the literature. We note that the current works support merely single-client setting. How to design fuzzy keyword search-based SSE scheme in the multi-client setting is still open. In this work, we first introduce a dynamic multi-client fuzzy keyword search scheme by employing Intel SGX, which can achieve forward privacy at the expense of multiple trapdoors communication. The proposed construction can reduce client-side computation and communication overload with the aid of Intel SGX. Furthermore, we present an enhanced multi-client fuzzy keyword search scheme that achieves forward privacy even in the presence of the corrupted user. The evaluation of security and efficiency indicates that our schemes are capable of meeting the desired security level and are well-suited for real-world applications.

Some Design Considerations in Passive Indoor Positioning Systems.

User location is becoming an increasingly common and important feature for a wide range of services. Smartphone owners increasingly use location-based services, as service providers add context-enhanced functionality such as car-driving routes, COVID-19 tracking, crowdedness indicators, and suggestions for nearby points of interest. However, positioning a user indoors is still problematic due to the fading of the radio signal caused by multipath and shadowing, where both have complex dependencies on the indoor environment. Location fingerprinting is a common positioning method where Radio Signal Strength (RSS) measurements are compared to a reference database of previously stored RSS values. Due to the size of the reference databases, these are often stored in the cloud. However, server-side positioning computations make preserving the user's privacy problematic. Given the assumption that a user does not want to communicate his/her location, we pose the question of whether a passive system with client-side computations can substitute fingerprinting-based systems, which commonly use active communication with a server. We compared two passive indoor location systems based on multilateration and sensor fusion using an Unscented Kalman Filter (UKF) with fingerprinting and show how these may provide accurate indoor positioning without compromising the user's privacy in a busy office environment.

A privacy-preserving cross-media retrieval on encrypted data in cloud computing

Frequent cloud data breaches cause irreparable damage to cloud users and providers. Cross-media retrieval can better leverage the value of data, but existing cross-media retrievals are conducted on plaintext data with limited security. In this paper, we propose a privacy-preserving cross-media retrieval on encrypted data in cloud computing (PPCMR). First, the user encrypts the data and uploads it to the cloud, which enhances cloud data security. Secondly, a two-branch feature extraction network based on a convolutional neural network is designed, which is used to extract cross-media features on encrypted data in a cloud environment. And the cosine distance between cross-media features is calculated for similarity metric to solve the ‘semantic gap’ problem of cross-media encrypted data. Finally, the user decrypts the encrypted retrieval results from the cloud to get the cross-media plaintext results. The scheme shifts complex computing operations from the client to the cloud server, with little client-side computation. We analytically evaluate PPCMR on real-world datasets: PPCMR outperforms plaintext retrieval schemes in terms of security and supports efficient cross-media encrypted retrieval on large-scale, dynamically updated cloud databases and mobile devices (lightweight).

STATE-OF-THE-ART AND TRENDS IN THE SYSTEMATIC DEVELOPMENT OF RICH INTERNET APPLICATIONS

Rich Internet Applications (RIAs) are widely adopted Web applications that add the richer interaction, presentation, and client-side computation capabilities of desktop applications to the Web. However, the evolution from Web applications towards RIAs comes at the cost of increased complexity in their development. For this reason, a wide variety of tools and technologies have been proposed in order to streamline their development effort. This paper investigates the current state of the art of the RIA development approaches. The review shows that the current industrial development practice lacks a comprehensive approach to RIA development, supporting all the development steps from the design to implementation, test and maintenance, and helping identifying correct design choices. This is in part due to the severe fragmentation of current RIA technologies that prevents the adoption of a commonly recognized set of best practices resulting in ad-hoc development processes. These aspects are in part treated by research methodologies and some innovative industrial solutions, but also these approaches present some limitations. The paper identifies future research directions for RIAs to fully support their development process and to support their design in a more comprehensive and systematic way, from both industrial and research perspectives.

Enabling Efficient, Secure and Privacy-Preserving Mobile Cloud Storage

Mobile cloud storage (MCS) provides clients with convenient cloud storage service. In this article, we propose an efficient, secure and privacy-preserving mobile cloud storage scheme, which protects the data confidentiality and privacy simultaneously, especially the access pattern. Specifically, we propose an oblivious selection and update (OSU) protocol as the underlying primitive of the proposed mobile cloud storage scheme. OSU is based on onion additively homomorphic encryption with constant encryption layers and enables the client to obliviously retrieve an encrypted data item from the cloud and update it with a fresh value by generating a small encrypted vector, which significantly reduces the client’s computation as well as the communication overheads. Compared with previous works, our presented work has valuable properties, such as fine-grained data structure (small item size), lightweight client-side computation (a few of additively homomorphic operations) and constant communication overhead, which make it more suitable for MCS scenario. Moreover, by employing the “verification chunks” method, our scheme can be verifiable to resist malicious cloud. The comparison and evaluation indicate that our scheme is more efficient than existing oblivious storage solutions with the aspects of client and cloud workloads, respectively.

Multi-matrix verifiable computation

The problem of securely outsourcing computation to cloud servers has attracted a large amount of attention in recent years. The verifiable computation of Gennaro, Gentry, Parno (Crypto'10) allows a client to verify the server's computation of a function with substantially less time than performing the outsourced computation from scratch. In a multi-function model (Parno, Raykova, Vaikuntanathan; TCC'12) of verifiable computation, the process of encoding function and the process of preparing input are decoupled such that any client can freely submit a computation request on its input, without having to generate an encoding of the function in advance. In this paper, we propose a multi-matrix verifiable computation scheme that allows the secure outsourcing of the matrix functions over a finite field. Our scheme is outsourceable. When it is used to outsource $m$ linear functions, the scheme is roughly $m$ times faster and has less communication cost than the previously best known scheme by Fiore and Gennaro (CCS'12), both in the client-side computation and in the server-side computation. We also show the cost saving with detailed implementations.

SLAMCast: Large-Scale, Real-Time 3D Reconstruction and Streaming for Immersive Multi-Client Live Telepresence

Real-time 3D scene reconstruction from RGB-D sensor data, as well as the exploration of such data in VR/AR settings, has seen tremendous progress in recent years. The combination of both these components into telepresence systems, however, comes with significant technical challenges. All approaches proposed so far are extremely demanding on input and output devices, compute resources and transmission bandwidth, and they do not reach the level of immediacy required for applications such as remote collaboration. Here, we introduce what we believe is the first practical client-server system for real-time capture and many-user exploration of static 3D scenes. Our system is based on the observation that interactive frame rates are sufficient for capturing and reconstruction, and real-time performance is only required on the client site to achieve lag-free view updates when rendering the 3D model. Starting from this insight, we extend previous voxel block hashing frameworks by introducing a novel thread-safe GPU hash map data structure that is robust under massively concurrent retrieval, insertion and removal of entries on a thread level. We further propose a novel transmission scheme for volume data that is specifically targeted to Marching Cubes geometry reconstruction and enables a 90% reduction in bandwidth between server and exploration clients. The resulting system poses very moderate requirements on network bandwidth, latency and client-side computation, which enables it to rely entirely on consumer-grade hardware, including mobile devices. We demonstrate that our technique achieves state-of-the-art representation accuracy while providing, for any number of clients, an immersive and fluid lag-free viewing experience even during network outages.

RASP-Boost: Confidential Boosting-Model Learning with Perturbed Data in the Cloud

Mining large data requires intensive computing resources and data mining expertise, which might be unavailable for many users. With widely available cloud computing resources, data mining tasks can now be moved to the cloud or outsourced to third parties to save costs. In this new paradigm, data and model confidentiality becomes the major concern to the data owner. Data owners have to understand the potential trade-offs among client-side costs, model quality, and confidentiality to justify outsourcing solutions. In this paper, we propose the RASP-Boost framework to address these problems in confidential cloud-based learning. The RASP-Boost approach works with our previous developed RAndom Space Perturbation (RASP) method to protect data confidentiality and uses the boosting framework to overcome the difficulty of learning high-quality classifiers from RASP perturbed data. We develop several cloud-client collaborative boosting algorithms. These algorithms require low client-side computation and communication costs. The client does not need to stay online in the process of learning models. We have thoroughly studied the confidentiality of data, model, and learning process under a practical security model. Experiments on public datasets show that the RASP-Boost approach can provide high-quality classifiers, while preserving high data and model confidentiality and requiring low client-side costs.

Real-Time Web GIS Analysis Using WebGL

Parallel processing methods in Geographic Information Systems (GIS) are traditionally used to accelerate the calculation of large data volumes with sophisticated spatial algorithms. Such kinds of acceleration can also be applied to provide real-time GIS applications to improve the responsiveness of user interactions with the data. This paper presents a method to enable this approach for Web GIS applications. It uses the JavaScript 3D graphics API (WebGL) to perform client-side parallel real-time computations of 2D or 2.5D spatial raster algorithms on the graphics card. The potential of this approach is evaluated using an example implementation of a hillshade algorithm. Performance comparisons of parallel and sequential computations reveal acceleration factors between 25 and 100, mainly depending on mobile or desktop environments.

Reasoning about Web Applications

We propose a small-step operational semantics to support reasoning about Web applications written in the multitier language HOP. The semantics covers both server side and client side computations, as well as their interactions, and includes creation of Web services, distributed client-server communications, concurrent evaluation of service requests at server side, elaboration of HTML documents, DOM operations, evaluation of script nodes in HTML documents and actions from HTML pages at client side. We also model the browser same origin policy (SOP) in the semantics. We propose a safety property by which programs do not get stuck due to a violation of the SOP and a type system to enforce it.

Query Processing in Private Data Outsourcing Using Anonymization

Data outsourcing is a growing business. Cloud computing developments such as Amazon Relational Database Service promise further reduced cost. However, use of such a service can be constrained by privacy laws, requiring specialized service agreements and data protection that could reduce economies of scale and dramatically increase costs. We propose a private data outsourcing approach where the link between identifying information and sensitive (protected) information is encrypted, with the ability to decrypt this link residing only with the client. As the server no longer has access to individually identifiable protected information, it is not subject to privacy laws, and can offer a service that does not need to be customized to the needs of each country- or sector-specific requirements; any risk of violating privacy through releasing sensitive information tied to an individual remains with the client. The data model used in this work is shown with an example in Figure 1 . This work presents a relational query processor operating within this model. The goal is to minimize communication and client-side computation, while ensuring that the privacy constraints captured in the anatomization are maintained. At first glance, this is straightforward: standard relational query processing at the server, except that any joins involving the encrypted key must be done at the client; an appropriate distributed query optimizer should do a reasonably good job of this. However, two issues arise that confound this simple approach: 1. By making use of the anatomy groups, and the knowledge that there is a one-to-one mapping (unknown to the server) between tuples in such groups, we can perform portions of the join between identifying and sensitive information at the server without violating privacy constraints, and 2. Performing joins at the client and sending results back to the server for further processing can violate privacy constraints.

Web Distributed Computing Systems Implementation and Modeling

This article proposes a new approach for distributed computing. The main novelty consists in the exploitation of Web browsers as clients, thanks to the availability of JavaScript, AJAX and Flex. The described solution has two main advantages: it is client-free, so no additional programs have to be installed to perform the computation, and it requires low CPU usage, so client-side computation is no invasive for users. The solution is developed using both AJAX and Adobe®Flex® technologies embedding a pseudo-client into a Web page that hosts the computation. While users browse the hosting Web page, computation takes place resolving single sub-problems and sending the solution to the server-side part of the system. Our client-free solution is an example of high resilient and auto-administrated system that is able to organize the scheduling of the processes and the error management in an autonomic manner. A mathematical model has been developed over this solution. The main goals of the model are to describe and classify different categories of problems on the basis of the feasibility and to find the limits in the dimensioning of the scheduling systems to have convenience in the use of this approach. The new architecture has been tested through different performance metrics by implementing two examples of distributed computing, the cracking of an RSA cryptosystem through the factorization of the public key and the correlation index between samples in genetic data sets. Results have shown good feasibility of this approach both in a closed environment and also in an Internet environment, in a typical real situation.

Web Distributed Computing Systems

This article proposes a new approach for distributed computing. The main novelty consists in the exploitation of Web browsers as clients, thanks to the availability of Javascript, AJAX and Flex. The described solution has two main advantages: it is client-free, so no additional programs have to be installed to perform the computation, and it requires low CPU usage, so client-side computation is no invasive for users. The solution is developed using both AJAX and Adobe®Flex®technologies embedding a pseudo-client into a Web page that hosts the computation. While users browse the hosting Web page, computation takes place resolving single sub-problems and sending the solution to the server-side part of the system. Our client-free solution is an example of high resilient and auto-administrated system that is able to organize the scheduling of the processes and the error management in an autonomic manner. A mathematical model has been developed over this solution. The main goals of the model are to describe and classify different categories of problems on the basis of the feasibility and to find the limits in the dimensioning of the scheduling systems to have convenience in the use of this approach. The new architecture has been tested through different performance metrics by implementing two examples of distributed computing, the cracking of an RSA cryptosystem through the factorization of the public key and the correlation index between samples in genetic data sets. Results have shown good feasibility of this approach both in a closed environment and also in an Internet environment, in a typical real situation.

An efficient One-Time Password authentication scheme using a smart card

This paper presents a One-Time Password (OTP) mechanism to provide authentication, with particular application to thin clients in wireless networks. Many of the current OTP mechanisms have high client side computation costs, high communication costs, or limited login times. To cope with these problems, this paper proposes a new one-time password scheme using a smart card. In the scheme, we present a novel modification to the Depth-First Search (DFS) based on a unique tree structure to generate a private key. We present a detailed analysis of the proposed scheme using an OpenSSL based implementation.

Server-Side Statistics Scripting inPHP

On the UCLA Statistics WWW server there are a large number of demos and calculators that can be used in statistics teaching and research. Some of these demos require substantial amounts of computation, others mainly use graphics. These calculators and demos are implemented in various different ways, reflecting developments in WWW based computing. As usual, one of the main choices is between doing the work on the client-side (i.e. in the browser) or on the server-side (i.e. on our WWW server). Obviously, client-side computation puts fewer demands on the server. On the other hand, it requires that the client downloads Java applets, or installs plugins and/or helpers. If JavaScript is used, client-side computations will generally be slow. We also have to assume that the client is installed properly, and has the required capabilities. Requiring too much on the client-side has caused browsing machines such as Netscape Communicator to grow beyond all reasonable bounds, both in size and RAM requirements. Moreover requiring Java and JavaScript rules out such excellent browsers as Lynx or Emacs W3. For server-side computing, we can configure the server and its resources ourselves, and we need not worry about browser capabilities and configuration. Nothing needs to be downloaded, except the usual HTML pages and graphics. In the same way as on the client side, there is a scripting solution, where code is interpreted, or a ob ject-code solution using compiled code. For the server-side scripting, we use embedded languages, such as PHP/FI. The scripts in the HTML pages are interpreted by a CGI program, and the output of the CGI program is send to the clients. Of course the CGI program is compiled, but the statistics procedures will usually be interpreted, because PHP/FI does not have the appropriate functions in its scripting language. This will tend to be slow, because embedded languages do not deal efficiently with loops and similar constructs. Thus a first step towards greater efficiency is to compile the necessary primitives into the PHP/FI executable. This is easy to do, because the API is quite simple. In the extensions below, we have added the complete ranlib and dcdflib to PHP, plus some additional useful functions. The source code for these extensions, plus Solaris binaries for libranlib.a and libdcdf.a can be obtained from our server. Interpreting a PHP script, even with our new primitives, still requires starting up a CGI process for each page that is read. Again, this can be improved upon. We could use FastCGI to keep the CGI process around on a permanent basis. Instead, we have chosen a more direct method. PHP can be compiled as an Apache module, i.e. it can be compiled into the Apache HTTPD server binary. This means that PHP scripts are interpreted by the WWW server, which is always around, and which will fork additional children if necessary. No CGI processes need to be started. The PHP install process creates a libphp.a and mod_php.c in the Apache source directories, which can be used to build an enhanced server. This has the additional advantage of security, because all security features of the server can be used, and none of the pitfalls of using CGI or Java apply. Using PHP, in combination with the WWW server, also has some disadvantages. Although we can make simple static plots, using the gd library, we cannot use any dynamics, and interaction between the user and the page is somewhat limited. Java, or scripts using a client-side Xlisp-Stat as a helper, are more flexible in this respect. As a consequence, the UCLA Statistics pages still use a combined approach, with server-side PHP and CGI and client-side Xlisp-Stat and Java/JavaScript. Sometime this year, server-side Java scripting will become available, and then it seems advisable to switch as much of the code as possible to the server-side.