Lecture Notes in Computer Science Commenced Publication in 1973 Founding and Former Series Editors: Gerhard Goos, Juris Hartmanis, and Jan van Leeuwen
Editorial Board David Hutchison Lancaster University, UK Takeo Kanade Carnegie Mellon University, Pittsburgh, PA, USA Josef Kittler University of Surrey, Guildford, UK Jon M. Kleinberg Cornell University, Ithaca, NY, USA Alfred Kobsa University of California, Irvine, CA, USA Friedemann Mattern ETH Zurich, Switzerland John C. Mitchell Stanford University, CA, USA Moni Naor Weizmann Institute of Science, Rehovot, Israel Oscar Nierstrasz University of Bern, Switzerland C. Pandu Rangan Indian Institute of Technology, Madras, India Bernhard Steffen TU Dortmund University, Germany Madhu Sudan Microsoft Research, Cambridge, MA, USA Demetri Terzopoulos University of California, Los Angeles, CA, USA Doug Tygar University of California, Berkeley, CA, USA Gerhard Weikum Max Planck Institute for Informatics, Saarbruecken, Germany
7025
Bart De Decker Jorn Lapon Vincent Naessens Andreas Uhl
(Eds.)
Communications and Multimedia Security 12th IFIP TC 6 / TC 11 International Conference, CMS 2011 Ghent, Belgium, October 19-21, 2011 Proceedings
13
Volume Editors Bart De Decker K.U. Leuven, Department of Computer Science - DistriNet Celestijnenlaan 200A, 3001 Leuven, Belgium E-mail:
[email protected] Jorn Lapon Vincent Naessens KAHO Sint-Lieven - MSEC Gebroeders De Smetstraat 1, 9000 Gent, Belgium E-mail:{jorn.lapon,vincent.naessens}@kahosl.be Andreas Uhl University of Salzburg Visual Computing and Multimedia Jakob Haringer Str.2, A 5020 Salzburg, Austria E-mail:
[email protected]
ISSN 0302-9743 e-ISSN 1611-3349 ISBN 978-3-642-24711-8 e-ISBN 978-3-642-24712-5 DOI 10.1007/978-3-642-24712-5 Springer Heidelberg Dordrecht London New York Library of Congress Control Number: 2011937966 CR Subject Classification (1998): C.2, K.6.5, E.3, D.4.6, J.1, H.4 LNCS Sublibrary: SL 4 – Security and Cryptology
© Springer-Verlag Berlin Heidelberg 2011 This work is subject to copyright. All rights are reserved, whether the whole or part of the material is concerned, specifically the rights of translation, reprinting, re-use of illustrations, recitation, broadcasting, reproduction on microfilms or in any other way, and storage in data banks. Duplication of this publication or parts thereof is permitted only under the provisions of the German Copyright Law of September 9, 1965, in its current version, and permission for use must always be obtained from Springer. Violations are liable to prosecution under the German Copyright Law. The use of general descriptive names, registered names, trademarks, etc. in this publication does not imply, even in the absence of a specific statement, that such names are exempt from the relevant protective laws and regulations and therefore free for general use. Typesetting: Camera-ready by author, data conversion by Scientific Publishing Services, Chennai, India Printed on acid-free paper Springer is part of Springer Science+Business Media (www.springer.com)
Preface
It is with great pleasure that we present the proceedings of the 12th IFIP TC6 and TC-11 Conference on Communications and Multimedia Security (CMS 2011), which was held in Ghent, Belgium on October 19–21, 2011. The meeting continued the tradition of previous CMS conferences which were held in Linz, Austria (2010) and Heraklion, Crete, Greece (2006). The series of CMS meetings features an almost unique combined discussion of two specific topics in IT security which is hardly found elsewhere in the scientific community. At first sight communication and multimedia security does not seem to be highly related, but there are even applications where both aspects are obviously involved like streaming of secured video or privacy questions in social networks. On the one hand, there are specialized meetings on multimedia security like the ACM Multimedia and Security Workshop or the Information Hiding Conference, on the other hand there are specialized meetings on communication and network security like the ACM Computer and Communication Security Conference. The only meetings somewhat closer to CMS are the IFIP Information Security Conference (IFIP SEC), the Information Security Conference (ISC), and the Conference on Information and Communications Security (ICICS). However, the explicit focus on Multimedia Security is missing and usually, there are very few papers on this topic seen at those much more general conferences. The program committee (PC) received 52 submissions out of which only 11 full papers were accepted. In this edition, we have included 10 short papers, which describe valuable work-in-progress. Also, five extended abstracts reflecting the posters discussed at the conference, complete these proceedings. We would like to thank all the authors who submitted papers. Each paper was anonymously reviewed by three to five reviewers. In addition to the PC Members, several external reviewers joined the review process in their particular areas of expertise. We are grateful for their sincere and hard work. We tried to compile a balanced program covering various topics of communications and multimedia security: cryptanalysis, covert channels, biometrics, watermarking, ... just to name a few. We are also grateful to Moti Yung (Google Inc and Columbia University), Ronald Leenes (University of Tilburg), and Jaap-Henk Hoepman (TNO and Radboud University Nijmegen) for accepting our invitation to deliver keynote talks. We appreciate the contributions of our sponsors: Luciad, IBM, Google, BelSpo (Belgian State, Belgian Science Policy). Without their financial support, it would not have been possible to organize this conference or to attract as many young researchers. Finally, special thanks go to the organizing committee who handled all local organizational issues and provided us with a comfortable and inspiring location
VI
Preface
and a terrific social program. For us, it was a distinct pleasure to serve as program chairs of CMS 2011. We hope that you will enjoy reading these proceedings and that they may inspire you for future research in communications and multimedia security. October 2011
Bart De Decker Andreas Uhl
Organization
CMS 2011 was the 12th Joint IFIP TC6 and TC11 Conference on Communications and Multimedia Security. It was organized by KAHO Sint-Lieven in cooperation with K.U.Leuven.
Executive Committee Conference Chair Program Co-chairs Organizing Chair
Bart De Decker (K.U. Leuven, Belgium) Bart De Decker (K.U. Leuven, Belgium) Andreas Uhl (University of Salzburg, Austria) Vincent Naessens (KAHO Sint-Lieven, Belgium)
Program Committee Anas Abou El Kalam Partrick Bas David W. Chadwick Howard Chivers Isabelle Chrisment Gabriela Cretu-Ciocarlie Fr´ed´eric Cuppens Herv´e Debar Sabrina De Capitani di Vimercati Bart De Decker Yvo G. Desmedt Lieven Desmet Lieven De Strycker Yves Deswarte Jana Dittmann Stelios Dritsas Taher Elgamal Gerhard Eschelbeck Simone Fischer-H¨ ubner J¨ urgen Fuß Teddy Furon S´ebastien Gambs
IRIT - INP, France CNRS-Lagis, Lille, France University of Kent, UK Cranfield University, UK LORIA-University of Nancy, France Real-Time Innovations, Inc., USA T´el´ecom Bretagne, France T´el´ecom SudParis, France Universit` a degli Studi di Milano, Italy K.U.Leuven, Belgium University College London, UK K.U.Leuven, Belgium KAHO Sint-Lieven, Belgium LAAS-CNRS, France University of Magdeburg, Germany Athens University of Economics and Business, Greece Axway Inc., USA Webroot, USA Karlstad University, Sweden Upper Austria University of Applied Sciences, Austria INRIA Rennes - Bretagne Atlantique, France Universit´e de Rennes 1 - INRIA / IRISA, France
VIII
Organization
Christian Geuer-Pollmann Dieter Gollmann Mohamed Gouda R¨ udiger Grimm Jean Hennebert
Microsoft Research, Germany Hamburg University of Technology, Germany National Science Foundation, USA University of Koblenz, Germany University of Applied Sciences, HES-SO, Switzerland Eckehard Hermann Upper Austria University of Applied Sciences, Austria Jaap-Henk Hoepman TNO / Radboud University Nijmegen, The Netherlands Andreas Humm University of Fribourg, Switzerland Edward Humphreys XiSEC, UK Christophe Huygens K.U.Leuven, Belgium Witold Jacak Upper Austria University of Applied Sciences, Austria Sushil Jajodia George Mason University, USA Lech Janczewski University of Auckland, New Zealand G¨ unter Karjoth IBM Research - Zurich, Switzerland Stefan Katzenbeisser TU Darmstadt, Germany Markulf Kohlweiss Microsoft Research Cambridge, UK Herbert Leitold Secure Information Technology Center (A-SIT), Austria Javier Lopez University of Malaga, Spain Louis Marinos ENISA, Greece Keith Martin Royal Holloway, University of London, UK Fabio Massacci University of Trento, Italy Chris Mitchell Royal Holloway, University of London, UK Refik Molva Eur´ecom, France J¨ org R. M¨ uhlbacher Johannes Kepler Universit¨ at Linz, Austria Yuko Murayama Iwate Prefectural University, Japan Vincent Naessens KAHO Sint-Lieven, Belgium Chandrasekaran Pandurangan Indian Institute of Technology, Madras, India G¨ unther Pernul University of Regensburg, Germany Alessandro Piva University of Florence, Italy Hartmut Pohl University of Applied Sciences Bonn-Rhein-Sieg, Germany Jean-Jacques Quisquater Universit´e catholique de Louvain, Belgium Kai Rannenberg Goethe University Frankfurt, Germany Vincent Rijmen, K.U.Leuven, Belgium and Graz University of Technology, Austria Pierangela Samarati Universit` a degli Studi di Milano, Italy Riccardo Scandariato K.U.Leuven, Belgium Ingrid Schaum¨ uller-Bichl Upper Austria University of Applied Sciences, Austria J¨ org Schwenk Ruhr-Universit¨ at Bochum, Germany Andreas Uhl University of Salzburg, Austria
Organization
Umut Uludag Vijay Varadharajan Pedro Veiga Tatjana Welzer Andreas Westfeld Ted Wobber Shouhuai Xu Moti Yung
IX
Scientific and Technological Research Council (TUBITAK), Turkey Macquarie University, Australia University of Lisbon, Portugal University of Maribor, Slovenia University of Applied Sciences, Dresden, Germany Microsoft Research Silicon Valley, USA University of Texas at San Antonio, USA Google & Columbia University, USA
Referees Gergely Alp´ ar Haitham Al-Sinani Goekhan Bal Nataliia Bielova Christian Broser Gerardo Fernandez Christoph Fritsch Joaquin Garcia-Alfaro Mohamed Maachaoui Jef Maerien Sascha M¨ uller Khalid Salih Nasr Adam O’Neill Tobias Pulls Andreas Reisser Boyeon Song Borislav Tadic Peter Teufl Marianthi Theoharidou T.T. Tun Subhashini Venugopalan Ge Zhang Zhenxin Zhan Bernd Zwattendorfer
University of Nijmegen, The Netherlands Royal Holloway, University of London, UK Goethe University Frankfurt, Germany University of Trento, Italy University of Regensburg, Germany University of Malaga, Spain University of Regensburg, Germany T´el´ecom Bretagne, France IRIT - INP, France K.U.Leuven, Belgium TU Darmstadt, Germany IRIT - INP, France University of Texas, Austin, USA Karlstad University, Sweden University of Regensburg, Germany National Institute for Mathematical Sciences, Daejeon, Korea Deutsche Telekom AG, Germany IAIK, TU Graz, Austria Athens University of Economics and Business, Greece University of Trento, Italy Indian Institute of Technology, Madras, India Karlstad University, Sweden University of Texas at San Antonio, USA IAIK, TU Graz, Austria
Sponsoring Institutions/Companies Belgian State (Belgian Science Policy), IAP Programme, P6/26, “BCRYPT” Luciad IBM Google
Table of Contents
Part I: Research Papers Applicability and Interoperability Analysis of Revocation Strategies for Anonymous Idemix Credentials . . . Jorn Lapon, Markulf Kohlweiss, Bart De Decker, and Vincent Naessens
3
Architecture and Framework Security A Secure Key Management Framework for Heterogeneous Wireless Sensor Networks . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Mahdi R. Alagheband and Mohammad Reza Aref Twin Clouds: Secure Cloud Computing with Low Latency (Full Version) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Sven Bugiel, Stefan N¨ urnberger, Ahmad-Reza Sadeghi, and Thomas Schneider
18
32
Secure Hardware Platforms Implementation Aspects of Anonymous Credential Systems for Mobile Trusted Platforms . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Kurt Dietrich, Johannes Winter, Granit Luzhnica, and Siegfried Podesser
45
Biometrics Approximation of a Mathematical Aging Function for Latent Fingerprint Traces Based on First Experiments Using a Chromatic White Light (CWL) Sensor and the Binary Pixel Aging Feature . . . . . . . Ronny Merkel, Jana Dittmann, and Claus Vielhauer Two-Factor Biometric Recognition with Integrated Tamper-Protection Watermarking . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Reinhard Huber, Herbert St¨ ogner, and Andreas Uhl
59
72
XII
Table of Contents
Feature Selection by User Specific Feature Mask on a Biometric Hash Algorithm for Dynamic Handwriting . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Karl K¨ ummel, Tobias Scheidat, Christian Arndt, and Claus Vielhauer
85
Multimedia Security Dynamic Software Birthmark for Java Based on Heap Memory Analysis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Patrick P.F. Chan, Lucas C.K. Hui, and S.M. Yiu
94
A Secure Perceptual Hash Algorithm for Image Content Authentication . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Li Weng and Bart Preneel
108
Network Security Low-Attention Forwarding for Mobile Network Covert Channels . . . . . . . Steffen Wendzel and J¨ org Keller
122
Authentication Cryptanalysis of a SIP Authentication Scheme . . . . . . . . . . . . . . . . . . . . . . . Fuwen Liu and Hartmut Koenig
134
Part II: Work in Progress Applicability and Interoperability Mapping between Classical Risk Management and Game Theoretical Approaches . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Lisa Rajbhandari and Einar Arthur Snekkenes
147
Digital Signatures: How Close Is Europe to Truly Interoperable Solutions? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Konstantinos Rantos
155
Architecture and Framework Security A Generic Architecture for Integrating Health Monitoring and Advanced Care Provisioning . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Koen Decroix, Milica Milutinovic, Bart De Decker, and Vincent Naessens
163
Table of Contents
XIII
Secure Hardware Platforms A Modular Test Platform for Evaluation of Security Protocols in NFC Applications . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Geoffrey Ottoy, Jeroen Martens, Nick Saeys, Bart Preneel, Lieven De Strycker, Jean-Pierre Goemaere, and Tom Hamelinckx GPU-Assisted AES Encryption Using GCM . . . . . . . . . . . . . . . . . . . . . . . . . Georg Sch¨ onberger and J¨ urgen Fuß
171
178
Multimedia Security Radon Transform-Based Secure Image Hashing . . . . . . . . . . . . . . . . . . . . . . Dung Q. Nguyen, Li Weng, and Bart Preneel
186
Network Security On Detecting Abrupt Changes in Network Entropy Time Series . . . . . . . . Philipp Winter, Harald Lampesberger, Markus Zeilinger, and Eckehard Hermann
194
Motif-Based Attack Detection in Network Communication Graphs . . . . . Krzysztof Juszczyszyn and Grzegorz Kolaczek
206
Authentication Secure Negotiation for Manual Authentication Protocols . . . . . . . . . . . . . . Milica Milutinovic, Roel Peeters, and Bart De Decker
214
A Secure One-Way Authentication Protocol in IMS Context . . . . . . . . . . . Mohamed Maachaoui, Anas Abou El Kalam, and Christian Fraboul
222
Part III: Posters High Capacity FFT-Based Audio Watermarking . . . . . . . . . . . . . . . . . . . . . Mehdi Fallahpour and David Meg´ıas
235
Efficient Prevention of Credit Card Leakage from Enterprise Networks . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Matthew Hall, Reinoud Koornstra, and Miranda Mowbray
238
Security Warnings for Children’s Smart Phones: A First Design Approach . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Jana Fruth, Ronny Merkel, and Jana Dittmann
241
XIV
Table of Contents
Ciphertext-Policy Attribute-Based Broadcast Encryption Scheme . . . . . . Muhammad Asim, Luan Ibraimi, and Milan Petkovi´c
244
Anonymous Authentication from Public-Key Encryption Revisited (Extended Abstract) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Daniel Slamanig
247
Part IV: Keynotes Mobile Identity Management . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Jaap-Henk Hoepman
253
Who Needs Facebook Anyway - Privacy and Sociality in Social Network Sites . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Ronald E. Leenes
254
From Protecting a System to Protecting a Global Ecosystem . . . . . . . . . . Moti Yung
255
Author Index . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
257
Part I
Analysis of Revocation Strategies for Anonymous Idemix Credentials Jorn Lapon1 , Markulf Kohlweiss3 , Bart De Decker2 , and Vincent Naessens1 1
Katholieke Hogeschool Sint-Lieven, Industrial Engineering 2 Katholieke Universiteit Leuven, CS-DISTRINET 3 Microsoft Research, Cambridge
Abstract. In an increasing information-driven society, preserving privacy is essential. Anonymous credentials promise a solution to protect the user’s privacy. However, to ensure accountability, efficient revocation mechanisms are essential. Having classified existing revocation strategies, we implemented one variant for each. In this paper we describe our classification and compare our implementations. Finally, we present a detailed analysis and pragmatic evaluation of the strategies. Keywords: Anonymous Credentials, Revocation, Privacy, Performance.
1 Introduction Individuals release a lot of personal information to all kinds of service providers. Users have no impact on what is done with these data once they are released. Service providers can process them to build detailed profiles. The latter can be privacy sensitive (depending on the content) and possibly lead to discrimination, extortion, blackmail, or other illegal activities. For instance, a bookshop can detect a user’s interest in books related to certain diseases and sell that information to insurance companies that can fix higher life insurance contributions/premiums. Similarly, many governments collect information about people who submitted controversial political statements on fora and discriminate these citizens. During the last decades, many privacy enhancing technologies have been proposed and developed. They aim at offering a higher level of privacy (or anonymity) in the digital world. Examples are anonymous communication channels, anonymous e-mail and publication systems, privacy policy evaluation tools and anonymous credential systems. Anonymous credentials allow for anonymous authentication. Only the attributes – or properties thereof – that are required to access a service are proved to a service provider. For instance, users can prove to belong to a certain age category to get discounts on public transport tickets. Similarly, they only need to prove to live in the city in order to get access to the waste recycling center. Although those technologies are more privacy-friendly compared to certificate technology, revocation becomes more complex. Multiple revocation strategies have already been proposed in the literature, often with a theoretical security and performance analysis. However, a pragmatic assessment of revocation schemes for anonymous credentials is still lacking. Hence, it B. de Decker et al. (Eds.): CMS 2011, LNCS 7025, pp. 3–17, 2011. c IFIP International Federation for Information Processing 2011
4
J. Lapon et al.
is very difficult to compare results due to varying security parameters and alternative software implementations. However, a critical and pragmatic comparison is crucial to bring those technologies to practice. Contribution. The contribution of this paper is threefold. First, existing revocation schemes are classified in six categories or strategies. Second, one variant of each strategy has been implemented with comparable security parameters and added to an existing library, namely the Identity Mixer Library [1]. Third, the paper gives a detailed analysis and pragmatic evaluation of the implemented strategies. Amongst others, the security and anonymity properties, the connectivity and performance of the schemes are compared. Usable performance results are presented in the sense that all schemes were implemented within the same library and run on the same platform. From this evaluation, guidelines are derived that can be applied by software developers that have to select a revocation strategy – or a combination of them – in a particular setting. The rest of this paper is structured as follows. Section 2 introduces basic building blocks that are used throughout the rest of this paper. Thereafter, revocation schemes are classified according to six categories. Section 4 gives a pragmatic complexity analysis and compares multiple functional properties of the schemes. Section 5.2 focuses on implementation details and results, extracted from a practical realization after which guidelines are formulated. The guidelines assist the developer in selecting a strategy – or a combination of them – in a particular setting. Finally, Section 7 discusses further work and general conclusions.
2 Preliminaries We shortly discuss some key elements, important for a good understanding of the rest of the paper. Anonymous Credentials. Anonymous credential systems [2–5] allow for anonymous yet accountable transactions between users and organizations. Moreover, selective disclosure allows the user to reveal only a subset of possible properties of the attributes embedded in the credential: e.g. a credential with the user’s date of birth as an attribute can be used to prove that the owner is over 18 without disclosing the exact date of birth or other attributes. We focus on anonymous credentials in which multiple shows are unlinkable [2, 3, 6]. All these schemes originate from existing group signatures and identity escrow schemes. Proofs of Knowledge. Anonymous credential systems heavily rely on proofs of knowledge. These allow a prover to convince a verifier about its knowledge of certain values, without leaking any useful information. For instance, when showing a credential, the prover only wants to prove knowledge of a valid credential, and possibly disclose properties of attributes in the credential. To address revocation, these proofs are further extended to prove that the shown credential is indeed not revoked. Cryptographic Accumulators. An important, but more complicated revocation mechanism that will be discussed are based on so-called cryptographic accumulators. A cryptographic accumulator, first introduced by Benaloh and de Mare [7], is a construction
Analysis of Revocation Strategies for Anonymous Idemix Credentials
5
which allows the accumulation of a number of elements into one value. The size of this value is independent of the number of elements incorporated. For each accumulated element, there is a witness that allows to prove that the element is contained in the accumulator. It must be infeasible, for the adversary, to find a witness for an element that is not included in the accumulator. Camenisch and Lysyanskaya [8] further extended this notion into dynamic accumulators. In dynamic accumulators adding and removing values and updating individual witnesses can be done dynamically [4].
3 Revocation Strategies In traditional credential systems, verifying the revocation status of a credential is straightforward and involves a simple lookup of a revealed credential specific identifier in a list. Well-known examples are OCSP [9] and CRL [10] based schemes. This strategy can be used for both local and global revocation. A revocation authority controls the validity of the credential globally, while services can use the identifier for local access control. We can distinguish two types of lists: blacklists, in which only revoked credentials are listed; and whitelists, in which only valid credentials are listed. Moreover, the time can be limited between credential revocations and a service still accepting the credential show as valid (latency). In anonymous credential systems, on the other hand, the credential specific identifier is no longer revealed. In fact, this is one of the key requirements of anonymous credentials. In literature several revocation strategies for anonymous credentials have been developed, with each their advantages and drawbacks. Although some revocation mechanisms perform well for small groups, we focus on revocation schemes suitable for large scale settings such as electronic identity cards and e-passports. Efficiency in processing and communication is crucial. We distinguish three parties: the issuer I handles the issuance of credentials; the user U obtains credentials; and the service provider SP to whom users authenticate. Although the ultimate goal is to make the overhead caused by the revocation strategy as little as possible, most strategies assign substantial workload to one of these parties. Nevertheless, for some strategies there may be an additional overhead for other parties as well. Based on this, we identify four classes. In the first class, Limited Overhead, none of the parties gets a big payload to handle revocation. In fact we will see that none of those solutions are satisfactory for anonymous credential revocation. For the other three classes, handling revocation assigns a substantial payload to at least one of the parties (i.e. Issuer, User or Service Provider) in the scheme. 3.1 Limited Overhead Pseudonymous Access [Nym ]. Though, more related to service usage [11], a simple and efficient solution requires the owner to provably disclose a domain specific pseudonym [12, 13]. The service provider or a trusted party of that domain is in charge of creating and modifying the list of accepted or revoked pseudonyms. Although the domain specific pseudonym can be used for local access control, it cannot be used for a global revocation of the credential. Moreover, the user is no longer anonymous as all his transactions in the same domain are linkable.
6
J. Lapon et al.
Verifiable Encryption [VE ]. Although verifiable encryption is often cited in anonymous credential schemes related to anonymity revocation [14, 15], it could be used for revocation as well. Hence, the user verifiably encrypts the credential’s identifier with the public key of the issuer. To verify the revocation status, the service provider sends the ciphertext to the issuer, that decrypts the ciphertext. The issuer can now use the obtained identifier to do a simple lookup of the revocation status of the corresponding credential and report it to the service provider. This solution is closely related to the OCSP protocol in traditional credential schemes, with only little overhead. However, the user requires a lot of trust in the issuer, since it is able to monitor the usage of the credential (i.e. to which service providers the credential is shown). A possible solution is to require the service provider to make this request over an anonymous channel. Furthermore, replacing the public key of the issuer with the public key of another trusted third party, allows to have a separate authority in charge of the revocation tasks. Moreover, if the encrypted identifier is replaced with a domain specific pseudonym, a domain specific revocation authority may take care of access control in a certain domain. In spite of the Nym and VE strategies, a practical and privacy friendly revocation strategy with limited (constant) overhead is not yet available. 3.2 Issuer In the most naive solution, both the group public key and the credentials of each user are reissued whenever a party is revoked or added to the group. This solution, though its security is high for its zero latency, results in an unacceptable overhead for both users and issuers in large scale settings, hence, it is impractical. The Limited Lifetime and Signature Lists, discussed below, are two schemes requiring the issuer to frequently generate updates for users. Limited Lifetime [LL ]. In this scheme, an attribute expressing the lifetime of the credential, is enclosed. During each authentication, the user proves that the credential has not expired. The lifetime of a credential highly determines the usability of the revocation scheme. A short lifetime requires the user to frequently re-validate the credential, while a long lifetime makes the scheme insecure. Instead of reissuing new credentials, Camenisch et al. [16] pointed out that non-interactive credential updates are a useful replacement. The issuer generates credential update info for all valid credentials before the end of the credential’s lifetime is reached. Before the user can authenticate, the user has to download this information and update his credential. Signature Lists [RL ]. Similar to CRLs in traditional schemes, it is possible to maintain revocation lists in anonymous credential schemes. However, the verification is more complicated. Instead of the service provider performing the verification, the user has to prove that the credential is not revoked. In the case of whitelists, the list consists of signatures on the identifiers of each valid credential and a list identifier. The user selects the signature in the whitelist containing the identifier of his credential and then proves knowledge of the identifier together with the proof that the credential identifier in the
Analysis of Revocation Strategies for Anonymous Idemix Credentials
7
signature is the same as the one contained in the credential being validated. Additionally, the list identifier is revealed, such that the service provider can verify that the latest list was used. For blacklists, proving non-membership is more complex. T. Nakanishi et al. [17] propose an elegant solution by ordering the list of revoked identifiers. For each consecutive pair of identifiers, the issuer publishes a signature on the pair, together with an identifier of the list. During a credential show, the user then proves knowledge of his credential and a signature from the blacklist, such that the identifier in the credential lies between two revoked identifiers in the ordered blacklist. Similar as in the case of whitelists, the disclosed list identifier shows that the latest revocation list was used. If this proof verifies successfully, the service provider is ensured that the credential is valid with respect to the latest blacklist. In the latter two schemes, the effort of the issuer is significant. For every change that requires the removal of a signature from a whitelist or addition to the blacklist, the issuer has to rebuild the entire revocation list with a new list of identifiers. In case of a join in the whitelist, it is sufficient to add only one signature to the latest whitelist. Likewise, re-approving a previously revoked credential can be done by replacing two consecutive signatures by one new signature. Nevertheless, authentication in both schemes proving (non-)membership results in a non-negligible, but constant overhead. 3.3 User Accumulators [Acc ]. A more complex, but possibly more efficient solution for credential revocation is based on so-called dynamic accumulators [18–20]. The user needs to prove membership or non-membership in the accumulator, during authentication for whitelist, resp. blacklist revocation. The service provider therefore fetches the latest accumulator value from the revocation authority and if the proof of the credential show verifies correctly w.r.t. that accumulator value, the service provider is ensured that the credential has not been revoked. Except for the verification of a more elaborate proof, the service provider has no additional overhead. On the other hand, although building this proof can be done quite efficiently, it requires the user to first update its witness, which is time-consuming. The latter enables proving (non-)membership in the accumulator. Moreover, since revoking and possibly also adding credentials to the group change the value of the accumulator, a witness update is required. These updates require resources (e.g. exponentiations [18, 19], storage [20]) linear to the number of added or revoked credentials from the accumulator. 3.4 Service Provider Verifier Local Revocation[VLR ]. For many applications, the resources available to users to perform these witness updates, are very limited. In this case verifier local revocation[21, 22], first introduced by E. Brickell et al. [33], may come to the rescue. Service providers download a list of items each linked to a revoked credential. During authentication, the user provably reveals a token allowing the verifier to check that the token is not related to any of the items in the list. Therefore, as the service provider has to check each item in the list, verification takes a (maximum) number of resources
8
J. Lapon et al.
linear with the number of revoked credentials. Batch verification techniques try to tackle this [23]. Note that in some VLR schemes [33, 21], all signatures made with the same credential become linkable after its revocation. Therefore, more recent schemes ensure backward unlinkability [22] such that former credential shows remain unlinkable. This strategy has been adapted by the Trusted Computing Group for the use in trusted platform modules (TPM) [24]. Note that in this case, revocation is only possible if the private key is revealed to the public. As long as the corrupted private key is kept secret by the adversary, revocation of the corrupted TPM is not possible.
4 Discussion As we focus on strategies rather than on specific revocation schemes, the analysis of the strategies makes abstraction of scheme specific details. Nevertheless, we do not hesitate to pinpoint the advantages of some specific schemes. Complexity. All strategies try to tackle the same problem in a different way. For some strategies, the complexity analysis is obvious, in others it is rather subtle. Table 1 shows the complexity of the most expensive computations for each scheme. We assume that ˜ is constant. The last column illustrates the the average number of valid users (#U), frequency of occurrence of these complex computations. Table 1. Total complexity of the most computationally intensive processing during an interval Δ Complexity Nym Ord(1) VE Ord(1) ˜ LL I: Ord(#U) RLw
˜ I: Ord(#U)
Frequency − −
creation of credential updates for each valid credential creation of signatures for each valid credential
1 Δt 1 max(Δt ,Δc ) 1 max(Δt ,Δc )
creation of signatures for each ordered pair of revoked credentials 1 Acc U: Ord(#RΔ [+#J Δ ]) update of the user’s witness Δc VLR V: Ord(#R) verifying the list of revoked credentials every verification RLb
I: Ord(#R)
Description
#U˜ : average number of members Δt : time between list updates. #R(Δ ) : revoked members (since last update) Δ c : time between revocations/joins. #J (Δ ) : joined members (since last update)
The table confirms the classification in section 3. For both Nym and VE the workload is constant for every party. Further, the LL and RL strategies require the issuer to frequently compute updates, resp. signatures for valid or revoked credentials. As mentioned before, updating the list in the RL strategies is not required as long as no identifiers are removed from the list. As opposed to LL, in which after each time-interval, the issuer computes for every valid credential a new credential update.
Analysis of Revocation Strategies for Anonymous Idemix Credentials
9
Accumulator based strategies (Acc), on the other hand, alleviate the work of the issuer by moving a part of the computation to the users. In fact accumulator updates can be done quite efficiently and in batch by the issuer (e.g. 1 multibase exponentiation in the case of [8]). However, now the user has to perform a number of complex computations (i.e. exponentiations in [8, 25]) linear in the number of added and removed credentials. The accumulator scheme by Camenisch et al. [26] is in this sense quite efficient. Using the so called state information, users can efficiently update their witness by a number of multiplications. However, in large scale settings, the information required to perform the update is considerably large. Hence, special update servers are required to make the updates efficiently, since they may keep the state information in memory. To keep the number of changes of the accumulator in whitelist based accumulators to a minimum, during setup the issuer can accumulate a large set of unused identifiers. Once the issuer issues a credential it fetches a free identifier from the set and includes it in the credential. As such, the accumulator does not change whenever new users join the group. Instead of updating the accumulator after each addition or removal, it is possible to update the accumulator value only after a certain time, similar to the case of RL schemes. However, to increase flexibility and decrease latency, a list of the latest accumulators can be published, and allow the service provider to decide which accumulator values are still acceptable. Hence, the service provider may decide to accept proofs with older accumulators. Finally, often the issuer can perform the witness updates more efficiently [8]. However, in this case, the user is subject to timing attacks in cases the issuer and service provider collude. Finally, in the VLR strategy, the verifier carries the burden. In case of a valid credential, the verifier has to perform a computation for every item in the revocation list. There exist VLR schemes [27] that improve efficiency of the verification, however, for large scale settings the complexity of the credential show and the memory load become significant. Although verification of the validity of signatures (i.e. equality) can be done in batch [28], batch verification of revocation lists (i.e. inequality) has not been described in detail in literature. Functional Properties. Table 2 gives an overview of some functional properties of the different strategies with respect to the basic scheme without revocation. It illustrates that there is no straightforward winner. Schemes that score clearly better with certain properties, perform worse on others, and vice versa. It is for instance clear that the Nym and VE strategies are less privacy friendly. In fact all other strategies allow full anonymity. However, to obtain full anonymity in LL, RL and Acc, the user should download the entire set of update information, since otherwise timing attacks are possible. Alternatively, a private information retrieval scheme may allow the user to download the required data more efficiently, while maintaining anonymity. Of course, in large scale settings, with many service providers and users, and since the download may be done well before the actual credential show, the dangers of timing attacks may be negligible. The security of the LL and RL strategies, defined by the latency, perform worse than the other strategies, that allow for zero latency. Note that to decrease communication overhead, Acc and VLR can accept a non-zero latency, by accepting older accumulators resp. revocation lists.
10
J. Lapon et al.
Table 2. Functional properties (↓ and without revocation)
Anonymity Latency Netw. Conn. Download (U/SP) Global/Local
↑ shows the relation w.r.t. the basic credential scheme
Nym
VE
↓
↓
LL
RL
↑
↑
U
Acc
VLR
-/-
-/-
↑/-
U (SP) U (SP) SP ↑ / - ↑ / - -/↑
L
G[L]
G
G
G
G
To decrease latency in the case of LL and RL, the frequency of issuing update information resp. revocation lists should be higher than the frequency of revoking credentials. This is computationally expensive especially in the large scale settings that we envision. Nevertheless, both LL and RL can be useful in environments with lower security requirements. VLR schemes use blacklisting. RL and Acc, on the other hand, allow for both blackand whitelisting. In the case of RL schemes, while a proof of membership may be more efficient in the case of whitelists, some settings advocate for blacklist based schemes with possibly more efficient updates. Especially, the “valid versus revoked credentials” ratio determines which strategy is the better choice. In the case of accumulator based revocation, the difference between white- and blacklists is rather subtle. The table further shows that the user is required to be online for LL, RL and Acc. The service provider may have to download information for RL, Acc and VLR. However, for both RL and Acc it is possible to avoid downloads. In the case of RL, the service provider can simply verify the revealed validity time of the shown signature. If it lies in an acceptable (small) time interval, it accepts the credential show. Otherwise, it requires the use of a newer revocation list. In case of Acc, the user could provide the signed accumulator to the service provider. Note that the amount of data to be downloaded in case of the Acc by the user and VLR by the service provider may be substantial. For some VLR schemes, such as the one of Ateniese et al. [22], to obtain high security the revocation list requires frequent updates, resulting in even more data traffic. Combining strategies. As already discussed, the different schemes expose different properties. To maximize the advantage of those properties, multiple strategies can be combined in the same credential scheme. For instance, an updatable lifetime may be used in parallel with accumulators. The lifetime may be sufficient in low-security environments, while a service requiring high-security may require the same user to prove membership in the latest accumulator. In another example, Nym could be used for local access control, while another strategy is used for verifying the global revocation status. In fact all strategies discussed are compatible and only require the issuer to include the appropriate attributes in the credential.
Analysis of Revocation Strategies for Anonymous Idemix Credentials
11
5 Implementation 5.1 Implementation Notes One of the most versatile anonymous credential systems available to date is the Identity Mixer system [1], short Idemix. Some of the schemes (i.e. LL, Nym and VE) are readily available in this library. We extended the library with the other revocation strategies mentioned. For RL and Acc both a white- and a blacklist scheme is implemented as well as a VLR scheme. More details are given below. Note that our choice of schemes was restricted by the cryptographic schemes used in the Identity Mixer. For instance, the library does not implement pairings, heavily limiting the number of possible schemes. Note that the implementation was done respecting the architecture and design of the library as much as possible. In fact, all extensions can be optionally activated depending on the proofspecification. Most of the implementation effort went to the extended proofs of the credential shows. Except for the declaration and parsing of the appropriate attributes in the credentialspecifications, there are no major additions to the issuance of the credentials. An optional
element has been added to the proofspecification, in which , and elements allow to declare the revocation scheme applied during the credential show. Like the calls in the library to the extensions for proving, for instance, inequality and commitments, we added calls to the appropriate extensions (i.e. VLR-Prover and Verifier, Acc-Prover and Verifier and RL-Prover and Verifier), in the Prover and Verifier class. These handle the revocation scheme specific proofs. The credential shows in Idemix are implemented as common three-move zero-knowledge protocols (called sigma protocol), made non-interactive using the Fiat-Shamir heuristic [29]. The provers, in a first round compute the scheme specific t-values (i.e. the values in the first flow of the sigma protocol) and add those values to the computation of the challenge c. Then, the prover computes the s-values (i.e. the responses of the third flow of the sigma protocol) and adds them to the message sent to the verifier. Finally, at the verifier, the tˆ-values are computed based on the s-values and verified with the received common values. The extensions use the security parameters used in the original Idemix library for the construction of the proofs. Signature Lists. The signature lists for both white- and blacklists are instantiated by CL signatures, which are also used in the library. They allow to prove knowledge of the signature and its attributes, without revealing them. Moreover, it allows to prove relations such as equality of the identifier in the signature and the identifier in the credential in the case of whitelists. For blacklist revocation, an implementation was made based on the scheme of Nakanishi et al [17]. As mentioned before, the revocation list consists of an ordered list of revoked identifiers, which are pair-wise signed by the revocation authority together with a list identifier. Additionally, an unused minimum and maximum identifier is included in the list. To prove that the credential is not revoked, the user proves knowledge of a signature in the revocation list with a certain identifier such that the identifier in the credentials lies in the interval formed by the identifiers in the signature. Therefore, for the implementation we recover the inequality provers available in Idemix.
12
J. Lapon et al.
CL-Accumulator scheme. Several accumulator based revocation schemes exist. An implementation in C++, comparing three of them is available in [30]. The schemes implemented there, are all whitelist revocation schemes. One of the schemes compatible with the Idemix library is the construction by Camenisch et al [18]. Building on this construction J. Li et al [31] extended the scheme with a non-membership proof, allowing the same accumulator construction to be used for blacklisting as well. The schemes have been implemented based on the membership proof in Section 3.3 “Efficient Proof That a Committed Value Was Accumulated” presented in [18] and the non-membership proof defined in Protocol 1 in Section 5 “Efficient Proof That a Committed Value Was Not Accumulated” in [31] DAA-VLR scheme. Finally, the VLR scheme adopted by the TCG group [24] has been implemented. In contrast to what is implemented in TPMs, in which the private key is required for revocation, a separate random identity attribute id is enclosed in the credential. The latter is then used to perform the verification. This allows the issuer to revoke the credential based on this identity, and does not require the private key of the credential to be compromised. The protocol presented in [24] defines the issuance and proof of an entire DAA anonymous credential. Our implementation extends the ?
credential show of Idemix with the proof of knowledge PK{(id) : Nv = ζ id ∧ ζ ∈R γ } with id the identity of the user, and ζ a randomly chosen base. and the verification of the list of revoked values by verifying that ζ idi = Nv for each idi in the revocation list. 5.2 Results This section reports the results of two experiments. The first experiment deals with the issuance and showing of a single credential. The second experiment analyses the time required for the complex computations as in the complexity analysis. The experiments use the default security parameters (i.e. k = 160 bit) proposed in Appendix A, Table 2 of the Idemix library specification [1], and are executed on a DELL Latitude P9600 @ 2.53GHz, 4GB RAM. Note that since most algorithms are probabilistic, large variations in timings are possible. To make the measurements as realistic as possible and minimize overhead caused for instance by class loading, the given numbers are averages over a large number of runs. Moreover, the communication overhead is not included. Table 3 presents for each implemented scheme, the total time required to issue and show a credential. The credential-show includes the verification of the revocation status. Since for all schemes issuing a credential does not require complex calculations w.r.t. the Basic scheme, issuing a credential is about the same for most schemes. A small time difference may be noticed for all but the Nym scheme, caused by an additional attribute required by the revocation strategy. However, as could be expected, there is more variance in showing a credential. Only the time for a credential show in the Nym and VLR scheme lies close to the Basic scheme. For these schemes, the small overhead is caused by the computation and disclosure of a pseudonym. Note that in VLR this pseudonym is randomized. For the whitelist based RLw scheme, the time is doubled w.r.t. the Basic scheme. Here, showing a credential implies two proofs, namely one proof for proving the knowledge of a credential, and an additional proof for proving the knowledge of a signature from the revocation list, with the same identifier as in the credential. The
Analysis of Revocation Strategies for Anonymous Idemix Credentials
13
Table 3. Timing analysis for issuing and showing a single credential (average over 200 rounds) (in sec.)
Issue
Show
Basic Nym VLR Accb Accw LL RLw RLb VE
2.5 2.5 2.6 2.6 2.6 2.6 2.6 2.6 2.6
0.8 0.9 1.0 3.5 3.8 4.2 1.8 8.6 16.0
overhead for the credential show in the white- and blacklist accumulator based schemes, is induced by the complex membership resp. non-membership proof. A more detailed analysis may be found in [30]. It is a bit surprising that showing a credential in the LL scheme takes even more time. The reason for this is that the scheme (as implemented in Idemix) requires an expensive range proof to show that the credential’s expiration time, is larger than or equal to the current time. This way the epoch strategy is very flexible, as not all users have to update as frequently as others. However, if the lifetime attribute in credentials is synchronized and the same for all credentials, it is possible to simply disclose the lifetime value. As such, the credential show takes about as much time as in the case of the Basic scheme. Similarly, showing a credential in the RLb scheme requires an additional signature proof and two range proofs. The signature proof, proves knowledge of a signature in the revocation list and the range proofs prove that the identifier in the credential lies between the revoked identifiers in the proved signature. The worst scheme is the one based on verifiable encryption. This scheme may not be practical for revocation. Moreover, this result shows that using verifiable encryption for anonymity revocation implies a very large overhead as well. In the second experiment, summarized in table 4, the most complex computations as discussed in section 4 have been verified in practice. Since the total amount of valid users, in our setting will be much larger than the number of revoked users, it is clear that LL and RLw require a lot of computations by the issuer. Hence, RLb might be more interesting. However, as noted in the previous experiment, showing a credential in the RLb scheme is expensive, and may seem impractical. The accumulator based schemes have practically no overhead at the issuer’s side. However, before showing his credential, a user has to update his witness. The witness update takes approximately 20ms per revoked credential, since the previous update. As stated before, it is possible to avoid witness updates as a result of joining new credentials. If it is possible to let the user have frequent witness updates, then this overhead is spread over time and may be acceptable for applications. Finally, the VLR solution shows that it only takes approximately 3ms per revoked credential, to verify the validity of a credential.
14
J. Lapon et al. Table 4. Time analysis of the most complex computations (sec.) LL RLw RLb Accb Accw VLR
Issuer
User
1.4 ∗ #U˜ 1.31 ∗ #U˜ 1.50 ∗ #R 0.16 0.02 ∗ #RΔ + 0 ∗ #J 0.16 0.02 ∗ #RΔ + 0 ∗ #J
Verifier
0.003 ∗ #R
For the Belgian eID card1 , there are about ten million users, and about 375.000 revocations a year. We have to note though that the certificates of youngsters and kids in Belgium are automatically revoked, giving an incorrect image of the number of actual revocations resulting from lost or stolen credentials. Moreover, Belgian citizens may opt to revoke their digital certificates themselves. Applying the schemes to this large scale setting, we have the following results. Generating update information in the LL scheme would take about 160 days. For the RLb scheme with 375.000 revocations, it takes about 6.5 days. Similarly, for the VLR scheme, verifying a credential show takes 18 minutes. For the latter, however, batch verification may increase the speed. Note that in literature, there is no batch verification scheme available that is tuned for the verification that a credential is not in the list of the VLR. For VLR, the batch verification should allow to verify that none of the tokens in the list match with the one being verified, while in literature the authors often refer to batch verification of signatures. In this case, batch verification allows to verify that all signatures are valid. Although great improvements can be reached by faster implementations and processors (e.g. an implementation in C++ of the accumulator takes only 1.5ms instead of 20ms in Java in which Idemix is implemented), these numbers show that for large scale settings, the RL, LL and VLR schemes are impractical.
6 Applying Revocation Schemes - Guidelines It is clear that there is not one strategy superior to all the others. Therefore, we end the analysis with an overview of which strategies are useful in which settings. Nevertheless, a combination of multiple strategies may sometimes offer the best trade-off. The guidelines are summarized in table 5 and discussed below. Security. For high security environments (i.e. requiring low latency) accumulator based revocation is the most secure and privacy-friendly strategy, closely followed by some verifier local revocation schemes. For the latter, one has to select a VLR scheme carefully that provides adequate anonymity. On the other hand, for lower security environments, LL provides a reasonable trade-off. RL offers a similar solution but is not restricted to the issuer to act as revocation manager. 1
Results obtained from http://godot.be/eidgraphs
Analysis of Revocation Strategies for Anonymous Idemix Credentials
15
Table 5. Feasibility of the schemes w.r.t. connectivity and resources. (•: positive; ◦: neutral; else: negative)
Nym VE LL RL Acc VLR
Security Offline U SP • • • • ◦ • ◦ • • • (•) •
Low Resources U SP • • ◦ ◦ ◦ • ◦ • • •
Processing Environments. Often a user’s credential is kept in resource constrained environments (e.g. a smartcard). In this case, VLR schemes require the least computational overhead for the user. Also LL is a possible alternative. RL and Acc, however, require complex computations, making these scenarios less effective in resource constrained environments. In some settings, the verifier has limited resources (e.g. a door lock). In this case VLR is not an option. Connectivity. In case of RL and Acc the user requires frequent communication with the issuer. On the other hand, for the service provider in the case of Łand RL, it is sufficient to keep track of time to be able to verify the revocation status. This is especially important for offline service providers. In this case, when computing power is not an issue, the more secure accumulators may provide an alternative. Then the user should provide the latest accumulator, signed by the revocation authority. The verifier then simply checks the validity time of the revocation list. Online environments offer more freedom. In some schemes, computation may be outsourced to other possibly trusted environments. For instance, verification in the VLR setting may be done by an external more powerful party. When the verifier outsources this verification to a more powerful trusted party, it actually implements a kind of OCSP scenario. Related to accumulator schemes, some schemes [20] also take advantage of remote witness updates.
7 Conclusion This paper classifies existing revocation strategies for anonymous credential systems into six categories. The analysis shows that there is no straightforward winner, and the effectiveness and efficiency of a specific strategy heavily relies on the setting in which the mechanism is used. To maximise the applicability of anonymous credentials, only a combination of multiple strategies may provide some relieve. Therefore, guidelines are proposed that show which strategies should be applied in which settings. The practicality and applicability of anonymous credential schemes in real-life settings is an on-going discussion and remain important aspects to analyse. In the implementation and comparison presented in this paper, we focussed on schemes that are suitable within the Identity Mixer Library. Nevertheless, revocatoin schemes, for
16
J. Lapon et al.
instance, based on pairing based cryptography or suitable within the U-Prove credential scheme [32], may show to be better alternatives. For future work, we envision to compare the results of this paper, with implementations of more revocation schemes for anonymous credentials. Acknowledgements. This research is partially funded by the Interuniversity Attraction Poles Programme Belgian State, Belgian Science Policy and the Research Fund K.U.Leuven, and the IWT-SBO projects DiCoMas and MobCom.
References 1. Specification of the Identity Mixer Cryptographic Library – Version 2.3.2. Technical report, IBM Research – Zurich (2010) 2. Chaum, D.: Security Without Identification: Transaction Systems to Make Big Brother Obsolete. Commun. ACM 28(10), 1030–1044 (1985) 3. Camenisch, J.L., Lysyanskaya, A.: An Efficient System for Non-transferable Anonymous Credentials with Optional Anonymity Revocation. In: Pfitzmann, B. (ed.) EUROCRYPT 2001. LNCS, vol. 2045, pp. 93–118. Springer, Heidelberg (2001) 4. Camenisch, J., Herreweghen, E.V.: Design and implementation of the idemix anonymous credential system. In: Atluri, V. (ed.) ACM Conference on Computer and Communications Security, pp. 21–30. ACM, New York (2002) 5. Brands, S.: A Technical Overview of Digital Credentials (2002) 6. Bangerter, E., Camenisch, J.L., Lysyanskaya, A.: A Cryptographic Framework for the Controlled Release of Certified Data. In: Christianson, B., Crispo, B., Malcolm, J.A., Roe, M. (eds.) Security Protocols 2004. LNCS, vol. 3957, pp. 20–42. Springer, Heidelberg (2006) 7. Benaloh, J.C., de Mare, M.: One-Way Accumulators: A Decentralized Alternative to Digital Sinatures (Extended Abstract). In: Helleseth, T. (ed.) EUROCRYPT 1993. LNCS, vol. 765, pp. 274–285. Springer, Heidelberg (1994) 8. Camenisch, J.L., Lysyanskaya, A.: Dynamic Accumulators and Application to Efficient Revocation of Anonymous Credentials. In: Yung, M. (ed.) CRYPTO 2002. LNCS, vol. 2442, pp. 61–76. Springer, Heidelberg (2002) 9. Myers, M., Ankney, R., Malpani, A., Galperin, S., Adams, C.: X.509 internet public key infrastructure online certificate status protocol - ocsp (1999) 10. Housley, R., Polk, W., Ford, W., Solo, D.: Internet x.509 public key infrastructure certificate and certificate revocation list (crl) profile (2002) 11. Brands, S., Demuynck, L., De Decker, B.: A practical system for globally revoking the unlinkable pseudonyms of unknown users. In: Pieprzyk, J., Ghodosi, H., Dawson, E. (eds.) ACISP 2007. LNCS, vol. 4586, pp. 400–415. Springer, Heidelberg (2007) 12. Camenisch, J., M¨odersheim, S., Sommer, D.: A formal model of identity mixer. Formal Methods for Industrial Critical Systems, 198–214 (2010) 13. Bichsel, P., Camenisch, J.: Mixing identities with ease. In: de Leeuw, E., Fischer-H¨ubner, S., Fritsch, L. (eds.) IDMAN 2010. IFIP AICT, vol. 343, pp. 1–17. Springer, Heidelberg (to apppear, 2010) 14. Camenisch, J.L., Shoup, V.: Practical verifiable encryption and decryption of discrete logarithms. In: Boneh, D. (ed.) CRYPTO 2003. LNCS, vol. 2729, pp. 126–144. Springer, Heidelberg (2003) 15. Backes, M., Camenisch, J., Sommer, D.: Anonymous yet accountable access control. In: Proceedings of the 2005 ACM Workshop on Privacy in the Electronic Society, pp. 40–46. ACM, New York (2005)
Analysis of Revocation Strategies for Anonymous Idemix Credentials
17
16. Camenisch, J., Kohlweiss, M., Soriente, C.: Solving revocation with efficient update of anonymous credentials. In: Security and Cryptography for Networks, pp. 454–471 (2011) 17. Nakanishi, T., Fujii, H., Hira, Y., Funabiki, N.: Revocable group signature schemes with constant costs for signing and verifying. In: Jarecki, S., Tsudik, G. (eds.) PKC 2009. LNCS, vol. 5443, pp. 463–480. Springer, Heidelberg (2009) 18. Camenisch, J.L., Lysyanskaya, A.: Dynamic accumulators and application to efficient revocation of anonymous credentials. In: Yung, M. (ed.) CRYPTO 2002. LNCS, vol. 2442, pp. 61–76. Springer, Heidelberg (2002) 19. Nguyen, L.: Accumulators from bilinear pairings and applications. In: Menezes, A. (ed.) CT-RSA 2005. LNCS, vol. 3376, pp. 275–292. Springer, Heidelberg (2005) 20. Camenisch, J., Kohlweiss, M., Soriente, C.: An accumulator based on bilinear maps and efficient revocation for anonymous credentials. In: Jarecki, S., Tsudik, G. (eds.) PKC 2009. LNCS, vol. 5443, pp. 481–500. Springer, Heidelberg (2009) 21. Boneh, D., Shacham, H.: Group signatures with verifier-local revocation. In: Proceedings of the 11th ACM Conference on Computer and Communications Security, pp. 168–177. ACM, New York (2004) 22. Ateniese, G., Song, D., Tsudik, G.: Quasi-efficient revocation of group signatures. In: Blaze, M. (ed.) FC 2002. LNCS, vol. 2357, pp. 183–197. Springer, Heidelberg (2003) 23. Zaverucha, G.M., Stinson, D.R.: Group testing and batch verification. In: Kurosawa, K. (ed.) Information Theoretic Security. LNCS, vol. 5973, pp. 140–157. Springer, Heidelberg (2010) 24. Brickell, E., Camenisch, J., Chen, L.: Direct anonymous attestation. In: Proceedings of the 11th ACM Conference on Computer and Communications Security, pp. 132–145. ACM, New York (2004) 25. Nguyen, L.: Accumulators from Bilinear Pairings and Applications. In: Menezes, A. (ed.) CT-RSA 2005. LNCS, vol. 3376, pp. 275–292. Springer, Heidelberg (2005) 26. Camenisch, J., Kohlweiss, M., Soriente, C.: An Accumulator Based on Bilinear Maps and Efficient Revocation for Anonymous Credentials. In: Jarecki, S., Tsudik, G. (eds.) PKC 2009. LNCS, vol. 5443, pp. 481–500. Springer, Heidelberg (2009) 27. Demuynck, L., De Decker, B.: How to prove list membership in logarithmic time. CW Reports, KU Leuven, Department of Computer Science, vol. CW470 (2006) 28. Bellare, M., Garay, J.A., Rabin, T.: Fast batch verification for modular exponentiation and digital signatures. In: Nyberg, K. (ed.) EUROCRYPT 1998. LNCS, vol. 1403, pp. 236–250. Springer, Heidelberg (1998) 29. Fiat, A., Shamir, A.: How to Prove Yourself: Practical Solutions to Identification and Signature Problems. In: Odlyzko, A.M. (ed.) CRYPTO 1986. LNCS, vol. 263, pp. 186–194. Springer, Heidelberg (1987) 30. Lapon, J., Kohlweiss, M., De Decker, B., Naessens, V.: Performance analysis of accumulatorbased revocation mechanisms. In: Rannenberg, K., Varadharajan, V., Weber, C. (eds.) Security and Privacy - Silver Linings in the Cloud. IFIP AICT, vol. 330, pp. 289–301. Springer, Boston (2010) 31. Li, J., Li, N., Xue, R.: Universal Accumulators with Efficient Nonmembership Proofs. In: Katz, J., Yung, M. (eds.) ACNS 2007. LNCS, vol. 4521, pp. 253–269. Springer, Heidelberg (2007) 32. Stefan Brands, C.P.: U-Prove Cryptographic Specification V1.0. Technical report, Microsoft Corporation (2010) 33. Brickell, E., Camenisch, J., Chen, L.: The DAA scheme in context. Trusted Computing, 143–174
A Secure Key Management Framework for Heterogeneous Wireless Sensor Networks Mahdi R. Alagheband1, and Mohammad Reza Aref2 1
2
EE Department, Science and Research branch, Islamic Azad University, Tehran, Iran [email protected] EE Department, ISSL Laboratory, Sharif University of Technology, Tehran, Iran [email protected]
Abstract. A Wireless sensor network (WSN) is composed of numerous sensor nodes with both insecurely limited hardware and restricted communication capabilities. Thus WSNs suffer from some inherent weaknesses. Key management is an interesting subject in WSNs because it is the fundamental element for all security operations. A few key management models for heterogeneous sensor networks have been proposed in recent years. In this paper, we propose a new key management scheme based on elliptic curve cryptography and signcryption method for hierarchical heterogeneous WSNs. Our scheme as a secure infrastructure has superior sensor node mobility and network scalability. Furthermore, we propose both a periodic authentication and a new registration mechanism in our scheme due to prevention of sensor node compromising. Also, the proposed scheme does not increase the number of keys in sensor nodes and has a reasonable communication and computation overhead compared with the other schemes. Keywords: Key management, Heterogeneous sensor network, Signcryption , Elliptic curve cryptography, Authentication.
1
Introduction
A wireless sensor network (WSN) has ability to monitor and control events in a specified environment with the aid of numerous sensor devices. However, these sensor nodes (SNs) have noticeable constraints on energy, computation and bandwidth resources. Despite cited restrictions, WSNs have unique characteristics such as SN mobility, large scalability, limited resources, special traffic patterns and uncertain to many types of attacks. The structure of WSNs divides into two kinds: homogeneous and heterogeneous on the whole. All SNs are similar to each other and are deployed in a flat architecture in homogeneous WSNs, while in heterogeneous both are two or more kinds of sensors are defined and the whole of SNs are separated in some clusters. Hence, not only does the
This work was supported in part by Iran National Science Fund (INSF)-cryptography chair, and in part Iran Telecommunication Research Center (ITRC).
B. de Decker et al. (Eds.): CMS 2011, LNCS 7025, pp. 18–31, 2011. c IFIP International Federation for Information Processing 2011
A Secure Key Management Framework for Heterogeneous WSNs
19
average of communication overhead and energy consumption decrease, but also the network scalability and performance increase in heterogeneous WSN [1]. Due to the fact that WSNs are susceptible to many attacks and have widespread constraints, the design of security mechanisms is highly important. Key management is the first crucial function to achieve security objectives because sensor nodes and cluster leaders need valid common key to utilize cryptography mechanisms. According to SN technology development, the key management protocols are classified based on encryption techniques in three categories, including symmetric, asymmetric and hybrid key management models [1]. Symmetric schemes that also called pre-distribution schemes are responsible for loading some keys into the sensor nodes prior to deployment phase, based on either their physical or wireless interfaces. These schemes suffer from some problems such as probabilistic key distribution between SNs, non-scalability after deployment, weakness against node compromising, lack of mobility and high communication overhead [2, 3]. Asymmetric schemes use both elliptic curve cryptography (ECC) and identity based cryptography (IBC) in recent years [6]. Asymmetric models are more flexible but very heavyweight in the sensor networks. The recent progress in ECC and IBC awards new opportunities to apply public key cryptography in WSNs. Since ECC keys are defined on an additive group with 160-bit length, this family of public key cryptography is as secure as RSA keys with 1024-bit length [4]. Also, recent implementation on MICA2 or MICAz mote has approved the feasibility of ECC in WSN [4, 5]. Hybrid schemes have been designed based on heterogeneous WSNs with different kinds of nodes. Despite distinction among base station, cluster leaders and SNs, each element performs distinctive responsibility in hybrid hierarchical architecture. As computational cost of cluster leaders is more than SNs, cluster leaders usually have more obligations such as aggregation, routing, control and cluster leading. In this paper, we present a secure hybrid key management infrastructure in hierarchical heterogeneous WSN (HHWSN). ECC is used among cluster leaders and base station in the proposed scheme. Moreover, a special mechanism is used in the clusters for periodic authentication and SN mobility among the clusters. The contributions of this paper are four folds. i) In order to achieve complete security, a specific signcryption method with forward security characteristic is utilized in inter-cluster communication. ii) Our scheme supports SN mobility to move among the clusters. iii) We design a periodic authentication to prevent SN compromising. iv) A new registration model is designed for SNs enrollment after network deployment. The rest of the paper is organized as follows: section 2 describes the preliminaries which are practical for understanding the proposed protocol and related works. In section 3, some related works are analyzed. In section 4, we propose the new key management scheme. In section 5 we compare the scheme with a few related schemes. Section 6 gives comparison result. Finally, conclusion is presented.
20
2
M.R. Alagheband and M.R. Aref
Preliminaries
In this section, we describe some essential points used in this paper. BS should select some primitive parameters in initialization phase. F is the selected elliptic curve over finite field q: y 2 = x3 + ax + b (mod q). G is base point of elliptic curve F with order n and O is point of F at infinite. n is the order of point G, where n is a prime,n × G = O and n > 2160 . (The symbol ‘×’ denotes the elliptic curve point multiplication [6]. For simplicity, a list of notations used in the paper is shown in Table 1. Table 1. List of notations Notation BS CL
Description Base station Cluster leader
Notation Pbs Ubs
Description BS’s Private key BS’s public key Network key [128 bit] (just for SN Sensor node KN registration) Adjacent CL Neighbour leaders of CL KSNi Sensor node key IDcl or IDSN Identity of CL or SN Kcl Cluster key Pcli CLi ’s Private key Sgn Signcryption algorithm Ucli CLi ’s Public key t.s. Timestamp Least time duration for Maximum movement time for tcomp tmove node compromising SN A public and fixed A lightweight and secure meta H message one-way hash function Ek (.)/Dk (.) Lightweight symmetric encryption/decryption algorithm with key k
The security of asymmetric and hybrid key management especially in BS-CL links are based on ECDLP (Elliptic Curve Discrete Logarithm Problem)that is a hard problem until now [6]. Furthermore, the security of SN-SN links is supported by lightweight symmetric cryptography generally [7]. BS generates public-private keypairs based on ECDLP. These keys are assigned to all nodes in the asymmetric key management or just CLs in the hybrid key management schemes. BS performs following terms for key generation. - Choose P a random number as a private key P ∈ [1 q − 1]. - Compute U = P × G as a public key. - Embed (P, U ) in node securely after deployment and save it in its database. After this phase, every CL in heterogeneous WSN has a unique pairwise key. Key generation aside, signcryption is used in the paper particularly in CL-BS links too. Not only does signcryption technique combine the digital signature and encryption algorithms to achieve authentication and confidentiality but also signcryption has lower computation and communication overhead. Thus the utilization of signcryption in WSNs is highly profitable. Besides, we utilize the signcryption scheme (Sgn) with extra characteristics such as public verifiability
A Secure Key Management Framework for Heterogeneous WSNs
21
BS
CL1
CLn
CL2 CLi
SNs
Sensor Node (SN) into clusters
Cluster Leader (CL) with tamper-proof hardware
Fig. 1. A sample hierarchical heterogeneous sensor network model
and forward secrecy in our proposed scheme [8, 9]. If a cluster leader is revealed, the authenticity of past transmitted messages from the compromised CL to BS is valid because of forward security attribute. It protects the authenticity of messages even though the private key of the sender is disclosed [8, 10]. Every CL has both the public key of other CLs and BS. A typical signcryption model with cited attributes will be used in our scheme. The details of some reasonable signcryption scheme for WSN have been explained in [8, 10]. A HHWSN is composed of a BS as a sink node, a small number of CLs and numerous SNs that classified in clusters (Fig. 1). Number of CLs is not noticeable compared with density of SNs. The following assumptions are noted in our network model: 1. SNs are not equipped with tamper-proof hardware due to inherently constraints. 2. CLs have better resources and more responsibility compared with SNs. Since the ability of asymmetric cryptography computation is absolutely essential for them. Therefore, every CL has unique public-private keypairs and are equipped with tamper-proof hardware. 3. Each SN and CL have a unique ID (IDcli or IDSNi ). 4. BS does not have any restriction on computation, storage or power supply. BS know all CLs public key (Ucli ) and SNs keys (KSNi ). 5. CLs are static but SNs are mobile.
22
M.R. Alagheband and M.R. Aref
All CLs and SNs are usually deployed in uncontrolled regions without strict supervision. Every cluster of SNs sense environments and send raw data to corresponding CL. Each CL aggregates information and routes it to the BS by respective protocols.
3
The Analysis of Related Works
In this section, we demonstrate some considerable hierarchical heterogeneous key management schemes proposed until now and analyse their advantages and disadvantages [11–14]. Riaz et al. have proposed SACK [11] as a secure key management framework for a HHWSN. Every SN has a unique key with the BS and CLs have an extra key to communicate with BS and other CLs. Besides, all SNs in every cluster have a distinctive common key for secure intra cluster connection. One master key of 1024 bits is stored in each SN and CL after deployment in SACK. CLs and SNs use it to compute shared key after cluster formation. Furthermore, SACK has a revocation mechanism for compromised node. But intruder can abuse master key to penetrate the network as. Since initial seeds for key generation are sent plainly after cluster formation in key assignment phase, the adversary can simply eavesdrop it. Now the newcomer malicious adversary with both compromised master key and eavesdropped seed can compute intra cluster key subsequently. Indeed, the security of the whole WSN will seriously be failed if just one SN is compromised. Besides, SACK has some other damaging problems in key generation algorithm. As authors have pointed out, a single polynomial can generate only 895 distinct keys. After 895 times, a Re-keying algorithm should be employed for solving this weakness. But SACK undergoes substantial communication and computation overhead with the Rekeying algorithm. Moreover, 1024 bits as a master key is partially heavy burden for the sensor nodes. X. Du et al. [12] proposed a routing-driven key management scheme based on ECC (RDEC) in HHWSN. Although, every SN and CL has a pairwise privatepublic key based on ECC in RDEC, SNs do not have shared key with all neighbors in intra cluster connections. All SNs have a common key with just some neighbor SNs in the specific routes that the routing protocol has already defined to send data for BS. Each SN firstly sends Key-Request message to CL. Then the CL computes diverse shared key between every two neighbor SNs and sends it based on the defined route in RDEC scheme. RDEC has some damaging feature. i) Every CL requires enormous storage space to save all SNs public keys for common key generation because SNs are clustered after deployment phase. This amount of storage space is ineligible for WSNs. ii) All SNs have a certain time to send the un-encrypted Key-Request message to CL. An adversary can replace the parts of Key-Request messages and deceives CL in the defined time because the Key-Request message is sent un-encrypted. iii) KH is a pre-loaded symmetric key that is embedded in the newly-deploy SNs and CLs. An adversary can reveal KH because the hardware of
A Secure Key Management Framework for Heterogeneous WSNs
23
SNs is not tamper proof. However, it is probable that the compromised SNs key is revoked but adversary can damage the network as a newcomer SN. Furthermore, after KH revelation, RDEC does not have any mechanism to distinguish this catastrophe. iv) Every CL has keys related to all SNs after pre-deployment phase. Therefore, apart from pre-loaded SNs, any new SN cannot register its public key at the WSN based on RDEC scheme after deployment phase. Mizanur and Khalil [13] have proposed another key management framework (PKAS) on pairing based cryptography. PKAS has tried to improve RDEC scheme based on IBC. Every CL or SN has an ID and two distinctly random numbers embedded in the pre-deployment phase. Each CL has IDs and random numbers of all SNs and authenticates its SNs in its cluster. Thus the information of clustering is prerequisite in PKAS. In PKAS, although the random number of SNs is periodically updated by the BS and distributed to SNs via CLs, WSN should undergo enormous amount of communication overhead. The SACK’s solution to solve this challenge looks better than PKAS’s out because the cost of transmission is much more than the cost of computation. Moreover, each SN requires the nearest CL’s ID for mutual authentication. So either every SN should save all CL’s IDs or authentication should be run after cluster formation in PKAS scheme. Not only is saving of all CL’s IDs very heavy for the feeble SNs but also the clustering information declines the network scalability and flexibility. PIBK is another identity based key management protocol for HHWSN [14]. PIBK has been designed for a static network with fixed and location aware SNs that use IBC to establish pairwise keys. Each SN gets three keys (network key, cluster key and SN key) in pre-deployment phase. Then, every SN should communicate ID with neighbors in a restricted time duration (Bootstrapping time). After Bootstrapping time, all SN should save neighborhood IDs so that every two nodes can make shared secure key in their cluster.
4
The Proposed Framework
In this section, we describe our proposed key management infrastructure for HHWSN in six parts. 4.1
Key Assignment in Pre-deployment Phase
Prior to initialization and cluster formation phase, some symmetric and asymmetric keys should be embedded in all SNs in pre-deployment phase. We have used more strict security policies for CL-BS links because of the high emphasis on communication between CLs and the BS. Therefore, public key cryptography is tapped to achieve a higher level of security in WSN. As it was pointed out in Table 1, Ucl is the public key and Pcl is the private key of any CL (Ucl = Pcl × G). The Pcl is called the discrete logarithm of the Ucl to the base G. Also CLs have a common symmetric key as a group key (Kcl ) for secure communication together. The key will be useful in periodic authentication.
24
M.R. Alagheband and M.R. Aref
Likewise, BS has two keys Ubs and Pbs (Ubs = Pbs × G). Pbs will be secret key for BS that CLs and SNs do not know it forever. Ubs is embedded in CLs to execute signcryption algorithm after deployment phase. Indeed, CL computes the signcryption of messages by Ubs and Pcl , sends it to BS completely secure and verifies the authenticity of BS with the aid of Ubs . On the other hand, all SNs have a common network key (KN ). This key just is used in the registration procedure after network deployment that will be explained in section 4.3. In order to perform periodic authentication, every SN has an exclusive key with BS (KSNi ) which BS knows both KSNi and IDSNi . 4.2
Inter-cluster Communication
The structure of heterogeneous WSN emphasizes the importance of security in CL-BS and CL-CL links. The network needs a method to communicate securely between BS and CLs prior to SN’s registration. If an adversary discloses either a CL-BS or a CL-CL links, the network security will be damaged increasingly. Hence, every CL as well as BS has distinct public and private pairwise keys. Since message confidentiality and sender’s authentication in CLs-BS links have a particular emphasis, digital signature and ECC have been used in many key management schemes to drive confidentiality, integrity and authenticity [11–16]. In contrast, according to the computational and memory constraints in WSN, it is not acceptable to utilize signature-then-encryption method to keep message confidentiality and authenticity permanently among WSN’s nodes. 4.3
SN’s Registration
After WSN deployment, SNs should find the nearest CL for registration into its cluster. Fig. 2 illustrates the registration procedure among SN, CL and BS. A SN will be enrolled in the nearest CL by the following steps: 1. SN sends α = IDSNi and β = HKN (IDSNi ) to the nearest CL by means of keyed one-way hash function (H). 2. CL verifies whether HKN (α) is equal to β. If it is true, goes to step 3, otherwise rejects the message and alarms to BS. 3. CL computes Sgn(IDSNi , t.s.) with its private key and sends it to BS (Sgn is the Signcryption algorithm). 4. As soon as Unsigncryption and verification phase are done, BS responds to CL by Sgn(IDSNi , KSNi , t.s.). 5. CL saves ID and KSNi after verification. 6. CL uses a lightweight symmetric encryption algorithm to generate ciphertext γ = EKSN (meta Kclj ), where meta is a public and fixed passage that all nodes know it. 7. The SN computes DKSNi (γ) where the secret key KSNi has been embedded in SN at pre-deployment phase. SN verifies if the first part of DKSNi (γ) is equal to meta. If it is true, SN generates KN from KN with a lightweight one way hash function. Thus, the computation of KN from KN is impossible.
A Secure Key Management Framework for Heterogeneous WSNs
25
The beginning of registration procedure without KN is impossible. Therefore, in order to prevent disclosure of KN , each SN should change KN to KN after membership in a cluster immediately. Since KN is revealed entirely after registration, the adversary cannot compromise a SN subsequently. The transformation is based on a one-way function and computation KN from KN is impossible. Indeed, if a registered SN is compromised imaginatively, the adversary cannot take part in registration procedure as a legal node because he has just achieved to KN and KN was completely deleted. Every newcomer SN can use KN to do registration procedure in a defined range of time after WSN deployment. The time duration is not enough for newcomer SN compromising by means of adversary. Moreover, it is plainly visible that the transformation does not impose constraint on network scalability and new SNs are added during WSN’s life, as all nodes derive KN to KN . The adversary can obtain Kcl but he is unable to disorder secure connections between SNs and CLs with the aid of periodic authentication explained in the next section. 4.4
Periodic Authentication and SN Mobility
One of the crucial parts of the proposed key management infrastructure that is usually ignored in heterogeneous WSN is “periodic authentication”[11–14]. Since SNs in contrast to CLs are not equipped with tamper-proof hardware, it is completely probable that a SN is compromised after deployment. Although KN as unique parameter for registration has been deleted, the adversary can grab Kcl and KSNi readily and disorder the SN-CL and SN-SN links. Thus, the proposed key management scheme has a periodic authentication to preserve SNs against compromising as well as to support SN’s mobility among clusters especially in liquid environments. Fig. 3 illustrates the periodic authentication mechanism between SN and CL in every cluster. Every CL should regularly authenticate the SNs which have registered in its cluster. The period of this mechanism (tcomp ) depends on the duration of node compromising. WSNs usually utilize ZigBee or IEEE 802.15.4 platform for communication. Since the time duration compared with the period of ZigBee’s MAC layer is negligible, the periodic authentication does not impose extra overhead [17]. Furthermore, the overhead of periodic authentication compared with overhead of other policies such as key updating in SACK, RDEC, PKAS and PIBK is rational. According to the Fig. 3, CLj sends the query for all registered SN periodically in its cluster. SNi checks the truth of query. SNi sends flow 2 if the flow 1 be true. As soon as the CL receives the flow 2, it computes HKSN (KN ) and checks with α inasmuch as just CL knew both KSNi and KN after SN registration. The SN is confirmed for next tcomp period provided the flow 2 is verified. Otherwise, CL will alarm to BS that the mentioned SN is uncertain. In the normal conditions just phase 1 and 2 (Fig. 4) are performed but if CL does not receive any message in the defined time, the SN has presumably moved to another cluster. Thus the CL sends Sgn(KN , ID, P robeRequest) to adjacent CLs to track the SN (phase 5). Since every CL has Ucl of other CLs, they can
26
M.R. Alagheband and M.R. Aref
SNi
CL j
BS
1. D IDSNi , E HKN (IDSNi )o 2. H
?
KN
(D ) E
3. Sgn(IDSNi , t.s.)o 4. Sgn(IDSNi , KSNi , t.s.) m 5. register ID and KSNi in CL j
6. J EKSNi (meta Kcl j ) m 7. if
?
DKSN (J ) meta i
then : K N o K N' and delete K N admit Kcl j as a cluster key
Fig. 2. SN registration procedure with CL and BS cooperation SNi
CLj 1.query=[t.s.,IDSNi ,λ=HK
(IDSNi ,t.s.)] SNi
← −−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
2.α=HKSN (KN ,t.s. ),IDSNi ,t.s.
−−−−−−−−−−−−i−−−−−−−−−−−−−−−−−−→ Fig. 3. The periodic authentication mechanism between every SN and CL inside clusters
do unsigncryption algorithm. If the SN moved to another cluster, one of the adjacent CLs will find it in the defined time (tmov ). All adjacent CLs perform authentication mechanism again to find the moved SN. If an adjacent CL finds the moved SN and t < tmov , it sends a report to the prime CL. Otherwise, the prime CL supposes that the lost SN is compromising when t > tmov . In this condition, the lost SN should be revoked from the whole of WSN. The prime CL announces to adjacent CLs that the registered node with IDSNi is revoked. Also the prime CL sends the revocation message accompanied by IDSNi to BS and other registered SNs in its cluster. According to this model an adversary cannot enter to WSN by node compromising because KN as only registration key had been deleted and IDSNi had been revoked in WSN. Although each node must share a key with BS, the all authentication processes conduct without the aid of BS. Indeed, CL just informs BS in phase 8 (Fig. 4) for revocation provided the SN does not respond in time. On the other side, “SN mobility” is one of the most striking features of the periodic authentication and WSN can be easily deployed in liquid and unsteady environments easily. The moved SN can communicate with new CL after
A Secure Key Management Framework for Heterogeneous WSNs
27
BS
8
If adjacent CLs don't find the moved SN & t t tcomp then send : Sgn( revocation request )
1
Send : query
t.s, IDSNi , H K SN IDSNi , t.s. i
CL
3
Compute H KSN KNc & check equality with D i
SN
2
5
4
Send : D H KSN K N' , t.s.' , IDSNi , t.s.'
7
If 3 is false
then send : Sgn K SNi , ID, Probe request
If 3 is true then SNi is lawful and safe for next period
i
If one of the adjacent CLs find the SN & t tcomp
then the CL send : Sgn IDSNi , discovery message
Adjacent CLs
6
Adjacent CLs send the query into their clusters
Fig. 4. The flowchart of periodic authentication mechanism due to prevention of sensor node compromising and mobility among clusters
authentication because the new CL has received KSNi from the prime CL. Fig. 4 depicts vividly the mentioned mechanism. Although the process seems complicated, it is lightweight and straightforward because its period compared with similar policies in other key management frameworks in heterogeneous WSN (e.g. key updating) is logical and profitable. 4.5
Intra-cluster Communication between SNs
In this section, the model of intra-cluster communication between SNs in every cluster is described. Every SN has three embedded keys (KN , KSNi , Kclj ) as well as IDSNi after cluster formation. KN was used at periodic authentication. All registered SNs in a cluster have a common cluster key (Kclj ). However, Kclj will be changed provided SNi moves to other cluster. Therefore, they have mutual secure communication. Although an adversary can eavesdrop intra-cluster links and compromise Kcl, he cannot disclose any message and disorder intra-cluster transactions since the ID of revealed SN is revoked with the aid of periodic authentication mechanism and mutual intra-cluster communication without valid ID is impossible.
28
M.R. Alagheband and M.R. Aref
Also intra-cluster links need a mechanism to achieve authenticity. In contrast to inter-cluster links, the computation and communication overhead of digital signature and signcryption is irrational in intra-cluster links among limited SNs. Hence, each SN should accompany its ID in every encrypted message in order that receiver recognizes the identity of sender (Eq. 1). It is plainly visible that every SN can find its neighbors after some transactions. IDi ,EK (IDi ,m)
SNi −−−−−−cl−−−−−→ SNj
(1)
As we indicated in section 4.4, our proposed scheme can detect compromised SNs, while the attacker is compromising it. Although it is undeniable that the adversary can obtain Kcl , the periodic authentication mechanism finds this malicious node at once.
5
Security Analysis and Comparison
In this section we both compare our scheme with the last schemes on heterogeneous WSNs and demonstrate how it is resistant on important attacks. Firstly, we define well known attacks on WSNs and explain how our proposed scheme can prevent them. Node Capture Attack : In node capture attack, an adversary gains full control over sensor nodes through direct physical access [14]. According to the importance of CL-BS and CL-CL links, not only is public key cryptography (signcryption method with forward secrecy) used in BS-CL and CL-CL links but also the hardware of CLs is defined tamper-proof in our scheme. An adversary cannot compromise a CL and cannot do manipulation, replay and impersonation attacks, inasmuch as he should solve ECDLP. Furthermore, if a CL’s private key is compromised imaginatively, the adversary cannot still reveal previous plaintexts from signcrypted messages because of forward secrecy. On the other side, SN compromising is highly probable because the hardware of SNs is not tamper-proof. In order to increase persistence against the defect, registration mechanism and periodic authentication were designed to prevent penetration of an adversary to the WSN. Hence intra-cluster links will be secure. In the worst case, if an adversary compromises a SN after deployment in t > tcomp, the adversary cannot impersonate a legal SN with its compromised ID because the CL has already revoked it via periodic authentication mechanism. Although the adversary grabs Kcl , IDSNi and KN , he does not have enough time to send correct response to CL in the authentication protocol. Thus the CL revokes the compromised SN immediately. Moreover, if a random ID is chosen by adversary, the CL will reveal it in next periodic authentication as well. If the adversary obstructs the flows 1 or 6 in Fig. 2, he will have enough time to compromise the SN but he cannot generate desyncronization attack because KN has changed to KN in the last stage of SN’s registration mechanism and the adversary cannot take part in registration procedure with the aid of KN . On the other side, the maximum time duration for registration into a cluster to prevent
A Secure Key Management Framework for Heterogeneous WSNs
29
this disturbance is bootstrapping time (tboot ). When tboot is finished, all SNs should have been registered. Otherwise unregistered SNs will delete KN and will send out at the WSN practically. Since the time requirement for registration is very shorter than tboot , this policy has not decreased the throughput of network. Moreover, our scheme is extensible and it is possible to add new SNs during the life of WSN. Although the registered SNs do not have KN , the new SNs join a cluster with the aid of KN , compute KN and then delete KN . Replay Attack : An adversary can record IDi ans HKN (IDi ) (flow 1 in Fig. 2) in one location and sends it again either there or another location. Since BS has verified the IDi previously, the adversary cannot introduce itself as a trusted SN to CL and BS. Also in authentication protocol, upon receiving the response of SN at t.s. (flow 2 in Fig. 4), CL verifies whether t.s. − t.s. ≤ T for prevention of replay attack. If it holds, SNi will be safe and valid for next period. If an adversary reveals KSNi , the SN with KSNi is revoked immediately based on periodic authentication. Message Manipulation Attack : In this attack, an adversary may drop, change, or even forge exchanged messages in order to interrupt the communication process but he cannot manipulate messages in our proposed scheme because an adversary is not a valid node at all. The ways of this attack are three aspects. i) It is probable that an adversary manipulates query flow in periodic authentication (Fig. 3) but the SN checks the equality between α and HKSNi (KN , t.s. , IDSNi ) and then SN will realize this disturbance immediately because the adversary does not have the SN’s key and cannot impersonate SN without KSNi . ii) Despite the fact that the adversary knows meta, if the adversary modifies flow 6 (Fig. 2), the SN will not admit the received Kcli as the cluster key. The adversary cannot reveal KSNi in tboot duration. iii) All CL-CL and CL-BS links are resistant to every kind of manipulation or impersonation attacks as they are based on Signcryption method. Masquerade Attack : In this attack, an adversary can pretend to be a valid node and participate in the network communication. In our proposed scheme, all the nodes in the network are authenticated to each other along the way. Thus, the adversary cannot pretend to be valid nodes and cannot exchange the wrong information among the valid nodes. Therefore, a masquerade attack is not applicable on our proposed protocol. To sum up, we compare our proposed key management infrastructure with the SACK, RDEC, PKAS, PIBK schemes that have been designed based on HHWSN. Our scheme has some unique predominant features including SN mobility, periodic authentication, preventative mechanism against SN compromising and utilization of signcryption rather than signature-encryption (Table 2).
6
Conclusion
A few key management frameworks have been designed for HHWSN in recent years. In this paper we proposed a novel and secure key management infrastructure for HHWSN. Our proposed scheme has number of striking features,
30
M.R. Alagheband and M.R. Aref
Table 2. The comparison of five schemes (Enc.=Encryption, Sig.=Signature, Key Agr.=Key Agreement)
XXX
XXXScheme SACK[11] RDEC[12] PKAS[13] XXX Feature Mobility No No No Number of saved key 2+1 (1024 2 3 in every SN bit) Situation of network The More than Just the after one node Whole of one SN SN fail compromising WSN fail fail Difference among SN No Yes Yes and CL Authentication once The type of used Enc.+ Enc. Enc. PKC Sig. SN-CL & SN-CL & The position of PKC CL-BS CL-BS CL-BS Scalability after Yes Yes Yes network deployment Clustering as a Yes No Yes prerequisite for Key management
No
Our scheme YES
4
3
Whole of WSN fail
Just the SN fail
No
Yes
-
periodic
Key Agr.
Sgn
SN-CL & CL-BS
CL-BS
Yes
Yes
Yes
No
PIBK[14]
including ECC utilization just between CL and BS, using signcryption rather than encryption with signature by forward security and public verifiability characteristics, SN mobility, periodic authentication to prevent SN compromising and a unique SN registration model in clusters. Furthermore, SNs just have undergone light computation and power consumption.
References 1. Zhang, J., Varadharajan, V.: Wireless sensor network key management survey and taxonomy. Journal of Network and Computer Applications 33, 63–75 (2010) 2. Eschenauer, L., Gligor, V.D.: A key management scheme for distributed sensor networks. In: Proceeding of the 9th ACM Conference on Computer and Communication Security, pp. 41–47 (November 2002) 3. Perrig, A., Szewczyk, R., Wen, V., Cullar, D., Tygar, J.D.: SPINS: security protocols for sensor networks. In: Proceedings of the 7th Annual ACM/IEEE International Conference on Mobile Computing and Networking, pp. 189–199 (2001) 4. Gura, N., Patel, A., Wander, A., Eberle, H., Shantz, S.C.: Comparing elliptic curve cryptography and RSA on 8-bit CPUs. In: Joye, M., Quisquater, J.-J. (eds.) CHES 2004. LNCS, vol. 3156, pp. 119–132. Springer, Heidelberg (2004) 5. Malan, D.J., Welsh, M., Smith, M.D.: A public-key infrastructure for key distribution in Tinyos based on elliptic curve cryptography. In: First Annual IEEE Communications Society Conference on Sensor and Ad Hoc Communications and Networks (2004)
A Secure Key Management Framework for Heterogeneous WSNs
31
6. Hankerson, D., Menezes, A., Vanstone, S.: Guide to elliptic curve cryptography. Springer, Heidelberg (2004) 7. Lee, J., Kapitanova, K., Son, S.H.: The price of security in wireless sensor networks. Computer Networks Journal (2010) 8. Hwang, R.-J., Lai, C.-H., Su, F.-F.: An efficient signcryption scheme with forward secrecy based on elliptic curve. Journal of Applied Mathematics and Computation 167(2), 870–881 (2005) 9. Zheng, Y., Imai, H.: How to construct efficient signcryption schemes on elliptic curves. Information Processing Letters 68, 227–233 (1998) 10. Alaghband, M., Soleimanipour, M., Aref, M.: A new signcryption scheme with forward security. In: Fourth Information Security and Cryptology International Conference, ISCISC (2007) 11. Du, X., Guizani, M., Xiao, Y., Chen, H.-H.: A Routing-Driven Elliptic Curve Cryptography Based Key Management Scheme for Heterogeneous Sensor Networks. IEEE Transaction on Wireless Communications 8(3) (2009) 12. Riaz, R., Naureen, A., Akram, A., Hammad, A., Hyung Kim, K., Farooq, H.: A unified security framework with three key management schemes for wireless sensor networks. International Journal Computer Communications 31, 4269–4280 (2008) 13. Mizanur Rahman, S., El-Khatib, K.: Private key agreement and secure communication for heterogeneous sensor networks. Journal of Parallel and Distributed Computing 70, 858–870 (2010) 14. Boujelben, M., Cheikhrouhou, O., Abid, M., Youssef, H.: A Pairing Identity based Key Management Protocol for Heterogeneous Wireless Sensor Networks. IEEE Transaction on Wireless Communications Conference (2009) 15. Collins, M., Dobson, S., Nixon, P.: A Secure Lightweight Architecture for Wireless Sensor Networks. In: The Second International Conference on Mobile Ubiquitous Computing, Systems, Services and Technologies. IEEE Computer Society, Los Alamitos (2008) 16. Pei, Q., Wang, L., Yin, H., Pang, L., Tang, H.: Layer Key Management Scheme on Wireless Sensor Networks. In: Fifth International Conference on Information Assurance and Security. IEEE Computer Society, Los Alamitos (2009) 17. Baronti, P., Pillai, P., Chook, V.W.C., Chessa, S., Gotta, A., Fun Hu, Y.: Wireless sensor networks: A survey on the state of the art and the 802.15.4 and ZigBee standards. Computer Communications 30, 1655–1695 (2007)
Twin Clouds: Secure Cloud Computing with Low Latency (Full Version)
Sven Bugiel, Stefan N¨ urnberger, Ahmad-Reza Sadeghi, and Thomas Schneider Center for Advanced Security Research Darmstadt, Technische Universit¨ at Darmstadt, Germany {sven.bugiel,stefan.nuernberger,ahmad.sadeghi,thomas.schneider} @trust.cased.de
Abstract. Cloud computing promises a cost effective enabling technology to outsource storage and massively parallel computations. However, existing approaches for provably secure outsourcing of data and arbitrary computations are either based on tamper-proof hardware or fully homomorphic encryption. The former approaches are not scaleable, while the latter ones are currently not efficient enough to be used in practice. We propose an architecture and protocols that accumulate slow secure computations over time and provide the possibility to query them in parallel on demand by leveraging the benefits of cloud computing. In our approach, the user communicates with a resource-constrained Trusted Cloud (either a private cloud or built from multiple secure hardware modules) which encrypts algorithms and data to be stored and later on queried in the powerful but untrusted Commodity Cloud. We split our protocols such that the Trusted Cloud performs security-critical precomputations in the setup phase, while the Commodity Cloud computes the time-critical query in parallel under encryption in the query phase. Keywords: Secure Cloud Computing, Cryptographic Protocols, Verifiable Outsourcing, Secure Computation.
1
Introduction
Many enterprises and other organizations need to store and compute on a large amount of data. Cloud computing aims at renting such resources on demand. Today’s cloud providers offer both, highly available storage (e.g., Amazon’s Elastic Block Store [2]) and massively parallel computing resources (e.g., Amazon’s Elastic Compute Cloud (EC2) with High Performance Computing (HPC) Clusters [3]) at low costs, as they can share resources among multiple clients. On the other hand, sharing resources poses the risk of information leakage. Currently, there is no guarantee that security objectives stated in Service Level Agreements (SLA) are indeed fulfilled. Consequently, when using the cloud, the
A preliminary version of this paper was published as extended abstract in [7].
B. de Decker et al. (Eds.): CMS 2011, LNCS 7025, pp. 32–44, 2011. c IFIP International Federation for Information Processing 2011
Twin Clouds: Secure Cloud Computing with Low Latency
33
client is forced to blindly trust the provider’s mechanisms and configuration [9]. However, this is accompanied by the risk of data leakage and industrial espionage due to a malicious insider at the provider or due to other customers with whom they share physical resources in the cloud [32]. Example applications that need to protect sensitive data include, but are not limited to, processing of personal health records or payroll databases. Access usually occurs not very frequently, but needs to be processed very fast while privacy of the data should be preserved. Due to regulatory reasons, contractual obligations, or protection of intellectual property, cloud clients require confidentiality of their outsourced data, that computations on their data were processed correctly (verifiability), and that no tampering happened (integrity). Secure outsourcing of arbitrary computations on data is particularly difficult to fulfill if the client does not trust the cloud provider at all. Some cryptographic methods allow specific computations on encrypted data [4,18], or to securely and verifiably outsource storage [24]. Secure computation of arbitrary functions, e.g., arbitrary statistics or queries, on confidential data can be achieved based on fully homomorphic encryption as shown in [10,8]. However, these schemes are not yet usable in practice due to their poor efficiency. Furthermore, in a multi-client scenario, cryptography alone is not sufficient and additional assumptions have to be made such as using tamper-proof hardware [42]. Still, secure hardware which provides a shielded execution environment does not scale well as it is expensive and relatively slow. Our Approach. We propose a model for secure computation of arbitrary functions with low latency using two clouds (twins). The resource-constrained Trusted Cloud is used for pre-computations whereas the untrusted, but powerful Commodity Cloud is used to achieve low latency (cf. Fig. 1). Our approach allows to separate the computations into their security and performance aspects: securitycritical operations are performed by the Trusted Cloud in the Setup Phase, whereas performance-critical operations are performed on encrypted data in parallel by the Commodity Cloud in the Query Phase. Analogous to electricity, this can be seen as a battery that can be charged over night with limited amperage and later provides energy rapidly during discharge.
Fig. 1. Twin Clouds model with Client, Trusted Cloud, and Commodity Cloud
In the Setup Phase, the Trusted Cloud encrypts the outsourced data and programs using Garbled Circuits (GC) [43] which requires only symmetric cryptographic operations and a constant amount of memory. In the time-critical Query Phase, the Trusted Cloud verifies the results computed by the Commodity Cloud
34
S. Bugiel et al.
under encryption. Our proposed solution is transparent as the Client uses the Trusted Cloud as a proxy that provides a clearly defined interface to manage the outsourced data, programs, and queries. We minimize the communication over the secure channel (e.g., SSL/TLS) between Client and Trusted Cloud. Outline and Contribution. After summarizing related work in §2 and preliminaries in §3 we present the following contributions in the respective sections: In §4 we present our model for secure outsourcing of data and arbitrary computations with low latency using two clouds. The Trusted Cloud is mostly involved in the Setup Phase, while queries are evaluated under encryption and in parallel by the untrusted Commodity Cloud. In §5 we give an instantiation of our model based on GCs, the currently most efficient method for secure computation. Our proposed solution has several advantages over previous proposals (cf. §2): 1. Communication Efficiency. We minimize the communication between the client and the Trusted Cloud as only a program, i.e., a very compact description of the function, is transferred and compiled on-the-fly into a circuit. 2. Transparency. The client communicates with the Trusted Cloud over a secure channel and clear interfaces that abstract from the underlying cryptography. 3. Scalability and Low Latency. Our approach is highly scalable as both clouds can be composed from multiple nodes. In the Query Phase, the Trusted Cloud performs only few computations (independent of the function’s size). 4. Multiple Clients. Our protocols can be extended to multiple clients such that the Commodity Cloud securely and non-interactively computes on the clients’ input data.
2
Related Work
Here, we summarize related works for secure outsourcing of storage and arbitrary computations based on Trusted Computing (§2.1), Secure Hardware (§2.2), Secure Computation (§2.3), and Architectures for Secure Cloud Computing (§2.4). 2.1
Trusted Computing
The most prominent approach to Trusted Computing technology was specified by the Trusted Computing Group (TCG) [40]. The TCG proposes to extend common computing platforms with trusted components in software and hardware, which enable the integrity measurement of the platform’s software stack at boot-/load-time (authenticated boot, [35]) and the secure reporting of these measurements to a remote party (remote attestation, [14]). Thus, it provides the means to achieve verifiability and transparency of a trusted platform’s software state. Trusted Computing enables the establishment of trusted execution environments in commodity cloud infrastructures [37,36]. However, the reliable and efficient attestation of execution environments at run-time remains an open research problem. Trusted Computing is orthogonal to our approach and could be used to augment the Trusted Cloud with attestation capabilities.
Twin Clouds: Secure Cloud Computing with Low Latency
2.2
35
Secure Hardware / HSMs
Cryptographic co-processors, such as the IBM 4765 or 4764 [19], provide a highsecurity, tamper-resistant execution environment for sensitive cryptographic operations. Such co-processors are usually certified, e.g., according to FIPS or Common Criteria. Hardware Security Modules (HSM) or Smartcards additionally provide a secure execution environment to execute custom programs. As secure hardware is usually expensive, relatively slow, and provides only a limited amount of secure memory and storage, it does not qualify as building block for a cost-efficient, performant, and scalable cloud computing infrastructure. 2.3
Secure Computation
Secure computation allows mutually distrusting parties to securely perform computations on their private data without involving a trusted third party. Existing approaches for secure computation are either based on computing with encrypted functions (called Garbled Circuits), or computing on encrypted data (using homomorphic encryption) as summarized in the following. Garbled Circuits. Yao’s Garbled Circuits (GC) [43] allow secure computation with encrypted functions. On a high level, one party (called constructor) “encrypts” the function to be computed using symmetric cryptography and later, the other party (called evaluator) decrypts the function using keys that correspond to the input data (called “garbled values”). We give a detailed description of GCs later in §3.2. Although GCs are very efficient as they use only symmetric cryptographic primitives, their main disadvantage is that each GC can be evaluated only once and its size is linear in the size of the evaluated function. As used in several works (e.g., [28,1,13,23,17]), the trusted GC creator can generate GCs in a setup phase and subsequently GCs are evaluated by one or more untrusted parties. Afterwards, the GC creator can verify efficiently that the computations indeed have been performed correctly (verifiability). Our protocols in §5 use GCs in commodity clouds that are composed from off-the-shelf hardware. In particular our protocols do not require that the cloud is equipped with trusted hardware modules (as proposed in [20,21,34,26]), while they could benefit from hardware accelerators such as FPGAs or GPUs (cf. [23]). Homomorphic Encryption. Homomorphic Encryption (HE) allows to compute on encrypted data without using additional helper information. Traditional HE schemes are restricted to specific operations (e.g., multiplications for RSA [33], additions for Paillier [29], or additions and up to one multiplication for [6]). They allow to outsource specific computations, e.g., encryption and signatures [18], to untrusted workers, but require interaction to compute arbitrary functions. Recently, Fully HE (FHE) schemes have been proposed for arbitrary computations on encrypted data [11,38,41]. When combined with GCs for verifiability (cf. above), FHE allows to securely outsource data and arbitrary computations [10,8]. However, FHE is not yet sufficiently efficient to be used in practical applications [38,12].
36
S. Bugiel et al.
Multiple Data Owners. The setting of secure outsourcing of data and computations can be generalized to multiple parties who provide their encrypted inputs to an untrusted server that non-interactively computes the verifiably correct result under encryption. However, using cryptography alone, this is only possible for specific functions [15], but not arbitrary ones [42]. This impossibility result can be overcome by using a trusted third party, in our case the Trusted Cloud. 2.4
Architectures for Secure Cloud Computing
We combine advantages of the following architectures for secure cloud computing. An architecture for Signal Processing in the Encrypted Domain (SPED) in commodity computing clouds is described in [39]. SPED is based on cryptographic concepts such as secure multiparty computation or homomorphic encryption, which enable the secure and verifiable outsourcing of the signal processing. The authors propose a middleware architecture on top of a commodity cloud which implements secure signal processing by using SPED technologies. The client communicates via a special API, provided by a client-side plugin, with the middleware in order to submit new inputs and retrieve results. However, the authors do not elaborate on how to instantiate their protocols efficiently and do not answer problems regarding the feasibility of their approach. For instance, if GCs are used, they need to be transferred between the client-side plugin and the middleware which requires a large amount of communication. We parallelize the client plugin within the Trusted Cloud, provide a clear API that abstracts from cryptographic details, and give complete protocols. Another architecture for secure cloud computing was proposed in [34]. The authors propose to use a tamper-proof hardware token which generates GCs in a setup phase that are afterwards evaluated in parallel by the cloud. The token receives the description of a boolean circuit and generates the corresponding GC using a constant amount of memory (using the protocol of [22]). The hardware token is integrated into the infrastructure of the cloud service provider either in form of a Smartcard provided by the client, or as a cryptographic co-processor. We overcome several restrictions of this architecture by transferring smaller program descriptions instead of boolean circuits, virtualizing the hardware token in the Trusted Cloud, and providing a clear API for the client. This idea of secure outsourcing of data and computations based on a tamperproof hardware token was extended to the multi-cloud scenario in [26]. In this scenario, multiple non-colluding cloud providers are equipped with a tamperproof hardware token each. On a conceptual level, the protocol of [26] is similar to that of [34]: The token outputs helper information, i.e., multiplication tuples (resp. garbled tables in [34]), to the associated untrusted cloud provider who uses this information within a secure multi-party computation protocol executed among the cloud providers (resp. for non-interactive computation under encryption) based on additive secret-sharing (resp. garbled circuits). The tokens in both protocols need to implement only symmetric cryptographic primitives (e.g., AES or SHA) and require only a constant amount of memory. In contrast, our Twin Clouds protocol is executed between two clouds (one trusted and one untrusted) and does not require trusted hardware.
Twin Clouds: Secure Cloud Computing with Low Latency
3
37
Preliminaries
Our constructions make use of the following building blocks. 3.1
Encryption and Authentication
Confidentiality and authenticity of data can be guaranteed with symmetric cryptography: either with a combination of symmetric encryption (e.g., AES) and a Message Authentication Code (MAC, e.g., HMAC), or by using authenticated encryption, a special mode of operation of a block cipher (e.g., EAX [5]). Notation. x = AuthEnc(x) denotes the authentication and encryption of data x; x = DecVer( x) denotes the corresponding verification and decryption process. 3.2
Garbled Circuits (GC)
Arbitrary functions can be computed securely based on Yao’s Garbled Circuits (GC) [43]. Compared to FHE (cf. §2.3), GCs are highly efficient as they use only symmetric cryptographic primitives but require helper information (cf. Fig. 2).
constructor function f W1 W2 gate Gi ∧ W3 data x
CreateGC
garbled circuit f w 1 w 2
garbled table Ti
f
evaluator
∧ w 3
Garble
x
EvaluateGC y = f( x)
y = f (x)
Verify Fig. 2. Overview of Garbled Circuits
The main idea of GCs is that the constructor generates an encrypted version of the function f (represented as boolean circuit), called garbled circuit f. For this, it assigns to each wire Wi of f two randomly chosen garbled values w i0 , w i1 j that correspond to the respective values 0 and 1. Note that w i does not reveal any information about its plain value j as both keys look random. Then, for each gate of f, the constructor creates helper information in form of a garbled table Ti that allows to decrypt only the output key from the gate’s input keys (details below). The garbled circuit f consists of the garbled tables of all gates. Later, the evaluator obtains the garbled values x corresponding to the inputs x of the function and evaluates the garbled circuit f by evaluating the garbled gates one-by-one using their garbled tables. Finally, the evaluator obtains the corresponding garbled output values y which allow the constructor to decrypt them into the corresponding plain output y = f (x).
38
S. Bugiel et al.
Security and Verifiability. GCs are secure against malicious evaluator (cf. [13]) and demonstration of valid output keys implicitly proves that the computation was performed correctly (cf. [10]). To guarantee security and verifiability, a GC can be evaluated only once, i.e., a new GC must be created for each evaluation. Efficient GC constructions. The efficient GC construction of [25], provably secure in the random oracle model, provides “free XOR” gates, i.e., XOR gates have no garbled table and negligible cost for evaluation. For each 2-input nonXOR gate the garbled table has size ≈ 4t bits, where t is the symmetric security parameter (e.g., t = 128); creation of the garbled table requires 4 invocations of a cryptographic hash function (e.g., SHA-256) and evaluation needs 1 invocation. As shown in [22], generation of GCs requires only a constant amount of memory (independent of the size of the evaluated function) and only symmetric cryptographic operations (e.g., SHA-256). The implementation results of [31] show that evaluation of GCs can be performed efficiently on today’s hardware: GC evaluation of the reasonably large AES functionality (22,546 XOR; 11,334 non-XOR gates) took 2s on a single core of an Intel Core 2 Duo with 3.0 GHz. is the GC for boolean Notation. x is the garbled value corresponding to x. C x) denotes evaluation of C on x circuit C (with |C| non-XOR gates). y = C( . 3.3
Circuit Compiler
The functions to be computed securely can be expressed in a compact way in a hardware description language and compiled automatically into a boolean circuit. A prominent example is Fairplay’s [27] Secure Function Description Language (SFDL) which resembles a simplified version of a hardware description language, e.g., Verilog or VHDL (Very high speed integrated circuit Hardware Description Language), and supports types, variables, functions, boolean operators (∧, ∨, ⊕, . . . ), arithmetic operators (+, −), comparison (<, ≥, =, . . . ), and control structures like if-then-else or for-loops with constant range. Other candidates for compact description and compilation into boolean circuits are the languages and tools provided by [30,16]. As shown in [16], the compilation into a circuit can be implemented with a low memory footprint. In principle, it would be possible to compile algorithms formulated in any standard programming language such as C or Java into a boolean circuit, as every computable function can be expressed as boolean circuit of polynomial size. Notation. C = Compile(P ) denotes compilation of program P into circuit C.
4
Twin Clouds Model
Our Twin Clouds model, depicted in Fig. 1 on page 33, allows secure outsourcing of data and arbitrary computations with low latency to an untrusted commodity cloud. In our model, the Client makes use of the services offered by a cloud service provider to outsource its data and computations thereon into the provider’s
Twin Clouds: Secure Cloud Computing with Low Latency
39
Commodity Cloud in a secure way. The confidentiality and the integrity of the outsourced data must be protected against a potentially malicious provider, and the correctness of the outsourced computations must be verifiable by the Client. Due to the assumed large size of the Client’s data and/or the computational complexity of the computations thereon, it is not possible to securely outsource the data to the Commodity Cloud and let the Client execute its computations locally after retrieving back the entire data. Instead, the computations must be performed by the Commodity Cloud without interaction with the Client. To achieve these goals and satisfy the above mentioned security requirements, the Twin Cloud model uses a Trusted Cloud as proxy between the Client and the Commodity Cloud. The Trusted Cloud provides a resource-restricted execution environment and infrastructure that is fully trusted by the Client. As the resources of the Trusted Cloud are restricted, relatively expensive, and potentially slow, the computations can also not be performed within the Trusted Cloud. Instead, the Trusted Cloud is a transparent proxy that adds the needed security properties (integrity, confidentiality, verifiability) on top of the services provided by the fast but insecure Commodity Cloud. It provides an interface for secure storage and computations to the Client while abstracting from the service provider’s cloud infrastructure. This interface (e.g., a web-frontend or API) allows to securely submit data, programs, and queries to be securely stored and computed. The low-bandwidth connection between Client and Trusted Cloud is secured by a secure channel (e.g., SSL/TLS). The Trusted Cloud is used mostly during a Setup Phase, but performs only few computations during the time-critical Query Phase. It is assumed to have a small amount of storage only; if larger amounts of data need to be stored, they can be securely outsourced to the Commodity Cloud’s untrusted storage. To allow this secure outsourcing of storage, the Trusted Cloud is connected to the Commodity Cloud over an unprotected high-bandwidth channel. A possible instantiation of the Trusted Cloud can be a private cloud of the Client (e.g., his existing IT infrastructure). Alternatively, the Trusted Cloud could be a cluster of virtualized cryptographic co-processors (e.g., the IBM 4765 [19] or other Hardware Security Modules) which are offered as a service by a third party and which provide the necessary hardware-based security features to implement a secure remote execution environment trusted by the Client.
5
Twin Clouds Protocols
To efficiently instantiate the Twin Clouds model of §4 we use a “battery” for secure computations: In the Setup Phase, the battery is charged by precomputing encrypted (garbled) data and functions within the resource-limited Trusted Cloud. Later, in the Query Phase, the battery is rapidly discharged by evaluating these encryptions in parallel within the Commodity Cloud. Simplification. To ease presentation, we assume a single client who outsources a single program P . However, our protocols naturally extend to multiple programs and clients. We also assume that the Trusted Cloud takes appropriate
40
S. Bugiel et al.
measures to protect against replay attacks, e.g., an internal database of randomly chosen keys for each authenticated encryption and GC with associated garbled data. Interface. The Client accesses the Trusted Cloud over a secure channel and the following interface which abstracts from all underlying cryptographic details: During the Setup Phase, the Client provides the data D to be outsourced and the program P (formulated in a Hardware Description Language, cf. §3.3) to be computed. Later, in the Query Phase, the Client issues a query q which should be processed as fast as possible resulting in the response r = P (q, D) output to the Client. Additionally, the Client can update the stored data D or program P . Protocol Overview. On a high-level, our protocols work as follows: The Trusted Cloud stores Client’s data D and program P securely in the Commodity Cloud. Then, the Trusted Cloud retrieves back D and re-encrypts it and generates GCs C from P ; both are stored into its garbled equivalent D, in the Commodity Cloud. Later, the Client’s query q is encrypted and sent to q , D) under the Commodity Cloud which computes the garbled result r = C( encryption (using a pre-computed C which is deleted afterwards). Finally, the Trusted Cloud verifies the garbled result and sends r = P (q, D) to the Client. We describe the details of the two phases next. Actions invoked by the Client are denoted by Latin letters and automatically triggered actions by Greek ones. 5.1
Setup Phase
The Setup Phase, depicted in Fig. 3, consists of the following use-cases.
Fig. 3. Setup Phase: a,b) Client registers data D and program P to be stored securely in the Commodity Cloud. α) Updates of D require re-generation of garbled data D. β) Updates of P require re-generation of garbled circuits C.
a) Modify Data. When the Client provides new or modified data D to be out = AuthEnc(D) (cf. §3.1) in the Comsourced (a1), D is stored securely as D is re-generated modity Cloud (a2). Whenever D is modified, the garbled data D can be deleted. (cf. α below) and all pre-computed GCs C
Twin Clouds: Secure Cloud Computing with Low Latency
41
b) Modify Program. Whenever the Client provides a new or modified program P (b1), P is stored securely as P = AuthEnc(P ) (cf. §3.1) in the Commodity Cloud can be deleted. (a2). Whenever P is modified, all pre-computed GCs C must be reα) Garble Data. Whenever D is changed, the garbled data D from generated. For this, the Trusted Cloud requests the securely stored data D (cf. §3.1), genthe Commodity Cloud (α1), recovers the data D = DecVer(D) = Garble(D) (cf. §3.2), and stores this erates the corresponding garbled data D back into the Commodity Cloud (α2). β) Garble Program. Whenever D or P is changed or the Trusted Cloud has capacities for pre-computations, new GCs are generated. For this, the Trusted Cloud requests the securely stored program P from the Commodity Cloud (β1), recovers the program P = DecVer(P ) (cf. §3.1), compiles it into a boolean circuit = Garble(C) (cf. §3.2), and C = Compile(P ) (cf. §3.3), generates a new GC C stores this back into the Commodity Cloud (β2). 5.2
Query Phase
The query phase depicted in Fig. 4 consists of the following use-case:
Fig. 4. Query Phase: Client sends query q to the Trusted Cloud to be computed by is deleted afterwards. the Commodity Cloud under encryption (c). The used GC C
c) Process Query. When the Client sends a query q for secure evaluation (c1), the Trusted Cloud converts q into its garbled equivalent q = Garble(q) (cf. §3.2) which is forwarded to the Commodity Cloud (c2). The Commodity Cloud q , D) by evaluating a pre-computed GC C computes the garbled response r = C( (cf. §3.2) in parallel and deleting it afterwards. The garbled result r is returned to the Trusted Cloud (c3) which verifies the correctness of the result r = Verify( r) (cf. §3.2) and returns r = P (q, D) to the Client. 5.3
Analysis
In the following we analyze the security and efficiency properties of our protocols. Security Analysis. The security of our protocols stems from the fact that the Trusted Cloud is a secure execution environment, whereas the adversary can have full control over the Commodity Cloud and all communication channels.
42
S. Bugiel et al.
More specifically, our protocols are secure against a malicious Commodity Cloud provider as well as external adversaries: The Commodity Cloud is neither able to or program P as these are successfully modify nor to learn the outsourced data D authenticated and encrypted (cf. §3.1). The security and verifiability properties of GCs (cf. §3.2) ensure that the Commodity Cloud also cannot successfully C, r, or intermediate results of the computation. Clearly, modify or learn q, D, the Commodity Cloud learns an upper bound on the size of all data which can be circumvented by appropriate padding. The same holds true for external attackers that also cannot interfere with the communication between Client and Trusted Cloud due to the usage of a secure channel (e.g., SSL/TLS). Efficiency Analysis. The communication between Client and Trusted Cloud is minimized as only data and a compact program are transferred over the secure channel, while the communication between Trusted Cloud and Commodity of size ≈ 4t · |C| bits, where t is the Cloud is dominated by the transfer of C symmetric security parameter, e.g., t = 128 (cf. §3.2). The Commodity Cloud’s and C, while the Trusted storage is dominated by t · (|D| + 4|C|) bits for D Cloud needs only low memory/storage. The dominating factor of the computation complexity are 4|C| hash function evaluations by the Trusted Cloud in the Setup Phase and |C| parallel hash function evaluations by the Commodity Cloud in the Query Phase. Note that many functionalities such as queries on or statistics over large databases naturally allow parallelization. Finally, we’d like to emphasize that our protocols can be used to securely outsource data and arbitrary computations thereon, use only symmetric-key cryptographic primitives, and do not rely on tamper-proof hardware. A prototype implementation to verify their practical efficiency is left as future work. Acknowledgements. We thank Radu Sion for pointing out the analogy of our Twin Clouds model with a rechargeable battery that accumulates energy (computations) over some time and can then be uncharged rapidly. This work was in part funded in part by the European Commission through the ICT program under contract 257243 TClouds and 216676 ECRYPT II.
References 1. Algesheimer, J., Cachin, C., Camenisch, J., Karjoth, G.: Cryptographic security for mobile code. In: Security and Privacy, pp. 2–11. IEEE, Los Alamitos (2001) 2. Amazon. Elastic Block Store, EBS (2011), http://aws.amazon.com/ebs 3. Amazon. Elastic Compute Cloud, EC2 (2011), http://aws.amazon.com/ec2 4. Atallah, M., Pantazopoulos, K., Rice, J., Spafford, E.: Secure outsourcing of scientific computations. Advances in Computers 54, 216–272 (2001) 5. Bellare, M., Rogaway, P., Wagner, D.: The EAX mode of operation: A two-pass authenticated-encryption scheme optimized for simplicity and efficiency. In: Roy, B., Meier, W. (eds.) FSE 2004. LNCS, vol. 3017, pp. 389–407. Springer, Heidelberg (2004) 6. Boneh, D., Goh, E.-J., Nissim, K.: Evaluating 2-DNF formulas on ciphertexts. In: Kilian, J. (ed.) TCC 2005. LNCS, vol. 3378, pp. 325–341. Springer, Heidelberg (2005)
Twin Clouds: Secure Cloud Computing with Low Latency
43
7. Bugiel, S., N¨ urnberger, S., Sadeghi, A.-R., Schneider, T.: Twin Clouds: An architecture for secure cloud computing (Extended Abstract). In: Workshop on Cryptography and Security in Clouds (WCSC 2011), March 15-16 (2011) 8. Chung, K.-M., Kalai, Y., Vadhan, S.: Improved delegation of computation using fully homomorphic encryption. In: Rabin, T. (ed.) CRYPTO 2010. LNCS, vol. 6223, pp. 483–501. Springer, Heidelberg (2010) 9. Cloud Security Alliance. Top threats to cloud computing, v. 1.0 (2010) 10. Gennaro, R., Gentry, C., Parno, B.: Non-interactive verifiable computing: outsourcing computation to untrusted workers. In: Rabin, T. (ed.) CRYPTO 2010. LNCS, vol. 6223, pp. 465–482. Springer, Heidelberg (2010) 11. Gentry, C.: Fully homomorphic encryption using ideal lattices. In: STOC 2009, pp. 169–178. ACM, New York (2009) 12. Gentry, C., Halevi, S.: Implementing gentry’s fully-homomorphic encryption scheme. In: Paterson, K.G. (ed.) EUROCRYPT 2011. LNCS, vol. 6632, pp. 129– 148. Springer, Heidelberg (to appear, 2011) 13. Goldwasser, S., Kalai, Y.T., Rothblum, G.N.: One-time programs. In: Wagner, D. (ed.) CRYPTO 2008. LNCS, vol. 5157, pp. 39–56. Springer, Heidelberg (2008) 14. Trusted Computing Group. Trusted platform module (TPM) main specification (2007) 15. Halevi, S., Lindell, Y., Pinkas, B.: Secure computation on the web: Computing without simultaneous interaction. Cryptology ePrint Archive, 2011/157 (2011) 16. Henecka, W., K¨ ogl, S., Sadeghi, A., Schneider, T., Wehrenberg, I.: TASTY: Tool for Automating Secure Two-partY computations. In: CCS, pp. 451–462. ACM, New York (2010) 17. Herzberg, A., Shulman, H.: Secure guaranteed computation. Cryptology ePrint Archive, Report 2010/449 (2010) 18. Hohenberger, S., Lysyanskaya, A.: How to securely outsource cryptographic computations. In: Kilian, J. (ed.) TCC 2005. LNCS, vol. 3378, pp. 264–282. Springer, Heidelberg (2005) 19. IBM. Cryptocards (2011), http://www-03.ibm.com/security/cryptocards/ 20. Iliev, A.: Hardware-Assisted Secure Computation. PhD thesis, Dartmouth College, Hanover, NH, USA (2009) 21. Iliev, A., Smith, S.: Small, stupid, and scalable: secure computing with Faerieplay. In: Workshop on Scalable Trusted Computing (STC 2010), pp. 41–52. ACM, New York (2010) 22. J¨ arvinen, K., Kolesnikov, V., Sadeghi, A.-R., Schneider, T.: Embedded SFE: Offloading server and network using hardware tokens. In: Sion, R. (ed.) FC 2010. LNCS, vol. 6052, pp. 207–221. Springer, Heidelberg (2010) 23. J¨ arvinen, K., Kolesnikov, V., Sadeghi, A.-R., Schneider, T.: Garbled circuits for leakage-resilience: Hardware implementation and evaluation of one-time programs. In: Mangard, S., Standaert, F.-X. (eds.) CHES 2010. LNCS, vol. 6225, pp. 383–397. Springer, Heidelberg (2010) 24. Kamara, S., Lauter, K.: Cryptographic cloud storage. In: Sion, R., Curtmola, R., Dietrich, S., Kiayias, A., Miret, J.M., Sako, K., Seb´e, F. (eds.) RLCPS, WECSR, and WLC 2010. LNCS, vol. 6054, pp. 136–149. Springer, Heidelberg (2010) 25. Kolesnikov, V., Schneider, T.: Improved garbled circuit: Free XOR gates and applications. In: Aceto, L., Damg˚ ard, I., Goldberg, L.A., Halld´ orsson, M.M., Ing´ olfsd´ ottir, A., Walukiewicz, I. (eds.) ICALP 2008, Part II. LNCS, vol. 5126, pp. 486–498. Springer, Heidelberg (2008)
44
S. Bugiel et al.
26. Loftus, J., Smart, N.P.: Secure outsourced computation. In: Nitaj, A., Pointcheval, D. (eds.) AFRICACRYPT 2011. LNCS, vol. 6737, pp. 1–20. Springer, Heidelberg (to appear, 2011) 27. Malkhi, D., Nisan, N., Pinkas, B., Sella, Y.: Fairplay – a secure two-party computation system. In: Security, pp. 287–302. USENIX (2004) 28. Naor, M., Pinkas, B., Sumner, R.: Privacy preserving auctions and mechanism design. In: Electronic Commerce (EC 1999), pp. 129–139. ACM, New York (1999) 29. Paillier, P.: Public-key cryptosystems based on composite degree residuosity classes. In: Stern, J. (ed.) EUROCRYPT 1999. LNCS, vol. 1592, pp. 223–238. Springer, Heidelberg (1999) 30. Paus, A., Sadeghi, A.-R., Schneider, T.: Practical secure evaluation of semi-private functions. In: Abdalla, M., Pointcheval, D., Fouque, P.-A., Vergnaud, D. (eds.) ACNS 2009. LNCS, vol. 5536, pp. 89–106. Springer, Heidelberg (2009) 31. Pinkas, B., Schneider, T., Smart, N., Williams, S.: Secure two-party computation is practical. In: Matsui, M. (ed.) ASIACRYPT 2009. LNCS, vol. 5912, pp. 250–267. Springer, Heidelberg (2009) 32. Ristenpart, T., Tromer, E., Shacham, H., Savage, S.: Hey, you, get off of my cloud: exploring information leakage in third-party compute clouds. In: CCS 2009, pp. 199–212. ACM, New York (2009) 33. Rivest, R.L., Shamir, A., Adleman, L.: A method for obtaining digital signatures and public-key cryptosystems. Comm. ACM 21, 120–126 (1978) 34. Sadeghi, A.-R., Schneider, T., Winandy, M.: Token-based cloud computing: Secure outsourcing of data and arbitrary computations with lower latency. In: Acquisti, A., Smith, S.W., Sadeghi, A.-R. (eds.) TRUST 2010. LNCS, vol. 6101, pp. 417–429. Springer, Heidelberg (2010) 35. Sailer, R., Zhang, X., Jaeger, T., Van Doorn, L.: Design and implementation of a TCG-based integrity measurement architecture. In: Security. USENIX (2004) 36. Santos, N., Gummadi, K., Rodrigues, R.: Towards trusted cloud computing. In: Hot Topics in Cloud Computing (HotCloud 2009). USENIX (2009) 37. Schiffman, J., Moyer, T., Vijayakumar, H., Jaeger, T., McDaniel, P.: Seeding clouds with trust anchors. In: CCSW 2010, pp. 43–46. ACM, New York (2010) 38. Smart, N.P., Vercauteren, F.: Fully homomorphic encryption with relatively small key and ciphertext sizes. In: Nguyen, P.Q., Pointcheval, D. (eds.) PKC 2010. LNCS, vol. 6056, pp. 420–443. Springer, Heidelberg (2010) 39. Troncoso-Pastoriza, J.R., P´erez-Gonz´ alez, F.: CryptoDSPs for cloud privacy. In: Workshop on Cloud Information System Engineering, CISE 2010 (2010) 40. Trusted Computing Group (2011), http://www.trustedcomputinggroup.org 41. van Dijk, M., Gentry, C., Halevi, S., Vaikuntanathan, V.: Fully homomorphic encryption over the integers. In: Gilbert, H. (ed.) EUROCRYPT 2010. LNCS, vol. 6110, pp. 24–43. Springer, Heidelberg (2010) 42. Van Dijk, M., Juels, A.: On the impossibility of cryptography alone for privacypreserving cloud computing. In: HotSec 2010, pp. 1–8. USENIX (2010) 43. Yao, A.C.-C.: How to generate and exchange secrets. In: FOCS 1986, pp. 162–167. IEEE, Los Alamitos (1986)
Implementation Aspects of Anonymous Credential Systems for Mobile Trusted Platforms Kurt Dietrich, Johannes Winter, Granit Luzhnica, and Siegfried Podesser Institute for Applied Information Processing and Communications Graz, University of Technology Inffeldgasse 16a, 8010 Graz, Austria {Kurt.Dietrich,Johannes.Winter,Siegfried.Podesser}@iaik.tugraz.at [email protected]
Abstract. Anonymity and privacy protection are very important issues for Trusted Computing enabled platforms. Protection mechanisms are required in order to hide activities of the trusted platforms when performing cryptography based transactions over the Internet, which would otherwise compromise the platform’s privacy and with it the users’s anonymity. In order to address this problem, the Trusted Computing Group (TCG) has introduced two concepts addressing the question how the anonymity of Trusted Platform Modules (TPMs) and their enclosing platforms can be protected. The most promising of these two concepts is the Direct Anonymous Attestation (DAA) scheme which eliminates the requirement of a remote authority but includes complex mathematical computations. Moreover, DAA requires a comprehensive infrastructure consisting of various components in order to allow anonymous signatures to be used in real-world scenarios. In this paper, we discuss the results of our analysis of an infrastructure for anonymous credential systems which is focused on the Direct Anonymous Attestation (DAA) scheme as specified by the TCG. For the analysis, we especially focus on mobile trusted platforms and their requirements. We discuss our experiences and experimental results when designing and implementing the infrastructure and give suggestions for improvements and propose concepts and models for - from our point of view - missing components.
1
Introduction
The anonymity of trusted platforms is a crucial topic in Trusted Computing. The use of common digital signature schemes requires complex public-key infrastructures and allows adversaries to track and identify certain signing platforms. In order to address this problem, the TCG has introduced two schemes to protect the anonymity of Trusted Platform Modules (TPMs) and with it the anonymity of their host platforms and users. One of these schemes - the Privacy CA (PCA) scheme - relies on standard public-key infrastructures and performs the anonymization step in collaboration with a trusted third party. The other, B. de Decker et al. (Eds.): CMS 2011, LNCS 7025, pp. 45–58, 2011. c IFIP International Federation for Information Processing 2011
46
K. Dietrich et al.
from our point of view, more promising scheme is Direct Anonymous Attestation (DAA) which eliminates the requirement of a remote authority, but requires complex mathematical computations. Although large effort has been put into researching the efficient generation of anonymous signatures, little attention has been paid to the supporting infrastructures which are essential components for deploying anonymous credential technology in the field. When designing and developing infrastructures for the DAA scheme, one faces several obstacles. The first problem is that different protocols exist. Different DAA schemes have been proposed, for example in [3], [10] and [5]. These schemes are either variations of the original RSA-based DAA protocol or schemes based on different cryptographic primitives. Second, different clients have to be supported. DAA client platforms may range from server systems and desktop PCs, down to mobile phones or smart-cards. Each of these platforms has different processing capabilities and, therefore, different requirements on the used DAA scheme. The third obstacle is credential revocation. It is easy to see that revoking an anonymous credential is a complex task. Common approaches either involve revocation authorities or rogue tagging mechanisms. However, rogue-tagging typically implies drawbacks like high resource requirements that may not be available on mobile platforms. Suitable infrastructures that take all these issues into account are missing. In order to address these problems, we have designed and implemented a DAA infrastructure. Therefore, we introduce a Join protocol specification that supports the different variations of DAA schemes mentioned before. Moreover, we introduce an online revocation check mechanism that allows us to move the rogue tagging check from the client to a trusted third party. Although research has been done focusing on specific problems of DAA on mobile platforms ([7], [16]) investigations of the feasibility of DAA with all its aspects in the sense of a complete infrastructure with revocation etc. are missing. However, such infrastructures are especially interesting when taking new applications of DAA in the mobile world, such as anonymous authentication via NFC [1] or transport layer security (TLS) [8] into account. Therefore, we provide an investigation of the practicability and requirements of DAA and its infrastructure for mobile platforms. For our analysis, we have chosen the RSAbased DAA scheme as specified by the Trusted Computing Group (TCG) [14] as this is currently the only existing public version of a DAA scheme which is standardized by a public committee. 1.1
Related Work
Few publications can be found that address the topic of infrastructures for anonymous credentials. The most important one is the paper from Camenish et. al. [4] which deals with the design and the implementation of the idmix credential system prototype. The publication addresses protocols and credentials used in the idmix system which is related to DAA. The remainder of this article is organized as follows. We discuss the overall architecture of our implementation and give detailed results of the server and client components where we put special emphasis on the rogue tagging mechanism.
Implementation Aspects of Anonymous Credential Systems
47
Moreover, we discuss our proposed protocol with support for different types of clients and different schemes and we address the topic of credential revocation by proposing a modification of the online-certificate-status-protocol (OCSP).
2
Overview
The Direct Anonymous Attestation (DAA) scheme is a mechanism to provide trusted information to a challenger about a platform’s integrity without compromising the platform’s privacy. This can be achieved by applying an anonymous group signature on the attestation information provided by the TPM. The DAA model involves three parties: the issuer or group manager, the signer (or client) and a verifier. The issuer manages the group and controls which platform may enter the group and creates a group credential for the entering platforms. Moreover, the issuer defines and publishes a set of group parameters which allows verifiers to validate signatures that have been created by group members. Briefly summarized, an anonymous attestation scenario works as follows: on startup, the client platform which consists of a host (i.e. PC platform) and a TPM, executes a TCG based authenticated-boot and creates measurement values of the loaded software image, which are then stored in the TPM. The TPM now contains the current configuration of the platform. When the platform wants to prove this configuration to a remote platform, it generates a signature on these hash values with a so-called attestation key. The attestation key is a special RSA key which is created and used inside the TPM. The TPM ensures that the private parts of attestation keys acan not leave the TPM and that attestation keys are only used for signing configuration values. The platform sends the signed configuration values to the remote verifier which is then able to validate the local platform’s configuration with the public part of the attestation key. Moreover, the remote platform can trust that the signature was generated in a genuine TPM by validating a DAA signature on the public attestation key. For each attestation process, a new key has to be created and certified. This is where the DAA signature comes into play. Instead of sending the public-key to a Privacy CA every time, the TPM can locally certify its attestation key using an anonymous signature on the key. When using anonymous signatures to certify attestation key, the TPM first creates a temporary RSA key-pair. The public part of this temporary RSA key is locally signed with a DAA signature. Hence, the TPM is able to locally certify its temporary attestation key. This temporary attestation key is then used to create a signatures on the configuration values. When validating a signature over the configuration values, the remote verifier first has to verify the DAA group signature on the temporary attestation key. Before a TPM can create DAA signatures, it has to generate a private DAA-key f and execute the Join protocol with the group manager in order to receive a group-credential for f. Once the TPM has joined a group, it is able to generate DAA signatures to locally certify public-key held by the TPM. In order to analyze the efficiency of the scheme on mobile platforms, we developed an infrastructure that provides issuer, client and verifier components.
48
K. Dietrich et al.
Our DAA infrastructure is based on a client-server architecture consisting of different components which include an issuer, a trusted-third party (TTP) for long term certification of the issuer’s public-key, a DAA status responder and a certificate authority (CA) that issues credentials for the TTP, the responder and the revocation authority. Moreover, the CA issues credentials for all players in the infrastructure to enable end-point authentication for the transport layer security (TLS) endpoints. Furthermore, it provides the corresponding revocation information for all issued certificates. All communication is established using the TLS protocol in order to provide authenticity of the endpoints and confidentiality and integrity of the transmitted data. Although our design and proposed protocol aims at supporting different clients, our current implementation focuses on desktop systems and mobile phones. 2.1
The Issuer
The issuer is responsible for generating the group credentials and for issuing the credentials to client platforms. Before a client can join the group, it has to be authenticated, allowing only authorized clients from joining the group. Moreover, the issuer has to perform a rogue and revocation check of the client’s TPM. Therefore, the issuer maintains a list with Endorsement Keys (EKs) for all the clients, which are allowed to join. However, there are some cases when the issuer would allow arbitrary clients to join. Therefore, we introduce two modes of operation for the issuer: 1. Public Access mode - Clients can join even if their EK is not on the issuer’s list. Their key will be put on the list on the fly during execution of the join protocol in order to be able to monitor who is in the group. 2. Private Access mode - Only clients that have an authorized EK on the issuer’s list can join and request the corresponding group credentials from the issuer. In our approach, we focus on the DAA protocol discussed in [10] which is available on many different platforms [2], [13], [7]. Issuer Setup Protocol. Before the issuer can start to operate, it has to generate its group credentials which is done during the setup phase where all parameters required for the issuer are generated. The parameters include values for exclusive use by the issuer (e.g. issuer’s private key) and public values like the issuer’s public-key. The public values also include a non interactive proof showing that the issuer’s parameters have been generated correctly. Parameters are generated according the following protocol: 1. The issuer chooses a modulus n with length ln and primes p, q, p , q such that: n = pq, p = 2p + 1, q = 2q + 1 2. Next, it chooses random integers x0 , x1 , xz ∈ [1, p q ] and x ∈ [1, n] which will be used to generate the proof and computes S = x2 mod n, Z = S xz mod n, R0 = S x0 mod n and R1 = S x1 mod n
Implementation Aspects of Anonymous Credential Systems
49
3. The issuer produces a non-interactive proof that S, Z, R0 and R1 are computed correctly. (see [3] for more details) 4. It generates rouge tagging parameters by choosing random primes ρ, Γ and γ ∈R ZΓ∗ , satisfying Γ = rρ + 1 such that r is an integer, ρ r, 2lΓ −1 < Γ < 2lΓ , 2lρ −1 < ρ < 2lρ and γ (Γ −1)/ρ ≡ 1 mod (Γ ). Finally, the issuer calculates γ = γ (Γ −1)/ρ mod Γ 5. The public-key of the issuer is the tuple (n, S, Z, R0 , R1 , γ, Γ, ρ) and the private-key is the tuple (p , q ). In addition to the public-key, the issuer computes a proof that the parameters of the public-key are generated correctly. This proof can be used to verify that the Z, R0 , R1 ∈ S and S ∈ QRn parameters are properly constructed. As the verification of the public-key proof is time and resource consuming, it may be delegated by a client to a trusted-third-party which verifies the proof and signs the group-key, thereby attesting the authenticity and the correctness of the key. 2.2
The Client
In our scenario, the mobile phone is a Java 2 MicroEdition (J2ME) application which runs on a mobile phone. These mobile platforms can be equipped with dedicated micro-controllers or software based TPMs as discussed in ([9], [6], [6]). After computing the secret key f , the client may execute the join protocol with the issuer in order to obtain its credentials. Once the client has received the credentials, it is able to create DAA signatures on behalf of the group. Any verifier can verify these signatures with the issuer’s - respectively the group’s public-key. Prior to joining the group, the client has to verify the public-key of the issuer. It is very important to perform this step, since improperly generated issuer-parameters can cripple the anonymity protection of the DAA scheme [3]. Our client application delegates the computationally expensive parts of the issuer proof verification to a trusted third party (TTP). The steps done by the trusted third party are roughly: The TTP verifies the issuer’s proof that Z, R0 , R1 ∈ S and that S is a quadratic residue mod (n). Then the TTP verifies that rouge tagging is set up correctly by checking whether ρ and Γ are primes, ρ | (Γ − 1), ρ (Γ − 1)/ρ and γ ρ ≡ 1 (mod Γ ). Finally, it checks if all parameters of the issuer’s public-key have the required lengths. Following these steps, the client has proof that all the issuer-parameters are computed correctly which implies that the security properties for the client still hold [3, page 9].
3
The Join Protocol
During the Join protocol, client and issuer exchange parameters. Some of these parameters are only temporary parameters which are used to derive other parameters and others are credentials which are finally issued by the issuer to be stored as client-key and group credential. Moreover, we have modified the protocol in order to support different (i.e. future versions and devices that cannot
50
K. Dietrich et al.
rely on a trusted host platform like smart-cards) versions of the DAA scheme. The Join protocol works as follows: 1. The client sends the join command, version and hash of its public EK. 2. The issuer receives the join command and tests if the requested version and DAA scheme are supported. When operating in Private Access mode (see section 2.1) the issuer now tests if the client’s EK hash is on the list of allowed EK hashes. Regardless of the access mode the issuer requests the client to transmit its public EK. 3. The issuer chooses a random ne of length lΦ and encrypts it with the client’s public EK. The encrypted ne and the issuer’s basename bsn are sent back to the client. 4. The client needs to show proof of possession of the public EK – The client’s TPM decrypts ne , picks a random ν of length ln + lΦ and computes: U = R0f0 R1f1 S ν as well as aU = H(U ne) – The client sends ζI = (HΓ (1bsnI ))(Γ −1)/ρ to its TPM. lf
– The TPM verifies that ζIρ ≡ 1 mod Γ holds and computes NI = ζI 0 1 – Finally the client sends U, cnt, NI and aU to the issuer. Upon reception of aU , the issuer computes aU = H(U ne ) – the client has proved that it is the owner of the EK if and only if aU = aU holds. Next, the issuer checks for the rogue tagging using NI (see section 4). The issuer generates a random nonce ni of length lh and forwards it to the client. The client needs to prove knowledge of f0 , f1 and ν to the issuer. – The TPM generates random numbers rf0 , rf1 of length lf + lΦ + lH and ˜ = Rrf0 Rrf1 S rν mod n rν of length ln + 2lΦ + lH . It then computes U 0 1 ˜ – Client sends ch = H(nR0 R1 SU U ni ) to its TPM – The TPM generates a random nonce nt of length lΦ and computes the final hash c and values sf0 , sf1 , ν as: c = H(ch nt ), sf0 = rf0 +sf0 , sf1 = rf1 +sf1 and sν = rν + s · ν – The client forwards c, nt , sf0 , sf1 , ν to the issuer. The issuer verifies the computations done by the client and its TPM. – sf0 , Sf1 must be of length lf + lΦ + lH + 1. sν must have the length ln + 2lΦ + lH + 1. ˆ = U −c Rsf0 Rsf1 S sν mod n and the proof if and – The issuer computes U 0 1 ˆ ni )nt ) holds. only if c = H(H(nR0 R1 SU U After verification of the client proofs, the issuer constructs a CamenischLysyanskaya (CL) credential. – The issuer first generates a random number νˆ of length lν and calculates ν = νˆ + 2lν −1 . Then the issuer selects a random prime e ∈ [2le −1 , 2le −1 + 2le −1 ] and computes: Φ(n) = (p − 1)(q − 1) and d = e−1 mod Φ(n). – The issuer now calculates A = ( USZv )d mod n and sends it to the client. The client challenges the issuer to prove correct computation of A. In order to do so, the client sends a nonce nh of length lΦ . (f +f 2
5.
6. 7. 8.
9.
10.
11.
)
Implementation Aspects of Anonymous Credential Systems
51
12. The issuer generates a random re ∈[0, p q ] and computes A˜ = ( USZv )re mod n, ˜ h ) and se = re − c d c = H(nZSU AAn – The response (c , se , A, e, ν ) is forwarded to the client. 13. The client verifies the issuer’s response and obtains its CL credential. – To verify the issuer’s response the client computes Aˆ = Ac ( USZv )se mod n ˆ h ). The response is valid if and only if c = c and c = H(nZSU AAn holds and if e is prime with e ∈ [2le −1 , 2le −1 + 2le −1 ]. – Using ν the TPM computes ν = ν + ν and then stores (f0 , f1 , ν ) as private-key. 3.1
Prototype Implementation of the Join Protocol
No defined application protocol for the DAA join step has been defined either by the authors of [3] or by the TCG. The TCG Trusted Software Stack specification includes provisions for basic support of the DAA join and sign commands of the TPM [14]. The basic DAA support specified in [14] only consists of an API interface without any kind of provisions for the application level network protocols required to execute the DAA join sequence between an issuer and a client platform. Trusted Channel between Issuer-Service and Clients. For our prototype implementation, we developed a simple application protocol which allows the client to communicate with a DAA issuer over a TLS secured network connection. The application protocol discussed in this section describes a working prototype implementation which is intended to encourage a broader discussion of how a practical DAA issuer network service could look like. The application protocol used by our prototype is a simple request response protocol based upon a series of simple ASN.1 messages exchanged over a trusted channel. In our prototype system, this trusted channel is established using a TLS protected TCP/IP network connection. Using TLS server authentication enables us to authenticate the DAA issuer service against the host willing to join the DAA group. The host can resort to standard PKI methods for verifying the identity of the DAA issuer based on its server certificate. On mobile platforms, the online certificate status protocol (OCSP) can be employed to delegate the possibly resource and communication intensive certificate validation step to a trusted third party. Since different platforms have different strengths and computation powers and our implementation of the issuer should serve all of them, we support different versions of commands. As you can see from the join process section, the first message to be sent from the host to the issuer is the command message. This message includes the command which in that case is ”join” and also the version of the join protocol. In order to support multiple platforms and protocol we implement different forms of ASN.1 messages and differ them based on the used version. The first version would be e.g. “1.0” and the second one “1.1”. Hence, whenever a client
52
K. Dietrich et al.
which can not handle the first option wants to join, it simply specifies which version it can handle or rather which it understands and then the issuer interacts with it in an appropriate form. Additionally the versioning scheme allows us to implement protocol changes in future while maintaining compatibility with existing clients.
4
Rogue Detection and Revocation
In order to detect and prevent compromised TPMs from joining or from signing messages, a rogue and revocation detection mechanism must be used. As mentioned in [3], if the secret of a TPM is revealed it is tagged as rogue and the values f0 and f1 are put on a blacklist. In order to check whether a TPM is rogue or not, the following steps have to be performed: The host and the issuer separately compute ζI = (HΓ (1bsnI ))(Γ −1)/ρ . Then lf
(f0 +f1 2
the client’s TPM computes NI = ζI
)
and sends NI to the verifier. Now lf
(f +f 2
)
the verifier checks for all pairs (f0 , f1 ) on its blacklist whether NI = ζI 0 1 holds, if a pair satisfying the equation is found the TPM is considered to be rogue. The same procedure is used during the sign and verification process of a signature, allowing the verifier to check whether the TPM is rogue or not. Alternatively, the ζV (ζI ) can be chosen at random. In this case, ζ serves only for rogue detection. But if we derive it from the bsn, we would have the same ζ for the same bsn, and it would be possible to link different actions of the platform. In case the issuer acts as verifier and uses the same bsn, the platform may be identified and its transactions may be linked, since ζV = ζI and can be linked to the identity, which should not be the case. The authors of [12] address this problem and propose a simple solution by changing the calculation of ζV to: ζV = (HΓ (0bsnV ))(Γ −1)/ρ In this case, the ζV = ζI so it is not possible to link the identity of the platform to the actions. The biggest problem here is how to gather information in order to assemble a blacklist. In [3][Page 14] it is mentioned that when a certificate (A, e, ν) and the values f0 and f1 are found, they are tested whether Ae R0f0 R1f1 S ν ≡ Z (mod n) holds. If so, they are put on the blacklist. However, there is no mechanism to get the parameters f0 and f1 . If somebody is able to extract them out of a TPM and uses them to impersonate another party there is no way to distinguish between the original platform and the impersonating platform. It is unlikely that the impersonator will publish the extracted secrets. Moreover, there is no way that a platform can check if its secrets have been extracted. Even if the owner of the platform somehow gets the information that the platform has been compromised, the secrets can not be extracted from the TPM in order to perform a self-revocation. There is no command for that action because the secret is supposed to never leave the TPM even if it is requested by the user [15] (for example, if the user wants to revoke the DAA credential if he
Implementation Aspects of Anonymous Credential Systems
53
notices that the TPM keys are compromised). The only way a user can delete its credentials is by performing a take-ownership where new secrets (f0 , f1 ) will be generated. However, if he did not extract and publish the old secrets, someone might use these secrets for signing on behalf of the group and there is no way to detect it since the pair (f0 , f1 ) is not in the blacklist. Hence, the extracted credentials cannot be revoked and remain valid. 4.1
Online Credential Revocation Check
In order to shift the computational effort from the mobile client to a more resourceful platform we introduce a modification of the Online Certificate Status Protocol (OCSP) [11]. OCSP allows to retrieve the status of a certificate from an online source, the OCSP responder. To achieve this, the OCSP request structure contains the CertID field consisting of hash algorithm identifier, hash of the issuer’s name and the issuer’s key, and the serial number of the requested certificate, we want to obtain the status of. A status may be good, revoked or unknown. A status may be good, revoked or unknown. We slightly modified the RFC2560 CertID structure to include the basename, the pseudonym ζ and a reference the issuer’s public-key, which is used to obtain the group parameters. Figrue 1 illustrates the information flow in our modified variant of the OCSP protocol.
Fig. 1. Online Credential Status Reporting
Using the information provided in the modified CertID structure the responders checks if its black-list contains ζ and returns an appropriate OCSP status response. The authenticity and inbtegrity of the OCSP response can be verified using standard public-key signatures as discussed in RFC2560 [11].
5
Experimental Results
In this section, we discuss the results and setup of our infrastructure implementation. We tested the performance of the server (issuer) on a Sony Vaio VGN-NR11Z/S notebook and the client on a Nokia 5800 Express Music cell phone, a Frescale i.MX51 development board and an MSI U135 netbook. Table 1 shows the main characteristics of the testing devices.
54
K. Dietrich et al. Table 1. Testing devices (Roles: H = Host, I = Issuer)
Device Role CPU Clock Freq. RAM OS Nokia 5800 Express Music H ARM11 434 MHz 128 MB Symbian 60v5 Sony Vaio VGN-NR11Z/S I Intel Core 2 Duo 2.0 GHz 2 GB Windows XP i.MX51 EVK H ARM Cortex-A8 800 MHz 512 MB Linux (Debian) MSI U135 netbook H Intel Atom 1.2 GHz 1 GB Linux (SuSE)
Overall performance evaluation of the DAA setup was done with the Sony Vaio notebook configured as server (issuer) and the Nokia mobile phone configured as client (host). The Freescale development board an the MSI netbook did not take part in the overall client/server performance evaluation. Instead the latter two devices were used to evaluate performance impact of using different Java virtual machine configurations as discussed later in section 5.2. 5.1
Overall Client/Server System Performance
In the client/server performance test setup, both test devices were placed on the same local area network (LAN). Both the Nokia 5800 Express cell phone and the Sony Vaio notebook were connected to the test LAN using a wireless LAN access point. For this test. the issuer component was executed on a SUN Java 1.6 virtual machine configured with its installation default settings for Windows XP.
Modulus length Join Time 1024 bit 10.85 s 1536 bit 19.56 s 2048 bit 32.52 s (a) Join times with empty blacklist
Rouge TPMs 100 1000 2000 5000 10000
Time 33.57 s 46.67 s 59.76 s 103.35 s 187.20 s
(b) Join times with different black-list sizes
Rouge TPMs 200 500 1000 2000 10000
Time 79.95 s 179.47 s 352.11 s 699.06 s 187.20 s
(c) Rogue detection on a mobile phone
Fig. 2. Join and rouge detection times
Join Performance Results After the initial client and the server setup has been performed, the client can do the DAA join step. The performance results for joining a DAA group with empty blacklist shown below in table 2a include the network communication overhead. Since communication is done over network the results may vary in different connections with different strengths. These results were gained when performing joining with an empty blacklist. Hence, there is no rogue TPM on the list. Rogue Detection Performance. As discussed earlier the issuer has to comlf
(f +f 2
)
pute a rouge tagging value NI = ζI 0 1 for each pair (f0 , f1 ) on its blacklist. A single NI computation is very expensive, but overall cost increases linearly with
Implementation Aspects of Anonymous Credential Systems
55
the size of the blacklist. The more TPMs are on the list, the longer it takes to prove for any TPM whether it is rogue or not and the longer it takes to finish the join protocol. We measured the join process performance considering the effects of the rogue detection process. The tests were performed in a way that after each Join a new pair (f0 , f1 ) is inserted into the blacklist for the next Join. In table 2b we show the time required for a join with rogue TPMs in the blacklist. The length of modulus for these measurements was 2048. As visible in figure 3a, there is a nearly linear dependency between the number of TPMs on the rouge list and the total time required for the joining process. Given those results the amount of time required for each additional rouge TPM corresponds to approximately 14.7 milliseconds or equivalently to 1.47 seconds per 100 rouge TPMs.
220
700
200 600 180 500 Total verification time [s]
Total join time [s]
160 140 120 100 80
400
300
200
60 100 40 20 0
2000
4000
6000
8000
10000
12000
Number of rouge TPMs on the blacklist
(a) Join performance over black-list size
0 200
400
600
800
1000
1200
1400
1600
1800
2000
Number of rouge TPMs on the blacklist
(b) Verification with rogue detection
Fig. 3. Join and verify performance
The biggest problem is that the rogue detection has to be performed when verifying signatures. Since a client should be able to verify signatures, it also should be able to check for rogue TPMs. We measured the execution time of the rogue detection depending on the number of TPMs in the blacklist on the Nokia mobile phone. The corresponding results can be found in table 2 and figure 3b. Assuming medium to large blacklist sizes it clearly becomes evident that rouge detection is an expensive operation which might not be feasible on batterypowered devices like mobile phones. Moreover the level of user acceptance for signature verification processes in the order of minutes is at least questionable. Proof Verification. As previously discussed, a proof that the parameters of the issuer’s public-key are generated correctly, should be generated by the issuer. In order to prove that Z, R0 , R1 ∈ S, a total of 3 · 160 = 420 relatively expensive calculations (verifications of bit-commitments) are required. Each of these calculations includes a modular exponentiation with an exponent ∈ [1, p q ] and also a modular multplication. The proof verification step requires significant computational resources and takes significant time (≈ 99.44 s) even on the Sony Vaio platform used as issuer in our other experiments. On the Nokia mobile phone platform the verification time is far beyond any acceptability bounds
56
K. Dietrich et al.
(≈ 2399.24 s). The computing power of Java applications on mobile devices is clearly insufficient to verify this kind of proof. A viable solution for this case would be to delegate the verification step to a trusted third party. 5.2
Performance Impact of Different Java Virtual Machines
In the previous section we considered performance characteristics of a model realization of a DAA infrastructure based on a mobile phone acting as host and a notebook playing the part of the issuer. In this section, we briefly evaluate the impact of the Java virtual machine on the performance of the client side join process. In contrast to section 5.1 we ignore any server side computations and network overhead. Measurements shown in this section were performed using a special version of the client application which just instruments the client-side computations. Table 2. Average timing values for client-side computations of the join process Platform Freescale i.MX51 Freescale i.MX51 Freescale i.MX51 Intel Atom N450 Intel Atom N450
Java Virtual Machine Average join time (client) Deviation OpenJDK/Zero 8.591 s 0.019 s OpenJDK/Shark (mixed) 6.087 s 0.510 s OpenJDK/Shark (interpreted) 142.742 s 0.274 s OpenJDK/Client (interpreted) 40.312 s 0.209 s OpenJDK/Client (mixed) 3.512 s 0.025 s
We tested four combinations of Java virtual machines and just-in-time compiler settings which are intended to model typical JVMs found on mobile platforms. In order to produce comparable results for the tested platforms we used OpenJDK 1.6.0 as Java runtime environment. All cryptography related operations, including big number support was implemented with IAIK’s JCE-ME1 library. We tested the mixed-mode and interpreted Java VM configurations given in table 2. Figure 4 plots client-side computation times for repeated execution of the join process from within the same virtual machine instance. Table 2 gives average values for computation times. We decided to sample execution times for one particular VM configuration inside a loop from within a single VM invocation. This decision allows us to evaluate initial delays due to class loading and just-in-compilation. Three of the four VM configurations depicted in 4 exhibit relatively constant timing behavior with some minor jitter caused by other operating system processes interfering with our measurements. Only the OpenJDK “Shark” virtual machine exhibits great variations in join process execution times, caused by the relatively expensive just-in-time compilation steps done during the first few join process executions. As evident from figure 4 there is a huge performance gap almost in the range of one order of magnitude between the JIT (mixed mode) and the non-JIT (interpreted only) configurations on the Intel Atom platform. Interestingly the performance gap between the non-JIT and the JIT virtual machines on the ARM platform is by far smaller. 1
See http://jce.iaik.tugraz.at/sic/Products/Mobile-Security/JCE-ME
Implementation Aspects of Anonymous Credential Systems
57
50 ARM Cortex-A8, OpenJDK Zero VM ARM Cortex-A8, OpenJDK Shark VM Intel Atom 450, OpenJDK Client VM (interpreted) Intel Atom 450, OpenJDK Client VM (mixed mode)
45
Client-side join computation time [s]
40 35 30 25 20 15 10 5 0 0
10
20
30
40
50
60
70
80
Test run
Fig. 4. Join computation performance for different Java VM configurations
6
Conclusion
Based on the overall performance results of our implementation shown in section 5.1 we conclude that the most time-consuming part of the DAA protocol is the rogue detection. Even if rogue detection can be done relatively fast on desktop PCs and servers it still negatively affects the verification process which might be done on battery-powered mobile devices. Recalling from the test of the rogue TPMs, the time required by rouge checking process increases lineraly with the size of the black-list. For larger black-lists the time spent for rouge detection easily exceeds the actual signature verification time by orders of magnitude. The worst part is, that rouge detection has a big influence on mobile phones, even for small blacklists with sizes in the order of 30 rouge TPMs. Therefore, we conclude that delegating the validation of the rogue status to a third party is an unavoidable requirement. Another open problem with rogue detection are the mechanisms and protocols used to report corrupted TPMs. The current implementation of DAA in TPM 1.2 implicitly anticipates compromise of the DAA private key as only revocation reason. Currently there is no method that enables a user to voluntarily report corruption of his platform without knowing the f value guarded by the TPM. Moreover the proof verification process required to check the validity of an issuer’s public key requires impractical amount of storage and computational resources on mobile phones. This problem can be solved by off-loading the proof verification to a trusted third party. Finally the results from section 5.2 clearly show the impact of the choice of Java virtual machine on the performance of our purely Java-based prototype implementation. Acknowledgments. We thank the anonymous reviewers for their helpful comments. This work has been supported in part by the European Commission through the FP7 programme under contract 257433 SEPIA.
58
K. Dietrich et al.
References 1. Berna, S., Yalcin, O. (eds.): RFIDSec 2010. LNCS, vol. 6370. Springer, Heidelberg (2010) 2. Bichsel, P., Camenisch, J., Groß, T., Shoup, V.: Anonymous credentials on a standard java card. In: CCS 2009: Proceedings of the 16th ACM Conference on Computer and Communications Security, pp. 600–610. ACM, New York (2009) 3. Brickell, E., Camenisch, J., Chen, L.: Direct Anonymous Attestation. In: Proceedings of the 11th ACM Conference on Computer and Communications Security, Washington DC, vol.(5), pp. 132–145 (November 2004) 4. Camenisch, J., Van Herreweghen, E.: Design and implementation of the idemix anonymous credential system. In: CCS 2002: Proceedings of the 9th ACM Conference on Computer and Communications Security, pp. 21–30. ACM, New York (2002) 5. Chen, L., Page, D., Smart, N.P.: On the Design and Implementation of an Efficient DAA Scheme. Cryptology ePrint Archive, Report 2009/598 (2009), http://eprint.iacr.org/ 6. Dietrich, K.: An Integrated Architecture for Trusted Computing for Java Enabled Embedded Devices. In: STC 2007, pp. 2–6. ACM, New York (2007) 7. Dietrich, K.: Anonymous Credentials for Java Enabled Platforms: A Performance Evaluation. In: Chen, L., Yung, M. (eds.) INTRUST 2009. LNCS, vol. 6163, pp. 88–103. Springer, Heidelberg (2010) 8. Dietrich, K.: Anonymous client authentication for transport layer security. In: De Decker, B., Schaum¨ uller-Bichl, I. (eds.) CMS 2010. LNCS, vol. 6109, pp. 268–280. Springer, Heidelberg (2010) 9. Dietrich, K., Winter, J.: Implementation Aspects of Mobile and Embedded Trusted Computing. In: Chen, L., Mitchell, C.J., Martin, A. (eds.) Trust 2009. LNCS, vol. 5471, pp. 29–44. Springer, Heidelberg (2009), http://dblp.uni-trier.de/db/conf/trust/trust2009.html#DietrichW09 10. Mitchell, C.: Direct Anonymous Attestation in Context. In: Trusted Computing (Professional Applications of Computing), pp. 143–174. IEEE Press, Piscataway (2005) 11. Myers, M., Ankney, R., Malpani, A., Galperin, S., Adams, C.: X.509 Internet Public Key Infrastructure Online Certificate Status Protocol - OCSP (1999) 12. Smyth, B., Ryan, M.D., Chen, L.: Direct Anonymous Attestation (DAA): Ensuring Privacy with Corrupt Administrators. In: Stajano, F., Meadows, C., Capkun, S., Moore, T. (eds.) ESAS 2007. LNCS, vol. 4572, pp. 218–231. Springer, Heidelberg (2007), http://dblp.uni-trier.de/db/conf/esas/esas2007.html#SmythRC07 13. Sterckx, M., Gierlichs, B., Preneel, B., Verbauwhede, I.: Efficient Implementation of Anonymous Credentials on Java Card Smart Cards. In: 1st IEEE International Workshop on Information Forensics and Security (WIFS 2009), pp. 106–110. IEEE, London (2009) 14. Trusted Computing Group: TCG Software Stack (TSS) Specification Version 1.2 Level 1, part 1: Commands and Structures (January 6, 2006) 15. Trusted Computing Group: TPM Main Specification Level 2 Version 1.2, Revision 103. Tech. rep., Trusted Computing Group (October 26, 2006) 16. Wachsmann, C., Chen, L., Dietrich, K., L¨ ohr, H., Sadeghi, A.-R., Winter, J.: Lightweight Anonymous Authentication with TLS and DAA for Embedded Mobile Devices. In: Burmester, M., Tsudik, G., Magliveras, S., Ili´c, I. (eds.) ISC 2010. LNCS, vol. 6531, pp. 84–98. Springer, Heidelberg (2011)
Approximation of a Mathematical Aging Function for Latent Fingerprint Traces Based on First Experiments Using a Chromatic White Light (CWL) Sensor and the Binary Pixel Aging Feature Ronny Merkel1, Jana Dittmann1, and Claus Vielhauer2 1
Department of Computer Science, Research Group Multimedia and Security, Otto-von-Guericke-University of Magdeburg, Universitätsplatz 2, 39106 Magdeburg, Germany 2 Department of Informatics and Media, Brandenburg University of Applied Sciences, Magdeburger Straße 50, 14770 Brandenburg an der Havel, Germany {Ronny.Merkel,Jana.Dittmann}@iti.cs.uni-magdeburg.de, [email protected]
Abstract. The age determination of latent fingerprint traces is a very important challenge for forensic investigations, which has not been solved satisfyingly so far. Based on prior work, we use the novel and very promising aging feature of counting binary pixel for the approximation of a mathematical aging function to be used for the age determination of latent fingerprint traces. We first show the feasibility of this feature in a test set of nine test series (each comprised of a fingerprint sample scanned continuously over four days) using three different optical sensors (CWL) of the same model and varying resolutions (3,5,10µm). We then approximate the aging function for each test series, showing an average error of approximation between 13% and 40% for an optimal approximation. We discuss the prospects and restrictions of such a function for the age determination of latent fingerprint traces and identify future research challenges. Keywords: latent fingerprint traces, crime scene investigation, age determination, binary pixel, mathematical aging function.
1 Introduction The determination of the age of a latent fingerprint trace found at a crime scene is a strong need in forensic investigations since many decades. Only very limited results have been achieved in this field so far. In recent years, contactless scanning techniques have been introduced to the field of fingerprint forensic research, often adapting surface- or other purpose measurement devices for the non-invasive acquisition of latent fingerprint traces (see [1] for a summary of such techniques). These acquisition techniques offer new opportunities to the field of fingerprint age determination, since latent fingerprint traces can now be obtained with a very high resolution and accuracy (which could not fully be achieved by classical powdering and sticky tape lifting or fuming with cyanoacrylate or other development techniques and subsequent photographing). B. de Decker et al. (Eds.): CMS 2011, LNCS 7025, pp. 59–71, 2011. © IFIP International Federation for Information Processing 2011
60
R. Merkel, J. Dittmann, and C. Vielhauer
In [2], we suggested the measurement of ‘binary pixel’ as a first feature for a possible age determination, using a contact-less, non-invasive Chromatic White Light (CWL) sensor [3] as part of a surface measurement device for acquiring latent fingerprint traces from a hard disc platter. To the best of our knowledge, this is a novel approach, firstly using high-resolution image sensory in combination with pattern recognition techniques, which seems to be very promising to finally solve the important research challenge of the age determination of latent fingerprint traces. The technique normalises the captured fingerprint image, binarises it using a threshold and then counts the white pixel, which represent the background pixel not belonging to the residue. We show that the amount of this white pixel increases in a logarithmic way over time. This increase is assumed to happen due to decomposition processes of the fingerprint residue and the evaporation of water. In our design approach from [2] we scan a single fingerprint sample continuously over a time period of 10 hours, referred to as a test series throughout this paper. We examine only four of such test series in [2] using one CWL device (for each series, an individual left a fingerprint trace on a hard disc platter) and give no specific details on the parameters of the observed aging curve. Here, we extend these considerations by proposing a mathematical aging function which might be used for the age determination of latent fingerprint traces and evaluate the reproducibility of the characteristic tendency of the aging feature using different resolutions and different sensors of the same model as well as an increased test series length of four days. Our first test goal is to reproduce the results of [2] using an extended test set of nine test series, where each test series is comprised of a fingerprint left on a hard disc platter by an individual (randomly chosen from four different individuals providing their fingerprints for the tests) which is continuously scanned over four days (with a scan interval of 30 minutes or less, depending on the resolution). For this nine test series, we vary the resolution (3µm, 5µm and 10µm) and use three different CWL sensors of the same model (FRT MicroProf 200 CWL 600 [3], which is identical to the one used in [2]) to evaluate the reproducibility of the characteristic tendency of the feature under different scanning conditions. Our second test goal is to then approximate a mathematical aging function from our test results, which might later be used for the determination of the absolute age of a fingerprint trace. Based on the standard mathematical representation of a natural , t>0 we approximate the parameters a and b logarithmic curve for each test series. We then evaluate the average error of approximation of such an approximated mathematical function, showing no significant tendency for the influence of different scanners of the same model or different resolutions within the test range, but significant variations between the results of the test series (average errors of approximation between 13% and 40%), possibly caused by different influences such as the sweat composition of the residue (e.g. type and duration of sweating before fingerprint application or consumption of medicine, certain food or other substances), the environmental conditions (e.g. UV-light, temperature or humidity) or fingerprint application related influences (such as smearing or blurring of the fingerprint or contact time and –pressure when applying the print). We discuss the potential use of our approximated aging function in a forensic application scenario and identify future research challenges, which need to be solved for achieving a certain accuracy of the results.
Approximation of a Mathematical Aging Function for Latent Fingerprint Traces
61
The paper is structured as follows: in the next section, we give a short summary of current state of the art approaches concerning the topic and present our used sensor. We then introduce our design approach for a mathematical aging function in section 3, which might be used for the age determination of latent fingerprint traces. In section 4, we explain our assumptions, present our test setup and evaluate the test results for our two test goals. We afterwards discuss the potential application of an approximated mathematical aging function in a forensic investigation in section 6. Section 7 summarises the paper and identifies future work.
2 State of the Art So far, only very limited progress has been made in the domain of age determination of latent fingerprints in forensics. A few approaches include the use of fingerprint ridge thickness and changes of pores [4], the healing stage of a wound on the finger [5], fluorescence-properties of a fingerprint changing over time [6] or the use of a reference database of fingerprints of different aging states [7]. A good summary of current approaches for the age determination of latent fingerprints can be found in the German study of [6]. However, all of these approaches are either focused on very limited scenarios (e.g. a wound on the finger is required) or fail to deliver reliable results. They can therefore not satisfy the strong need for a comprehensive age determination of latent fingerprint traces. In prior work [2], we reported that a novel feature called ‘binary pixel’ shows a very promising, characteristic logarithmic aging curve for latent fingerprint traces left on a hard disc platter. The experiments are conducted using the FRT MicroProf 200 CWL 600 sensor [3] for acquiring the prints and four different fingerprint samples are captured continuously over 10 hours. For determining the binary pixel value, we normalise a scanned fingerprint image and binarise it using a threshold. We then measure the number of white background pixel in relation to the number of overall pixel, which results in our feature value for the binary pixel feature. Since the feature of counting binary pixel seems to be very characteristic for the aging process of latent fingerprint traces, we want to use it for our idea of approximating a mathematical aging function, which might be used for the age determination of latent fingerprint traces. To reproduce the characteristic tendency in our extended test set, we use the same FRT MicroProf 200 CWL 600 measurement device, which origins from the field of quality control of materials and is transferred to the domain of fingerprint imaging. It uses a chromatic white light (CWL) sensor and can produce high-resolution 16-bit intensity- and topography images of a fingerprint trace with a resolution of up to 1µm in the lateral domain and 20nm in the longitudinal domain. For our research, so far only the intensity images produced by the sensor are of interest, leaving the use of topographical values for future work. Potential other contactless sensors are summarised in [1].
3 Our Proposed Design for an Aging Function For the approximation of a mathematical aging function for a given aging feature, the general tendency of the course of the features aging curve needs to be known. To the
62
R. Merkel, J. Dittmann, and C. Vielhauer
best of our knowledge, most natural processes have a logarithmic, exponential or (in some cases) linear course. We identified the course of the aging curve for the binary pixel feature as logarithmic. This tendency was confirmed by all nine test series examined in this paper. We therefore approximate the course of the aging curve by using the standard mathematical formula for a logarithmic function: , >0.
(1)
The variables of the function (1) are represented by a point in time t and the relative amount of white background pixel f(t) present at this point. The constant parameters a, b and c describe specific aspects of the function and need to be determined for a specific aging curve. The parameter c describes the base of the logarithm and, since the aging of fingerprint traces is a natural process, is assumed to be Euler’s number (e), leading to formula (2). However, the function could be approximated using other values for the base c in an analogous way. , >0.
(2)
Although the mathematical aging function for the given aging feature is to be approximated, it is trivially not identical to the experimentally determined aging curve described by the test results. Therefore, we have to distinguish between a tuple tupEi=(tEi,fE(tEi)), tEi>0 which describes a specific point in time tEi and its corresponding amount of white background pixel fE(tEi) from the discrete experimental aging curve fE (where i describes the index number of the tuple within a test series) and the tuple tupMi=(tMi,fM(tMi)), tMi>0, which represents the corresponding point in time tMi and its value fM(tMi) as part of the continuous mathematical function fM approximating the course of the aging curve. Considering this naming scheme, formula (2) can be rewritten as: ,
> 0.
(3)
Furthermore, the experimental results of a test series described by the discrete aging function fE consist of a set of tuples TE={(tE1,fE(tE1)), (tE2,fE(tE2)), ..., (tEn,fE(tEn)); tEi>0, n N, n>0} representing all n measured samples of a fingerprint trace. Formula (3) can be transposed to calculate the point in time tMi of a sample from the amount of white background pixel fM(tMi) present: ,
0.
(4)
By substituting fM(tMi) with its experimental equivalent fE(tEi), we derive the following formula: ,
0.
(5)
The derived formula (5) enables us to calculate the absolute amount of time tMi’ which has passed from the time a fingerprint trace was left on a surface until the acquisition of a binary pixel feature value fE(tEi), given that the constant parameters a and b are
Approximation of a Mathematical Aging Function for Latent Fingerprint Traces
63
known. However, since influences like environmental conditions (which are discussed in section 4.1) might change over time and also other influences (such as sensor noise) are present, there is an offset between the calculated theoretical age tMi’ of a fingerprint trace and its real age tEi. This offset characterises the error of approximation erri for a specific tuple tupEi: |
|
,
> 0.
(6)
To obtain an average error of approximation erravg for a complete test series, we determine the errors erri for all tuples tupEi and calculate their average value:
1
|
1
|
1
. (7)
,
> 0,
> 0,
0
By using this formula, the average error of approximation erravg for an arbitrary test series can be calculated. In the following section, we evaluate the accuracy of such an approximation by determining the parameters a and b in a way to minimise the average error erravg.
4 Experimental Investigations Changing influences on the fingerprint aging process are supposed to be the biggest source of impreciseness of our approximated aging curve. Furthermore, some influence factors might have a big impact resulting from only small changes whereas other influence factors are rather insignificant. In this section, we therefore first introduce our main assumption concerning these influences, which is according to our knowledge a precondition for a reliable age determination. We then introduce our experimental test setup and evaluate the measured results regarding our two test goals: the reproduction of the characteristic aging tendency using an extended test set and the approximation of a mathematical aging function from our test results. 4.1 Assumptions Many different influences exist on the aging process of a latent fingerprint trace (see [4], [5], [6], [7], [8], [9], [10], [11] and [12]). We summarise them here as: the sweat influence (namely all factors influencing the consistency of the sweat and therefore its decomposition process), the environmental influence (such as UVlight, humidity, temperature, wind or air pressure), the application influence (which is determined by the characteristic way a fingerprint trace is left, such as smearing or blurring, contact-time, contact pressure or the application of creme or
64
R. Merkel, J. Dittmann, and C. Vielhauer
dirt to a finger prior to applying the fingerprint) and the surface influence (where characteristic surface properties influence the aging process, such as absorptive or corroding surfaces). Furthermore, the scan influence of the fingerprint acquisition process, meaning the influence of the technical properties of the capturing device and the acquisition parameters (such as the resolution of a scan or the size of the measured area), can have an important influence on the determination of the aging function of a given feature, especially if chosen wrong. In this paper, we assume that the sweat influence, the environmental influence and the application influence are kept constant. We are not interested in the explicit values of these influences (e.g. if the temperature is 20°C or 30°C) as long as they are constant. However, it might not be totally possible in practice to keep all this influences constant, since they are subject to changes over time, such as temperature and humidity changes or differences in the sweat composition of different fingerprint traces. Therefore, the resulting error of approximation of the aging function calculated in the next sections might be partially a result of such influences not being totally constant. It might be improved in future work by taking additional arrangements to keep all influences, which are not subject of the study, as constant as possible, or taking such influences into account when determining the age of a fingerprint. Other influences, such as the surface influence, can be kept constant very well by fixing the used material to a hard disc platter used for all tests. The scan influence of the fingerprint acquisition process is subject to investigation in the scope of our first test goal (see section 1) and is therefore systematically varied in the next section to experimentally determine the significance of its influence. 4.2 Test Setup For our test setup we designed nine different test series (see table 1). Each test series is comprised of one fingerprint sample from an individual (randomly chosen from four individuals contributing their fingerprints to the experiments) left on a hard disc platter (constant surface influence, ideal surface for the used measurement device), of which a randomly selected part of the size 2.5x2.5 mm is continuously scanned over a total period of four days (with a scan interval of 30 minutes or less, depending on the resolution). The size of the measured area and the scan interval are chosen in respect to the performance of the CWL sensor. At a resolution of 3µm, a size of the measured area of 2.5x2.5mm can be scanned in 30 minutes. If the scan interval is to be increased, the size of the measured area or the resolution needs to be decreased and vice versa. A size of the measured area of 2.5x2.5mm furthermore seems to be very sufficient for calculating the binary pixel feature (containing approximately between 5 and 8 ridge lines) and might even be decreased in future work. It is furthermore assumed that a total scan period of four days is sufficient for a first approximation of the aging function, since most changes to the fingerprint are happening within the first hours (which is already mentioned in [2] and is confirmed in our test results). For a more precise approximation, longer scanning periods might also be of interest in future work. Figure 1 exemplary depicts five different scan images of our test series 1, captured at different points in time t1=0days, t2=1day, t3=2days, t4=3days and t5=4days.
Approximation of a Matthematical Aging Function for Latent Fingerprint Traces
65
Fig. 1. Captured fingerprint im mages from test series 1 at five different points in time (from m left to right): t1=0days, t2=1day, t3=2days, = t4=3days and t5=4days
The used CWL sensor as a well as the resolution of scans captured within a testt series is varied to extract possible influences of these factors (scan influence). Whhile the intensity images of threee different CWL sensors of the same model (FRT MiccroProf 200 CWL 600; see [3]) are used, the resolution of the test series for each of thhese sensors is varied between 3, 5 and 10µm. 6bit grey scale intensity images acquired by the sensor are For all test series, the 16 normalised to the interval [0;1] and are binarised using the threshold thresh = 00.8. h disc platter in our experiments, such general threshhold Since we use only similar hard is applicable to all test seriies, which has been confirmed in preliminary tests. Hoowever, for using different ty ypes of platter or different surfaces in future work, the threshold might have to be adapted to different pixel grey value distributions. Table 1. Overview of our exp perimental test setup for nine test series, each comprised of one fingerprint trace on a hard diisc platter, of which a randomly selected area of 2.5x2.5mm m is measured in intervals of 30 miinutes or less (depending on the resolution) over four days Test series number Scanning Scan device influence resolution
9 1 2 3 4 5 6 7 8 CWL CWL CWL CWL CWL CWL CWL CWL CW C WL 3 1 1 1 2 2 2 3 3 3 3µm 5µm 10µm 3µm 5µm 10µm 3µm 5µm 10µµm
Given the introduced scaan interval (≤30min) and scan period (4 days), a total oof at least 192 tuples (tEi,fE(tEi)) of o different times tEi and corresponding relative amounts of white background pixel fE(ttEi) can be extracted for each test series, which can be uused for the approximation of the mathematical aging function and the corresponding errror d in section 3. of approximation described 4.3 Experimental Resultss The reproduction of the lo ogarithmic course of a fingerprint aging curve using the binary pixel feature was inttroduced as our first test goal in section 1. For all nine test series, a clear logarithmic course of the aging curve can be seen in figure 2. Theeref the approximation of our aging function is shown too be fore, the basic assumption for valid. We also re-sketched the t experimental aging-curve from the investigations off [2] for comparison (see figure 2). 2
R. Merkel, J. Dittmann, and C. Vielhauer
rel. amount of white (background) pixel
66
1
0.9
fE test series 4 fE test series 6
0.8
fE test series 2 fE test series 5 fE test series 8 fE test series 3 fE test series 9 fE re-sketched from [2]
0.7
fE test series 7
0.6
fE test series 1
0.5 0
20
40 60 time in hours
80
Fig. 2. The experimental aging curves for our nine test series depicting the relative amount of white background pixel in relation to the time passed; the experimental results from [2] are also re-sketched for comparison
The test results show that all experimental aging curves for the binary pixel feature have a logarithmic course and that the biggest changes happen within the first hours. They therefore confirm the results presented in [2] and furthermore show that there are differences in the slopes of the curves. Also, the curves are shifted along the y-axis. This is most likely caused by the different amounts of residue present for the different test series, since different latent fingerprint traces bear different amounts of residue (due to sweat composition, contact pressure when leaving a print, or other influences). Comparing the experimental aging curves of different resolutions and different CWL sensors frome these first experiments, no clear dependency can be found on either the resolution or the used sensor. However, the distortion of some curves (such as the ones from test series 6 and 7 depicted in fig. 2) is much higher than that of others, which seems to be a result of environmental influences (such as temperature, humidity or wind) which can not totally be controlled during our current experiments but should be taken into account in future research. In our second test goal from section 1 we want to approximate the parameters a and b of our formula (7) to calculate and minimise the average error of approximation erravg (see also section 3). For each test series, we have at least 192 tuples tupEi (as calculated in section 4.2), each consisting of a point in time tEi and the corresponding relative amount of white background pixel fE(tEi). The approximation of a and b can be seen as an optimisation problem. More precise, we want to find the minimum value for the average error erravg described by function (7) for varying parameters a and b. We solve this minimisation problem with the help of a computer program, which is systematically varying a and b in steps of 1/10000 in the interval of [0,1] and determines the values of a and b for which erravg is minimal. With the optimised parameters a and b we can approximate the course of
Approximation of a Mathematical Aging Function for Latent Fingerprint Traces
67
the discrete experimental aging curve by our derived continuous mathematical curve (see figure 3). The optimised parameters a and b as well as their corresponding average error erravg are listed in table 2 for all test series.
rel. amount of white (background) pixel
experimental aging curve fE for test series 1 approximated mathematical aging curve fM for test series 1 0.57 0.56 0.55 0.54 0.53 0.52 0.51 0.5 0.49 0
20
40 60 time in hours
80
100
Fig. 3. Exemplary illustration of the experimental aging curve and the approximated mathematical aging curve for the aging feature of counting binary pixel, shown for test series 1. The relative amount of white background pixel is shown in relation to the time passed.
In figure 3 we illustrate for test series 1 that the derived mathematical aging function seems to approximate the average course of the experimental curve very well, leaving offsets (which are probably due to the influence factors described in section 4.1 not being totally constant) of the practically measured white background pixel to both sides of the curve. Table 2. Our experimental test results for the optimized values of the parameters a and b as well as the average error of approximation erravg for all test series Test series number Scanning device resolution Optimal a Optimal b erravg
1
2
3
4
5
6
7
8
9
CWL1 CWL1
CWL1
CWL2 CWL2 CWL2 CWL3 CWL3
CWL3
3µm 5µm 0.0105 0.0093 0.5101 0.8151 0.1437 0.1548
10µm 0.0071 0.7504 0.2006
3µm 5µm 10µm 3µm 5µm 0.0036 0.0112 0.0059 0.0119 0.0079 0.9133 0.7489 0.8764 0.5752 0.7573 0.1689 0.1319 0.3988 0.2991 0.1652
10µm 0.0080 0.7454 0.2580
The test results in table 2 show three findings: a) No clear dependency on either the resolution of a test series or the used sensor within the test range. For neither the parameters a or b, nor the average error of approximation erravg any clear tendency can be extracted, which might be related to the resolution or the used sensor. Therefore, we can assume that the differences in the test results are caused by influences other than the scan influence.
68
R. Merkel, J. Dittman nn, and C. Vielhauer
b) The values of the param meters a and b vary greatly. While the parameter b is dependent on the relative am mount of residue in relation to the overall pixel (as m mentioned earlier) and thereforee is expected to vary in dependence of the fingerprint traace, the high variation in the values v of the parameter a is very challenging to explain. Here, as mentioned already y in section 4.1, changing influences such as the envirronmental influence (e.g. tem mperature, humidity or wind) or the sweat influence ((e.g. the composition of the resid due) might have a strong impact. c) The average error of app proximation erravg takes on values between 13-40% forr all test series. This shows that under the given conditions, even if the optimal values for the parameters a and b can be determined, this error is the best we can get. The reaason for this error might be flucctuations in the amount of white background pixel fE((tEi) measured for a certain poin nt in time tEi, which can be a result of changing influennces (such as temperature chang ges, humidity changes or wind) where slight changes miight be enough to change the deecomposition speed of the fingerprint sample or even aff ffect the sensors capturing characteristics. Therefore, the error might be improved in futture work by taking additional measures to keep all influences more constant or to ttake their changes into account. Of course, if the age of a fingerprint trace is to be deetermined at a crime scene, theese changes of influences might not always be controllaable or reproducible. Furthermore, examining g the error of approximation erri between experimenntal points in time tEi and theirr calculated theoretical equivalents tMi shows varying results. Figures 4 and 5 ex xemplary represent two characteristic tendencies, whhich occurred for the test series. In some cases (see figure 4), the error of approximattion erri is very high in the beginning and decreases over time, whereas in other caases (see figure 5) it is very un npredictable. This confirms the assumption that the errror might be a result of fluctuations in the external influences, since they are expeccted to occur randomly. test series 1
1 0.8 0.6 0.4 0.2 0 0
20
40 60 time in hours
80
1000
Fig. 4. Our experimental resullts for the error of approximation erri between the measured ttime tEi and the mathematically caalculated time tMi’ of a sample in relation to the absolute ttime passed, exemplary shown for test t series 1
Approximation of a Matthematical Aging Function for Latent Fingerprint Traces
69
test series 7
1 0.8 0.6 0.4 0.2 0 0
20
40 60 time in hours
80
1000
Fig. 5. Our experimental resullts for the error of approximation erri between the measured ttime tEi and the mathematically caalculated time tMi’ of a sample in relation to the absolute ttime passed, exemplary shown for test t series 7.
The other test series show w similar tendencies in the progression of their error off approximation if compared to the exemplary depicted ones. Both tendencies occcur nearly equally often among gst the test series.
5 Discussion For our mathematical aging function to be usable in a forensic application scenaario (e.g. at a crime scene), the constant parameters a and b play a major role. If they can be derived correctly, we caan determine the age of a fingerprint with an average errror of approximation erravg of about 13-40%. This can be done by scanning the finggerprint at the crime scene sho ortly after the crime investigation team arrives and witthin the next hours or even days (which is still practical, as our crime scene examiiner contact told us) with the pro oposed surface measurement device using the CWL sensor. Having measured the relative amount of white background pixel fE(tEi), we can eaasily calculate the age of the fin ngerprint by using formula (5). Since erravg only applies to an average case and erri can n be much higher for a single scan, several scans shouldd be carried out and the results should be averaged for a more reliable result. However, the correct ap pproximation of the parameters a and b remains a maajor challenge. To the best of our o knowledge, it is not possible to obtain a and b direcctly from a crime scene withoutt any additional information, regardless of how many sccans are performed. This is duee to the fact that neither the absolute time tEi of a scann is given, nor the parameter a or o the parameter b. It is unlikely that tEi is given at a crime scene (since then the age determinattion would not be necessary). Th herefore, either a or b need to be determined in advancee. If one of the two parameters is known, the other one can be calculated by conductting only two scans of the fingeerprint trace at the crime scene and solving the follow wing system of equations:
70
R. Merkel, J. Dittmann, and C. Vielhauer
,
> 0. ,
> 0,
(8) > 0.
(9)
Using this system of equations, Δt represents the time between the two scans, a or b are given and tMi is to be substituted. If a is given, b can be calculated, if b is given, a can be calculated. Determining the parameter b from a given parameter a solving the system of equations (8)(9) and inserting the corresponding values fE(tE2) for fM(tMi+Δt) and fE(tE1) for fM(tMi) whereas Δt describes the time difference between the two scans Δt=tE2-tE1 results in the following formula: 1
,
> 0,
0.
(10)
With the derived formula (10), the parameter b can be calculated from a given parameter a using at least two scans of the fingerprint trace. Again, in this situation it is recommended to use more than two scans for a better approximation of the average value of the parameters and minimising the influence of outliers. The biggest problem remains the determination of one of the parameters a or b prior to the age determination. Since b is strongly dependent on the amount of residue (as mentioned earlier), it is not possible to determine it in advance. However, it might be possible to determine the value of a by taking all significant influences on the aging process into account. In future work, a generalised table might be created, which assigns certain values to a, according to the temperature, humidity, presence of UV-light or even chemical composition of the fingerprint residue.
6 Conclusions and Future Work In this paper, the novel and very promising aging feature of counting binary pixel was examined in a test set of nine test series and a logarithmic course of its experimental aging curves was reported. A mathematical aging function was approximated for each test series as a continuous representation of the discrete experimental aging curve from the test results, to be used for the age determination of latent fingerprint traces in forensic investigations. The average error of approximation of this function was shown to be 13-40% under the given conditions. No characteristic influence of different resolutions or different sensors of the same model could be extracted within the test range. Possible reasons for the observed errors of approximation as well as prospects and limitations of an application of this function for the age determination of forensic latent fingerprint traces were discussed. In future work, the average error of approximation of the function should further be decreased by taking additional measures to keep the influences on the aging process constant or to take changes of these influences into account. Here, additional studies need to be conducted to distinguish major influences from minor ones. Furthermore, a technique should be investigated and developed for the reliable determination of the parameter a of the proposed aging function prior to the age
Approximation of a Mathematical Aging Function for Latent Fingerprint Traces
71
determination. This might be done by assigning certain values to the parameter depending on the specific characteristics of the present influences. Again, for this task, the significance of these influences needs to be studied further. Acknowledgments. The work in this paper has been funded in part by the German Federal Ministry of Education and Science (BMBF) through the Research Programme under Contract No. FKZ: 13N10816 and FKZ: 13N10818. We also want to thank Anja Bräutigam from the Federal State Police Head Quarters of Saxony-Anhalt and Stefan Gruhn from the Brandenburg University of Applied Sciences for their support in conducting the scans.
References 1. Leich, M., Kiltz, S., Dittmann, J., Vielhauer, C.: Non-destructive forensic latent fingerprint acquisition with chromatic white light sensors. In: Proc. SPIE 7880, 78800S (2011), doi:10.1117/12.872331 2. Hildebrandt, M., Dittmann, J., Pocs, M., Ulrich, M., Merkel, R., Fries, T.: Privacy Preserving Challenges: New Design Aspects for Latent Fingerprint Detection Systems with Contact-Less Sensors for Future Preventive Applications in Airport Luggage Handling. In: Vielhauer, C., Dittmann, J., Drygajlo, A., Juul, N.C., Fairhurst, M.C. (eds.) BioID 2011. LNCS, vol. 6583, pp. 286–298. Springer, Heidelberg (2011) 3. Fries Research Technology (January 19, 2011), http://www.frt-gmbh.com/en/ 4. Popa, G., Potorac, R., Preda, N.: Method for Fingerprints Age Determination (December 6, 2010), http://www.interpol.int/Public/Forensic/fingerprints/ research/AgeDetermination.pdf 5. Stamm, V.: Methoden zur Altersbestimmung daktyloskopischer Spuren. Wiesbaden: 9. Grundlehrgang für daktyloskopische Sachverständige, Hausarbeit (1997) 6. Aehnlich, J.: Altersbestimmung von datkyloskopischen Spuren mit Hilfe der LaserFluoreszenzspektroskopie. Diplomarbeit, Universität Hannover (2001) 7. Baniuk, K.: Determination of Age of Fingerprints. Forensic Science International (46), 133–137 (1990) 8. Stüttgen, G., Ippen, H.: Die normale und pathologische Physiologie der Haut. G. Fischer Verlag, Stuttgart (1965) 9. Liappis, N., Jakel, A.: Free Amino Acids in Human Eccrine Sweat. Arch. Dermatol. Res. 254, 185–203 (1975) 10. Wertheim, K.: Fingerprint Age Determination: Is There Any Hope? Journal of Forensic Identification 53(1), 42–49 (2003) 11. Holyst, B.: Kriminalistische Abschätzung des Spurenalters bei Fingerpapillarlinien. Archiv für Kriminologie, 94–103 (1983) 12. Sampson, M.: Lifetime of a Latent Print on Glazed Ceramic Tile. Journal of Forensic Identification 44(4), 379–386 (1994)
Two-Factor Biometric Recognition with Integrated Tamper-Protection Watermarking Reinhard Huber1 , Herbert St¨ ogner1 , and Andreas Uhl1,2 1 2
School of CEIT, Carinthia University of Applied Sciences, Austria Department of Computer Sciences, University of Salzburg, Austria [email protected]
Abstract. Two-factor authentication with biometrics and smart-cards enabled by semi-fragile watermarking is proposed. Several advantages of the scheme as compared to earlier approaches are discussed and experiments for an iris-based recognition system demonstrate that semi-fragile integrity verification can be provided by the system. This is achieved without impact on recognition performance, since the slight degradation in terms of ROC behavior which is observed on the watermarked sample data is more than compensated by the additionally available template that is transferred from the smart-card to the matching site via watermarking technology.
1
Introduction
Biometric recognition applications become more and more popular. Biometric authentication systems can resolve most of security issues of traditional token-based or knowledge-based authentication systems, since a biometric feature belongs only to one person and cannot be lost or forgotten. But eventually, biometric features can be stolen or adopted and there exist various other ways to circumvent the integrity of a biometric authentication system (see e.g. a corresponding collection of security issues compiled by the UK Government Biometrics Working Group1 ). Recent work systematically identifies security threats against biometric systems and possible countermeasures [15, 16] and e.g. discusses man-in-the-middle attacks and BioPhishing against a web-based biometric authentication system [21]. Among other suggestions to cope with security threats like applying liveness detection or classical cryptographic encryption and authentication techniques, watermarking has been suggested to solve security issues in biometric systems in various ways [5]. Dong et al. [2] try to give a systematic view of how to integrate watermarking into biometric systems in the case of iris recognition by distinguishing whether biometric template data are embedded into some host 1
This work has been partially supported by the Austrian Science Fund, project no. L554-N15. http://www.cesg.gov.uk/policy technologies/biometrics/ media/biometricsecurityconcerns.pdf
B. de Decker et al. (Eds.): CMS 2011, LNCS 7025, pp. 72–84, 2011. c IFIP International Federation for Information Processing 2011
Two-Factor Biometric Recognition
73
data (“template embedding”), or biometric sample data is watermarked by embedding some data into them (“sample watermarking”). One of the application scenarios described in literature involving watermarks actually represents a two-factor authentication scheme [8]: biometric data is stored on a smart-card and the actual biometric data acquired at the sensor is used to verify if the user at the sensor is the legitimate owner of the smart-card. Watermarking is used to embed data of a second modality into the data which is stored on the card (in the reference given, facial data is embedded into fingerprint images and at the access control site, a fingerprint sensor is installed). Therefore, watermarking is employed as a simple means of transportation data of two different modalities in an integrated manner. Obviously, this application scenario represents as well a case of enabling the application of multibiometric techniques by using watermarking techniques, where biometric template data is embedded into biometric sample data (of different modalities) to enable multibiometric fusion. Traditionally, in these schemes two different sensors are used to acquire the data and again, watermarking is used as a transportation tool only. For an overwhelming majority of watermarking-based techniques for these two scenarios (i.e. two-factor authentication with smart-cards and multibiometrics), robust watermarks have been suggested. However, the motivations for applying this specific type of watermarks are not made clear and discussed superficially only, if at all, in most papers. The usage of robust embedding schemes seems to indicate that both data need to be tightly coupled and that the entire transmitted data might be subject to various manipulations, since robust embedding is meant to make the embedded data robust against changes of the host data. Therefore it seems that an insecure channel between sensor and processing module is assumed in this context. In such an environment host data manipulations are to be expected, including even malicious tampering like cropping. In recent work [4] it has been shown that most robust watermarks cannot prevent even a massive tampering attack (i.e. exchanging the entire iris texture) in the context of an iris recognition system with embedded template data. This comes as no surprise since these watermarks are actually designed to be robust against this type of attacks. Obviously, robust watermarking is not the best suited watermarking technology for the purpose it is suggested for in this context. While this specific attack discussed is targeted against the security of robust embedding (and can be resolved by using different types of watermarks as shown in this work), robust watermarking additionally introduces distortions into the sample data impacting on recognition performance [3]. Also for this problem, different types of watermarks may represent better solutions as also covered here. In this paper, we introduce the application of semi-fragile watermarking in the context of a two-factor authentication scheme using iris recognition and smart-cards. Contrasting to most multibiometric approaches, we do not embed template data from a different modality, but the modality of sample data and template data do match. We demonstrate that in addition to enable tightly coupled transport, semi-fragile watermarking can also provide sensitivity against
74
R. Huber, H. St¨ ogner, and A. Uhl
tampering and almost negligible impact on recognition performance. An additional advantage of the proposed scheme is the improved recognition accuracy due to the use of two templates in the matching process and increased security due to the two factor approach in general. Section 2 provides an overview of several techniques how to incorporate watermarking techniques into biometric systems. Emphasis is given to the discussion of several examples of two-factor authentication and multibiometric techniques, which are enabled by embedding template data into sample data using watermarking. In Section 3, we explain and discuss the proposed scheme and present experimental results in Section 4. Section 5 concludes the paper.
2
Watermarking in Biometric Systems
A recent overview on the topic and an extensive literature review is given in [5]. One of the first ideas to somehow combine biometric technologies and watermarking is “biometric watermarking” [18]. The aim of watermarking in this approach is not to improve any biometric system, but to employ biometric templates as “message” to be embedded in classical robust watermarking applications like copyright protection in order to enable biometric recognition after the extraction of the watermark (WM). A second application case for robust WMs is to prevent the use of sniffed sample data to fool the sensor in order to complement or replace liveness detection techniques. During data acquisition, the sensor (i.e. camera) embeds a WM into the acquired sample image before transmitting it to the feature extraction module. In case an intruder interferes the communication channel, sniffs the image data and presents the fake biometric trait (i.e. the image) to the sensor, it can detect the WM, will deduce non-liveness and will refuse to process the data further (see e.g. [1] embedding voice templates into iris sample data). A steganographic approach is to transmit biometric data (i.e. template data) hidden into some arbitrary carrier / host data or biometric samples of different biometric modalities. The idea is to conceal the fact that biometric data transfer takes place, e.g. Jain et al. [6] propose to embed fingerprint minutiae data into an arbitrary host image while Khan et al. [9] suggest to embed fingerprint templates into audio signals. Questions of sensor and sample authentication using watermarks have also been discussed. During data acquisition, the sensor (i.e. camera) embeds a watermark into the acquired sample image before transmitting it to the feature extraction module. The feature extraction module only proceeds with its tasks if the WM can be extracted correctly. For example, fragile watermarking has been suggested to serve that purpose either embedding image-independent [20] or image-dependent data as WM [19]. A significant amount of work has also been published in the area of using WMs to enable a multibiometric approach by embedding a biometric template into a biometric sample of different biometric modalities. There are two variants:
Two-Factor Biometric Recognition
75
First, there are two different sensors acquiring two biometrics traits. Since for one modality template data is embedded, these data need to be generated at the sensor site which makes this approach somewhat unrealistic, at least for low power sensor devices. In addition to that, besides the increased recognition performance of multimodal systems in general there is no further specific gain in security (see for example: Jain et al. [7] embed face data into fingerprint images as well as do Chung et al. [11] and Noore et al. [12]; Park et al. [13] suggest to use robust embedding of iris templates into face image data, etc.). The second variant is to store the template on a smart-card which has to be submitted by the holder at the access control site. The smart-card embeds the template into the host sample data. This in fact represents a two-factor authentication system which increases security by introducing an additional token-based scheme and also leads to higher recognition accuracy as compared to a single biometric modality. With respect to general two-factor authentication schemes, [17] propose to embed additional classical authentication data with robust watermarking into sample data, where the embedded signature is used as an additional security token like a password. Jain and Uludag [8] propose to embed face template data in fingerprint images stored on a smart-card (called scenario 2 in the paper while scenario 1 is a steganographic one). Instead of embedding an additional security token also biometric template data from a second sensor can be embedded – in [14] an encrypted palmprint template is embedded into a fingerprint image, where the key is derived from palmprint classes. Since these additional data are not used in multibiometric fusion but serve as independent second token coming from a second sensor, this approach can be interpreted as being both, a multibiometric recognition scheme or a two factor authentication scheme. The impact of watermarking on the recognition performance of biometric systems has been investigated most thoroughly in the context of iris recognition. While Dong et al. [2] do not report on performance degradations when investigating a single watermark embedding algorithm and one iris recognition technique only, H¨ ammerle et al. [3] find partially significant reductions in recognition accuracy (especially in case of high capacity) when assessing two iris recognition schemes and a couple of robust watermarking algorithms. Similar to the latter results, recognition impact has been observed as well for speech recognition [10] and fingerprint recognition [14].
3
Two-Factor Biometric Recognition: Semi-fragile Template Embedding
We focus on a two-factor authentication scheme based on biometrics and a token, i.e. a smart-card. When a user is enrolled into the system, sample data are acquired, corresponding template data is extracted and stored in two different ways: first, in the centralized biometric database required for the actual recognition process, and second, on the smart-card. In the authentication phase, the
76
R. Huber, H. St¨ ogner, and A. Uhl
smart-card is submitted by the user to the access control site and the sensor acquires “new” sample data. The following actions are performed (Fig. 1 illustrates the scenario): 1. From the acquired sample data, a template is extracted and compared to the template on the smart-card. Only if there is sufficient correspondence, the following stages are conducted subsequently. Note that this is done at the sensor site, so there is no necessity to contact the centralized database. 2. The smart-card embeds its template into the sample data employing a semifragile embedding technique (this template is referred to as “template watermark” subsequently). 3. The data is sent to the feature extraction and matching module. 4. At the feature extraction module, the watermark template is extracted, and is compared to the template extracted from the sample (denoted simply as “template” in the following). In this way, the integrity of the transmitted sample data is ensured when there is sufficient correspondence between the two templates. In case of a biometric system operating in verification mode the template watermark can also be compared to the template in the database corresponding to the claimed identity (denoted “database template” in the following). Note that in the latter case, the correspondence is expected to be higher since the template generated during enrollment has been extracted as template watermark – coming from the smart card – and is also extracted from the database. 5. Finally, in case the integrity of the data has been proven, the template watermark and the template are used in the matching process, granting access if the similarity to the database template is high enough. When comparing this approach to previous techniques proposed in literature, we notice the following differences / advantages: As opposed to techniques employing robust watermarking, the proposed scheme can ensure sample data integrity in addition to enabling tightly coupled transport. As opposed to techniques employing arbitrary (semi-)fragile watermarks for integrity protection (instead of the template watermark used here), there is no need to transmit / store the watermarks at the receiving site for integrity verification. Additionally, the recognition performance is better since two templates can be used in the matching process, one of which eventually identical to the database template. When compared to integrity protection enabled by (robust) digital signatures, our approach offers the advantage of disclosing the location of eventual modification which enables the assessment of the modifications’ significance. Also, the verification data is embedded and does not have to be taken care of separately. Besides, a signature-based scheme cannot provide the functionality of transporting the authentication data stored on the card, it is intrinsically restricted to integrity verification and cannot support the two-factor aspect of the scheme we have introduced here. However, some issues need to be investigated with respect to the proposed scheme (which will be done in the experiments):
Two-Factor Biometric Recognition
77
Fig. 1. Considered application scenario
– How can we construct an actual semi-fragile watermarking technique capable of embedding template data ? – What is the impact of the embedded template watermark on the recognition performance using the template for matching only ? – What is the amount of robustness we can support with a scheme like this (as opposed to a fragile scheme) ? – Does integrity verification indeed work in a robust manner ? – Can biometric matching take advantage of the two different templates available for matching ?
4
Experiments in the Case of Iris Recognition
4.1
Iris Recognition and Iris Databases
The employed iris recognition system is Libor Masek’s Matlab implementation2 of a 1-D version of the Daugman iris recognition algorithm. First, this algorithm 2
http://www.csse.uwa.edu.au/~pk/studentprojects/libor/sourcecode.html
78
R. Huber, H. St¨ ogner, and A. Uhl
segments the eye image into the iris and the remainder of the image. Iris image texture is mapped to polar coordinates resulting in a rectangular patch which is denoted “polar image”. For feature extraction, a row-wise convolution with a complex Log-Gabor filter is performed on the polar image pixels. The phase angle of the resulting complex value for each pixel is discretized into 2 bits. The 2 bit of phase information are used to generate a binary code. After extracting the features of the iris, considering translation, rotations, and disturbed regions in the iris (a noise mask is generated), the algorithm outputs the similarity score by giving the Hamming distance between two extracted templates. The sensible range of the Hamming distance reaches from zero (ideal matching of two iris images of the same person) to 0.5 (ideal mismatch between two iris images of different persons). The following three datasets are used in the experiments: CASIAv3 Interval database3 consists of 2639 images with 320 × 280 pixels in 8 bit grayscale .jpeg format, out of which 500 images have been used in the experiments. MMU database4 consists of 450 images with 320×240 pixels in 24 bit grayscale .bmp format, all images have been used in the experiments. UBIRIS database5 consists of 1876 images with 200×150 pixels in 24 bit colour .jpeg format, out of which 318 images have been used in the experiments. All intra-class and inter-class matches possible with the selected respective image sets have been conducted to generate the experimental results shown. 4.2
The Watermarking Scheme
As the baseline system, we employ the fragile watermarking scheme as developed by Yeung et. al and investigated in the context of fingerprint recognition [20]. For this algorithm, the watermark embedded is binary and padded to the size of the host image. Subsequently, the WM is embedded into each pixel according to some key information. As a consequence, the WM capacity is 89600, 76800, and 30000 bits for CASIAv3, MMU, and UBIRIS, respectively. Fig. 1 shows PSNR values averaged over all images embedding 10 randomly generated WM into each image. Obviously, the quality of the images remains very high after embedding, especially with enabled error diffusion which is therefore used in all subsequent experiments. In Figure 2 we display tampering localization examples of the original fragile scheme. Fig. 2.b shows a doctored image corresponding to images as used in the attack in [4] – the attack is clearly revealed and the location is displayed in exact manner. As expected, when applying compression to the image with JPEG quality 75%, the WM indicates errors across the entire image (except for the pupil area which is not affected by compression due to its uniform grayscale) as shown in Fig. 2.f. 3 4 5
http://www.cbsr.ia.ac.cn/IrisDatabase.htm/ http://pesona.mmu.edu.my/~ccteo/ http://www.di.ubi.pt/~hugomcp/investigacao.htm
Two-Factor Biometric Recognition
79
Table 1. PSNR without and with error diffusion
PSNR [dB] PSNR with ED [dB]
CASIAv3 MMU UBIRIS 48.07 43.22 47.69 49.57 44.57 49.16
(a) original
(b) replaced iris
(c) compressed image
(d) original watermark
(e) WM of (b)
(f) WM of (c)
Fig. 2. Tamper localization of the original Yeung scheme
Since this technique is a fragile WM scheme, no robustness against any image manipulations can be expected of course. Table 2 demonstrates this property by displaying averaged bit error rates (BER) computed between original and extracted WMs for a subset of 100 images with randomly generated WMs. As can be observed, there is a certain amount of robustness against noise and JPEG compression with quality 100. For the other attacks, the BER of 0.5 indicates that the extracted WMs are purely random and therefore entirely destroyed by the attack. So far, randomly generated WM with size identical to the images have been embedded. The usually smaller size of biometric templates can be exploited to embed the template in redundant manner, i.e. we embed the template several times as shown in Fig. 3.a. After the extraction process, all template watermarks are used in a majority voting scheme which constructs a “master” template watermark as shown in Fig. 3.b. We expect to result in higher robustness leading to an overall semi-fragile WM scheme for the template WMs. In our implementation, the iris code consists of 9600 bits, therefore, we can embed 9, 8, and 3 templates into images from the CASIAv3, MMU, and UBIRIS databases, respectively.
80
R. Huber, H. St¨ ogner, and A. Uhl Table 2. BER for six different attacks Attack CASIAv3 MMU UBIRIS Mean filtering 0.50 0.50 0.50 Gaussian Noise N = 0.0005 4.6 · 10−5 5.6 · 10−5 6.1 · 10−5 Gaussian Noise N = 0.001 0.03 0.03 0.03 JPEG Q100 0.05 0.06 0.05 JPEG Q95 0.43 0.45 0.45 JPEG Q75 0.49 0.50 0.50
(a) redundant embedding
(b) majority voting
Fig. 3. The semi-fragile Yeung scheme
4.3
Experimental Results
In Table 3 we show results for the robustness tests when applied to the database images with redundantly embedded template watermarks. When compared to Table 2, we clearly observe improved robustness against noise insertion and moderate JPEG compression. It can be clearly seen that with an increasing amount of redundancy, robustness is improved which is to be expected due to the more robust majority decoding (please recall, that for CASIAv3 redundancy is maximal among the three datasets). In interesting question is the extent of influence an embedded watermark has on the recognition performance of the system. In Fig. 4 we compare ROC curves of the original data and ROC curves of sample data with embedded WMs in the latter case, the average of ten embedded WMs is shown. While for the CASIAv3 and MMU there is hardly a noticeable impact, we notice significant result degradation in the case of the UBIRIS dataset. A possible explanation for this effect is the already low quality of this dataset, in case of additional degradation results get worse quickly, while for the other datasets there is still room for slight quality reduction since the original quality is very high. The situation changes when it comes to additional distortions: As shown in Table 4, also in the case of the CASIAv3 we notice some impact on recognition performance with embedded WMs as compared to the original sample data without WMs embedded. Beside the EER, we show FRR (for F AR = 10−3 ) and FAR (for F RR = 5 · 10−3 ). It is interesting to see that mean filtering and moderate JPEG compression can even improve the recognition results of the data
Two-Factor Biometric Recognition
81
Table 3. BER for seven different attacks Attack CASIAv3 MMU UBIRIS Mean filtering 0.50 0.50 0.50 Gaussian Noise N = 0.0005 0 0 0 Gaussian Noise N = 0.001 0 0 0.003 JPEG Q100 0 0 0.01 JPEG Q99 0 0.01 0.05 JPEG Q98 0.08 0.14 0.22 JPEG Q95 0.35 0.40 0.43
(a) CASIAv3
(b) MMU
(c) UBIRIS
Fig. 4. ROC curves for the sample data with random embedded WMs and without
without WM embedded – this effect is due to the denoising capabilities of mean filtering and compression. In any case, we notice a slight result degradation for the variant with embedded WMs. Finally, we want to consider the question in how far matching between template WM and database template(s) is influenced by attacks, i.e. we investigate robustness of the embedded template WM. The corresponding information can be used to assess the integrity of the data, i.e. in case a sufficient high degree of correspondence between those templates is observed, the integrity of the sample data is proven. We consider the case that 5 different templates are stored in the database out of which a single database template is generated by majority coding like explained before in the case of the template WM (compare Figure 3.b). Table 5 shows the BER for the different attacks considered. A typical decision threshold for the iris recognition system in use is at a BER ranging in [0.3, 0.35]. When taking this into account, we realize that integrity verification in our technique is indeed robust against moderate JPEG compression and noise. On the other hand, mean filtering and JPEG compression at quality 95% destroys the template WM and indicates modification. The distribution of incorrect bits can be used to differentiate between malicious attacks (where an accumulation of incorrect bits can be observed in certain regions, compare Fig. 2.e) and significant global distortions like compression (compare Fig. 2.f).
82
R. Huber, H. St¨ ogner, and A. Uhl Table 4. ROC behavior under different attacks ERR FRR FAR CASIAv3 no attack original template watermark mean filter original template watermark JPEG Q98 original template watermark UBIRIS no attack original template watermark Gaussian Noise N = 0.001 original template watermark JPEG Q95 original template watermark
0.045 0.048 0.035 0.044 0.037 0.049
0.091 0.081 0.061 0.063 0.074 0.086
0.650 0.742 0.644 0.669 0.626 0.617
0.032 0.046 0.038 0.049 0.036 0.045
0.062 0.071 0.068 0.073 0.066 0.070
0.764 0.865 0.871 0.868 0.838 0.975
Table 5. BER for seven different attacks Attack No attack Mean filtering Gaussian Noise N = 0.0005 Gaussian Noise N = 0.001 JPEG Q100 JPEG Q99 JPEG Q98 JPEG Q95
5
CASIAv3 MMU UBIRIS 0.21 0.49 0.21 0.21 0.21 0.21 0.25 0.41
0.23 0.50 0.23 0.23 0.23 0.24 0.30 0.45
0.19 0.50 0.19 0.19 0.19 0.22 0.32 0.45
Conclusion
In this paper we have introduced a two-factor authentication system using biometrics and a token-based scheme, e.g. a smart-card. Semi-fragile WM is used to embed the template data stored on the smart-card into the sample data acquired at the authentication site. We have discussed certain advantages of the approach as compared to earlier work and have shown experimentally in the case of an iris recognition system, that indeed semi-fragile integrity verification is achieved using the proposed approach. Care has to be taken in the actual biometric matching process since contrasting to claims in literature recognition performance of the templates extracted from watermarked sample data suffers degradation to some minor extent. However, this can more than compensated by the additional template watermark which should be involved in matching as well.
Two-Factor Biometric Recognition
83
References [1] Bartlow, N., Kalka, N., Cukic, B., Ross, A.: Protecting iris images through asymmetric digital watermarking. In: IEEE Workshop on Automatic Identification Advanced Technologies, vol. 4432, pp. 192–197. West Virginia University, Morgantown (2007) [2] Dong, J., Tan, T.: Effects of watermarking on iris recognition performance. In: Proceedings of the 10th International Conference on Control, Automation, Robotics and Vision (ICARCV 2008), pp. 1156–1161 (2008) [3] H¨ ammerle-Uhl, J., Raab, K., Uhl, A.: Experimental study on the impact of robust watermarking on iris recognition accuracy (best paper award, applications track). In: Proceedings of the 25th ACM Symposium on Applied Computing, pp. 1479– 1484 (2010) [4] H¨ ammerle-Uhl, J., Raab, K., Uhl, A.: Attack against robust watermarking-based multimodal biometric recognition systems. In: Vielhauer, C., Dittmann, J., Drygajlo, A., Juul, N.C., Fairhurst, M.C. (eds.) BioID 2011. LNCS, vol. 6583, pp. 25–36. Springer, Heidelberg (2011) [5] H¨ ammerle-Uhl, J., Raab, K., Uhl, A.: Watermarking as a means to enhance biometric systems: A critical survey. In: Ker, A., Craver, S., Filler, T. (eds.) IH 2011. LNCS, vol. 6958, pp. 238–254. Springer, Heidelberg (2011) [6] Jain, A.K., Uludag, U.: Hiding fingerprint minutiae in images. In: Proceedings of AutoID 2002, 3rd Workshop on Automatic Identification Advanced Technologies, Tarrytown, New York, USA, pp. 97–102 (March 2002) [7] Jain, A.K., Uludag, U., Hsu, R.L.: Hiding a face in a fingerprint image. In: Proceedings of the International Conference on Pattern Recognition (ICPR 2002), Quebec City, Canada, pp. 756–759 (August 2002) [8] Jain, A.K., Uludag, U.: Hiding biometric data. IEEE Transactions on Pattern Analysis and Machine Intelligence 25(11), 1494–1498 (2003) [9] Khan, M.K., Xie, L., Zhang, J.S.: Robust hiding of fingerprint-biometric data into audio signals. In: Lee, S.-W., Li, S.Z. (eds.) ICB 2007. LNCS, vol. 4642, pp. 702–712. Springer, Heidelberg (2007) [10] Lang, A., Dittmann, J.: Digital watermarking of biometric speech references: impact to the eer system performance. In: Delp, E.J., Wong, P.W. (eds.) Proceedings of SPIE, Security, Steganography, and Watermarking of Multimedia Contents IX, vol. 6505, p. 650513 (2007) [11] Moon, D.-s., Kim, T., Jung, S.-H., Chung, Y., Moon, K., Ahn, D., Kim, S.-K.: Performance evaluation of watermarking techniques for secure multimodal biometric systems. In: Hao, Y., Liu, J., Wang, Y.-P., Cheung, Y.-m., Yin, H., Jiao, L., Ma, J., Jiao, Y.-C. (eds.) CIS 2005, Part II. LNCS (LNAI), vol. 3802, pp. 635–642. Springer, Heidelberg (2005) [12] Noore, A., Singh, R., Vatsa, M., Houck, M.M.: Enhancing security of fingerprints through contextual biometric watermarking. Forensic Science International 169, 188–194 (2007) [13] Park, K.R., Jeong, D.S., Kang, B.J., Lee, E.C.: A Study on Iris Feature Watermarking on Face Data. In: Beliczynski, B., Dzielinski, A., Iwanowski, M., Ribeiro, B. (eds.) ICANNGA 2007. LNCS, vol. 4432, pp. 415–423. Springer, Heidelberg (2007) [14] Rajibul, M.I., Shohel, M.S., Andrews, S.: Biometric template protection using watermarking with hidden password encryption. In: Proceedings of the International Symposium on Information Technology 2008 (ITSIM 2008), pp. 296–303 (2008)
84
R. Huber, H. St¨ ogner, and A. Uhl
[15] Ratha, N.K., Connell, J.H., Bolle, R.M.: Enhancing security and privacy in biometrics-based authentication systems. IBM Systems Journal 40(3), 614–634 (2001) [16] Roberts, C.: Biometric attack vectors and defenses. Computers & Security 26, 14–25 (2007) [17] Satonaka, T.: Biometric watermark authentication with multiple verification rule. In: Proceedings of the 12th IEEE Workshop on Neural Networks in Signal Processing, pp. 597–606 (2002) [18] Vielhauer, C., Steinmetz, R.: Approaches to biometric watermarks for owner authentification. In: Proceedings of SPIE, Security and Watermarking of Multimedia Contents III, San Jose, CA, USA, vol. 4314 (January 2001) [19] Wang, D.-S., Li, J.-P., Hu, D.-K., Yan, Y.-H.: A novel biometric image integrity authentication using fragile watermarking and Arnold transform. In: Li, J.P., Bloshanskii, I., Ni, L.M., Pandey, S.S., Yang, S.X. (eds.) Proceedings of the International Conference on Information Computing and Automatation, pp. 799–802 (2007) [20] Yeung, M.M., Pankanti, S.: Verification watermarks on fingerprint recognition and retrieval. Journal of Electronal Imaging, Special Issue on Image Security and Digital Watermarking 9(4), 468–476 (2000) [21] Zeitz, C., Scheidat, T., Dittmann, J., Vielhauer, C.: Security issues of internetbased biometric authentication systems: risks of man-in-the-middle and BioPhishing on the example of BioWebAuth. In: Delp, E.J., Wong, P.W., Dittmann, J., Nemon, N.D. (eds.) Proceedings of SPIE, Security, Forensics, Steganography, and Watermarking of Multimedia Contents X, vol. 6819, pp. 0R-1–0R12 (2008)
Feature Selection by User Specific Feature Mask on a Biometric Hash Algorithm for Dynamic Handwriting Karl Kümmel, Tobias Scheidat, Christian Arndt, and Claus Vielhauer Brandenburg University of Applied Sciences, P.O. Box 2132, 14737 Brandenburg, Germany {kuemmel,scheidat,arndtch,claus.vielhauer}@fh-brandenburg.de
Abstract. One of the most important requirements on a biometric verification system, beside others (e.g. biometric template protection), is a high user authentication performance. During the last years a lot of research is done in different domains to improve user authentication performance. In this work we suggest a user specific feature mask vector MV applied on a biometric hash algorithm for dynamic handwriting to improve user authentication and hash generation performance. MV is generated using an additional set of reference data in order to select/deselect certain features used during the verification process. Therefore, this method is considered as a simple feature selection strategy and is applied for every user within the system. In our first experiments we evaluate 5850 raw data samples captured from 39 users for five different semantics. Semantics are alternative written content to conceal the real identity of a user. First results show a noticeable decrease of the equal error rate by approximately three percentage points for each semantic. Lowest equal error rate (5.77%) is achieved by semantic symbol. In the context of biometric hash generation, the reproduction rates (RR) increases by an average of approx. 26%, whereas the highest RR (88.46%) is obtained by semantic symbol along with a collision rate (CR) of 5.11%. The minimal amount of selected features during the evaluation is 81 and the maximum amount is 131 (all available features). Keywords: biometrics, dynamic handwriting, biometric hashing, user bitmask, feature selection.
1 Introduction Today, biometric user authentication is an important field in IT security. It relies on individual biological or behavioral characteristics of a person. The purpose of a generic biometric system is to identify and/or verify a person’s identity based on at least one biometric modality (i.e. fingerprint, iris, voice). For all biometric systems, it is crucial to protect the biometric reference data (template) in order to avoid misuse of individual and personal data. However, biometric templates cannot be easily protected by common cryptographic hash algorithms, like they are used in ordinary password authentication systems. The biometric intra-class variability has to be taken into account to ensure reproducibility and protection of a template. The problem of biometric template protection is a frequently discussed issue in biometrics [1]. One possibility to ensure reproducibility and simple template protection is for example the B. de Decker et al. (Eds.): CMS 2011, LNCS 7025, pp. 85–93, 2011. © IFIP International Federation for Information Processing 2011
86
K. Kümmel et al.
Biometric Hash algorithm for dynamic handwriting introduced in [2]. The aim of this method is to transform intra-subject biometric data, into stable and individual hash vector values; an overview is given in section 2. In this work we focus on the authentication performance and robustness of this particular biometric hash algorithm. During the last years a lot of research in almost every biometric authentication algorithm and modality is done to improve user authentication performance. Hollingsworth et al. introduce in [4] a method where potential fragile iris code bits are masked to increase the separation between the match and non-match distributions in iris based authentication systems. Fratric et al. propose in [5] a method of feature extraction from face images to improve recognition accuracy. They use a so-called local binary linear discriminant analysis (LBLDA), which combines the good characteristics of both LDA and local feature extraction methods. Biometric fusion is another technique to improve user authentication performance. Rathgeb et al. describe in [6] a generic fusion technique for iris recognition at bit-level (called Selective Bit Fusion) to improve accuracy and processing time. Another method, besides many others, is the improvement of the authentication performance by determination of useful features during a feature selection process. In this context, useful features are features which positively affect the user authentication and biometric hash generation performance. Kumar et al. show in [7] that an evaluation and selection of useful biometric features can improve the recognition accuracy. They used a correlation based feature selection (CFS) for bimodal biometric systems and analyzed the classification performance. Makrushin et al. compare in [8] different feature selection strategies to determine sophisticated features. It has been shown that forward and backward selection algorithms have always better results than considered heuristics. In this work we suggest a much simpler way of feature selection as described in [8]: We apply a user specific feature mask on a biometric hash algorithm for dynamic handwriting to select and/or deselect specific features in order to improve the authentication performance as well as the generation of stable individual biometric hashes. The structure of the paper is composed as follows. In section 2 we give an overview on the Biometric Hash algorithm for dynamic handwriting. A simple user specific feature mask generation method is introduced in section 3. Experimental results are shown and discussed in section 4. In the last section we present a conclusion and our future work based on the findings.
2 Biometric Hash Algorithm The Biometric Hash algorithm for dynamic handwriting (hereafter BioHash) is initially introduced by Vielhauer et al. in [2] and enhanced in [3]. During the enrollment process the BioHash algorithm generates a so-called Interval Matrix IM for each user. The IM is based on raw data of the writer and several parameters. The raw data of each dynamic handwriting sample consists of a time dependent sequence of physical values derived from a digitizer device (e.g. Tablet PC, signature tablet). Generally, there are five values per sample point: pen tip positions x(t) and y(t), pen tip pressure p(t) and pen orientation angles altitude Φ(t) and azimuth Θ(t). From each raw data sample derived from a person during the enrollment process, a statistical
Feature Selection by User Specific Feature Mask on a Biometric Hash Algorithm
87
feature vector (static and dynamic features) is calculated with a dimensionality of k (k=131 in the implementation used in this paper). The IM consists of a vector containing the length of a mapping interval for each feature and an offset vector. Both vectors are calculated based on an analysis of intra-class variability of the user using his/her statistical feature vectors. There are two possibilities to parameterize the hash generation by scaling the mapping intervals stored in the IM: Tolerance Vector TV and Tolerance Factor TF. The aim of the TV is to provide a scaling of the mapping interval of each statistical feature separately. Thus, the dimensionality of TV is also k. TV can be calculated individually for each user or globally by a group of users, e.g. either based on all or a selection of enrolled persons, but also on a disjoint group. In contrast to the Tolerance Vector, the Tolerance Factor TF is a global hash generation parameter, which is a scalar value. Using the TF, it is possible to scale the mapping intervals for all features globally by the same factor. Based on one statistical feature vector derived from the enrollment data and the users’ individual IM the so-called interval mapping function determines the reference hash vector bref of a user. Therefore, the feature dependent interval lengths and offsets provided by IM are used to map each of the k statistical features to the corresponding hash value. Each further biometric hash is calculated in the same manner, independently if it is used for biometric verification or hash generation application. For verification, the hash vector b derived from the currently presented handwriting sample is compared against the reference hash vector bref by some distance measurement. For more details of the single calculation steps, the interested reader is referred to reference [2].
3 User Specific Feature Mask Generation In addition to the reference BioHash vector bref and the corresponding Interval Matrix IM, we generate a k dimensional (k=131) feature mask vector MV for each user. MV is created during the feature selection process after the enrollment. The main idea of creating a feature mask vector is to select or deselect specific features. If a bit is set to 1, the represented feature is considered during the verification process and if it is set to 0, it is not taken into account. This method allows an uncomplicated user specific enabling or disabling of used features. 3.1 Selection Strategy A user specific feature mask vector MV is generated using the reference BioHash vector bref and corresponding IM. Furthermore, raw data samples s0, s1, …, sn, which are not used during the enrollment process, are required. The identifier n represents the maximum amount of used samples. The feature selection (MV generation) is done in three steps. Firstly, the k-dimensional feature vectors fv0, fv1, …, fvn are determined from all raw data samples s0, s1, …, sn. Secondly, feature vectors of each user are mapped to the biometric hash vectors b0, b1, …, bn using the reference Interval Matrix IM of this specific user. In the last step the feature mask vector MV is generated for each user. Therefore a element-wise comparison is done using the reference BioHash bref and BioHashes b0, b1, …, bn of the specific user. If a certain number of values at
88
K. Kümmel et al.
position i is equal, the corresponding i-th bit of MV is set to 1; otherwise it is set to 0. We define a so-called similarity threshold ths as the maximum number of allowed differences between the i-th element of the hashes. If ths is set to 0, all values have to be equal; if ths set to 1, only one different value is allowed and so on. In the end, the result of the MV generation is a k-dimensional feature mask vector MV. The MV is a new part of the reference data (template) and is therefore stored together with the corresponding Interval Matrix IM and BioHash bref, for example in a database or on a Smart Card. In our first implementation we only generate the MV once for each user during the enrollment process. Figure 1 exemplarily shows the MV generation using only three short BioHashes (b1, b2 and b3) to demonstrate the procedure. In this example we use a threshold ths of 0 and the character “∧” (logical conjunction) represents the element-wise comparison between the three vectors. 24
26
24
0
13
13
13
1
113
117
117
0
309 5
ޔ
309 5
ޔ
309 5
=
1 1
710
710
710
1
81
83
84
0
28
28
28
1
b1
b2
b3
MV
Fig. 1. Example of MV generation during the enrollment process
3.2 Feature Mask Vector and Verification During a regular verification without feature mask vector consideration, the hash vector bcur derived from the currently presented handwriting sample is compared against the reference hash vector bref by some distance measurement. In the current configuration, we use the Hamming Distance combined with the feature mask vector as measurement. If two k-dimensional BioHashes bref and bcur are compared using the Hamming Distance, an intermediate result in terms of a k-dimensional bit vector HV is calculated. The number of all ones inside this vector is equal to the Hamming Distance of the two k-dimensional vectors bref and bcur. In order to include the feature selection results stored inside the feature mask vector MV, a k-dimensional vector HVMV is calculated by determining the result of the AND (logical conjunction) operation of the two vectors MV and HV. In the end, the Hamming Distance of bref and bcur, considering the feature mask vector MV, is the sum of all ones of the HVMV vector. Therefore, the maximum Hamming Distance value depends not only on the
Feature Selection by User Specific Feature Mask on a Biometric Hash Algorithm
89
dimensionality of a vector but also on the number of ones of the feature mask vector. Figure 2 shows the effect of the MV during the verification process; only short BioHashes are used to demonstrate the procedure. The result of this simple example, calculating the Hamming Distance of bref and bcur using the MV, is HDMV = 1. 5
4
1
1
0
0
7
7
0
0
1
0
17
17
0
0
0
0
0
0
1
1
41 2
⊕
41 3
=
ޔ
1 1
=
0 1
103
103
0
0
1
0
8
9
1
1
0
0
13
13
0
0
1
0
bcur
bref
HV
HV
MV
ҿ
HDMV = 1
HVMV
Fig. 2. Example of MV used during the verification process
4 Experimental Evaluation In this section we show our first experiments on applying a user specific feature mask vector on the Biometric Hash algorithm for dynamic handwriting. Our goal is to compare performance of user authentication and biometric hash generation of the algorithm with and without a feature mask vector. In this section, first we define experimental settings. Secondly, we introduce our methodology to provide a comparative study of the achieved results. Thirdly, experimental results are presented and discussed. 4.1 Experimental Settings The biometric database of our initial tests consists of 39 subjects, which have donated 30 handwriting samples in three sessions with an interval of at least one month between two sessions. Within a session a user provides 10 handwritten samples for five different semantics (5850 test samples overall). These semantics are “Free chosen Pseudonym” (pseudonym), “Free chosen Symbol” (symbol), “Answer to the Question: Where are you from?” (place), “Fixed 5 digit PIN: 77993” (public PIN) and “Free chosen 5 digit PIN” (secret PIN). It has been observed in [2] that semantics produce similar recognition accuracy compared to handwriting signatures, without disclosing the true identity of the writer. All samples were captured under laboratory conditions using a Toshiba M200 Portege tablet PC. The handwriting samples acquired during the first session are used as enrollment data in order to determine the reference
90
K. Kümmel et al.
BioHash bref as well as to generate the Interval Matrix IM. The samples of the second session are used for tuning of the Tolerance Factor TF and feature selection in terms of feature mask vector calculation. Finally, the data collected within the third session are used for evaluation. An attempt of one user to be verified as another one is considered as an imposter trial. Each test implies 390 genuine trials, where reference data of a user is matched against its own verification data (39 user times 10 test samples) and 14,820 imposter trials, where reference data of a user is matched against all other verification data except its own (38 user claims times 39 actual users times 10 test samples). Within the feature extraction process of the BioHash algorithm 131 features are calculated based on the handwritten samples. 4.2 Methodology In our first test we compare the performance of the BioHash algorithm with and without a user specific feature mask vector. Therefore, biometric error rates FRR/FAR, and EER are calculated for both settings. The false rejection rate (FRR) describes the ratio between the number of false rejections of authentic persons and the total number of tests. The FAR (false acceptance rate) is the ratio between number of false acceptances of non-authentic persons and the entire number of authentication attempts. For a comparative analysis of the verification performance, the equal error rate (EER) is a common measurement in biometrics. EER denotes the point in error characteristics, where FRR and FAR yield identical value. We also evaluate the reproducibility rate (RR) and collision rate (CR) for both settings; these values are related sums of identical reproduced hashes in genuine and imposter trials (see [9]). Because of the reciprocal effect of RR and CR, a tuning of the system to improve RR leads to a degradation of CR and vice versa. Therefore, the collision reproduction rate (CRR, [8]) is selected as a hash generation quality criterion. The CRR is defined in the following equation, whereas CR and RR are weighted equally. CRR =
1 (CR + (1 − RR)) 2
(1)
The tolerance vector TV is set to (1, …, 1) since all features are considered equally. Thus, the tolerance factor (TF) is the main parameter for controlling CR and RR. In previous work [8] we already determined tolerance factor values of the same evaluation data for two scenarios, lowest EER (EER mode) and highest RR (CRR mode), in all semantics. According to these results of the previous test, based on all 131 features, the TF values are set as shown in table 1. Table 1. Tolerance factor (TF) values used during the evaluation Semantic Public PIN Secret PIN Pseudonym Symbol Place
TF in CRR mode 1.50 1.75 2.50 3.50 2.50
TF in EER mode 1.00 1.00 1.25 1.50 1.25
Feature Selection by User Specific Feature Mask on a Biometric Hash Algorithm
91
Feature mask vectors are generated for each user in all semantic classes separately, as described in section 3.2, using the evaluation data of the second session. During the MV generation, only if all values at a specific position i are equal, then MVi is set to 1. Therefore the similarity threshold ths is set to 0. The minimal, average and maximal amounts of selected features are determined to show how many features are actually used during the verification or hash generation process. Note that the evaluation protocol leads to a realistic scenario since the reference data has already undergone an aging of at least 2 month compared to the evaluation data. In our first evaluation we do not consider the slightly increased computational effort which is caused by the MV calculation during the enrollment (MV creation) and verification. Compared to the feature extraction processing time it is negligible. 4.3 Experimental Results Table 2 shows EERs of all semantics with and without use of the user specific feature mask vector MV. The results point out that the EER decreases approximately by three percentage points in all semantic classes when the user specific feature mask vector MV is applied. The lowest EER is obtained by the semantic symbol and is marked in bold letters (5.77%). Semantic public PIN obtains the highest EER (12.86%), which might be caused due to the same written content of all users. Table 2. Equal error rates (EER) of all semantic classes with and without applied MV
No MV MV
Public PIN 16.55 % 12.86 %
Secret PIN 13.42 % 10.86 %
Pseudonym 10.96 % 6.58 %
Symbol 8.30 % 5.77 %
Place 9.79 % 7.09 %
Collision reproduction rates (CRR), reproduction rates (RR) and collision rates (CR) for all semantics (with and without MV) are shown in table 3. First results indicate that for all semantics the CRR decreases when a MV is applied. Therefore, the reproduction rate increases as well as the collision rate. A maximum reproduction rate (RR) of 88.46% is obtained by the semantic symbol with a collision rate (CR) of 5.11%. An average RR increase of approx. 26% is observed for all semantics, whereas the largest increase is obtained by semantic public PIN (from 48.72% up to 71.03%). Table 3. Collision reproduction rates (CRR), reproduction rates (RR) and collision rates (CR) of all semantic classes with and without user specific feature mask vector MV Semantic Public PIN Secret PIN Pseudonym Symbol Place
CRR 27.81% 24.27% 18.57% 11.19% 19.15%
No MV RR 48.72% 55.64% 66.67% 82.31% 65.38%
CR 4.33% 4.18% 3.79% 4.70% 3.68%
CRR 18.15% 16.76% 10.59% 8.33% 10.22%
MV RR 71.03% 73.33% 83.85% 88.46% 84.87%
CR 7.33% 6.84% 5.03% 5.11% 5.31%
92
K. Kümmel et al.
Table 4 shows the minimal, average and maximal amount of selected features represented by the feature mask vector in each semantic class for both scenarios (verification and hash generation mode). The minimal amount (81) of features used during a verification process is obtained by semantic secret PIN within the EER mode. In CRR mode the number of used features is always higher than in EER mode. The average amount of selected features over all semantics in EER mode is 122 and in CRR mode 128. Table 4. Minimal, average and maximal amount of selected features for each semantic in both scenarios (verification and hash generation mode)
Mode Min. Avg. Max.
Public PIN EER CRR 86 96 120 125 130 131
Secret PIN EER CRR 100 81 120 128 130 131
Pseudonym EER CRR 103 116 122 128 131 131
Symbol EER CRR 103 116 125 129 131 131
Place EER CRR 103 121 122 128 131 131
5 Conclusion and Future Work In this work we introduce a simple feature selection method applied on a biometric hash algorithm for dynamic handwriting. A generated user specific feature mask vector MV is used to switch specific features on or off, which are used during the verification or hash generation process. By analyzing the results, we come to a first conclusion that the application of feature mask vector MV leads to improved recognition accuracy. In our tests, the equal error rates (EER) decreases in all semantics noticeable by approximately three percentage points. Furthermore, the reproducibility of generated biometric hashes increases in all tests considerable. The average increase of the reproduction rate (RR) is approx. 26%, whereas the highest RR was achieved by the semantic symbol (88.46%) and the highest rise of the RR (from 48.72% up to 71.03%) was reached by the semantic public PIN. These results show that a simple feature selection strategy is able to substantial increase the biometric hash generation as well as the user authentication performance. In future work we will verify our first results by using additional test subjects and study the effects on a non-binary MV. A dynamic adaption of the MV is also considered in future works, where the MV is adapted after each successful verification attempt. Due to the reduction of relevant features to a specific user, caused by the feature mask vector MV; we will investigate the security issue on this side effect. Especially the advantages an attacker gains if he/she is in possession of a MV and reference data will be studied. The side effect also leads to reduced entropy and therefore to a potential reduction of a cryptographic key length, if the generated biometric hash is used as a basis for cryptographic key generation. Acknowledgments. This work is supported by the German Federal Ministry of Education and Research (BMBF), project “OptiBioHashEmbedded” under grant number 17N3109. The content of this document is under the sole responsibility of the authors. We also like to thank Prof. Jana Dittmann of the Otto-von-Guericke University Magdeburg and the StepOver GmbH for supporting the project “OptiBioHashEmbedded”.
Feature Selection by User Specific Feature Mask on a Biometric Hash Algorithm
93
References 1. Jain, A.K., Nandakumar, K., Nagar, A.: Biometric Template Security. In EURASIP Journal on Advances in Signal Processing, Article ID 579416 (2008) 2. Vielhauer, C.: Biometric User Authentication for IT Security: From Fundamentals to Handwriting. Springer, New York (2006) 3. Vielhauer, C., Steinmetz, R., Mayerhöfer, A.: Biometric Hash based on Statistical Features of Online Signature. In: Proc. of the Intern. Conf. on Pattern Recognition (ICPR), Quebec City, Canada, vol. 1 (2002) 4. Hollingsworth, K.P., Bowyer, K.W., Flynn, P.J.: The best bits in an iris code. IEEE Trans. on Pattern Analysis and Machine Intelligence 31(6), 964–973 (2009) 5. Fratric, I., Ribaric, S.: Local binary LDA for face recognition. In: Vielhauer, C., Dittmann, J., Drygajlo, A., Juul, N.C., Fairhurst, M.C. (eds.) BioID 2011. LNCS, vol. 6583, pp. 144– 155. Springer, Heidelberg (2011) 6. Rathgeb, C., Uhl, A., Wild, P.: Combining Selective Best Bits of Iris-Codes. In: Vielhauer, C., Dittmann, J., Drygajlo, A., Juul, N.C., Fairhurst, M.C. (eds.) BioID 2011. LNCS, vol. 6583, pp. 127–137. Springer, Heidelberg (2011) 7. Kumar, A., Zhang, D.: Biometric recognition using feature selection and combination. In: Kanade, T., Jain, A., Ratha, N.K. (eds.) AVBPA 2005. LNCS, vol. 3546, pp. 813–822. Springer, Heidelberg (2005) 8. Makrushin, A., Scheidat, T., Vielhauer, C.: Handwriting biometrics: Feature selection based improvements in authentication and hash generation accuracy. In: Vielhauer, C., Dittmann, J., Drygajlo, A., Juul, N.C., Fairhurst, M.C. (eds.) BioID 2011. LNCS, vol. 6583, pp. 37–48. Springer, Heidelberg (2011) 9. Scheidat, T., Vielhauer, C., Dittmann, J.: Advanced studies on reproducibility of biometric hashes. In: Schouten, B., Juul, N.C., Drygajlo, A., Tistarelli, M. (eds.) BioID 2008. LNCS, vol. 5372, pp. 150–159. Springer, Heidelberg (2008)
Dynamic Software Birthmark for Java Based on Heap Memory Analysis Patrick P.F. Chan, Lucas C.K. Hui, and S.M. Yiu Department of Computer Science The University of Hong Kong, Pokfulam, Hong Kong {pfchan,hui,smyiu}@cs.hku.hk
Abstract. Code theft has been a serious threat to the survival of the software industry. A dynamic software birthmark can help detect code theft by comparing the intrinsic characteristics of two programs extracted during their execution. We propose a dynamic birthmark system for Java based on the object reference graph. To the best of our knowledge, it is the first dynamic software birthmark making use of the heap memory. We evaluated our birthmark using 25 large-scale programs with most of them of tens of megabytes in size. Our results show that it is effective in detecting partial code theft. No false positive or false negative were found. More importantly, the birthmark remained intact even after the testing programs were obfuscated by the state-of-the-art Allatori obfuscator. These promising results reflect that our birthmark is ready for practical use. Keywords: software birthmark, software protection, code theft detection, Java.
1
Introduction
Over the years, code theft has been an issue that keeps threatening the software industry. From time to time, there are cases brought to the court about software license violation. For example, a former Goldman Sachs programmer was found guilty of code theft recently [19]. The software being stolen was for making fast trades to exploit tiny discrepancies in price. Such trading was the core source of revenue of that firm. Various software protection techniques have been proposed in the literature. Watermarking is one of the well-known and earliest approaches to detect software piracy in which a watermark is incorporated into a program by the owner to prove the ownership of it [9,7]. Although it cannot prevent software theft, it provides proof when legal action against the thief is needed. However, it is believed that “a sufficiently determined attacker will eventually be able to defeat any watermark” [8]. Watermarking also requires the owner to take extra action (embed the watermark into the software) prior to releasing the software. Thus, some existing Java developers do not use watermarking, but try to obfuscate their source code before publishing. Code obfuscation is a semantics-preserving B. de Decker et al. (Eds.): CMS 2011, LNCS 7025, pp. 94–107, 2011. c IFIP International Federation for Information Processing 2011
Dynamic Software Birthmark for Java Based on Heap Memory Analysis
95
transformation of the source code that makes it more difficult to understand and reverse engineer [10]. However, code obfuscation only prevents others from learning the logic of the source code but does not hinder direct copying of them. On the other hand, the thief may further obfuscate the source code rendering code theft detection difficult. Thus, code obfuscation may not be a good mean to prevent software copying. A relatively new but less popular software theft detection technique is software birthmark. Software birthmark does not require any code being added to the software. It depends solely on the intrinsic characteristics of two programs to determine the similarity between them [23,17,20,15,22,14,10,18]. It was shown in [17] that a birthmark could be used to identify software theft even the embedded watermark had been destroyed by code transformation. According to Wang et al. [23], a birthmark is a unique characteristic a program possesses that can be used to identify the program. There are two categories of software birthmarks, static birthmarks and dynamic birthmarks. Static birthmarks are extracted from the syntactic structure of programs [22,18,13]. Dynamic birthmarks are extracted from the dynamic behavior of programs at run-time [23,17,20,15,14]. The usual method to destroy the birthmark and prevent discovery of code theft is by obfuscating the program. Since semantics-preserving transformations like code obfuscation only modify the syntactic structure of a program but not the dynamic behavior of it, dynamic birthmarks are more robust against them. Existing dynamic birthmarks make use of the complete control flow trace or API call trace obtained during the execution of a program [23,17,20,15,14]. Birthmarks based on control flow trace are still vulnerable to obfuscation attack such as loop transformation. The ones based on API call trace may suffer from not having enough API calls to make the birthmark unique. In this paper, we propose a novel dynamic birthmark, which we call object reference graph (ORG) birthmark, based on the unique characteristics of a program extracted from the heap memory at run-time. The heap memory is a location in the memory in which dynamically created objects are stored. The core idea of the proposed ORG birthmark is that the referencing structure represented by the object reference graph reflects the unique behavior of a program. An object reference graph is a directed graph. The nodes represent objects and the edges represent the referencing between the objects. They are independent of the syntactic structure of the program code and hence, are not to be changed by semantics-preserving code transformations. Although it is likely that software developed for the same purpose have similar dynamic behaviors, they may not have the same objects referencing structure. For example, a programmer may decide to put the file I/O instructions in a separate class for easier maintenance while others may not. We implemented a library theft detection system exploiting the ORG birthmark to justify this idea. The goal of the system is to detect if a library L is used by a software S. The first phase of the system dumps out the heap during the execution of the software S. The second phase of the system builds ORGs out of
96
P.P.F. Chan, L.C.K. Hui, and S.M. Yiu
the heap dumps. Finally, the system searches the ORGs to see if the ORG birthmark for library L, ORGBL , can be found by exploiting a subgraph isomorphism algorithm. Note that to extract the birthmark for library L, we need a software that is known to be using library L. From it, we build the object reference graph with respect to L by focusing only on those objects defined in that library. As classes from the same library often have the same prefix in their names, we can identify them by a prefix match of their names. We evaluated our ORG birthmark system using 25 large-scale Java programs with most of them of tens of megabytes in size. During the evaluation, our birthmark system successfully detected 2 libraries in the testing programs. This shows that our system is effective in identifying library theft and is able to distinguish programs developed for the same purpose. To test the robustness of the system against semantics-preserving code transformation, we obfuscated the programs with the state-of-the-art Allatori obfuscator. After that, the system could still successfully detect the 2 libraries in the obfuscated programs. This shows that our system is robust against semantics-preserving code transformation. The rest of the paper is structured as follows. In section 2, we explore the existing works in the literature. The definitions are given in section 3. In section 4, we formulate the threat model in which our system is designed. We provide the design details and evaluation results in section 5 and 6. Further discussion is covered in section 7 and section 8 concludes.
2
Related Work
Software birthmark is different from software watermarking in twofold. First, it is solely the characteristics of a program but not an identifier purposely embedded into the program. Therefore, even though the author of a program was not aware of software piracy when he released the program, a software birthmark can still be extracted from the program to help identify the copying of his program. Second, a birthmark cannot prove the authorship of a program. It can only suggest that a program is a copy of another program. In practice, it is used to collect some initial evidences before taking further investigations. Software birthmarks are further divided into static birthmarks and dynamic birthmarks. Static birthmarks (e.g. [22,18,13]) are extracted from the syntactic structure of a program and can be destroyed by semantics-preserving transformations. The trend of software birthmark research is going towards the direction of dynamic birthmarks. The rest of this section will discuss a few pieces of latest work on dynamic birthmarks. The first dynamic birthmark was proposed by G. Myles and C. Collberg [17]. They exploited the complete control flow trace of a program execution to identify the program. They showed that their technique was more resilient to attacks by semantics-preserving transformations than published static techniques. However, their work is still susceptible to various loop transformations. Moreover, the whole program path traces are large and make the technique not scalable.
Dynamic Software Birthmark for Java Based on Heap Memory Analysis
97
Tamada et al. proposed two kinds of dynamic software birthmarks based on API calls [15]. Their approach was based on the insights that it was difficult for adversaries to replace the API calls with other equivalent ones and that the compilers did not optimize the APIs themselves. Through analyzing the execution order and the frequency distribution of the API calls, they extracted dynamic birthmarks that could distinguish individually developed same-purpose applications and were resilient to different compiler options. Schuler et al. proposed a dynamic birthmark for Java that relies on how a program uses objects provided by the Java Standard API [20]. They observed short sequences of method calls received by individual objects from the Java Platform Standard API. By chopping up the call trace into a set of short call sequences received by API objects, it was easier to compare the more compact call sequences. Evaluation performed by the authors showed that their dynamic birthmark solution could accurately identify programs that were identical to each other and differentiate distinct programs. Their API birthmark is more scalable and more resilient than the WPP Birthmark proposed by Myles and Collberg [17]. Wang et al. proposed system call dependence graph (SCDG) based software birthmark called SCDG birthmark [23]. An SCDG is a graph representation of the dynamic behavior of a program, where system calls are represented by vertices, and data and control dependences between system calls are represented by edges. The SCDG birthmark is a subgraph of the SCDG that can identify the whole program. They implemented a prototype of SCDG birthmark based software theft detection system. Evaluation of their system showed that it was robust against attacks based on different compiler options, different compilers and different obfuscation techniques.
3
Problem Definitions
The section first provides the definition of dynamic birthmarks to ease further discussion. We borrow part of the definition from Tamada et al [15]. They are the first formal definition appearing in the literature and have been restated in subsequent papers related to dynamic software birthmark. After that, the formal definition of an ORG birthmark is introduced. 3.1
Software Birthmarks
A software birthmark is a group of unique characteristics extracted from a program that can uniquely identify the program. There are two categories of software birthmarks: static birthmarks and dynamic birthmarks. We focus on dynamic birthmarks in this research. Dynamic Birthmarks. A dynamic birthmark is one that is extracted when the program is executing. It relies on the run-time behavior of the program. Therefore, semantics-preserving transformations of the code like obfuscation cannot defeat dynamic birthmarks. Dynamic birthmarks are more robust compared with static birthmarks.
98
P.P.F. Chan, L.C.K. Hui, and S.M. Yiu
Definition 1. (Dynamic Birthmark) Let p, q be two programs or program components. Let I be an input to p and q. Let f (p, I) be a set of characteristics extracted from p when executing p with input I. f (p, I) is a dynamic birthmark of p only if both of the following criteria are satisfied: 1. f (p, I) is obtained only from p itself when executing p with input I 2. program q is a copy of p ⇒ f (p, I) = f (q, I) This definition is basically the same as that of static birthmarks except that the birthmark is extracted with respect to a particular input I. 3.2
ORG Birthmark
Before we give the definition of ORG birthmark, we need to define what is an object reference graph (ORG). An ORG is a directed graph representation of the structure formed between objects through object referencing. A node represents an object while an edge represents a field of one object referring to another. Objects instantiating the same class are grouped together and are denoted by one node. All the referencing made by this group of objects is represented by the out-going edges from that node. Multiple referencing to the same class of objects by this group of objects is represented by a single edge. We ignore any self-referencing as that can be exploited by an attacker to defeat the birthmark easily. We now give the formal definition of ORG. Definition 2. (ORG: Object Reference Graph) The object reference graph of a program run is a 2-tuple graph ORG = (N, E), where – N is a set of nodes, and a node n ∈ N corresponds to a class with non-zero number of instantiations – E ∈ N × N is the set of references between objects, and each edge n1 → n2 ∈ E corresponds to one or more references from any field of any objects instantiating the class represented by node n1 to any other objects instantiating the class represented by n2 . There is no duplicated edge between two nodes. Figure 1 shows an example ORG for 4 objects instantiating 3