Reviewerly/exHarmony huggingface dataset:
On Adaptively Secure Prefix Encryption Under LWE

Prefix Encryption is a public-key encryption scheme, where ciphertexts are associated with a string y and secret keys are associated with a string x. Any secret key for which x is a prefix of y can decrypt a ciphertext associated with x. Secret keys are issued by a trusted authority, that publishes a set of public parameters used for encryption and decryption. Prefix encryption was formalized in a work of Lewko and Waters (EUROCRYPT'14) to show that certain partitioning proof techniques fail to achieve adaptive security without an exponential loss in the security reduction. This loss requires a stronger security assumption to achieve adaptive security, which is undesirable. Prefix encryption can be constructed from Hierarchical Identity-Based Encryption (HIBE) or Attribute-Based Encryption (ABE), which implies that the same partitioning techniques must incur an exponential loss in the security reduction when applied to HIBE and ABE. While it remains a long-standing open problem to achieve adaptive security with a polynomial reduction loss for HIBE or ABE under LWE, the same work showed how to obtain adaptively secure prefix encryption from adaptively secure Identity-Based Encryption. In this work, we give a construction of an adaptively secure prefix encryption scheme with a polynomial reduction loss, directly from LWE. To encrypt to a string y we derive a public key for every prefix of y from a fixed set of public parameters using lattice-based homomorphic operations, similar to previous work. Our approach differs in the secret key generation, where a secret key for x takes into account and ties together every prefix of x, and our techniques may be of independent interest. This leaves open the possibility for the secret keys to be extended in a way that could lead to adaptive security of delegation functionalities, in the future. For security, we leverage a work of Tsabary (CRYPTO'19) and extend it to obtain our result.
Single Instance Self–masking via Permutations

Self–masking allows the masking of success criteria, part of a problem instance (such as the sum in a subset-sum instance) that restricts the number of solutions. Self–masking is used to prevent the leakage of helpful information to attackers; while keeping the original solution valid and, at the same time, not increasing the number of unplanned solutions. Self–masking can be achieved by xoring the sums of two (or more) independent subset sum instances [4, 5], and by doing so, eliminate all known attacks that use the value of the sum of the subset to find the subset fast, namely, in a polynomial time; much faster than the naive exponential exhaustive search. We demonstrate that the concept of self–masking can be applied to a single instance of the subset sum and a single instance of the permuted secret-sharing polynomials. We further introduce the benefit of permuting the bits of the success criteria, avoiding leakage of information on the value of the i'th bit of the success criteria, in the case of a single instance, or the parity of the i'th bit of the success criteria in the case of several instances. In the case of several instances, we permute the success criteria bits of each instance prior to xoring them with each other. One basic permutation and its nesting versions (e.g., $$\pi ^i$$ ) are used, keeping the solution space small and at the same time, attempting to create an "all or nothing" effect, where the result of a wrong $$\pi $$ trials does not imply much.
Fast ORAM with Server-Aided Preprocessing and Pragmatic Privacy-Efficiency Trade-Off

Data-dependent accesses to memory are necessary for many real-world applications, but their cost remains prohibitive in secure computation. Prior work either focused on minimizing the need for data-dependent access in these applications, or reduced its cost by improving oblivious RAM for secure computation (SC-ORAM). Despite extensive efforts to improve SC-ORAM, the most concretely efficient solutions still require $$\approx $$ 0.7 s per access to arrays of $$2^{30}$$ entries. This plainly precludes using MPC in a number of settings. In this work, we take a pragmatic approach, exploring how concretely cheap MPC RAM access could be made if we are willing to allow one of the participants to learn the access pattern. We design a highly efficient Shared-Output Client-Server ORAM ( $$\textsf {SOCS}\hbox {-}\textsf {ORAM}$$ ) that has constant overhead, uses one round-trip of interaction per access, and whose access cost is independent of array size. $$\textsf {SOCS}\hbox {-}\textsf {ORAM}$$ is useful in settings with hard performance constraints, where one party in the computation is more trust-worthy and is allowed to learn the RAM access pattern. Our $$\textsf {SOCS}\hbox {-}\textsf {ORAM}$$ is assisted by a third helper party that helps initialize the protocol and is designed for the honest-majority semi-honest corruption model. We implement our construction in C++ and report its performance. For an array of length $$2^{30}$$ with 4B entries, we communicate 13B per access and take essentially no overhead beyond network latency.
Evaluating the Robustness of Automotive Intrusion Detection Systems Against Evasion Attacks

