Jean-Jacques Vandewalle

The Web of Things: Interconnecting Devices with High Usability and Performance

In this paper, we show that Web protocols and technologies are good candidates to design the Internet of Things. This approach allows anyone to access embedded devices through a Web application, via a standard Web browser. This Web of Things requires to embed Web servers in hardware-constrained devices. We first analyze the traffics embedded Web servers have to handle. Starting from this analysis, we propose a new way to design embedded Web servers, using a dedicated TCP/IP stack and numerous cross-layer off-line pre-calculation (where information are shared between IP, TCP, HTTP and the Web application). We finally present a prototype -- named Smews -- as a proof of concept of our proposals. It has been embedded in tiny devices (smart cards, sensors and other embedded devices), with a requirement of only 200~bytes of RAM and 7~kilo-bytes of code. We show that it is significantly faster than other state of the art solutions. We made Smews source code publically available under an open-source license.

Developing Smart Card-Based Applications Using Java Card

In this paper we describe a methodology for developing smart card-based applications which accounts for both internal and external software production: on-card and client programs. This development methodology is based on the application of distributed object-oriented principles to Java Card. We design a model in which a card application is viewed as a remote object accessed through method invocations handled by a proxy object executing on the terminal. With a simple example, we show how this model enhances the development of smart card-based applications by allowing Java programmers to rapidly design and develop on-card and off-card programs without worrying about the specific smart card features. This scheme has been implemented as the core technology in the Gemplus Java Card application development environment GemXpresso RAD.

How smart cards can benefit from object-oriented technologies

Abstract We submit that a key enabling technology for non-predefined and multi-purpose smart cards is object-oriented technology. Object-oriented concepts and skills have proved their efficiency to model, design, and implement information systems made of small components. Smart cards become more and more personal environments for multiplicity of services. Therefore, they need to allow downloading of unpredictable services and to be easily integrated into information systems. This paper presents the usage of object-oriented technologies to implement a generic smart card operating system and to provide a card object adapter to access smart card services from distributed object-oriented information systems based on CORBA architecture.

Pluggable personal data servers

An increasing amount of personal data is automatically gathered on servers by administrations, hospitals and private companies while several security surveys highlight the failure of database servers to keep confidential data really private. The advent of powerful secure tokens, combining the security of smart card microcontrollers with the storage capacity of NAND Flash chips, introduces a credible alternative to the systematic centralization of personal data. By embedding a full-fledged database server in such device, an individual can now store her personal data in her own secure token, kept under her control, and never disclose in clear her private data to the outside untrusted world. This demonstration shows the benefit of the proposed approach in terms of privacy protection and pervasiveness through a healthcare scenario. This scenario is extracted from a field experiment where medical folders embedded in secure tokens are used to improve the coordination of medical care at home for elderly people. The demonstration also highlights interesting features of the embedded DBMS engine introduced to tackle the secure tokens strong hardware constraints.

A tamper-resistant and portable healthcare folder

Electronic health record (EHR) projects have been launched in most developed countries to increase the quality of healthcare while decreasing its cost. The benefits provided by centralizing the healthcare information in database systems are unquestionable in terms of information quality, availability, and protection against failure. Yet, patients are reluctant to give to a distant server the control over highly sensitive data (e.g., data revealing a severe or shameful disease). This paper capitalizes on a new hardware portable device, associating the security of a smart card to the storage capacity of a USB key, to give back to the patient the control over his medical data. This paper shows how this device can complement a traditional EHR server to (1) protect and share highly sensitive data among trusted parties and (2) provide a seamless access to the data even in disconnected mode. The proposed architecture is experimented in the context of a medicosocial network providing medical care and social services at home for elderly people.

Consistency and scalability in event notification for embedded Web applications

A new way to interact with small devices consists in embedding tiny Web servers, allowing the devices to serve fully-fledged Web applications. When the device needs to keep its users up-to-date of its internal state, the Web application has to use an event publication solution. Several works have recently been conducted in order to evaluate the trade-offs of various Web-based event notification solutions. In this paper, we propose to evaluate the feasibility of event notification in embedded Web applications. We conduct a large set of experiments in order to compare various push and pull based approaches for embedded systems. We show that a push-based approach can be very efficient in most situations, both in terms of client consistency and of scalability.

Serving embedded content via web applications: model, design and experimentation

Embedded systems such as smart cards or sensors are now widespread, but are often closed systems, only accessed via dedicated terminals. A new trend consists in embedding Web servers in small devices, making both access and application development easier. In this paper, we propose a TCP performance model in the context of embedded Web servers, and we introduce a taxonomy of the contents possibly served by Web applications. The main idea of this paper is to adapt the communication stack behavior to application contents properties. We propose a strategies set fitting with each type of content. The model allows to evaluate the benefits of our strategies in terms of time and memory charge. By implementing a real use case on a smart card, we measure the benefits of our proposals and validate our model. Our prototype, called Smews, makes a gap with state of the art solutions both in terms of performance and memory charge.

JCCAP: capability-based access control for Java card

This paper describes JCCap, a protection facility for cooperating applications in the context of Java Card. It enables the control of access rights between mutually suspicious applications, either between one terminal application and one Java Card applet or between two applets hosted inside the same Java Card. Using JCCap, access to objects is controlled by means of software capabilities that can be exchanged between mutually suspicious applications. An important advantage of JCCap is that the definition of the protection policy of an application (i.e., how access rights are granted to other applications) is completely separated from the application code. The protection policy is described in an extended Interface Definition Language (IDL) at the interface level, thus enhancing modularity, separation of concerns, and ease of expression in the design of the overall security architecture Each application can define its own protection policy independently from the other applications, thus enabling the expression of mutual suspicion without any prior knowledge about the policies of other applications. Every protection policy is then applied when applications interact with each other. This paper describes the implementation of a prototype of JCCap. It shows the feasibility and applicability of this technique in today’s Java Card and outline its advantages.

Efficient off-board deployment and customization of virtual machine-based embedded systems

This article presents a new way to deploy and customize embedded virtual machine based operating systems for very restrained devices. Due to the specificity of restrained embedded devices (large usage of read-only memory, very few writable memory available, …), these systems are typically deployed off-board, in a process called romization. However, current romization solutions do not allow a complete deployment to take place outside of the execution device: they are capable of converting system components and applications into their executable form, but are unable to perform any operation that would require the system to be running. This results in a good part of the deployment being performed by the target device, at the cost of longer startup times, bloat with code and data that are only executed once at startup, and suboptimal memory placement of data structures. In this article, we propose a new romization scheme that allows the system to be started within a virtual execution environment, and thus to be fully deployed off-board before being transferred to its real execution support. We then take advantage of all the information provided by the deployed state in order to analyze and customize it, resulting in a very low-footprint, custom-tailored embedded system. The Java platform is used as a support to implement our romization architecture and perform our experiments. For the evaluated set of embedded applications, we were able to obtain embedded systems which memory footprint was lower than their J2ME counterpart, while being based on a full-fledged J2SE environment.

Application-Driven customization of an embedded java virtual machine

Java for embedded devices is today synonym of “embeddable pseudo-Java”. Embedded flavors of Java introduce incompatibilities against the standard edition and break its portability rule. In this paper, we introduce a way to embed applications written for Java 2 Standard Edition. The applications are pre-deployed into a virtual Java execution environment, which is analyzed in order to tailor the embedded Java virtual machine according to their runtime needs. Experiments reveal that this method produces customized virtual machines that are comparable in size to existing embedded Java solutions, while being more flexible and preserving standard Java compatibility.