Kensho Yamamoto, Toshio Hirotsu · 2022
Cloud storage is a common platform for multiple users to share data over the Internet. It offers a huge storage capacity at low cost and an easy-to-access interface for all users. However, data protection is considered to be an issue, especially for highly secret information. Users usually trust cloud storage providers who do not leak information, but the administrator and tools they use can access arbitrary storage data. One approach against these problems is encrypting files stored in cloud storage. Using encryption, files are kept confidential, but this requires a complicated procedure and understanding of some specific level of cryptography. In this paper, we propose a secure cloud filesystem that enables files to be encrypted and decrypted transparently when storing to or extracting from the filesystem. Each file is protected using a key-based encryption mechanism, and the keys are also stored on the cloud filesystem in secure indexed with the pathname of the target files. This enables users to easily use secure cloud storage that maintains confidentiality and share data using multiple cloud storages without the users needing special knowledge on encryption.
Cited by 3
Michael Austin Halcrow · 2008
Securing file resources under Linux is a team effort. No one library, application, or kernel feature can stand alone in providing robust security. Current Linux access control mechanisms work in concert to provide a certain level of security, but they depend upon the integrity of the machine itself to protect that data. Once the data leaves that machine, or if the machine itself is physically compromised, those access control mechanisms can no longer protect the data in the filesystem. At that point, data privacy must be enforced via encryption. As Linux makes inroads in the desktop market, the need for transparent and effective data encryption increases. To be practically deployable, the encryption/decryption process must be secure, unobtrusive, consistent, flexible, reliable, and efficient. Most encryption mechanisms that run under Linux today fail in one or more of these categories. In this paper, we discuss solutions to many of these issues via the integration of encryption into the Linux filesystem. This will provide access control enforcement on data that is not necessarily under the control of the operating environment. We also explore how stackable filesystems, Extended Attributes, PAM, GnuPG web-of-trust, supporting libraries, and applications (such as GNOME/KDE) can all be orchestrated to pro-
Cited by 0
Andreas Joachim Peters · CERN Document Server (European Organization for Nuclear Research) · 2022
<!--HTML-->With XRootD5 the on the wire protocol provides confidentiality of data inside the transport layer. However data files are human readable on storage nodes and can be accessed and downloaded by any EOS administrator and any person with read access. Filesystem level encryption on storage nodes does not solve this confidentiality problem. To provide better data privacy the most recent versions of EOS support client and server side high-performance obfuscation and (with certain limitations) data encryption. The presentation will explain opportunities, challenges and limitations of the implementation.
Cited by 0
Peters, Andreas Joachim · CERN Document Server (European Organization for Nuclear Research) · 2022
<!--HTML-->With XRootD5 the on the wire protocol provides confidentiality of data inside the transport layer. However data files are human readable on storage nodes and can be accessed and downloaded by any EOS administrator and any person with read access. Filesystem level encryption on storage nodes does not solve this confidentiality problem. \nTo provide better data privacy the most recent versions of EOS support client and server side high-performance obfuscation and (with certain limitations) data encryption. The presentation will explain opportunities, challenges and limitations of the implementation.
Cited by 0
Md Raz, P. V. Sai Charan, P. Krishnamurthy et al. · ArXiv.org · 2025
Ransomware's escalating sophistication necessitates tamper-resistant, off-host detection solutions that capture deep disk activity beyond the reach of a compromised operating system. Existing detection systems use host/kernel signals or rely on coarse block-I/O statistics, which are easy to evade and miss filesystem semantics. The filesystem layer itself remains underexplored as a source of robust indicators for storage-controller-level defense. To address this, we present SHIELD: a Secure Host-Independent Extensible Metric Logging Framework for Tamper-Proof Detection and Real-Time Mitigation of Ransomware Threats. SHIELD parses and logs filesystem-level features that cannot be evaded or obfuscated to expose deep disk activity for real-time ML-based detection and mitigation. We evaluate the efficacy of these metrics through experiments with both binary (benign vs. malicious behavior) and multiclass (ransomware strain identification) classifiers. In evaluations across diverse ransomware families, the best binary classifier achieves 97.29% accuracy in identifying malicious disk behavior. A hardware-only feature set that excludes all transport-layer metrics retains 95.97% accuracy, confirming feasibility for FPGA/ASIC deployment within the storage controller datapath. In a proof-of-concept closed-loop deployment, SHIELD halts disk operations within tens of disk actions, limiting targeted files affected to <0.4% for zero-shot strains at small action-windows, while maintaining low false-positive rates (<3.6%) on unseen benign applications. Results demonstrate that filesystem-aware, off-host telemetry enables accurate, resilient ransomware detection, including intermittent/partial encryption, and is practical for embedded integration in storage controllers or alongside other defense mechanisms.
Cited by 0Open access
Winter, Mike, Garnett, Alex, Simpson, Justin · Open Science Framework · 2018
Computing checksums to prevent bit rot is accepted wisdom in the digital preservation community. Yet in other domains, this wisdom is approached quite differently. New hashing algorithms continue to be developed in the cryptography community, typically with very different use cases in mind, focusing on encryption and security over integrity or identification. Checksumming is also a key feature of modern filesystems. The implementers of these filesystems concern themselves with block-level integrity, rather than focus on ‘files’ or objects in the way digital preservation systems do. Cloud-based object storage systems also compute checksums, providing integrity guarantees as part of the service. And there is the blockchain - distributed peer to peer systems where hashing is fundamental. How do we reconcile these different approaches to bit-level preservation using checksums? Can we compare the costs, in terms of compute resources or time, of the different approaches? Is there a way to verify the accepted wisdom of the digital preservation community and reconcile this with the diverse and expanding approaches to checksum validation? This paper describes how checksumming functionality is understood and implemented in modern filesystems. A cost analysis is presented, comparing different approaches to data integrity, including pure CPU checksumming with tools such as md5sum, the block-level metadata used by filesystems such as ZFS, and the contrast with data integrity done by cloud service providers’ object storage services. From this analysis we describe the benefits of developing a new standard for mapping the block-level metadata produced by filesystem checksum reporting tools to the file-centered checksum reporting and validation required for adherence to current expectations of accepted digital preservation best practices. By better understanding different approaches to data integrity, it is possible to make better use of the computer hardware dedicated to digital preservation, taking advantage of the increased computational efficiency of filesystem-level checksumming techniques. This work closes a gap between current best practices in digital preservation and in high-performance computing. Sample code paths for working with and validating block checksums are also demonstrated.
Cited by 0Open access
Michael B. Jones · 1991
Many contemporary operating systems utilize a system call interface between the operating system and its clients. Increasing numbers of systems are providing low-level mechanisms for intercepting and handling system calls in user code. Nonetheless, they typically provide no higher-level tools or abstractions for effectively utilizing these mechanisms. Using them has typically required reimplementation of a substantial portion of the system interface from scratch, making the use of such facilities unwieldy at best.I am currently constructing an object-oriented toolkit which substantially increases the ease of interposing user code between clients and instances of the system interface by allowing such code to be written in terms of the high-level objects provided by this interface, rather than in terms of the intercepted system calls themselves. This toolkit helps enable new interposition agents to be written which otherwise would not have been attempted.I am also currently using this toolkit to construct several agents including: protected environments for running untrusted binaries, modified filesystem namespaces, logical devices implemented entirely in user space, transparent network data compression and/or encryption agents, and system call tracing tools. Examples of other interesting agents which could be built include: transactional software environments, and emulators for other operating system environments.
Cited by 0
Arash Mahboubi, Seyit Camtepe, Keyvan Ansari et al. · Journal of Information Security and Applications · 2024
Understanding the attributes of critical data and implementing suitable security measures help organisations bolster their data-protection strategies and diminish the potential impacts of ransomware incidents. Unauthorised extraction and acquisition of data are the principal objectives of most cyber invasions. We underscore the severity of this issue using a recent attack by the Clop ransomware group, which exploited the MOVEit Transfer vulnerability and bypassed network-detection mechanisms to exfiltrate data via a Command and Control server. As a countermeasure, we propose a method called Buffer-Based Signature Verification (BBSV). This approach involves embedding 32-byte tags into files prior to their storage in the cloud, thus offering enhanced data protection. The BBSV method can be integrated into software like MOVEit Secure Managed File Transfer, thereby thwarting attempts by ransomware to exfiltrate data. Empirically tested using a BBSV prototype, our approach was able to successfully halt the encryption process for 80 ransomware instances from 70 ransomware families. BBSV not only stops the encryption but also prevents data exfiltration when data are moved or written from the original location by adversaries. We further develop a hypothetical exploit scenario in which an adversary manages to bypass the BBSV, illicitly transmits data to a Command and Control server, and then removes files from the original location. We construct an extended state space, in which each state represents a tuple that integrates user authentication and system components at the filesystem level.
Cited by 2Open access
Vikram Patalbansi, G. Prasanna Laxmi · Journal of University of Shanghai for Science and Technology · 2021
The ubiquitous network like Mobile Cloud Computing (MCC) provides a high quality of wireless services depending upon the wireless communication system network security level. And so many researches are carried out by the researcher on security algorithms for wireless communication system constructed in different network reliability. In our proposed thesis paper, on a theoretical basis, we developed the theory of MCC Security Layer Protocol security system in which we used the cryptographic hash function SHA-256 to generate a private key for entities, RC5 encryption, and decryption algorithm, Temporal Key Integrity Protocol (TKIP) generating a dynamic sequential key and CRC-32 checksum to detecting the error in our packets. The MSLP uses the stored symmetric secret key calculated on the basis of the Diffie-Hellman Key sharing scheme to generate keystream for cryptography functions. The secret key stored in the device’s filesystem our database prior to the deployment on Mobile Cloud Computing and remains the same throughout the session of communication. These systems use the dynamic initialization vector to avoid reply attacks and message integrity code calculated on source and destination devices addresses and actual frame contents. In the proposed thesis paper we analyze the security measures at the MSLP level and before transmitting information over the mobile networks, the information is encrypted in the form of frames and at the physical layer, this frame converted into its equivalent radio signals.
Cited by 0Open access
Greenspan, Derrick Alex · Journal of International Crisis and Risk Communication Research · 2024
Persistent memory (PM) is expected to augment or replace DRAM as main memory. PM combines byte-addressability with non-volatility, providing an opportunity to host byte-addressable data persistently. There are two main approaches for utilizing PM: either as memory mapped files or as persistent memory objects (PMOs). Memory mapped files require that programmers reconcile two different semantics (file system and virtual memory) for the same underlying data, and require the programmer use complicated transaction semantics to keep data crash consistent. To solve this problem, the first part of this dissertation designs, implements, and evaluates a new PMO abstraction that addresses these problems by hosting data in pointer-rich data structures without the backing of a filesystem, and introduces a new primitive, psync, that when invoked renders data crash consistent while concealing the implementation details from the programmer via shadowing. This new approach outperforms a state-of-the-art memory mapped design by 3.2 times depending on the workload. It also addresses the security of at-rest PMOs, by providing for encryption and integrity verification of PMOs. To do this, it performs encryption and integrity verification on the entire PMO, which adds an overhead of between 3-46% depending on the level of protection. The second part of this dissertation demonstrates how crash consistency, security, and integrity verification can be conserved while the overall overhead is reduced by decrypting individual memory pages instead of the entire PMO, yielding performance improvements compared to the original whole PMO design of 2.62 times depending on the workload. The final part of this dissertation improves the performance of PMOs even further by mapping userspace pages to volatile memory and copying them into PM, rather than directly writing to PM. Bundling this design with a stream buffer predictor to decrypt pages into DRAM ahead of time improves performance by 1.9 times.
Cited by 0Open access
James C. Drennan · OhioLink ETD Center (Ohio Library and Information Network) · 2011
Data is becoming much more portable these days with thumb drives and smart phones that can easily have gigabytes of storage.While the portability and ease of transfer of this data is beneficial, it can cause problems when it is lost or stolen.Traditionally securing data on a storage device is achieved using data encryption techniques.This can be accomplished using an encrypted filesystem such as TrueCrypt or some on-device encryption scheme such as that performed by IronKey's secure flash memory devices.This thesis explores an alternate technique to secure data within a storage device.More precisely, a technique to authenticate each I/O (Input/Output) request issued to the storage device is explored.The device authenticates requests and responds to the request only when the authentication step succeeds.While authentication can occur with each request and is valid only for the individual request, various alternate configurations are possible where authentication is performed for various subsets of the requests.For example, authentication can be enforced only for data reads, data writes, for specific (block) address regions, and so on.For requests that fail authentication, the device may be configured with a number of response mechanisms.While these responses can be virtually anything, some notable response actions would be to: (i) act as a faulty device, (ii) respond with fake data (possibly from some onboard response prepared storage area), or (iii) destroy/erase the stored data rendering the data completely unavailable.Depending on the level of security desired, these failure modes can be temporary or permanent.Lastly, this approach can decouple the act of building an authenticable I/O request from the host and storage devices.More specifically, the I/O requests can be transmitted from the host to a third party for translation to an authenticable form.The third party could be an online server system or a nearby bluetooth device.Thus, a lost or stolen device is decoupled from the platform that builds authenticable requests thereby disabling access to the information stored in a lost device.i
Cited by 0Open access
Greve, Lukas · TIB KMO / FLOWWORKS GmbH · 2022
Most Linux distributions are not designed to support desktop virtualization, and GPU vendors have failed to agree on a common way to let virtual machines access 3D capabilities (SR-IOV; vfio-pci; vfio-mdev or virtio-gpu...). The result is that it is still complicated to create fast and responsive virtual machines locally. Phyllome OS is a Fedora Remix based on Fedora Server which attempts to make it easier to run virtual machines locally on computers that support hardware-assisted virtualization, using mostly paravirtualization (aka virtio-devices). It currently relies on existing technologies (libvirt; KVM/QEMU; virt-manager; GNOME Shell; etc), but will eventually implement its own virtual machine manager, package the cloud hypervisor as an alternative to QEMU, and use filesystem-level encryption to protect virtual machines disks. The main idea behind this OS is to treat the host, Phyllome OS, as a read-only system, i.e. as a mere appliance to host virtual machines. The presentation will give a demonstration of Phyllome OS in its current state. Despite steady progress, especially on the KVM/QEMU front, desktop virtualization today still leaves much to be desired when it comes to usability. For most users, it is still complicated to create virtual machines with advanced media capabilities, including 3D acceleration. 3D-accelerated guests are a must-have nowadays and most desktop environments leverage it to provide a smooth user experience. Existing approaches attempting to grant 3D capabilities to virtual machines are not straightforward, sometimes incompatible and often require trade-offs between usability, performance and security. As a result, a successful implementation on a single host typically requires careful considerations and is often hardware-dependent. For instance, passing through real hardware to a virtual machine using vfio-pci is only possible if the piece of hardware is well-isolated in a single IOMMU group. Paravirtualization, on the other hand, and especially virtio-gpu, promises to be hardware-independent but is not (yet?) supported by all modern guest operating systems. What if an operating system was designed to provide the best experience regardless of the guest operating system in use?
Cited by 0Open access
Ilya Dubinsky · Auerbach Publications eBooks · 2023
Although cryptography plays an essential part in most modern solutions, especially in payments, cryptographic algorithms remain a black box for most users of these tools. Just as a sane backend developer does not drill down into low-level disk access details of a server filesystem, payments professionals have enough things to worry about before they ever need to bother themselves with debugging an encrypted value or a message digest. However, at a certain point, an engineer faces the need to identify a problem with a particular algorithm or, perhaps, to create a testing tool that would simulate a counterpart in a protocol that involves encryption. The world of cryptography has moved on with giant leaps. Available technical standards mention acronyms and link to more standards, some of which are very large while others are not available for free. After finding the standards for the algorithm, the specific mode of operation must also be identified. Most implementations use several cryptographic primitives—for example, key derivation with a block cipher, which produces a secret that is used together with a hash function and a double padding scheme to produce a digital signature of a base64-encoded value. Understanding this requires more sifting through online sources, more reading of platform and library documents, and finally, when some code can be written, there are very few test cases to validate it. Cryptography for Payment Professionals is intended for technical people, preferably with some background in software engineering, who may need to deal with a cryptographic algorithm in the payments realm. It does not cover the payment technology in-depth, nor does it provide more than a brief overview of some regulations and security standards. Instead, it focuses on the cryptographic aspects of each field it mentions. Highlights include: Major cryptographic algorithms and the principles of their operation Cryptographic aspects of card-present (e.g., magnetic stripe, EMV) and online (e.g., e-Commerce and 3DS 2.0) transactions A detailed description of TDES DUKPT and AES DUKPT protocols, as well as an example implementation and test cases for both It is best if the reader understands programming, number and string representations in machine memory, and bit operations. Knowledge of C, Python, or Java may make the examples easier to read but this is not mandatory. Code related to the book is available at the author’s GitHub site: https://github.com/ilya-dubinsky/cfpp
Cited by 1