This paper discusses the robustness of machine learning-based intrusion detection systems (IDSs) used in the Controller Area Networks context against adversarial samples, inputs crafted to deceive the system. We design a novel methodology to deploy evasion attacks and address the domain-specific challenges (i.e., the time-dependent nature of automotive networks) discussing the problem of performing online attacks. We evaluate the robustness of state-of-the-art IDSs on a real-world dataset by performing evasion attacks. We show that, depending on the targeted IDS and the degree of the attacker's knowledge, our approach achieves significantly different evasion rates.
Improving Performance in Space-Hard Algorithms

Protecting secret keys from malicious observers is a major problem for cryptographic algorithms in untrusted environments. White-box cryptography suggests hiding the key in the cipher code with an appropriate method such that extraction of the key becomes impossible in the white-box settings. The key is generally embedded into the confusion layer with suitable methods. One of them is using encoding techniques. Nevertheless, many encoding methods are vulnerable to algebraic attacks and side-channel analysis. Another is the space hardness concept, which creates large lookup tables that cannot be easily extracted from the device. In (M,Z)-space hard algorithms, the secret key is embedded in large tables created as a substitution box with a suitable block cipher. So the key extraction problem in the white-box settings turns into a key recovery problem in the black-box case. One of the main issues in (M,Z)-space hard algorithms is accelerating the run-time of the black-box/white-box implementation. In this study, we aim to use the advantage of the efficiency of lightweight components to speed up the diffusion layer of white-box algorithms without decreasing the security size. Therefore, we compare the linear components of NIST Lightweight Standardization candidates for efficiency and suitability to white-box settings in existing space hard ciphers. The performance results of the algorithms are compared with WARX and SPNbox-32. According to the results, using the lightweight components in the diffusion layer accelerates the performance of white-box algorithms by at least nine times.
A New Interpretation for the GHASH Authenticator of AES-GCM

AES-GCM authenticated encryption scheme has a significant role in modern secure communications. It combines AES CTR encryption with authentication that is based on a polynomial evaluation hash function (GHASH) computed in $$ \mathbb {F}_{2^{128}} [x] {\Big /}\texttt {P}_{{\tiny \texttt {GCM}}}(x)$$ , where $$\texttt {P}_{{\tiny \texttt {GCM}}}(x)= x^{128} + x^7 + x^2 + x + 1$$ . AES-GCM operates on 128-bit strings: it views them as AES inputs/outputs for the encryption, and as elements in $$ \mathbb {F}_{2^{128}}$$ for the authentication. Unfortunately, the order of the bits, by which GHASH parses 128-bit strings as field elements is inconsistent with the way that AES uses 128-bit ciphertext/plaintext strings as arrays of 16 bytes. This leads to one of the following conclusions: a) GHASH does not operate directly on the ciphertext blocks. In this case, AES ciphertext blocks need to be bit-reflected before they are input to the GHASH computations; b) the field representation is not $$ \mathbb {F}_{2^{128}} [x] {\Big /}\texttt {P}_{{\tiny \texttt {GCM}}}(x)$$ . In this case, field multiplications are not directly expressed by polynomial arithmetic modulo $$\texttt {P}_{{\tiny \texttt {GCM}}}(x)$$ . The specification AES-GCM bypasses this discrepancy by describing the GHASH field operations as bit-level algorithms, rather than in terms of polynomial arithmetic, as expected. We resolve the inconsistency by introducing a description of GHASH that uses polynomial arithmetic in $$\mathbb {{G}}= \mathbb {F}_{2^{128}} [x] {\Big /}\left( x^{128} + x^{127} + x^{126} + x^{121} + 1 \right) $$ . This formulation helps parsing 128-bit strings as AES inputs/outputs and as field elements, in a consistent manner. It also leads naturally to several recent AES-GCM software optimizations which are now already in use by leading open source cryptographic libraries.
The Use of Performance-Countersto Perform Side-Channel Attacks

