USound, the leading provider of advanced audio solutions from Austria, announced that it has been selected by Physical Synthesis, a US-based hardware startup that builds state-of-the-art musical instruments,

USound & Physical Synthesis to Send the Tiniest Speaker to Space

USound’s Achelous UT-P2016 MEMS speaker is ideal for manufacturing MRI-headphones due to the absence of ferromagnetic parts in its design. Achelous is now a key component of NordicNeuroLab’s ...

NordicNeuroLab Selects USound as A MEMS Speaker Supplier for Its New MRI-Compatible Headphones

USound, a fast-growing company providing advanced audio solutions, has been selected by NordicNeuroLab, the leading global producer of medical equipment for functional magnetic resonance imaging (MRI) studies, as a MEMS microspeaker supplier for the ...

USound, a fast-growing company providing advanced audio solutions, has been selected by NordicNeuroLab, the leading global producer of medical equipment for functional magnetic resonance imaging ...

USound's Achelous UT-P2016 MEMS speaker is ideal for manufacturing MRI-headphones due to the absence of ferromagnetic parts in its design. Achelous is now a key component of NordicNeuroLab's ...

USound’s Achelous UT-P2016 MEMS speaker is ideal for manufacturing MRI-headphones due to the absence of ferromagnetic parts in its design. Achelous is now a key component of NordicNeuroLab’s patient-soothing MRI-compatible over-ear headphones that will ...

USound

usound

Google Fails to Undermine the Search Ad and Text Ad Market

Was Craig Wright’s 2008 Bitcoin Email Just an Elaborate Forgery?

This paper is available on arxiv under CC 4.0 license. Authors: (1) Pietro Ghezzi, Brighton & Sussex Medical School, Falmer, Brighton, UK; (2) Peter G Bannister, Brighton & Sussex Medical School, Falmer, Brighton, UK; (3) Gonzalo Casino, Communication Department, Pompeu Fabra University, Barcelona, Spain and Iberoamerican Cochrane Center, Barcelona, Spain; (4) Alessia Catalani, Department of Biomolecular Sciences, University of Urbino Carlo Bo, Urbino, PU, Italy; (5) Michel Goldman, Institute for Interdisciplinary Innovation in healthcare (I3h), Université libre de Bruxelles; (6) Jessica Morley, Oxford Internet Institute, University of Oxford, Oxford, UK; (7) Marie Neunez, Institute for Interdisciplinary Innovation in healthcare (I3h), Université libre de Bruxelles; (8) Andreu Prados, Communication Department, Pompeu Fabra University, Barcelona, Spain, Iberoamerican Cochrane Center, Barcelona, Spain, Department of Biomolecular Sciences, University of Urbino Carlo Bo, Urbino, PU, Italy, Institute for Interdisciplinary Innovation in healthcare (I3h), Université libre de Bruxelles, Oxford Internet Institute, University of Oxford, Oxford, UK, and Blanquerna School of Health Sciences, Universitat Ramon Llull, Barcelona, Spain; (9) Mariarosaria Taddeo, Oxford Internet Institute, University of Oxford, Oxford, UK, Blanquerna School of Health Sciences, Universitat Ramon Llull, Barcelona, Spain, and The Alan Turing Institute, London, UK; (10) Tania Vanzolini, Department of Biomolecular Sciences, University of Urbino Carlo Bo, Urbino, PU, Italy; (11) Luciano Floridi, Oxford Internet Institute, University of Oxford, Oxford, UK, Blanquerna School of Health Sciences, Universitat Ramon Llull, Barcelona, Spain, and The Alan Turing Institute, London, UK. Table of Links Abstract and Introduction Methods Web search and content analysis Results Discussion Conclusion and References Table 1. Example of classification of webpages Table 2. Percentage of vaccine-negative webpages in different SERPs Discussion The aim of this research was to investigate whether search engines focused on privacy preservation ranked webpages with higher and/or lower levels of IQ (interpreted as EBM based content i.e. vaccine-positive rather than vaccine-negative) differently to the primary commercial search engines. In turn, this answered the research question “What is the current relationship between search engines’ approach to privacy and the scientific quality of the information they return?”. The results indicate that currently privacy-enhancing search engines often give more visibility to webpages promoting vaccine hesitancy or with a clear anti-vaccine position than Google. This is in agreement with the findings from a recent study by the Economist which analyzed 175,000 news links returned by Google to demonstrate that the search engine’s algorithm favorstrustworthy publications 20. Reputation and trustworthiness are key factors included in Google’s ranking algorithm. In 2019, Google published search quality evaluation guidelines, 4 which define webpages containing information that may affect the users’ health or financial stability, as “your money your life” (YMYL) pages. These guidelines reveal that when rating YMYL webpages, Google looks at the three criteria of Expertise-Authority-Trustworthiness (EA-T) and states “High E-A-T information pages on scientific topics should be produced by people or organizations with appropriate scientific expertise and represent well-established scientific consensus on issues where such consensus exists”. Thus, in the case of Google, the bandwagon heuristic mechanism of assessing medical information credibility is working in favour of promoting IQ. This is perhaps because those responsible for driving up the ‘reputation’ of specific websites by, for example, linking to them, have higher levels of eHealth literacy and therefore act as pseudo-gatekeepers protecting those with lower eHealth literacy from poor IQ results by ensuring that websites providing inaccurate online health information have a low ranking in the search results. In the case of privacy-preserving engines this appears not to be working – potentially because they do not track ‘reputation’ factors, which could be seen as proxies for IQ and credibility, e.g. clicks and bounce-rate, and so have no gatekeepers (pseudo or otherwise) working to limit the circulation of misinformation. To our knowledge, the algorithms used by these ‘alternative’ search engines are not public - Qwant states that they use their own algorithms5 - but despite this, we found a large overlap between the SERP of Qwant and those of Bing and Ecosia. Likewise, Ecosia and Swisscows showed a similar overlap (70%) with Bing. This means that it is not possible to check what factors determine the outcome of the decision making processes of the search engines algorithms, and hence identify those elements that contribute to circulate misinformation. Even without being able to check the exact mechanisms for the overall poorer results, the results suggest that, currently, decisions made by search engines to prioritize privacypreservation may have a negative impact on the IQ of results returned to users in health contexts. The pledge to provide independent and unbiased results or not to promote or hide websites based on political or moral interests can be seen as ethically ambiguous, in view of the potential consequences of pointing to scientifically unsound health information. Medical ethics requires that patients give informed consent before treatment and must, therefore, be informed accurately of the risks and benefits associated with treatment, something that is not possible if the search engine provider used by an individual is returning results with low IQ. From this consequentialist perspective, it is inherently unethical choosing not to interfere with a search engine’s ranking algorithm to ensure ‘manually’ that results of higher IQ are prioritized, whilst those of lower IQ are suppressed. This builds on arguments already made in the wider literature about algorithm ethics 21,22. For example, the Association for Computing Machinery (ACM) code of ethics and professional conduct includes, as a general principle, “avoid harm” along with that of “respect privacy” 23, which aligns with the Hippocratic oath. Specifically, the implication that the current design of privacy-preserving search engine algorithms underestimates the need for evaluation of IQ fits into the wider discussion about algorithmic design and how to ensure design decisions are made to protect and incorporate key values such as IQ. It is necessary, but insufficient, to design search engine algorithms that index purely on ‘relevance’, they must also be designed to index on quality. The challenge lies in the ability to do this in a way that balances the need to accept different perspectives (particularly those that are rooted in different cultural, religious or social ideals) whilst also filtering for IQ. Supporters of such arguments, including the authors, note that this requirement necessitates making the workings of search engine algorithms more transparent 24 to ensure their ethical compliance. Providing information on vaccines that is based on misinformation or disinformation (including studies whose data or conclusions have been shown to be wrong) is a deceptive practice, which goes against the basic tenets of medical and business ethics 25. This is in line with those who argue that the promotion of ‘alternative medicine’ is unethical because it lacks evidence and transparency of clinical efficacy and should be considered ‘false advertising’ 26. Online service providers have a moral responsibilities to ensure that users access health information that is scientifically validate 27. Misinformation and disinformation concerning healthcare circulating on the internet can have severe consequences and lead to widespread harm. Consider the example of South African president Mbeki, who delayed introducing anti-retroviral drugs in favor of alternative medicine based on information obtained from HIV-denialist internet websites, a decision estimated to have resulted in over 300,000 deaths 28. More recently, a cancer patient died in China after following an alternative, non-approved therapy they found using a search engine 29. In response Chinese authorities issued new rules that require search engines to provide “objective, fair and authoritative results”. Moral responsibility follows on the level of harm that misinformation and disinformation on healthcare may cause. It could be argued that there is a greater onus on Google – and other commercial search engine providers – than on alternative search engines to take these considerations into account when designing or interfering with algorithms for the purposes of promoting ethical compliance, given their larger market share. Google currently has over 90% of the worldwide market share6 and therefore has the potential to indirectly ‘cause harm’, through the potential promotion of low IQ webpages on vaccinations, to a great many more people than any of the alternative providers. However, studies have shown that those who hold anti-authoritarian views, openness to (potentially) controversial opinions, and an interest in alternative medicine are, in some cases, already more likely to hold vaccine-hesitant beliefs 30. These are also the individuals who are most likely to use alternative search providers given their sensitivity to privacy and tracking concerns. Therefore, while the alternative providers might reach a proportionally smaller audience – they are reaching an audience that is already more receptive to antivaccine information 31, and therefore more vulnerable to its effects. In other words, unless the alternative providers take steps to rank vaccine-related search results according to IQ, they may cause greater harm to those they do reach, meaning that the net negative impact is still greater even though the number of individuals they reach is smaller.

