Search

Frame-Based Editing (FBE) is a relatively new programming paradigm that sits between Block and Text based editing, by implementing good features of both practices. Moreover, FBE is designed as a middle step between block and text based editing, in order to ease the transition from the first to the later. Strype is a new online editor which implements FBE’s idea for Python and is used for programming the micro:bit. This demo will showcase the unique elements of Strype and demonstrate its use. This demo aims in introducing FBE and Strype to the educational community in order to generate fruitful discussions, get feedback and also promote its use to educational settings.

The cloud computing paradigm utilizes neutralization to isolate data, workloads and network bandwidth in an elastic mode. The providers hence have historically used Virtual Machines (VM) to perform this workload isolation. However these virtual machines require huge resources and are costly to set-up and deploy. Containerization has of late been used as a different approach for neutralization albeit as a Software as a service approach. Docker containerization has been one of the most popular approaches and its a solution where containers all share the same resources and operating system as opposed to virtual machines which use hyper-visor technology to abstract hardware and operating systems. The study uses different cloud vendors to compare docker containers for response time, download time, CPU processing time as well as memory usage against virtual machines. The study did a performance comparison for Virtual Machines and Docker Containers in various cloud providers namely AWS, Google Cloud as well as Microsoft Azure cloud platforms. The dataset used included deep learning big data downloaded from Kaggle website and classified for loan defaulting with Keras and tensorflow python implementation frameworks. The comparisons do prove that docker containers are faster than KVMs and Xen virtual machines. The study also proves that by using Kubernetes framework for scaling the containers, the performance of the docker containers improves compared to the docker and bare metal as well as cloud frameworks.

Federated Learning (FL) has emerged as a promising technique for edge devices to collaboratively learn a shared machine learning model while keeping training data locally on the device, thereby removing the need to store and access the full data in the cloud. However, FL is difficult to implement, test and deploy in practice considering heterogeneity in common edge device settings, making it fundamentally hard for researchers to efficiently prototype and test their optimization algorithms. In this work, our aim is to alleviate this problem by introducing FL_PyTorch : a suite of open-source software written in python that builds on top of one the most popular research Deep Learning (DL) framework PyTorch. We built FL_PyTorch as a research simulator for FL to enable fast development, prototyping and experimenting with new and existing FL optimization algorithms. Our system supports abstractions that provide researchers with a sufficient level of flexibility to experiment with existing and novel approaches to advance the state-of-the-art. Furthermore, FL_PyTorch is a simple to use console system, allows to run several clients simultaneously using local CPUs or GPU(s), and even remote compute devices without the need for any distributed implementation provided by the user. FL_PyTorch also offers a Graphical User Interface. For new methods, researchers only provide the centralized implementation of their algorithm. To showcase the possibilities and usefulness of our system, we experiment with several well-known state-of-the-art FL algorithms and a few of the most common FL datasets., Comment: DistributedML '21: Proceedings of the 2nd ACM International Workshop on Distributed Machine Learning

Federated Learning (FL) allows parties to learn a shared prediction model by delegating the training computation to clients and aggregating all the separately trained models on the server. To prevent private information being inferred from local models, Secure Aggregation (SA) protocols are used to ensure that the server is unable to inspect individual trained models as it aggregates them. However, current implementations of SA in FL frameworks have limitations, including vulnerability to client dropouts or configuration difficulties. In this paper, we present Salvia, an implementation of SA for Python users in the Flower FL framework. Based on the SecAgg(+) protocols for a semi-honest threat model, Salvia is robust against client dropouts and exposes a flexible and easy-to-use API that is compatible with various machine learning frameworks. We show that Salvia's experimental performance is consistent with SecAgg(+)'s theoretical computation and communication complexities., Comment: Accepted to appear in the 2nd International Workshop on Distributed Machine Learning

Recent developments in Deep Neural Networks have resulted in their wide deployment for services around many aspects of human life, including security critical domains that handle sensitive data. Congruently, we have seen a proliferation of IoT devices with limited resources. Together, these two trends have led to the distribution of data analysis, processing, and decision making between edge devices and third parties such as cloud services. In this work we assess the security of the previously proposed distributed machine learning (ML) schemes by analyzing the information leaked from the output of the edge devices, i.e. the intermediate representation (IR). We particularly look at a Deep Neural Network that is used for video/image classification and tackle the problem of image/frame reconstruction from the output of the edge device. Our work focuses on assessing whether the proposed scheme of partitioned enclave execution is secure against chosen-image attacks (CIA). Given the attacker has the capability of querying the model under attack (victim model) to create image-IR pairs, can the attacker reconstruct the private input images? In this work we show that it is possible to carry out a black-box reconstruction attack by training a CNN based encoder-decoder architecture (reconstruction model) using image-IR pairs. Our tests show that the proposed reconstruction model achieves a 70% similarity between the original image and the reconstructed image.

Edge computing has received significant attention from both academic and industrial research circles. The paradigm aims to decentralize the existing cloud infrastructure by incorporating resources co-located alongside its client. Researchers have also proposed solutions for a fully decentralized crowdsourced compute paradigm enabled by Distributed Ledger Technologies (DLTs). This paper investigates the rationale behind DLTs over crowdsourced resource marketplaces to support the requirements of latency-critical applications targeted by edge computing. We develop a fully configurable NEtworked Blockchain emULAtor, or NEBULA, to scrutinize the internal performance bottlenecks of DLTs. We evaluate two blockchain categories - proof-based (popularly used in Bitcoin, Ethereum) and hybrid consensus and find that the enabling factor of DLTs -scale - is also its primary latency contributor. We show that, in reality, the latency overheads due to DLT operation far exceed the operational requirements of edge applications.