Performance and power counters were invented to allow optimizing applications, but they can also be used to expose private information about the system and the user that uses it; thus, they have the potential to become a major privacy threat. This work shows that performance traces, achieved with performance counters, are sufficient for three efficient privacy attacks on a computer. The first attack allows the identification of webpages the user uses with a high success rate of up to 100%. This attack may expose private information about the user, like political views and affiliations. The second attack allows browser version identification. Browsers are updated regularly to protect against known cyber-attacks. An attacker can use this information to choose the best attack method to achieve successful cyber-attacks. The attack is unique since it is the first study to demonstrate the detection of the browser version using a side-channel attack. The third attack allows the recovery of structural elements of Neural Networks, like the number of layers and activation functions being used. This information may assist in preparing adversarial examples against the Neural Network or in creating a similar copy of the Neural Network. To evaluate these attacks, we collected performance traces using Intel Power Gadget software-based performance counter tool. We collect traces of power consumption, utilization percentage, and clock frequency of the Intel CPU and its internal parts like DRAM memory and GPU.
A Fusion-Based Framework for Unsupervised Single Image Super-Resolution

Image super-resolution has been a continuously demanding topic in the computer-vision community in recent decades and has witnessed impressive applications in increasing spatial resolution in every field like medicine, agriculture, remote sensing, defense security, and many more applications. Further, deep learning-based image super resolution methods have shown tremendous improvement in reconstruction performance. However, most of the recent state-of-the-art deep learning-based methods for image super-resolution assume an ideal degradation by the bicubic kernel on standard dataset approaches and perform poorly on real-world satellite images in practice, as real degradations are far away and more complex in nature than pre-defined assumed kernels. Motivated by this real-time challenge, our idea is to enhance the 600 m spatial-resolution image, which is extremely low, and implicitly defines image-specific features in an iterative way without defining any fixed explicit degradation for image super-resolution. Besides, we also did a comparative study based on a No-Reference Image Quality Assessment. The evaluation is done both qualitatively (vision based) and quantitatively without recurring to a reference image for quality assessment. The proposed framework outperforms by incorporating domain knowledge from recently implemented unsupervised single-image blind super-resolution techniques.
On Distributed Randomness Generation in Blockchains

We present a smart contract for generating unbiased randomness on a blockchain/ledger-style system. Our smart contract can be stored on a blockchain and be executed publicly whenever needed. In particular, our protocol is suitable for leader-election-style applications and for mitigating front-running attacks. We prove correctness and security of our smart contract within a formal model of a distributed ledger extended by financial incentives and smart contracts. To the best of our knowledge, our formalization is the first to capture the concept of "time" in the context of smart contracts. Furthermore, we show that our protocol is incentive compatible, namely, under some reasonable financial assumption, following the honest execution, even for an all but one corruptions, gives the most financial benefit. Technically, our smart contract utilizes recently-introduced non-malleable time-lock puzzles. At a very high level, these are cryptographic commitments that can be "force opened" after a predefined delay. Using those, we implement a commit-and-reveal-style protocol but where we consider the particulars of the blockchain setting.
Localhost Detour from Public to Private Networks