Online Information of Vaccines: Discussion

Sound Call Graph Construction for Java Object: Conclusions, Acknowledgment, & References

This paper is available on arxiv under CC 4.0 license. Authors: (1) JOANNA C. S. SANTOS, University of Notre Dame, USA; (2) MEHDI MIRAKHORLI, University of Hawaii at Manoa, USA; (3) ALI SHOKRI, Virginia Tech, USA. Table of Links Introduction Background Seneca: Taint-Based Call Graph Construction for Object Deserialization Evaluation Results Related Work Conclusions, Acknowledgment, and References 5 Results 5.1 RQ1: Call Graph Soundness This section describes the results of the experiments for measuring the soundness of the call graphs computed by Seneca. As shown in Table 4, only our serialization-aware call graph construction (Seneca) and Salsa passed of the nine test cases. Only three other algorithms partially provided support for callback methods, namely Soot') and Soot⇠ (2 out of 9) and OPAL') (5 out of 9) [Reif et al. 2019]. The remaining algorithms, i.e., Soot (VTA, and Spark), Wala (RTA, 0-CFA, 1-CFA, 0-1-CFA), and Doop (context-insensitive), did not provide support at all for serialization-related callback methods. all It is also important to highlight that the frameworks that provided partial support for serialization-related features (SootRTA, SootCHA, and OpalRTA) use call graph construction algorithms (CHA [Dean et al. 1995] or RTA [Bacon and Sweeney 1996]). Table 5 shows a comparison of call graphs’ sizes in terms of nodes and edges. As we can infer from these charts, the only call graph construction algorithms used by Soot, and Opal that provided support for serialization create much larger call graphs (in terms of the number of nodes and edges). Since these algorithms only rely on static types when computing the possible targets of a method invocation, they introduce spurious nodes and edges, thereby increasing the call graph’s size. imprecise partial Our approach enhances the underlying pointer analysis policy in order to strike a balance between improving soundness while not greatly affecting the call graph’s precision by adding spurious nodes and edges. A more recent work, Salsa, also produced call graphs with reasonable sizes, very similar to ours. However, this is because the test cases in the CATS dataset are rather simple; they are up to two classes that exercise one custom call back method at a time. As we will discuss in the next subsection, Salsa’s ability to create sound call graphs is greatly diminished when using the source code of real software projects. 5.1.2 Dataset #2: XCorpus Dataset Figure 7 depicts the percentage of edges in the runtime call graph of the projects, that are missing on the static call graph computed by each approach. From this chart, we notice that Seneca Wala and Salsa. Our approach has missing edges compared to other the approaches, ., it is able to soundly infer hidden paths through serialization callbacks. outperformed less i.e When inspecting the edges that Seneca missed, we observed that these edges were to serialization callbacks. That is, these were edges to which the underlying pointer analysis algorithm cannot soundly infer the points-to sets of variables. For example, we observed edges that were missed because instructions were using re"ection to invoke methods. These were constructs that the underlying 0-1-CFA and 1-CFA pointer analysis provided by Wala (our baseline framework) could not correctly infer the dispatch. unrelated One of the reasons as to why Salsa performed similar to Seneca with the CATS test suite but performed poorly on the XCorpus dataset has to do with its inability to compute potential method dispatches from classes in the classpath. As described in their work [Santos et al. 2021, 2020], the approach relies on downcasts of objects to infer what are the object(s) being deserialized. When downcasts are unavailable, the approach relies on a simple approach of computing all possible dispatches, but limited to classes on the application scope. Our approach, on the other hand, follows Java’s serialization specification and includes classes in the classpath, irrespective of its scope (i.e., extension, primordial, or application scope). all 5.2 RQ2: Precision This section describes the evaluation results of the precision of the call graphs computed by Seneca. CATS Figure 8 depicts the number of edges in the call graph that were not present in the call graph for the test cases in the CATS test suite [Reif et al. 2019]. As shown in this chart, Seneca was able to provide full support for serialization callbacks (passing all test cases, see Table 4) while maintaining reasonably sized call graphs. Compared to Soot and OPAL, the derived call graphs were far more . While Opal and Soot had over 800 imprecise edges, Seneca had between 95 and 343 incorrect edges. 5.2.1 Dataset #1: static runtime imprecise This comparison also shows that Salsa’s performance was similar to Seneca. As explained in the previous section, however, this similar performance is caused by the fact that the programs in the CATS test suite are small, which does not include scenarios where Salsa’s unsound assumptions fall short. Figure 9 plots the percentage of edges that are in the runtime call graph, but that are not in the static call graph of each approach. As observed on this chart, unsurprisingly, increasing the soundness of the call graph also increased the number of imprecise edges ( ., edges that did not arise at runtime). The increase of missed edges is comparable to the one by Salsa. 5.2.2 Dataset #2: XCorpus Dataset i.e When we inspected the imprecise edges, we noticed that those were related to serialization nodes, i.e., cases in which our call graph included all possible objects that can be serialized. Indeed, as our test cases serialized only one object at a time, all these edges are deemed as incorrect. However, as the Java API allows the deserialization of arbitrary types (i.e., any serializable type available on the class path), the edges in Seneca could arise at runtime if an object being read uses one of the other serializable classes (other than the one from the test case). 5.3 RQ3: Performance The observed differences, however, do not hinder the overall scalability of the approach. The approach still finishes within seconds of execution. Moreover, when further inspecting the worklist of our algorithm, we noticed that Seneca incurs between 3–6 extra iterations over Wala’s worklist. These extra iterations along with the taint analysis are the root cause for the extra running time needed for Seneca to finish. 5.4 RQ4: Usefulness for Vulnerability Detection We have implemented a client analysis that attempts to find vulnerable paths caused by untrusted object deserialization in a program. We then verified how well this client analysis could detect vulnerable paths by comparing its performance using the call graph computed by Salsa and the one generated by Seneca. The results for this experiment are shown in Table 6. As shown in this table, Salsa’s call graphs were not suitable for performing vulnerability detection. The key issue lies on the unsoundness of Salsa. This approach relies on type casts (downcasts) to infer what object is being deserialized from a stream. However, as explained in Section 2.2.1, untrusted object deserialization vulnerabilities are caused by the ability of an attacker to craft arbitrary objects using any serializable class available in the classpath. Thus, even if the program performs a downcast over the serialized object, the exploit would have been executed anyway, as the vulnerability arises during deserialization and not after it. Unlike Salsa, our approach was able to !nd vulnerable paths within our allocated time budget (of 15 minutes and up to 15 call graph nodes in a path). The identi!ed paths included the vulnerable paths from previously disclosed gadget chains, documented on the YSoSerial repository of deserialization exploits [Froho# 2018].