Building customised IoT applications is often labor intensive. While several frameworks support developers in building sophisticated applications, they mainly focus on the communication with the underlying devices and their automation. Modular programming may further improve the reuse of components in other applications. However, integrating automatic device configuration, connection management, and user support for solving connectivity issues, remains a real endeavor for application developers. Likewise, integrating and enforcing policies in an IoT application is complex, and the dynamic nature of IoT systems makes it even more difficult to develop applications that properly handle changes in the environment. This paper presents a middleware that simplifies the development of smart IoT applications. The middleware hosts a modular, event-based, logic reasoner. The reasoner is developed in Prolog and communicates with the underlying IoT framework. The middleware leverages the actual benefits of Prolog through complex querying and inference capabilities on the IoT system. This, combined with built-in functionality for automatic device and connection management, access control, advanced automation and an abstraction module that decouples the applications from the underlying infrastructure, grants the developer to focus on the specific application. An integration in a server and a mobile application demonstrates the capabilities of the middleware and its modules.

Simplicity in elastically scalable application development is a key concern addressed by the serverless computing paradigm, in particular the code-level Function-as-a-Service (FaaS). Various FaaSification frameworks demonstrated that marking code methods to streamline their offloading as cloud functions offers a simple bridge to software engineering habits. As application complexity increases, more complex runtime patterns with background activities, such as keeping containerised cloud functions warm to ensure the absence of cold starts, usually require giving up on simplicity and instead investing efforts into orchestrating infrastructure. By bringing infrastructure-as-code concepts into the function source via powerful code annotations, typical orchestration patterns can be simplified again. We evaluate this idea and demonstrate its practical feasibility with FaaS Fusion, an annotations library and transpiler framework for JavaScript.

The RDF Mapping Language (RML) allows to map semi-structured data to RDF knowledge graphs. Besides CSV, JSON and XML, this also includes the mapping of spreadsheet tables. Since spreadsheets have a complex data model and can become rather messy, their mapping creation tends to be very time consuming. In order to reduce such efforts, this paper presents Spread2RML which predicts RML mappings on messy spreadsheets. This is done with an extensible set of RML object map templates which are applied for each column based on heuristics. In our evaluation, three datasets are used ranging from very messy synthetic data to spreadsheets from data.gov which are less messy. We obtained first promising results especially with regard to our approach being fully automatic and dealing with rather messy data., 17 pages, 1 figure, 2 tables, accepted at K-CAP 2021

Whilst Knowledge Graphs (KGs) are increasingly used in business scenarios, the construction of enterprise ontologies and the population of KGs from existing relational data remains a significant challenge. In this paper we report our experience in supporting CSols (an SME operating in the analytical laboratory domain) in transitioning their data from legacy databases to a bespoke KG. We modelled the KG using a streamlined approach based on state of the art ontology engineering methodologies, that addresses the challenges faced by SMEs when transitioning to new technologies: lack of resources to devote to the transition, paucity of comprehensive data governance policies, and resistance within the organisation to accepting new practices and knowledge. Our approach uses a combination of UML diagrams and a controlled language glossary to support stakeholders in reaching consensus during the knowledge capture phase, thus reducing the intervention of the ontology engineer only to cases where no agreement can be found. We present a case study illustrating the generation of the KG from a UML specification of part of the analytical domain and from legacy relational data, and we discuss the benefits and challenges of the approach.

Computational offloading is a technique commonly indicated to mitigate computational and energy constraints on mobile devices. However, this procedure occurs over a wireless network, an insecure environment, and susceptible to attacks. Currently, one of the main problems related to offloading is how to perform it safely. By acting in conjunction with the TLS protocol, secure gRPC connections ensure the authenticity and integrity of the data transmitted through a network, which provides greater security for distributed applications. In this work, we conducted experiments that evaluated the performance of secure gRPC connections during the computational offloading procedures in a Mobile Cloud Computing scenario. The tests adopted an Android image manipulation application that performs the offloading into a Go or Java process using the multi-language framework gRPC. The results indicated that the adoption of secure gRPC connections saved up to 9 times the processing time and up to 88% of the mobile device's energy consumption compared to local processing.

This paper adopts Named Data Network technology for data delivery/forwarding over the Internet of Vehicles (IoVs) and proposes an NDN-based architecture for IoVs based on mobile edge computing(MEC). Advanced research has demonstrated the considerable benefits of introducing MEC into IoVs, but comes with issues such as insufficient security and privacy protection problems. To address these issues, we propose a dual-mode privacy-preserving framework for the security layer of the proposed network architecture. Specifically, we construct a privacy protection identity-based broadcast proxy re-encryption scheme to provide privacy to a set of vehicles with data requests. Furthermore, we use a federated learning scheme based on local differential privacy in the proposed NDN-based architecture for MEC-empowered IoV to achieve high-speed response and decision making. Simulation results demonstrate that our proposed scheme performs effectively.

Wireless technologies coexisting in unlicensed bands should receive a fair share of the available channel resources, even when they use different access methods. We consider the problem of coexistence between Wi-Fi and New Radio Unlicensed (NR-U) nodes, which employ, respectively, a random and scheduled access scheme. The latter typically resorts to reservation signals (RSs), which allow keeping the control of the channel until the start of the next synchronized slot. This mechanism, although effective for increasing the channel access opportunities of scheduled-based nodes, is also a waste of channel resources. We investigate alternative solutions, based on self-deferral only. We built analytical and simulations models for a Wi-Fi and NR-U coexistence scenario and found that (a) airtime fairness can be achieved with proper contention window (CW) settings and (b) this solution can be exploited for optimizing network performance for both Wi-Fi and NR-U. Additionally, we demonstrate how an artificial recurrent neural network-based regression model can be applied to predict such proper CW settings. Our research confirms that by embedding contending devices with machine learning intelligence in CW selection, scheduled-based systems such as NR-U do not have to resort to RSs.