This paper presents a new localhost browser based vulnerability and corresponding attack that opens the door to new attacks on private networks and local devices. We show that this new vulnerability may put hundreds of millions of internet users and their IoT devices at risk. Following the attack presentation, we suggest three new protection mechanisms to mitigate this vulnerability. This new attack bypasses recently suggested protection mechanisms designed to stop browser-based attacks on private devices and local applications [18, 20].
GeaFlow: A Graph Extended and Accelerated Dataflow System

GeaFlow is a distributed dataflow system optimized for streaming graph processing, and has been widely adopted at Ant Group, serving various scenarios ranging from risk control of financial activities to analytics on social networks and knowledge graphs. It is built on top of a base with full-fledged stateful stream processing capabilities, extended with a series of graph-aware optimizations to address the space explosion and programming complexity issues of conventional join-based approaches. We propose new state backends and streaming operators that facilitate processing on dynamic graph-structured datasets, reducing space consumed by states. We develop a hybrid domain-specific language that embeds Gremlin into SQL, supporting both table and graph abstractions over streaming data. In addition to streaming workloads, GeaFlow is also extensively used for some batch processing jobs. In the largest deployments to date, GeaFlow is able to process tens of millions of events per second and manage hundreds of terabytes of states.
Scapin: Scalable Graph Structure Perturbation by Augmented Influence Maximization

Generating data perturbations to graphs has become a useful tool for analyzing the robustness of Graph Neural Networks (GNNs). However, existing model-driven methodologies can be prohibitively expensive to apply in large graphs, which hinders the understanding of GNN robustness at scale. In this paper, we present Scapin, a data-driven methodology that opens up a new perspective by connecting graph structure perturbation for GNNs with augmented influence maximization-to either facilitate desirable spreads or curtail undesirable ones by adding or deleting a small set of edges. This connection not only allows us to perform data perturbation on GNNs with computation scalability but also provides nice interpretations. To transform such connections into efficient perturbation approaches for the new GNN setting, Scapin introduces a novel edge influence model, decomposed influence maximization objectives, and a principled algorithm for edge addition by exploiting submodularity of the objectives. Empirical studies demonstrate that Scapin can give orders of magnitude improvement over state-of-art methods in terms of runtime and memory efficiency, with comparable or even better performance.
Software-Hardware Co-design of Heterogeneous SmartNIC System for Recommendation Models Inference and Training

Deep Learning Recommendation Models (DLRMs) are important applications in various domains and have evolved into one of the largest and most important machine learning applications. With their trillions of parameters necessarily exceeding the high bandwidth memory (HBM) capacity of GPUs, ever more massive DLRMs require large-scale multi-node systems for distributed training and inference. However, these all suffer from the all-to-all communication bottleneck, which limits scalability.
FT-topo: Architecture-Driven Folded-Triangle Partitioning for Communication-efficient Graph Processing

As graph size (numbers of vertices and edges) is increasing from billions to trillions, efficient graph processing requires exascale computing clusters, which consist of hundreds of thousands of nodes connected via hierarchical networks with multiple levels of communication domains, e.g., multilevel triangle communication domains. While the computation of traversal-centric graph algorithms is relatively simple (e.g., status check), communication is the bottleneck due to the transfer of numerous small messages among hierarchical triangle communication domains.
CMLCompiler: A Unified Compiler for Classical Machine Learning

Classical machine learning (CML) occupies nearly half of machine learning pipelines in production applications. Unfortunately, it fails to utilize the state-of-the-practice devices fully and performs poorly. Without a unified framework, the hybrid deployments of deep learning (DL) and CML also suffer from severe performance and portability issues. This paper presents the design of a unified compiler, called CMLCompiler, for CML inference. We propose two unified abstractions: operator representations and extended computational graphs. The CMLCompiler framework performs the conversion and graph optimization based on two unified abstractions, then outputs an optimized computational graph to DL compilers or frameworks. We implement CMLCompiler on TVM. The evaluation shows CMLCompiler's portability and superior performance. It achieves up to 4.38× speedup on CPU, 3.31× speedup on GPU, and 5.09× speedup on IoT devices, compared to the state-of-the-art solutions --- scikit-learn, intel sklearn, and hummingbird. Our performance of CML and DL mixed pipelines achieves up to 3.04x speedup compared with cross-framework implementations. The project documents and source code are available at https://www.computercouncil.org/cmlcompiler.
Parallel Software for Million-scale Exact Kernel Regression