Sound Call Graph Construction for Java Object Deserialization: Results

This paper is available on arxiv under CC 4.0 license. Authors: (1) JOANNA C. S. SANTOS, University of Notre Dame, USA; (2) MEHDI MIRAKHORLI, University of Hawaii at Manoa, USA; (3) ALI SHOKRI, Virginia Tech, USA. Table of Links Introduction Background Seneca: Taint-Based Call Graph Construction for Object Deserialization Evaluation Results Related Work Conclusions, Acknowledgment, and References 4 Evaluation In this section, we introduce our research questions and describe our experiment setup and design to answer those. 4.1 Research Questions This paper addresses the following research questions: Soundness. RQ1 Does Seneca handle object deserialization soundly? Precision. RQ2 Does an increase in the call graph’s soundness incur a significant loss in its precision? Scalability. RQ3 Does Seneca scale well for real software systems? Usefulness. RQ4 Is Seneca useful for a client analysis focused on vulnerability detection? 4.2 Answering RQ1: Soundness We aim to verify whether Seneca improves a call graph’s soundness with respect to deserialization callbacks and how it compares with existing approaches [Reif et al. 2019, 2018; Santos et al. 2021, 2020]. The soundness of a call graph construction algorithm corresponds to being able to create a call graph that incorporate all possible paths (nodes and edges) that can arise at runtime [Ali et al. 2019; Kummita et al. 2021]. In this work, we are specifically looking at improving a call graph’s soundness to cover possible invocations that arise during object serialization and deserialization. Therefore, we use two datasets to answer this first research question: • Call Graph Assessment & Test Suite (CATS) [Eichberg 2020]: This dataset was released as part of recent empirical studies [Reif et al. 2019, 2018] to investigate the soundness of the call graphs computed by existing algorithms with respect to particular programming language constructs. The CATS test suite6 was derived by an extensive analysis of real Java projects to create test cases that are representative of common ways that projects use these language constructs (e.g., lambdas, reflection, serialization, etc.). The dataset includes 9 test cases for verifying the soundness of call graphs during serialization and deserialization of objects. Each test case is a Java program with annotations that indicate the expected target for a given method call. Table 2 provides an overview of the test cases available in the CATS test suit and what aspects they aim to probe. Hence, in this !rst experiment, we run Seneca using two pointer analysis configurations: 0-1-CFA, and 1-CFA. Then, we compare it against Salsa (0-CFA, 1-CFA), a state-of-the-art tool, as well as the same algorithms used in the empirical study by Reif [Reif et al. 2019], namely Soot (CHA, RTA, VTA, and Spark), Wala (RTA, 0-CFA, 1-CFA, and 0-1-CFA), Doop (context-insensitive), and Opal (RTA). et al. — Metric: Likewise to the prior empirical study by Reif et al. [Reif et al. 2019, 2018], we compute the number of failed and passed test cases for each approach as a way to investigate the soundness of our approach. • XCorpus dataset: Although the CATS dataset was carefully constructed to test call graph construction algorithms with respect to programming language features, the test cases are small programs (i.e., with few serializable classes). Therefore, to enhance our analysis, we used programs available on the XCorpus dataset [Dietrich et al. 2017b]. We chose this dataset because it has been widely used in prior related works [Fourtounis et al. 2018; Santos et al. 2021, 2020] and it was manually curated to be representative of real Java projects. From this dataset, we selected a total of 10 programs from the XCorpus dataset [Dietrich et al. 2017b] (listed in Table 3). We selected these projects because they match the following criteria: (i) they perform object serialization / deserialization; (ii) they contain serializable classes that provide custom implementation for callback methods; hence, they would be suitable to verify whether our approach can properly compute a call graph that uncover hidden paths via callback methods. For each of these 10 projects, we created a set of test cases that exercised the serialization and deserialization of objects from the classes that contained custom callback methods. Each test case serializes an object into a !le, and then deserializes it back from this !le, as shown in Listing 4. The systematic process we followed to create these test cases were as follows. For each class in the XCorpus program that had a custom callback method, we created a “simple” test case. This “simple” test case returns a single instance from the class inside the method getObject(). We read the project’s documentation to initialize the object’s !elds correctly and avoid exceptions thrown by the class’ constructor. We also created “composite” test cases in which the class instance is wrapped into a collection, an , a , a , or an array. i.e., ArrayList HashSet HashMap By following this systematic process, we create !ve test cases (1 “simple” test case, and 4 “composite” ones) for each class with a custom callback in an XCorpus project. The list of XCorpus programs and the number of test cases for each of them is shown in Table 3. After creating these test cases, we execute them to extract their dynamic call graph (runtime call graph). We implemented a JVMTI (Java Virtual Machine Tool Interface) agent in C to compute these runtime call graphs. This implementation has an instrumentation agent that is attached to the program’s execution. It captures every method that is invoked in the program and its caller method. Since we aim to investigate whether our taint-based call graph algorithm handle object deserialization soundly or would unsound assumptions be able to find vulnerabilities, we compare Seneca against Salsa [Santos et al. 2021, 2020], a state-of-the-art tool that computes call graphs for object deserialization based on downcasts within the program, which yields to less sound call graphs. Metric: Similar to prior works [Ali et al. 2019; Ali and Lhoták 2012; Kummita et al. 2021; Li et al. 2014; Smaragdakis et al. 2015], we verify our approach’s soundness based on the number of edges in the runtime call graph that are missing in the static call graph. In our comparison, we differentiate application-to-application edges, application-to-library, and library-to-library edges. That means that we disregard missing edges due to: (a) class initializers (because methods are modeled by Wala using a synthetic method that invokes all class initializers at once), (b) native code (because it cannot be statically analyzed), (c) explicitly excluded classes (i.e., classes inside our list of exclusions !le that are removed from the static call graph), and (d) library-to-library edges (i.e., edges from a built-in Java class to another built-in language class). 4.3 Answering RQ2: Precision Although soundness is a desirable property for static analysis, in practice, however, creating a sound analysis also implies a loss of precision. Due to the undecidability of program veri!cation, it is impossible to create an analysis that is both sound and precise [Rice 1953]. Therefore, a sound analysis is an over-approximation that may include spurious results (e.g., unrealistic paths). While our approach aims to enhance an existing call graph construction algorithm to handle serialization-related callbacks soundly, we need to verify whether our approach introduces imprecision and to what extent. Imprecision in this work refers to adding nodes and edges that will not arise at the program’s runtime during object serialization and deserialization [Ali et al. 2019]. In other terms, the precision of a call graph means that it does not contain nodes and edges that will not arise at runtime during object deserialization and serialization. To answer this question, we use our JVMTI agent to compute the runtime call graph for each program in the CATS test suite [Eichberg 2020] and our manually constructed Test Cases derived from the XCorpus dataset [Dietrich et al. 2017b]. Subsequently, we compute the number of edges in the static call graph that did not exist in the runtime call graph. — : We calculate the number of nodes and edges that appeared in Seneca’s call graph but did not appear on the dynamic call graph. Similar to prior works [Smaragdakis et al. 2015; Smaragdakis and Kastrinis 2018], when performing this calculation, we only consider applicationto-application edges and application-to-library edges as long as these edges do not include nodes that are a class initializer, a native code method, or a method from an explicitly excluded class. Metric 4.4 Answering RQ3: Performance — : We measure (i) the running time to compute the call graphs when using our approach, and (ii) the extra added number of iterations over the worklist of the call graph construction algorithm. We run these analyses on a machine with a 2.9 GHz Intel Core i7 processor and 32 Gb of RAM memory. Metric 4.5 Answering RQ4: Efficiency One of the premises of this work is that a taint-based call graph construction enable the computation of sound call graphs with respect to (de)serialization, which can be useful for client analyses, such as vulnerability detection. In this question, we aim to verify whether Seneca can help a static analysis technique in finding potential vulnerable paths in the program. To answer this question, we obtained 3 open-source projects with known disclosed deserialization vulnerabilities. We selected these projects because their exploits have been widely discussed by practitioners and are available on the YSoSerial GitHub repository [Froho# 2018]. That is, these projects have well-known “gadget chains” which were previously disclosed in vulnerability reports. To answer this RQ, we used Seneca and Salsa to compute the call graphs of these projects (con!gured to use 0-1-CFA and 1-CFA). Subsequently, we use these call graphs to extract vulnerable paths which are paths from ObjectInputStream.readObject() to sinks, i.e., method invocations to security-sensitive operations. To identify sinks, we manually curated a list of security-sensitive method signatures. To do so, we extracted the list of sink methods from a prior published work [Thomé et al. 2017]. Moreover, we parsed the manifest !le from the Juliet Test Suite [Software 2023]. This test suite is a dataset from NIST (National Institute of Standards and Technology) which has a collection of synthetic C/C++ and Java code samples with di#erent software weaknesses (CWEs). Their manifest !le indicates all the !les for a test case, the kind of weakness it contains, and its location in the code. Thus, we parsed the manifest to extract the lines that are "agged as vulnerable, !ltered out the lines that are not method invocations, grouped them by signature, and manually identi!ed the ones that are sinks. After performing these two complementary curation steps, we obtained a total of 101 methods signatures for sinks. — : We measured how many vulnerable paths each approach was able to identify. Metric [7] https://github.com/wala/WALA/blob/master/com.ibm.wala.core/src/main/resources/Java60RegressionExclusions.txt

Sound Call Graph Construction for Java Object Deserialization: Evaluation

This paper is available on arxiv under CC 4.0 license. Authors: (1) JOANNA C. S. SANTOS, University of Notre Dame, USA; (2) MEHDI MIRAKHORLI, University of Hawaii at Manoa, USA; (3) ALI SHOKRI, Virginia Tech, USA. Table of Links Introduction Background Seneca: Taint-Based Call Graph Construction for Object Deserialization Evaluation Results Related Work Conclusions, Acknowledgment, and References Object serialization and deserialization is widely used for storing and preserving objects in !les, memory, or database as well as for transporting them across machines, enabling remote interaction among processes and many more. This mechanism relies on re"ection, a dynamic language that introduces serious challenges for static analyses. Current state-of-the-art call graph construction algorithms does not fully support object serialization/deserialization, i.e., they are unable to uncover the callback methods that are invoked when objects are serialized and deserialized. Since call graphs are a core data structure for multiple type of analysis (e.g., vulnerability detection), an appropriate analysis cannot be performed since the call graph does not capture hidden (vulnerable) paths that occur via callback methods. In this paper, we present Seneca, an approach for handling serialization with improved soundness in the context of call graph construction. Our approach relies on taint analysis and API modeling to construct sound call graphs. We evaluated our approach with respect to soundness, precision, performance, and usefulness in detecting untrusted object deserialization vulnerabilities. Our results show that Seneca can create sound call graphs with respect to serialization features. The resulting call graphs do not incur signi!cant overhead and was shown to be useful for performing identi!cation of vulnerable paths caused by untrusted object deserialization. CCS Concepts: • - ; ; ; • - Software and its engineering Automated static analysis Software verification and validation General programming languages Social and professional topics History of programming languages. Additional Key Words and Phrases: object serialization, taint analysis, call graphs ACM Reference Format: Joanna C. S. Santos, Mehdi Mirakhorli, and Ali Shokri. 2024. Sound Call Graph Construction for Java Object Deserialization. Proc. ACM Program. Lang. 1, CONF, Article 1 (January 2024), 27 pages. 1 Introduction Static program analysis is a key component of today’s software analysis tools that bring automation into activities such as defect localization and/or !nding (e.g., [Dolby et al. 2007; Thaller et al. 2020]), vulnerability detection (e.g., [Jovanovic et al. 2006; Liu Ping et al. 2011]), information "ow analysis [Sridharan et al. 2011], code refactoring (e.g., [Khatchadourian et al. 2019]), code navigation (e.g., [Feldthaus et al. 2013]), code clone !nding (e.g., [Wyrich and Bogner 2019]), and optimization [Hines et al. 2005]. Such tools often perform multiple types of inter-procedural analysis, that leverage call graphs – data structures that indicate caller-callee relationships [Grove and Chambers 2001]. However, prior works have demonstrated that constructing a call graph for object-oriented programs is often non-trivial, expensive and/or non-feasible due to the usage of many dynamic programming language constructs. For instance, native calls, re"ection, and object serialization make it challenging to statically construct a sound call graph [Ali et al. 2019; Kummita et al. 2021; Reif et al. 2019, 2018; Smaragdakis et al. 2015; Sridharan et al. 2013]. These programming constructs are heavily used in contemporary software systems as they enable the developers to link/load new class libraries, methods, and objects and extend the programs’ functionalities [Landman et al. 2017; Reif et al. 2019]. Ignoring such constructs leads to unsound call graphs in which feasible runtime paths are missed, and call graphs cannot be used to infer the possible execution from the code [Reif et al. 2019, 2018; Sridharan et al. 2013]. To tackle this problem, previous works explored certain classes of language features, such as re"ection features [Bodden et al. 2011; Li et al. 2014, 2019; Smaragdakis et al. 2015], native (opaque) code [Smaragdakis et al. 2015], dynamic proxies [Fourtounis et al. 2018], and programs with Remote Method Invocation (RMI) [Sharp and Rountev 2006]. However, as demonstrated by Reif et al. [Reif et al. 2019, 2018], a powerful and frequently used programming construct that has been left out from the programming analysis techniques is serialization (and deserialization) of objects. Object serialization is the process of converting (the state of) an object into an abstract representation (e.g., a byte stream or JSON, etc.). The reverse process of reconstructing objects from its abstract representation is called deserialization. This is a widely used mechanism for storing and preserving objects in !les, memory, or database as well as for transporting them across machines, enabling remote interaction among processes and many more. For example, the Android API provides a Bundle object which can be used for inter-process communication between apps as well as Android’s OS with an individual app via their serialization and deserialization [Arzt et al. 2014; Enck et al. 2014]. Moreover, object (de)serialization is also used to improve the system’s performance by saving objects for later retrieval, e.g., saving a trained machine learning model to be used later without the need to retrain the algorithm. Serializing an object has other advantages, such as being readable by applications in other languages. For instance, JavaScript running in a web browser can natively serialize and deserialize objects to and from JSON, therefore interact with other applications written non-JavaScript languages. Although object serialization is widely used in many languages and commonly adopted by programmers, static analyzers do not fully cover analysis of programs with this construct yet [Reif et al. 2019, 2018]. This is particular important considering the spike of vulnerabilities related to untrusted object deserialization [Muñoz and Schneider 2018; Sayar et al. 2023; Schneider and Muñoz 2016] that cannot be automatically detected because call graphs are unsound. For example, Apache’s Log4j software library (versions 2.0-beta9 to 2.14.1) had an untrusted object deserialization vulnerability that allowed remote code execution. This was a critical vulnerability that affected several software systems. As demonstrated by previous studies on the soundness of call graph construction approaches [Reif et al. 2019, 2018]— guaranteeing that all possible behaviors are modeled in a call graph — state-of-theart techniques do not support serialization-related operations. They fall shortly in having nodes and edges that represent callback methods that are invoked during the serialization or deserialization of objects. There are multiple reasons on why it is hard to handle this language construct: — Serialization and deserialization uses several overridable callback method(s). These call back methods are invoked by the Java API using “non-trivial” re"ective calls that current techniques [Landman et al. 2017] for taming re"ection do not address. Therefore, the resulting call graph underapproximate the program’s behavior; they miss potential program paths through these call back methods. — The invoked callbacks during deserialization methods depend on the received object, which is coming from an external stream. The values and internal !eld types are only known at runtime when the object deserialization occurs. — The external stream may include objects whose types are not observed statically, i.e., they are available in the classpath (imported libraries, or Java built-in API) but were never actually used (instantiated) in the application scope. A typical static analysis would consider these types as unused. Therefore, existing techniques on addressing re"ections has failed to address call-graph generation with the presence of object serialization/de-serialization [Reif et al. 2019]. As such, potential program "ows are disregarded in existing call graph construction algorithms. Since the call graph is a core data structure in performing many inter-procedural code analyses, the underlying client would suffer with the unsoundness. In use-cases such as detection of untrusted deserialization vulnerabilities, an appropriate analysis cannot be performed since the call graph does not capture hidden (vulnerable) paths that occur via callback methods. There are two algorithms that (partially) handle serialization constructs (i.e., CHA [Dean et al. 1995] and RTA [Bacon and Sweeney 1996]) but they are imprecise; they abstract program executions to consider more paths than those feasible in the program. Therefore, they introduce spurious nodes and edges, rendering large call graphs. Relying on such algorithms for downstream analyses (e.g., vulnerability detection) makes the analysis imprecise, resulting in a high amount of false positives. A recent line of work [Santos et al. 2021, 2020], presented an approach (named Salsa) for providing support for serialization-related features. Although Salsa aids the static analyses of programs that uses Java’s serialization/deserialization API, it is not enough to find hidden (potentially) malicious paths in the program. Salsa relies on API modeling for abstracting the serialization/deserialization protocol which dictates callback methods control and data "ow. Specially, it relies on downcasts in the program to infer the callbacks invoked during deserialization. However, malicious objects often violate downcasts and are crafted in such way that it triggers the exploit during deserialization, i.e., the exploit executes before the downcast is performed [Dietrich et al. 2017a]. Therefore, we introduce in this paper Seneca, a novel approach that handles the challenge of constructing call graphs for programs that uses serialization features. Specially, we are focusing on improving the call graph’s soundness for Java programs with respect to serialization and deserialization callbacks without greatly affecting its precision. Seneca performs a novel taint-based call graph construction, which relies on the taint state of variables when computing possible dispatches for callback methods. The contributions of this work are: — a novel taint-based call graph construction algorithm to improve call graphs’ soundness with respect to deserialization callbacks. It is agnostic to the underlying pointer analysis method used to construct a call graph, and it is meant to complement them. — an evaluation of the approach’s soundness, precision, and scalability. Our experiments demonstrated that our approach soundly handled all the six different callbacks that can be invoked during serialization or deserialization. — a publicly available implementation of Seneca [1]. The rest of this paper is organized as follows: Section 2 describes the serialization and deserialization mechanism and the challenges in creating a call graph that is sound with respect to this feature. Section 3 explains our approach. Subsequently, Section 4 presents the evaluation of the approach whereas Section 5 presents the results. Section 6 contextualizes our approach within the state-of-the art. Section 7 concludes the paper and make final considerations. [1] The scripts to reproduce the paper results are currently available on an anonymous repository SenecaRepo. The source code for Seneca will be released upon publication and submitted for artifact evaluation

Sound Call Graph Construction for Java Object Deserialization: Introduction

If you haven’t read The Reality of Digital Nomads: Chasing Highs, Finding What? (Part 1), it delves into the challenges I faced as a digital nomad — the lack of stability, absence of community, and the constant stress and fatigue. A key takeaway is my suggestion that “digital homeless” might be a more fitting term for digital nomads. I end by comparing today’s nomads to historical figures like Mountain Hermits and Monastic Wanderers, who also led lives of solitude and self-reliance. Read <Part 1> The Reality of Digital Nomads: Chasing Adventure, Finding What? on Hackernoon! [Click Here.] <Part 2> The common thread that ties digital nomads, Christian monks, and Buddhist monks together is that they all leave their hometowns in pursuit of greater enlightenment and growth. For someone like my parents, watching their daughter constantly pursue challenges can be concerning. Yet, traveling as a digital nomad has been incredibly meaningful for self-discovery and personal growth. Before beginning this journey, I struggled with anxiety rooted in self-consciousness. I was the type of girl who loved popcorn but would skip it when at the theater alone, worried about what strangers might think if they saw me in line by myself. I’d even wait until the theater emptied out to shyly grab a bag on my way out. One unexpected advantage of having to work full-time while traveling is that you don’t really have the leisure to get swept up in all the local tourist attractions. Instead, you find small joys in visiting cafes where you can quietly observe locals while working, or by changing neighborhoods for an evening stroll each day to experience subtle differences in scenery. Contrary to the high-pitched dialogue often heard in Japanese anime, residential neighborhoods in Tokyo are always astonishingly quiet. In Siem Reap, children rummage through trash cans in search of necessities just a few kilometers away from one of the largest and most impressive religious monuments. In Asia’s most liberal city, Bangkok, located in the only country to have legalized cannabis, a less hipster and more capitalistic, and self-conscious scene can be observed, with people waiting their turn at beauty clinics as late as 9 PM. Meanwhile, in Bali, locals begin and end their day with religious rituals, with every store and accommodation advertising their fast Wi-Fi speeds. In Philadelphia, some cafes do not provide Wi-Fi or even allow laptop use, yet still manage to thrive. Seeing such differences in real-life cultures all over the world leads to the questioning of how much of who I am was shaped by the culture and environment I grew up in, this journey becomes a time of introspection. Traveling is the culture and community that shaped a significant part of my identity disappearing right before my eyes. I start asking myself, “Who am I without my culture?” and “What are my fundamental traits?” And from city to the next, the answers to these questions about myself slowly unveil. Who am I without my culture? There’s a unique liberation that comes with exploring “me” in a foreign country. Here, everyone sheds their familiar identity and becomes a foreigner, free from their usual roles and expectations. The term “foreigner” means “a person who does not belong to a particular group or community.” You’re not the hometown girl, recognized by her daily iced black coffee, or the guy who’s known for his DIY car washes since he moved in last year. Instead, you’re simply you, stripped down to the essentials, unbound by the routines and labels from home. One of the greatest advantages of traveling to many places is adopting the mindset of “I am a foreigner anyway.” This mentality of inherently “being different” is freeing. Although we are always unique individuals, experiencing multiple cultures and their contrasts makes this truth resonate deeply. Realizing that no two communities are identical and that we don’t need to conform to any single one allows us to uncover our true nature and personality. As innate social animals, we’ve grown accustomed to communal life over thousands of years. In Eastern cultures, where communal living is especially valued, we sometimes overlook a key fact: communities are composed of individuals, each with unique traits. Often, we subconsciously prioritize the identity of the community over our own, hesitating to adopt beliefs or behaviors that set us apart. As a foreigner passing through an area briefly, it’s rare to get much attention from locals, apart from the enthusiastic promotions of bar promoters. This freedom of not being seen, to simply blend into the background, is liberating and accelerates your self-discovery by giving you more space to allow yourself to be who you are. This is entirely different from wearing a bikini on the streets in Southeast Asia after wearing Confucian-style clothing in your home country. The initial adventurous spirit of arriving in a new place fades, and it’s in the period when you’ve grown somewhat familiar with the place but still don’t belong to the community that you start to see your authentic self emerge. In various cities across the world, I encountered my intrinsic kindness. Even when I didn’t care about how I might be seen to others, and was under a massive amount of stress, I remained kind to others. My shyness was replaced with lengthy conversations with cab drivers. This new found self became a source of strength and uplifted me in ways I hadn’t expected. Language barrier was surprisingly not much of a discomfort, but a factor that helped with self-discovery. How much do the words and sounds we hear around us everyday influence our thoughts? Even last weekend, while hiking in the utter peace of nature, I passed by a group discussing the housing prices of Seoul. Under the clear sky, their conversation made blurred my future into darkness. Koreans, as a whole, seem particularly focused on wealth and the economy, with a strong drive toward accumulating wealth. Since my only financial planning involves saving whatever is left after impulsively spending my salary, hearing these conversations makes me feel on the verge of a panic attack. Additionally, I’m often greeted by a YouTube ad playing the moment I get in although I pay for each ride. Just how much do the words and sounds around us in daily life influence our state of mind In this day and age, exposure to materialistic and consumerist attitudes and media isn’t an experience exclusive to my home country. However, in a foreign country, all advertisements and other people’s conversations just come across as noise, so even if I was exposed to them, I wasn’t really impacted by them. Of course, just because I can’t understand the language around me doesn’t mean that the influence of the culture I’ve lived in for decades simply disappears. Even in the laid-back atmosphere of Southeast Asia, I still found myself prioritizing efficiency and speed — like a true Korean. But when the surrounding noise faded, I began to hear an authentic voice within me — a voice I couldn’t hear as clearly back in Korea. It was the desire to pursue art and creative work, so I began writing again. Traveling to different places felt almost like being free of a past, and therefore your age. Perhaps it’s because, as a foreigner, you’re somewhat invisible, not part of that community’s recorded history — only by staying long enough, by becoming a familiar face, might you start to leave a mark. Or maybe it’s because the places woven into the history of my life are out of sight, and all I see is ‘new’ around me. Anyways, with the emergence of the unique voice inside me, I also stopped feeling so self-conscious of my age. The self-doubt that normally would have risen with the emergence of my authentic voice subdued in the seeming absence of the history it was born from. But the best part of being a digital nomad didn’t strike me until it was over.. I’ll tell you guys everything about it in Part 3, next week.. Thanks for reading If you haven’t read The Reality of Digital Nomads: Chasing Highs, Finding What? (Part 1) , it delves into the challenges I faced as a digital nomad — the lack of stability, absence of community, and the constant stress and fatigue. A key takeaway is my suggestion that “digital homeless” might be a more fitting term for digital nomads. I end by comparing today’s nomads to historical figures like Mountain Hermits and Monastic Wanderers, who also led lives of solitude and self-reliance. The Reality of Digital Nomads: Chasing Highs, Finding What? (Part 1) Read <Part 1> The Reality of Digital Nomads: Chasing Adventure, Finding What? on Hackernoon! [ Click Here .] Click Here <Part 2> The common thread that ties digital nomads, Christian monks, and Buddhist monks together is that they all leave their hometowns in pursuit of greater enlightenment and growth. For someone like my parents, watching their daughter constantly pursue challenges can be concerning. Yet, traveling as a digital nomad has been incredibly meaningful for self-discovery and personal growth . Before beginning this journey, I struggled with anxiety rooted in self-consciousness. I was the type of girl who loved popcorn but would skip it when at the theater alone, worried about what strangers might think if they saw me in line by myself. I’d even wait until the theater emptied out to shyly grab a bag on my way out. self-discovery personal growth anxiety self-consciousness. I was the type of girl who loved popcorn but would skip it when at the theater alone, worried about what strangers might think if they saw me in line by myself. I’d even wait until the theater emptied out to shyly grab a bag on my way out. One unexpected advantage of having to work full-time while traveling is that you don’t really have the leisure to get swept up in all the local tourist attractions. Instead, you find small joys in visiting cafes where you can quietly observe locals while working, or by changing neighborhoods for an evening stroll each day to experience subtle differences in scenery. Contrary to the high-pitched dialogue often heard in Japanese anime, residential neighborhoods in Tokyo are always astonishingly quiet. In Siem Reap , children rummage through trash cans in search of necessities just a few kilometers away from one of the largest and most impressive religious monuments. In Asia’s most liberal city, Bangkok , located in the only country to have legalized cannabis, a less hipster and more capitalistic, and self-conscious scene can be observed, with people waiting their turn at beauty clinics as late as 9 PM. Meanwhile, in Bali , locals begin and end their day with religious rituals, with every store and accommodation advertising their fast Wi-Fi speeds. In Philadelphia , some cafes do not provide Wi-Fi or even allow laptop use, yet still manage to thrive. visiting cafes evening stroll Tokyo Siem Reap Bangkok Bali Philadelphia Seeing such differences in real-life cultures all over the world leads to the questioning of how much of who I am was shaped by the culture and environment I grew up in, this journey becomes a time of introspection. Traveling is the culture and community that shaped a significant part of my identity disappearing right before my eyes. I start asking myself, “Who am I without my culture?” and “What are my fundamental traits? ” And from city to the next, the answers to these questions about myself slowly unveil. “Who am I without my culture?” “What are my fundamental traits? Who am I without my culture? Who am I without my culture? Who am I without my culture? There’s a unique liberation that comes with exploring “me” in a foreign country. Here, everyone sheds their familiar identity and becomes a foreigner, free from their usual roles and expectations. The term “foreigner” means “a person who does not belong to a particular group or community.” You’re not the hometown girl, recognized by her daily iced black coffee, or the guy who’s known for his DIY car washes since he moved in last year. Instead, you’re simply you, stripped down to the essentials, unbound by the routines and labels from home. foreigner, you, One of the greatest advantages of traveling to many places is adopting the mindset of “I am a foreigner anyway.” This mentality of inherently “ being different” is freeing. Although we are always unique individuals, experiencing multiple cultures and their contrasts makes this truth resonate deeply. Realizing that no two communities are identical and that we don’t need to conform to any single one allows us to uncover our true nature and personality. being different” multiple cultures and their contrasts As innate social animals, we’ve grown accustomed to communal life over thousands of years. In Eastern cultures, where communal living is especially valued, we sometimes overlook a key fact: communities are composed of individuals, each with unique traits. Often, we subconsciously prioritize the identity of the community over our own, hesitating to adopt beliefs or behaviors that set us apart. As a foreigner passing through an area briefly, it’s rare to get much attention from locals, apart from the enthusiastic promotions of bar promoters. This freedom of not being seen, to simply blend into the background, is liberating and accelerates your self-discovery by giving you more space to allow yourself to be who you are. This freedom of not being seen, to simply blend into the background, is liberating and accelerates your self-discovery by giving you more space to allow yourself to be who you are. This is entirely different from wearing a bikini on the streets in Southeast Asia after wearing Confucian-style clothing in your home country. The initial adventurous spirit of arriving in a new place fades, and it’s in the period when you’ve grown somewhat familiar with the place but still don’t belong to the community that you start to see your authentic self emerge. In various cities across the world, I encountered my intrinsic kindness. Even when I didn’t care about how I might be seen to others, and was under a massive amount of stress, I remained kind to others. My shyness was replaced with lengthy conversations with cab drivers. This new found self became a source of strength and uplifted me in ways I hadn’t expected. In various cities across the world, I encountered my intrinsic kindness. Even when I didn’t care about how I might be seen to others, and was under a massive amount of stress, I remained kind to others. My shyness was replaced with lengthy conversations with cab drivers. This new found self became a source of strength and uplifted me in ways I hadn’t expected. Language barrier was surprisingly not much of a discomfort, but a factor that helped with self-discovery. How much do the words and sounds we hear around us everyday influence our thoughts? Even last weekend, while hiking in the utter peace of nature, I passed by a group discussing the housing prices of Seoul. Under the clear sky, their conversation made blurred my future into darkness. Koreans, as a whole, seem particularly focused on wealth and the economy, with a strong drive toward accumulating wealth. Since my only financial planning involves saving whatever is left after impulsively spending my salary, hearing these conversations makes me feel on the verge of a panic attack. Additionally, I’m often greeted by a YouTube ad playing the moment I get in although I pay for each ride. Language barrier Just how much do the words and sounds around us in daily life influence our state of mind Just how much do the words and sounds around us in daily life influence our state of mind Just how much do the words and sounds around us in daily life influence our state of mind In this day and age, exposure to materialistic and consumerist attitudes and media isn’t an experience exclusive to my home country. However, in a foreign country, all advertisements and other people’s conversations just come across as noise, so even if I was exposed to them, I wasn’t really impacted by them. Of course, just because I can’t understand the language around me doesn’t mean that the influence of the culture I’ve lived in for decades simply disappears. Even in the laid-back atmosphere of Southeast Asia, I still found myself prioritizing efficiency and speed — like a true Korean. But when the surrounding noise faded, I began to hear an authentic voice within me — a voice I couldn’t hear as clearly back in Korea. It was the desire to pursue art and creative work, so I began writing again. authentic voice within me Traveling to different places felt almost like being free of a past, and therefore your age. Perhaps it’s because, as a foreigner, you’re somewhat invisible, not part of that community’s recorded history — only by staying long enough, by becoming a familiar face, might you start to leave a mark. Or maybe it’s because the places woven into the history of my life are out of sight, and all I see is ‘new’ around me. Anyways, with the emergence of the unique voice inside me, I also stopped feeling so self-conscious of my age. The self-doubt that normally would have risen with the emergence of my authentic voice subdued in the seeming absence of the history it was born from. But the best part of being a digital nomad didn’t strike me until it was over.. But the best part of being a digital nomad didn’t strike me until it was over.. I’ll tell you guys everything about it in Part 3, next week.. Thanks for reading

<Part 2> The Reality of Digital Nomads: Defying Sight and Sound

<Deel 2> Die realiteit van digitale nomades: trotseer sig en klank

<Част 2> Реалността на дигиталните номади: противопоставяне на зрението и звука

<পর্ব 2> ডিজিটাল যাযাবরের বাস্তবতা: দৃষ্টি ও শব্দকে অস্বীকার করা

<Parte 2> La realidad de los nómadas digitales: desafiando la vista y el oído

<Drugi dio> Stvarnost digitalnih nomada: prkoseći vidu i zvuku

<第2部> デジタル遊牧民の現実：視覚と聴覚を無視

<2-бөлүк> Санариптик көчмөндөрдүн чындыгы: Көрүү жана үнгө каршы

<2 dalis> Skaitmeninių klajoklių realybė: nepaisyti vaizdo ir garso

<Część 2> Rzeczywistość cyfrowych nomadów: rzucanie wyzwania wzrokowi i słuchowi

<Chikamu 2> Chokwadi cheDigital Nomads: Kuzvidza Kuona uye Kunzwika

<Частина 2> Реальність цифрових кочівників: заперечення зору та звуку

<پارٹ 2> ڈیجیٹل خانہ بدوشوں کی حقیقت: نظر اور آواز کی مخالفت

Authors:
(1) Hamid Bateni, Nobitex Labs (hamid@europe.com);
(2) Keyvan Kambakhsh, Nobitex Labs (keyvankambakhsh@gmail.com). Table of Links Abstract and 1 Introduction 2 Proof of Liability and 2.1 Commitment 2.2 Merkle Tree 2.3 Leaves Structure 2.4 Proof Statement 3 Proof of Reserve 3.1 Ethereum 3.2 Bitcoin 4 Proof of Solvency 5 Future Works and References 3.2 Bitcoin Bitcoin, the first decentralized cryptocurrency, was introduced in 2009 by an individual or group known as Satoshi Nakamoto. It operates on a peer-to-peer network where transactions are verified by network nodes through cryptography and recorded on a public ledger known as blockchain. Unlike Ethereum’s account-based model, Bitcoin uses an Unspent Transaction Output (UTXO) model for its accounting system. In this model, transactions output a certain number of bitcoins, which can be spent by future transactions. Each UTXO represents a chain of ownership encoded in the Bitcoin blockchain, and the sum of these UTXOs represents a user’s total bitcoin balance. Bitcoin nodes maintain a database of active UTXOs, also known as the chain state. This database is crucial for verifying new transactions, as it allows nodes to check whether the UTXOs a transaction wants to spend are indeed valid and have not been spent yet. By only keeping track of unspent bitcoins, the UTXO model simplifies transaction verification and improves the scalability of the Bitcoin network.[5] 3.2.1 UTXO and ChainStat At the heart of Bitcoin’s operation is the Unspent Transaction Output (UTXO) model. In this model, each transaction begins with inputs that are references to previous transaction outputs and ends with outputs that specify a new Bitcoin amount and a new owner. These outputs then become the inputs of future transactions, forming a chain of ownership. Transaction types in Bitcoin, such as Pay-to-Public-Key-Hash (P2PKH) and Payto-Script-Hash (P2SH), govern the conditions under which these UTXOs can be spent. The Chain State in Bitcoin is a key-value database that maintains a record of all active UTXOs. With the arrival of every new block, spent UTXOs are removed, and new UTXOs are added to the Chain State. This dynamic update of the Chain State ensures that it accurately reflects the current state of all transactions. The balance of a Bitcoin address is determined by the total amount of bitcoins in the UTXOs that the address owns. Each full node in the Bitcoin network independently maintains the Chain State. Every node computes its own Chain State by applying all transactions from the blockchain starting from the genesis block. This decentralized approach ensures that every node has a complete and independent verification of the state of all transactions, contributing to the security and robustness of the Bitcoin network. However, this also means that the Chain State is not directly included in the block header and varies from node to node, making it challenging to create a proof of reserve that commits to a specific number of active UTXOs owned by an address. In the next section, we will discuss a solution to this challenge. 3.2.2 Bitcoin Proof Statement The first approach to proving a Bitcoin balance might be to adopt the idea from EIP7503. This would involve transferring a specific amount of Bitcoin in a transaction, and then privately proving the transaction and the amount. This approach is feasible but involves operational costs, making it less than ideal. A more efficient approach might involve the following steps: Announce that the platform intends to commit to its Bitcoin balances up to a specific block.


Download the entire Chain State for that block from a Bitcoin node. This Chain State includes every active UTXO at the time of the block.


Insert every UTXO from the Chain State as a leaf in a Merkle tree. This process converts the Chain State into a structure that allows for efficient proofs.


Publish the root of the Merkle tree. Anyone can then verify the correctness of the published root with the help of a Bitcoin node and some additional code. With this approach, we now have a Merkle tree representing all active UTXOs at a specific block. As a business, we know which UTXOs belong to our addresses. We can then create a Zero-Knowledge Proof (ZKP) circuit to prove that we know some leaves (UTXOs) that belong to a specific address and prove their paths in the Merkle tree. This approach allows us to commit to a specific number of active UTXOs owned by an address without revealing the address itself, providing a privacy-preserving proof of reserve for Bitcoin addresses. This paper is available on arxiv under CC BY-NC-ND 4.0 DEED license. Authors: (1) Hamid Bateni, Nobitex Labs (hamid@europe.com); (2) Keyvan Kambakhsh, Nobitex Labs (keyvankambakhsh@gmail.com). Authors: Authors: (1) Hamid Bateni, Nobitex Labs (hamid@europe.com); (2) Keyvan Kambakhsh, Nobitex Labs (keyvankambakhsh@gmail.com). Table of Links Abstract and 1 Introduction Abstract and 1 Introduction 2 Proof of Liability and 2.1 Commitment 2 Proof of Liability and 2.1 Commitment 2.2 Merkle Tree 2.2 Merkle Tree 2.3 Leaves Structure 2.3 Leaves Structure 2.4 Proof Statement 2.4 Proof Statement 3 Proof of Reserve 3 Proof of Reserve 3.1 Ethereum 3.1 Ethereum 3.2 Bitcoin 3.2 Bitcoin 4 Proof of Solvency 4 Proof of Solvency 5 Future Works and References 5 Future Works and References 3.2 Bitcoin Bitcoin, the first decentralized cryptocurrency, was introduced in 2009 by an individual or group known as Satoshi Nakamoto. It operates on a peer-to-peer network where transactions are verified by network nodes through cryptography and recorded on a public ledger known as blockchain. Unlike Ethereum’s account-based model, Bitcoin uses an Unspent Transaction Output (UTXO) model for its accounting system. In this model, transactions output a certain number of bitcoins, which can be spent by future transactions. Each UTXO represents a chain of ownership encoded in the Bitcoin blockchain, and the sum of these UTXOs represents a user’s total bitcoin balance. Bitcoin nodes maintain a database of active UTXOs, also known as the chain state. This database is crucial for verifying new transactions, as it allows nodes to check whether the UTXOs a transaction wants to spend are indeed valid and have not been spent yet. By only keeping track of unspent bitcoins, the UTXO model simplifies transaction verification and improves the scalability of the Bitcoin network.[5] 3.2.1 UTXO and ChainStat At the heart of Bitcoin’s operation is the Unspent Transaction Output (UTXO) model. In this model, each transaction begins with inputs that are references to previous transaction outputs and ends with outputs that specify a new Bitcoin amount and a new owner. These outputs then become the inputs of future transactions, forming a chain of ownership. Transaction types in Bitcoin, such as Pay-to-Public-Key-Hash (P2PKH) and Payto-Script-Hash (P2SH), govern the conditions under which these UTXOs can be spent. The Chain State in Bitcoin is a key-value database that maintains a record of all active UTXOs. With the arrival of every new block, spent UTXOs are removed, and new UTXOs are added to the Chain State. This dynamic update of the Chain State ensures that it accurately reflects the current state of all transactions. The balance of a Bitcoin address is determined by the total amount of bitcoins in the UTXOs that the address owns. Each full node in the Bitcoin network independently maintains the Chain State. Every node computes its own Chain State by applying all transactions from the blockchain starting from the genesis block. This decentralized approach ensures that every node has a complete and independent verification of the state of all transactions, contributing to the security and robustness of the Bitcoin network. However, this also means that the Chain State is not directly included in the block header and varies from node to node, making it challenging to create a proof of reserve that commits to a specific number of active UTXOs owned by an address. In the next section, we will discuss a solution to this challenge. 3.2.2 Bitcoin Proof Statement The first approach to proving a Bitcoin balance might be to adopt the idea from EIP7503. This would involve transferring a specific amount of Bitcoin in a transaction, and then privately proving the transaction and the amount. This approach is feasible but involves operational costs, making it less than ideal. A more efficient approach might involve the following steps: Announce that the platform intends to commit to its Bitcoin balances up to a specific block. Download the entire Chain State for that block from a Bitcoin node. This Chain State includes every active UTXO at the time of the block. Insert every UTXO from the Chain State as a leaf in a Merkle tree. This process converts the Chain State into a structure that allows for efficient proofs. Publish the root of the Merkle tree. Anyone can then verify the correctness of the published root with the help of a Bitcoin node and some additional code. Announce that the platform intends to commit to its Bitcoin balances up to a specific block. Announce that the platform intends to commit to its Bitcoin balances up to a specific block. Download the entire Chain State for that block from a Bitcoin node. This Chain State includes every active UTXO at the time of the block. Download the entire Chain State for that block from a Bitcoin node. This Chain State includes every active UTXO at the time of the block. Insert every UTXO from the Chain State as a leaf in a Merkle tree. This process converts the Chain State into a structure that allows for efficient proofs. Insert every UTXO from the Chain State as a leaf in a Merkle tree. This process converts the Chain State into a structure that allows for efficient proofs. Publish the root of the Merkle tree. Anyone can then verify the correctness of the published root with the help of a Bitcoin node and some additional code. Publish the root of the Merkle tree. Anyone can then verify the correctness of the published root with the help of a Bitcoin node and some additional code. With this approach, we now have a Merkle tree representing all active UTXOs at a specific block. As a business, we know which UTXOs belong to our addresses. We can then create a Zero-Knowledge Proof (ZKP) circuit to prove that we know some leaves (UTXOs) that belong to a specific address and prove their paths in the Merkle tree. This approach allows us to commit to a specific number of active UTXOs owned by an address without revealing the address itself, providing a privacy-preserving proof of reserve for Bitcoin addresses. This paper is available on arxiv under CC BY-NC-ND 4.0 DEED license. This paper is available on arxiv under CC BY-NC-ND 4.0 DEED license. available on arxiv

Stories, News & Mentions about USOUND

Usound’s Stories on HackerNoon

Usound's News & Mentions