With the start of a new era of Intelligently Connected Vehicular Networks, the communication in vehicular networks is no longer limited to vehicle-to-vehicle and vehicle-to-infrastructure but also expands to vehicle-to-pedestrian, vehicle-to-grid vehicle-to-device, collectively referred to as vehicle-to-everything (V2X). Network softwarization is an essential attribute to address the challenges in heterogeneous networks through share interface platform an control. However, it brings several issues to the topology design of software-defined vehicular networks. In this paper, we propose a dynamic split and merge-based clustering method for software-defined vehicular networks. The proposed method adaptively change the network's topology based on latency, load, and traffic-flow. The proposed scheme is evaluated under realistic mobility and network structure. The results indicate the efficiency of the proposed scheme in terms of latency and load on network entities.

In this paper, we describe the integration of a step-by-step interactive trace table into an existing practice system for introductory Java programming. These autogenerated trace problems provide help and scaffolding for students who have trouble in solving traditional one-step code tracing problems, accommodating a wider variety of learners. Findings from classroom deployments suggest the scaffolding provided by the trace table is a plausible form of help, most notably increases in performance and persistence and lower task difficulty. Based on usage data, we propose future implications for an adaptive version of the interactive trace table based on learner modeling.

With the “Lehrplan 21” school curriculum, a new subject “Media and Computer Science” was introduced in the German-speaking cantons of Switzerland. The curriculum defines competence areas that should be achieved by students within this subject. One such competence area is that middle school students should be able to develop executable and correct computer programs that use variables and subprograms. To evaluate and analyze how middle school students work with these more abstract CS concepts, we organized a Scratch Challenge – an online programming competition using the block-based programming language Scratch. We then compared the 203 submitted projects with an analysis of projects from the general Scratch repository. We found a similar use of types and quantities of blocks per projects (when considering projects developed in a short timeframe), but also an increased use of the targeted abstract concepts (especially of procedures), potentially influenced by the educational materials we provided for the challenge. Secondly, we examined the way middle school students work with these abstract concepts in Scratch, the errors they typically make, which challenges they face and the preconceptions they might have. These results contribute to the little studied area of middle school students working with more abstract concepts, such as variables, lists and procedures in Scratch. With this contribution, we hope to support schools to implement the aims of the “Lehrplan 21” successfully, and at the same time gain insight into the use of Scratch for teaching and learning more advanced CS concepts.

This work introduces and demonstrates the viability of a novel SQL automarking tool (“SQAM”) that: (1) provides a fair grade to the student, one which matches the student’s effort and understanding of the course material, and (2) to provide personalized feedback, allowing the student to remain engaged in the material and learn from their mistakes while still being in that headspace. Additionally, we strive to ensure that our tool maintains the same standards (grade and feedback) that a highly qualified member of teaching staff would produce, so we compare and contrast our automarker’s results to that of teaching assistants over several historic offerings of the same database course at a large research intensive public institution, while reducing the grading time, thus enabling the teaching staff to channel more time into instruction. Furthermore, we describe SQAM’s design and our model which applies the aggregate result of four different string similarity metrics to compute solution similarity in conjunction with our discretization process to fairly evaluate a student’s submission. Our results show that SQAM produces very similar grades to those which were historically given by teaching assistants.

Near novice programmers face transfer challenges when learning a second or subsequent programming language (PL). Although these transfer challenges are known, minimal attention is given to developing a pedagogic model that can guide educators in improving transfer in the classroom. We therefore propose a transfer pedagogy that uses implicit, explicit, and bridging techniques which align with the Model of Programming Language Transfer (MPLT) predictions. To evaluate this pedagogy, we conducted a between-subject study with a total of 62 second-year undergraduate students who were transitioning from Python to Java. The study was for the duration of the first two and a half weeks of the Java course. We provide the quantitative and qualitative results on the effects of this pedagogy on learning programming concepts in the new Java language. We also report the lecturer’s views on using the pedagogy. The results show that students who used the transfer pedagogy performed significantly better in the post-test than the control group in most concepts. The qualitative results showed that 88% of the students appreciated the explicit teaching interventions, with some students noting they helped with avoiding transfer mistakes and made them understand concepts better. The lecturer also appreciated the value of the pedagogy, taking it as an opportunity to help students learn deeper programming concepts. However, they reported some challenges too. These findings suggest that the transfer pedagogy is beneficial and can be of value to second programming language learning.

We introduce Sinergym, an open-source building simulation and control framework for training reinforcement learning agents. The proposed framework is compatible with EnergyPlus models and allows to implement Python-based controllers, facilitating reproducibility of experiments and generalization to multiple scenarios. A comparison between Sinergym and other existing libraries for building control is included. We describe its design and main functionalities, such as offering a diverse set of environments with different buildings, weather types and action spaces. The provided examples show the usage of the framework for benchmarking reinforcement learning methods for building control.

This paper presents a search engine system for sensor time series data and metadata in the context of building management. It takes natural language queries as input and retrieves sensor time series data, ranks them with respect to their relevance to a given query, and visualizes the results as graphs. In addition, the system allows users to interact with the search results: they can define events of interest in the visualized results and search across sensor data for time series with similar shape, i.e. the search by example scheme. We leverage both a feature based cosine similarity model and DTW to find similar time series and rank them by relevance. Our quantitative evaluations and user studies demonstrate the value of this system for managing building sensor data.

Traditional post-hoc high-fidelity scientific visualization (HSV) of numerical simulations requires multiple I/O check-pointing to inspect the simulation progress. The costs of these I/O operations are high and can grow exponentially with increasing problem sizes. In situ HSV dispenses with costly check-pointing I/O operations, but requires additional computing resources to generate the visualization, increasing power and energy consumption. In this paper we present LOOM, a new interweaving approach supported by a task scheduling framework to allow tightly coupled in situ visualization without significantly adding to the overall simulation runtime. The approach exploits the idle times of the numerical simulation threads, due to workload imbalances, to perform the visualization steps. Overall execution time (simulation plus visualization) is minimized. Power requirements are also minimized by sharing the same computational resources among numerical simulation and visualization tasks. We demonstrate that LOOM reduces time to visualization by 3 × compared to a traditional non-interwoven pipeline. Our results here demonstrate good potential for additional gains for large distributed-memory use cases with larger interleaving opportunities.