We present the design and the implementation of a kernel principal component regression software that handles training datasets with a million or more observations. Kernel regressions are nonlinear and interpretable models that have wide downstream applications, and are shown to have a close connection to deep learning. Nevertheless, the exact regression of large-scale kernel models using currently available software has been notoriously difficult because it is both compute and memory intensive and it requires extensive tuning of hyperparameters.
Lightweight Huffman Coding for Efficient GPU Compression

Lossy compression is often deployed in scientific applications to reduce data footprint and improve data transfers and I/O performance. Especially for applications requiring on-the-flight compression, it is essential to minimize compression's runtime. In this paper, we design a scheme to improve the performance of cuSZ, a GPU-based lossy compressor. We observe that Huffman coding - used by cuSZ to compress metadata generated during compression - incurs a performance overhead that can be significant, especially for smaller datasets. Our work seeks to reduce the Huffman coding runtime with minimal-to-no impact on cuSZ's compression efficiency.
Distributed-Memory Parallel JointNMF

Joint Nonnegative Matrix Factorization (JointNMF) is a hybrid method for mining information from datasets that contain both feature and connection information. We propose distributed-memory parallelizations of three algorithms for solving the JointNMF problem based on Alternating Nonnegative Least Squares, Projected Gradient Descent, and Projected Gauss-Newton. We extend well-known communication-avoiding algorithms using a single processor grid case to our coupled case on two processor grids. We demonstrate the scalability of the algorithms on up to 960 cores (40 nodes) with 60% parallel efficiency. The more sophisticated Alternating Nonnegative Least Squares (ANLS) and Gauss-Newton variants outperform the first-order gradient descent method in reducing the objective on large-scale problems. We perform a topic modelling task on a large corpus of academic papers that consists of over 37 million paper abstracts and nearly a billion citation relationships, demonstrating the utility and scalability of the methods.
Privacy-Preserving Outsourcing of <i>K</i>-Means Clustering for Cloud-Device Collaborative Computing in Space-Air-Ground Integrated IoT

Facing the explosive growth of data, the introduction of cloud computing in the Space-Air-Ground Integrated Internet of Things (SAGIIoT) can solve the problem of limited computing power of the terminals. At the same time, data security on the cloud is also a focus that cannot be ignored. Secure outsourcing computing is helpful in improving privacy preserving. Due to the wide applicability of <inline-formula xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink"> <tex-math notation="LaTeX">$K $ </tex-math></inline-formula> -means clustering, outsourcing computing for <inline-formula xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink"> <tex-math notation="LaTeX">$K $ </tex-math></inline-formula> -means has become a major research hotspot in industry and academia. Most of the existing work on outsourcing <inline-formula xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink"> <tex-math notation="LaTeX">$K $ </tex-math></inline-formula> -means clustering is based on homomorphic encryption, which has a high computational overhead due to the mathematical puzzles’ nature of homomorphic encryption. In addition, the high computational overhead of designing a verification algorithm based on homomorphic encryption is unacceptable. To address the above issues, we design a <inline-formula xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink"> <tex-math notation="LaTeX">${K}$ </tex-math></inline-formula> -means clustering outsourcing algorithm by sparse matrix transformation, which can verify the deceptive behavior of cloud while achieving high efficiency. In this article, we theoretically prove the accuracy, security, efficiency, and verifiability of the proposed algorithm. Extensive experiments indicate that our algorithm is efficient.