Synthetic biology has utilised engineering concepts for the rational design of biocompatible systems. Here we utilise two bacterial populations to create a modulated molecular channel coding scheme for molecular communications systems. We believe this approach can drive the development of more reliable biocompatible molecular communications systems to apply in the dairy industry.

This paper proposes a framework for automatic exploit generation in JIT compilers, focusing in particular on heap corruption vulnerabilities triggered by dynamic code, i.e., code generated at runtime by the JIT compiler. The purpose is to help assess the severity of vulnerabilities and thereby assist with vulnerability triage. The framework consists of two components: the first extracts high-level representations of exploitation primitives from existing exploits, and the second uses the primitives so extracted to construct exploits for new bugs. We are currently building a prototype implementation of the framework focusing on JavaScript JIT compilers. To the best of our knowledge, this is the first proposal to consider automatic exploit generation for code generated dynamically by JIT compilers.

Deep learning has been increasingly applied to improve human activity recognition (HAR) accuracy and reduce the human efforts of handcrafted feature extractions. Federated Learning (FL) is an emerging learning paradigm that enables the collaborative learning of a global model without exposing users' raw data. However, existing FL approaches yield unsatisfactory HAR performance as they fail to dynamically aggregate models according to the statistical diversity of users' data. In this paper, we propose FedDL, a novel federated learning system for HAR that can capture the underlying user relationships and apply them to learn personalized models for different users dynamically. Specifically, we design a dynamic layer sharing scheme that learns the similarity among users' model weights to form the sharing structure and merges models accordingly in an iterative, bottom-up layer-wise manner. FedDL merges local models based on the dynamic sharing scheme, significantly speeding up the convergence while maintaining high accuracy. We have implemented FedDL and evaluated using a new data set we collected using LiDAR and four public real-world datasets involving 178 users in total. The results show that FedDL outperforms several state-of-the-art FL paradigms in terms of model accuracy (by more than 15%), converging rate (by more than 70%), and communication overhead (about 30% reduction). Moreover, the testing results on the datasets of different scales show that FedDL has high scalability and hence can be deployed for large-scale real-world applications.

Homomorphic encryption (HE), especially the CKKS scheme, can be extremely challenging to use. The EVA language and compiler (Dathathri et al., PLDI 2020) was an attempt at addressing this challenge. EVA allows a developer to express their encrypted computation in a simple form with a Python-integrated language called PyEVA. It then compiles the program into an executable form by inserting operations such as relinearization and rescaling, applying optimizations, and choosing encryption parameters with the objective of minimizing execution time. Compiled programs can be executed with a parallelizing back-end against a library of HE primitives. Our work improves upon the EVA toolchain in several ways: changes to the Python front-end make writing PyEVA programs more natural, while a rework of EVA's C++ APIs makes writing new passes easier. We also implement two new optimizations, common subexpression elimination and reduction balancing, which we show allow users to write simpler and more modular PyEVA programs. We argue that the abstraction EVA provides is insufficient to resolve some common usability challenges. For example, managing vectors of arbitrary size is non-trivial. To resolve these problems, we demonstrate how building a library of commonly used data structures and functions is simple in PyEVA. EVA's automation allows writing very concise code, which gets fused and optimized together with the user program. We create the beginnings of an EVA Extension Library (EXL), that provides vector and matrix classes and a collection of common statistical functions, to demonstrate the power of this approach.

New software security threats are constantly arising, including new classes of attacks such as the recent spate of micro-architectural vulnerabilities, from side-channels and speculative execution to attacks like Rowhammer that alter the physical state of memory. At the same time, new defensive technologies are proposed and adopted, including advancements in programming languages and novel hardware architectures with a focus on security. Moving target defenses were developed to provide performant, incremental security to programs written in unsafe languages running on processors designed solely for performance. Here we examine the challenges and opportunities for moving target defenses in the evolving security landscape, and in new applications domains such as cloud computing and real-time systems.

Playing is an essential way for preschoolers to learn. There are three types of games for preschoolers: functional play, constructive play, and symbolic play. However, existing works/games can only work for one specific type of children's play. Therefore, we designed and implemented an extensible children's game framework based on Augmented Reality building blocks. We implement an AR prototype from scratch that achieves up to 8 blocks with 81% detection rate and overhead of 21ms (46 FPS) on average.

Computing derivatives is key to many algorithms in scientific computing and machine learning such as optimization, uncertainty quantification, and stability analysis. Enzyme is a LLVM compiler plugin that performs reverse-mode automatic differentiation (AD) and thus generates high performance gradients of programs in languages including C/C++, Fortran, Julia, and Rust. Prior to this work, Enzyme and other AD tools were not capable of generating gradients of GPU kernels. Our paper presents a combination of novel techniques that make Enzyme the first fully automatic reversemode AD tool to generate gradients of GPU kernels. Since unlike other tools Enzyme performs automatic differentiation within a general-purpose compiler, we are able to introduce several novel GPU and AD-specific optimizations. To show the generality and efficiency of our approach, we compute gradients of five GPU-based HPC applications, executed on NVIDIA and AMD GPUs. All benchmarks run within an order of magnitude of the original program's execution time. Without GPU and AD-specific optimizations, gradients of GPU kernels either fail to run from a lack of resources or have infeasible overhead. Finally, we demonstrate that increasing the problem size by either increasing the number of threads or increasing the work per thread, does not substantially impact the overhead from differentiation.

High-performance quantum circuit simulation in a classic HPC is still imperative in the NISQ era. Observing that the major obstacle of scalable state-vector quantum simulation arises from the massively fine-grained irregular data-exchange with remote nodes, in this paper we present SV-Sim to apply the PGAS-based communication models (i.e., direct peer access for intra-node CPUs/GPUs and SHMEM for inter-node CPU/GPU clusters) for efficient generalpurpose quantum circuit simulation. Through an orchestrated design based on device functional pointer, SV-Sim is able to abstract various quantum gates across multiple heterogeneous backends, including IBM/Intel/AMD CPUs, NVIDIA/AMD GPUs, and Intel Xeon Phi, in a unified framework, but still asserting outstanding performance and tractable interface to higher-level quantum programming environments, such as IBM Qiskit, Microsoft Q# and Google Cirq. Circumventing the obstacle from the lack of polymorphism in GPUs and leveraging the device-initiated one-sided communication, SV-Sim can process circuit that are dynamically generated in Python using a single GPU/CPU kernel without the need of expensive JIT or runtime parsing, significantly simplifying the programming complexity and improving performance for QC simulation. This is especially appealing for the variational quantum algorithms given the circuits are synthesized online per iteration. Evaluations on the latest NVIDIA DGX-A100, V100-DGX-2, ALCF Theta, OLCF Spock, and OLCF Summit HPCs show that SV-Sim can deliver scalable performance on various state-of-the-art HPC platforms, offering a useful tool for quantum algorithm validation and verification. SV-Sim has been released at http://github.com/pnnl/sv-sim. A version specially tweaked for Q#/QDK is also provided.

As we approach the exascale computing era, the focused understanding of power consumption and its overall constraint on HPC architectures and applications are becoming increasingly paramount. Summit, located at the Oak Ridge Leadership Computing Facility (OLCF), is one of the fastest and largest pre-exascale platforms in operation today. This paper provides a first-order examination and analysis of power consumption at the component-level, node-level, and system-level, from all 4,626 Summit compute nodes, each with over 100 metrics at 1Hz frequency over the entire year of 2020. We also investigate the power characteristics and energy efficiency of over 840k Summit jobs and 250k GPU failure logs for further operational insights. To the best of our knowledge, this is the first systematic analysis of power data of HPC system at this scale.

In this paper, we propose a novel hint-accelerated Remote Procedure Call (RPC) framework based on Apache Thrift over Remote Direct Memory Access (RDMA) protocols, called HatRPC. HatRPC proposes a hierarchical hint scheme towards optimizing heterogeneous RPC services and functions. The proposed hint design is composed of service-granularity and function-granularity hints for achieving varied optimization goals and reducing design space for further optimizing the underneath RDMA communication engine. We co-design a key-value store called HatKV with HatRPC and LMDB. The effectiveness and efficiency of HatRPC are validated and evaluated with our proposed Apache Thrift Benchmarks (ATB), YCSB, and TPC-H workloads. Performance evaluations show that the proposed HatRPC approach can deliver up to 55% performance improvement for ATB benchmarks and up to 1.51X speedup for TPC-H queries compared with vanilla Thrift over IPoIB. In addition, the co-designed HatKV can achieve up to 85.5% improvement for YCSB workloads.

Recognizing the importance of whole genome alignment (WGA), the National Institutes for Health maintains LASTZ, a sequential WGA application. As genomic data grows, there is a compelling need for scalable, high-performance WGA. Unfortunately, high-sensitivity, `gapped' alignment which uses dynamic programming (DP) is slow, whereas faster alignment with ungapped filtering is often less sensitive. We develop FastZ, a GPU-accelerated, gapped WGA software which matches gapped LASTZ in sensitivity. FastZ employs a novel inspector-executor scheme in which (a) the lightweight inspector elides DP traceback except in common, extremely short alignments, where the inspector performs limited, eager traceback to eliminate the executor, and (b) executor trimming avoids unnecessary work. Further, FastZ employs register-based cyclic-buffering to drastically reduce memory traffic, and groups DP problems by size for load balance. FastZ running on an RTX 3080 GPU and our multicore implementation of LASTZ achieve 111x and 20x speedups over the sequential LASTZ, respectively.

JavaScript engines have been shown prone to security vulnerabilities, which can lead to serious consequences due to their popularity. Fuzzing is an effective testing technique to discover vulnerabilities. The main challenge of fuzzing JavaScript engines is to generate syntactically and semantically valid inputs such that deep functionalities can be explored. However, due to the dynamic nature of JavaScript and the special features of different engines, it is quite challenging to generate semantically meaningful test inputs. We observed that state-of-the-art semantic-aware JavaScript fuzzers usually require manually written rules to analyze the semantics for a JavaScript engine, which is labor-intensive, incomplete and engine-specific. Moreover, the error rate of generated test cases is still high. Another challenge is that existing fuzzers cannot generate new method calls that are not included in the initial seed corpus or pre-defined rules, which limits the bug-finding capability. To this end, we propose a novel semantic-aware fuzzing technique named SoFi. To guarantee the validity of the generated test cases, SoFi adopts a fine-grained program analysis to identify available variables and infer types of these variables for the mutation. Moreover, an automatic repair strategy is proposed to repair syntax/semantic errors in invalid test cases. To improve the exploration capability of SoFi, we propose a reflection-based analysis to identify unseen attributes and methods of objects, which are further used in the mutation. With fine-grained analysis and reflection-based augmentation, SoFi can generate more valid and diverse test cases. Besides, SoFi is general in different JavaScript engines without any manual configuration (e.g., the grammar rules). The evaluation results have shown that SoFi outperforms state-of-the-art techniques in generating semantically valid inputs, improving code coverage and detecting more bugs. SoFi discovered 51 bugs in popular JavaScript engines, 28 of which have been confirmed or fixed by the developers and 10 CVE IDs have been assigned.

Safe system programming is often a crucial requirement due to its critical role in system software engineering. Conventional low-level programming languages such as C and assembly are efficient, but their inherent unsafe nature makes it undesirable for security-critical scenarios. Recently, Rust has become a promising alternative for safe system-level programming. While giving programmers fine-grained hardware control, its strong type system enforces many security properties including memory safety. However, Rust's security guarantee is not a silver bullet. Runtime crashes and memory-safety errors still harass Rust developers, causing damaging exploitable vulnerabilities, as reported by numerous studies. In this paper, we present and evaluate MirChecker, a fully automated bug detection framework for Rust programs by performing static analysis on Rust's Mid-level Intermediate Representation (MIR). Based on the observation of existing bugs found in Rust codebases, our approach keeps track of both numerical and symbolic information, detects potential runtime crashes and memory-safety errors by using constraint solving techniques, and outputs informative diagnostics to users. We evaluate MirChecker on both buggy code snippets extracted from existing Common Vulnerabilities and Exposures (CVE) and real-world Rust codebases. Our experiments show that MirChecker can detect all the issues in our code snippets, and is capable of performing bug finding in real-world scenarios, where it detected a total of 33 previously unknown bugs including 16 memory-safety issues from 12 Rust packages (crates) with an acceptable false-positive rate.

The ChaCha20-Poly1305 AEAD scheme is being increasingly widely deployed in practice. Practitioners need proven security bounds in order to set data limits and rekeying intervals for the scheme. But the formal security analysis of ChaCha20-Poly1305 currently lags behind that of AES-GCM. The only extant analysis (Procter, 2014) contains a flaw and is only for the single-user setting. We rectify this situation. We prove a multi-user security bound on the AEAD security of ChaCha20-Poly1305 and establish the tightness of each term in our bound through matching attacks. We show how our bound differs both qualitatively and quantitatively from the known bounds for AES-GCM, highlighting how subtle design choices lead to distinctive security properties. We translate our bound to the nonce-randomized setting employed in TLS 1.3 and elsewhere, and we additionally improve the corresponding security bounds for GCM. Finally, we provide a simple yet stronger variant of ChaCha20-Poly1305 that addresses the deficiencies highlighted by our analysis.

A longstanding problem in computer privacy is that of data anonymization. One common approach is to present a query interface to analysts, and anonymize on a query-by-query basis. In practice, this approach often uses a standard database back end, and presents the query semantics of the database to the analyst. This paper presents a class of novel side-channel attacks that work against any query-based anonymization system that uses a standard database back end. The attacks exploit the implicit conditional logic of database runtime optimizations. They manipulate this logic to trigger timing and exception-throwing side-channels based on the contents of the data. We demonstrate the attacks on the implementation of the CHORUS Differential Privacy system released by Uber as an open source project. We obtain perfect reconstruction of millions of data values even with a Differential Privacy budget smaller than epsilon = 1.0 and no prior knowledge. The paper also presents the design of a general defense to the runtime-optimization attacks, and a concrete implementation of the defense in the latest version of Diffix. The defense works without modifications to the back end database, and operates by modifying SQL to eliminate the runtime optimization or disable the side-channels. In addition, two other attacks that exploit specific flaws in Diffix and CHORUS are reported. These have been fixed in the respective implementations.

We address the problem of multiparty private set intersection against a malicious adversary. First, we show that when one can assume no collusion amongst corrupted parties then there exists an extremely efficient protocol given only symmetric-key primitives. Second, we present a protocol secure against an adversary corrupting any strict subset of the parties. Our protocol is based on the recently introduced primitives: oblivious programmable PRF (OPPRF) and oblivious key-value store (OKVS). Our protocols follow the client-server model where each party is either a client or a server. However, in contrast to previous works where the client has to engage in an expensive interactive cryptographic protocol, our clients need only send a single key to each server and a single message to a pivot party (where message size is in the order of the set size). Our experiments show that the client's load improves by up to 10x (compared to both semi-honest and malicious settings) and that factor increases with the number of parties. We implemented our protocol and conducted an extensive experiment over both LAN and WAN and up to 32 parties with up to $2^20 $ items each. We provide a comparison of the performance of our protocol and the state-of-the-art for both the semi-honest setting (by Chandran et al.) and the malicious setting (by Ben Efraim et al. and Garimella et al.).

Dery et al. recently proposed a secure voting protocol for score-based elections, where independent talliers perform the tallying procedure. The protocol offers perfect ballot secrecy: it outputs the identity of the winner(s), but keeps all other information secret, even from the talliers. This high level of privacy, which may encourage voters to vote truthfully, and the protocol's extremely lightweight nature, make it a most adequate and powerful tool for democracies of any size. We have implemented that system and in this work we describe the system's components - election administrators, voters and talliers - and its operation. Our implementation is in Python and is open source. We view this demo as an essential step towards convincing decision makers in communities that practice score-based elections to adopt it as their election platform.

Static program analysis tools can automatically prove many useful properties of programs. However, using static analysis to prove to a third party that a program satisfies a property requires revealing the program's source code. We introduce the concept of zero-knowledge static analysis, in which the prover constructs a zero-knowledge proof about the outcome of the static analysis without revealing the program. We present novel zero-knowledge proof schemes for intra- and inter-procedural abstract interpretation. Our schemes are significantly more efficient than the naive translation of the corresponding static analysis algorithms using existing schemes. We evaluate our approach empirically on real and synthetic programs; with a pairing-based zero knowledge proof scheme as the backend, we are able to prove the control flow analysis on a 2,000-line program in 1,738s. The proof is only 128 bytes and the verification time is 1.4ms. With a transparent zero knowledge proof scheme based on discrete-log, we generate the proof for the tainting analysis on a 12,800-line program in 406 seconds, the proof size is 282 kilobytes, and the verification time is 66 seconds.

This paper presents OnionPIR and stateful OnionPIR, two single-server PIR schemes that significantly improve the response size and computation cost over state-of-the-art schemes. OnionPIR scheme utilizes recent advances in somewhat homomorphic encryption (SHE) and carefully composes two lattice-based SHE schemes and homomorphic operations to control the noise growth and response size. Stateful OnionPIR uses a technique based on the homomorphic evaluation of copy networks. OnionPIR achieves a response overhead of just 4.2x over the insecure baseline, in contrast to the 100x response overhead of state-of-the-art schemes. Our stateful OnionPIR scheme improves upon the recent stateful PIR framework of Patel et al. and drastically reduces its response overhead by avoiding downloading the entire database in the offline stage. Compared to stateless OnionPIR, Stateful OnionPIR reduces the computation cost by 1.8~x for different database sizes.

Software supply-chain attacks target components that are integrated into client applications. Such attacks often target widely-used components, with the attack taking place via operations (for example, file system or network accesses) that do not affect those aspects of component behavior that the client observes. We propose new active library learning and regeneration (ALR) techniques for inferring and regenerating the client-observable behavior of software components. Using increasingly sophisticated rounds of exploration, ALR generates inputs, provides these inputs to the component, and observes the resulting outputs to infer a model of the component's behavior as a program in a domain-specific language. We present Harp, an ALR system for string processing components. We apply Harp to successfully infer and regenerate string-processing components written in JavaScript and C/C++. Our results indicate that, in the majority of cases, Harp completes the regeneration in less than a minute, remains fully compatible with the original library, and delivers performance indistinguishable from the original library. We also demonstrate that Harp can eliminate vulnerabilities associated with libraries targeted in several highly visible security incidents, specifically event-stream, left-pad, and string-compare.

Memory-safety issues have been a long-standing concern of the security practitioners. According to Microsoft and Google, memory-safety bugs still represent 70% of the exploited vulnerabilities in complex, real-world programs like OSes and Web browsers. However, it doesn't mean that academics and practitioners haven't tried hard to alleviate the problem. Advances in automatic techniques like fuzzing and sanitizers revolutionize the way we tame the memory safety bugs, but the increasing volume of new software simply outpaces the adoption rate of these promising new techniques, setting the legacy programs aside. In this talk, I'd like to share "our" own journey to fight against memory-safety bugs - "our" is important as all research is conducted together with the brightest hackers in SSLab at Georgia Tech. First, I'd like to talk about our group's research agenda in the memory-safety world ranging from binary exploitation, programming analysis, fuzzing, symbolic execution and security education. Second, I will share our group's journey to participate in the DARPA CGC, DEFCON CTF and pwn2own competitions. Third, I will also present where our group is heading to: a promising new memory/thread-safe language, called Rust. Lastly, I will conclude the talk with an important projection by using our recent work on finding bugs in the Rust packages: like COVID-19, the memory-safety bugs likely stay with us for the next decade, if not more.

Deep learning has demonstrated its strengths in numerous binary analysis tasks, including function boundary detection, binary code search, function prototype inference, value set analysis, etc. When applying deep learning to binary analysis tasks, we need to decide what input should be fed into the neural network model. More specifically, we need to answer how to represent an instruction in a fixed-length vector. The idea of automatically learning instruction representations is intriguing, however the existing schemes fail to capture the unique characteristics of disassembly. These schemes ignore the complex intra-instruction structures and mainly rely on control flow in which the contextual information is noisy and can be influenced by compiler optimizations. In this paper, we propose to pre-train an assembly language model called PalmTree for generating general-purpose instruction embeddings by conducting self-supervised training on large-scale unlabeled binary corpora. PalmTree utilizes three pre-training tasks to capture various characteristics of assembly language. These training tasks overcome the problems in existing schemes, thus can help to generate high-quality representations. We conduct both intrinsic and extrinsic evaluations, and compare PalmTree with other instruction embedding schemes. PalmTree has the best performance for intrinsic metrics, and outperforms the other instruction embedding schemes for all downstream tasks.

Given the widespread prevalence of vulnerabilities, remediation is a critical phase that every software project has to go through. When comparing the studies on understanding the security vulnerabilities in software, such as vulnerability discovery and patterns, there is a lack of studies on the vulnerability remediation phase. To address this, we have done a timeline analysis for 130 of the most dependent upon open source projects written in JavaScript language, hosted on GitHub to understand the nature and the lifetime of the vulnerabilities in those projects. We used a static code analyzer on 501K commits from the repositories to identify commits that introduced new vulnerabilities to the code and fixed existing vulnerabilities in the code. In 90% of the projects, we identified that a commit that fixed an existing vulnerability had introduced one or more new vulnerabilities into the code. On average, 16% of the commits intended to fix vulnerabilities have introduced one or more new vulnerabilities from the analyzed projects. We also found that 18% of the total vulnerabilities found in those projects have originated from a commit meant to fix an existing vulnerability, and 78% of those vulnerabilities could have been avoided of introduction if the developers were to use proper internal testing. Here, we demonstrate Sequza, a visualization tool to help organizations detect such instances at the earliest possible.

Browser extensions are popular to enhance users' browsing experience. By design, they have access to security- and privacy-critical APIs to perform tasks that web applications cannot traditionally do. Even though web pages and extensions are isolated, they can communicate through messages. Specifically, a vulnerable extension can receive messages from another extension or web page, under the control of an attacker. Thus, these communication channels are a way for a malicious actor to elevate their privileges to the capabilities of an extension, which can lead to, e.g., universal cross-site scripting or sensitive user data exfiltration. To automatically detect such security and privacy threats in benign-but-buggy extensions, we propose our static analyzer DoubleX. DoubleX defines an Extension Dependence Graph (EDG), which abstracts extension code with control and data flows, pointer analysis, and models the message interactions within and outside of an extension. This way, we can leverage this graph to track and detect suspicious data flows between external actors and sensitive APIs in browser extensions. We evaluated DoubleX on 154,484 Chrome extensions, where it flags 278 extensions as having a suspicious data flow. Overall, we could verify that 89% of these flows can be influenced by external actors (i.e., an attacker). Based on our threat model, we subsequently demonstrate exploitability for 184 extensions. Finally, we evaluated DoubleX on a labeled vulnerable extension set, where it accurately detects almost 93% of known flaws.

Device drivers tend to be vulnerable to errant/malicious devices because many of them assume that devices always operate correctly. If a device driver is compromised either deliberately or accidentally, this can lead to system failure or give adversaries entire system access. Therefore, testing whether device drivers can handle compromised I/O correctly is important. There are several studies on testing device drivers against I/O attacks or device failures. Previous studies, however, either require source code for testing, lack test efficiency, only support a specific OS, or only target MMIO accesses. In this paper, we present a novel testing framework of device drivers' I/O boundaries. By combining a hypervisor-based fault injection mechanism and coverage-guided fuzzing scheme, our testing framework is not only OS-independent but also efficient and can test closed-source drivers. To get the information needed to test without OS cooperation, we use IOMMU to detect DMA regions and a hardware tracing mechanism to get coverage. We describe the detailed design and the current status.

We see three different roles (peer, tutee, tutor) for humanoid robots in education. The role of a monitor or an invigilator is understudied. Therefore, in this paper, we describe a method for the social robot to act as an invigilator. We implemented this method on the Nao robot. We conducted a study to compare an active invigilator robot v.s. a passive invigilator robot. The study aimed to understand the participant’s perception of the robot in the role of an invigilator. We found that the robot was highly rated as an invigilator regardless of the condition. Participants were generally satisfied with the use of the robot as an invigilator. Participants rated the active robot invigilator to be more human-like and responsive as compared to the passive one. The findings highlight the applicability of the role of a robot invigilator in education and call for a more careful investigation in the future.

Second language learning has become very important because of globalization and as a result, many online language learning platforms have gained popularity. Despite their popularity and convenience, they still lack the human factor and meaningful interaction. Robot-Assisted language learning (RALL) is a concept where social robots are employed to assist in language learning, adding meaningful and human-like interactions to the process. In the case of online learning platforms, a similar approach can be taken using virtual robots. Virtual robots are similar to social robots as they can have a visual appearance, communication capabilities as well as human-like features. This research aims to understand the potential users', i.e., university students' perceptions, and expectations of a virtual robot as a language learning companion. We are focusing on three major aspects of its design: Appearance, interaction and rewarding behavior. This is a qualitative and explorative study, which employs a human-centered design (HCD) approach by conducting a co-design workshop with five groups of university-level language students (n = 25) and a theme interview with seven design students. This article presents the first phase of the HCD process. The participants were asked questions about the appearance, behavior, movements, motivational factors, sound and rewarding features of the potential virtual language companion robot. The findings show that the idea of having an interactive virtual robot to assist online language learning was accepted and appreciated by all the participants but their expectations about the robot's design varied. The potential users preferred a robot-like appearance rather than a human-like one for the virtual language learning companion, however, different robot-like appearances were mentioned in terms of their body parts, hands, head, shapes etc. Human-like gestures and movements were appreciated by the participants. Finally, seven design implications were formulated to support the further design of a virtual robot that can act as a virtual language learning companion as part of an online learning platform for university students. acceptedVersion

Nowadays, many organizations store and publish their data and services based on the Cloud Computing paradigm. In this scenario, cloud consumers access these resources anytime and anywhere. Software as a Service (SaaS) and Data as a Service are examples of cloud services. While DaaS delivers and manages data on-demand, SaaS is a delivery model of applications in a cloud environment. However, the vast amount of social data and applications enable different formats of DaaS, such as non-structured (e.g., text), semi-structured (e.g., JSON), and structured format (e.g., Relational Database). The lack of standardization makes users dependent on a system due to the lack of interoperability among different providers. Interoperability is heterogeneous systems' ability to communicate transparently, and it is classified into syntactic, semantic, and pragmatic levels. Middleware for SaaS and DaaS (MIDAS) is a solution to provide interoperability among cloud services. Although the latest version of MIDAS promotes a semantic approach, pragmatic aspects are not addressed. This paper enhances MIDAS to provide pragmatic interoperability in a cloud environment. Our approach presents the necessary elements that MIDAS must consider to provide pragmatic interoperability among cloud services. We conduct a set of experiments to validate our pragmatic MIDAS. We evaluate the overhead of our approach, the correctness of our novel MIDAS, and the effort to implement the MIDAS middleware with dynamic pragmatic information. Results evidence that our approach is towards pragmatic interoperability among cloud services.

Widgets are part of many web applications and implement distinct interaction mechanisms, in reusable user interface components. However, implementing accessible widgets is a challenge, associated to different factors highlighted in the state-of-the-art, such as: lack of developers knowledge of accessibility guidelines, organization support and tools that support accessible development. This paper reports an investigation on JavaScript source-code complexity impacts of implementing accessibility requirements in widgets. We investigated Dialog, Drop-down menu and Tab widgets of 27 open-source JavaScript libraries. The results showed that widget software artifacts reported an increased average of source-code complexity when implementing accessibility requirements. Results also showed that using DOM-oriented JavaScript libraries (eg. jQuery) significantly increased source-code complexity of widgets. Nevertheless, when using Declarative Component-based JavaScript libraries, no significant difference in source-code complexity was observed. These results suggest that using Declarative Component-based widget libraries might reduce maintainability costs of JavaScript front-end projects.