Body composition assessment helps conducting a healthy life or tracking the effectiveness of a weight management therapy. Ultrasound (US)-based body composition research has gained momentum because of the emergence of portable and inexpensive instruments bundled with user-friendly software. Previously, US-based assessment of body fat percentage (% BF) was found precise, but inaccurate in certain populations. Therefore, this study sought to compute % BF from subcutaneous fat thicknesses (SFs) given by US converting an anthropometric formula that involves skinfold thicknesses (SKFs) measured at the same sites. The symmetry of the body with respect to the central sagittal plane is an underlying assumption in both anthropometry and US-based body composition assessment, so measurements were taken on the right side of the body. Relying on experimental data on skinfold compressibility, we adapted 33 SKF formulas for US use and tested their validity against air displacement plethysmography on a study group of 97 women (BMI = 25.4 ± 6.4 kg/m2, mean ± SD) and 107 men (BMI = 26.7 ± 5.7 kg/m2). For both sexes, the best proprietary formula had Lin’s concordance correlation coefficient (CCC) between 0.7 and 0.73, standard error of estimate (SEE) < 3% BF and total error (TE) > 6% BF—mainly because of the underestimation of % BF in overweight and obese subjects. For women (men) the best adapted formula had CCC = 0.85 (0.80), SEE = 3.2% (2.4%) BF, and TE = 4.6% (5.4%) BF. Remarkably, certain adapted formulas were more accurate for overweight and obese people than the proprietary equations. In conclusion, anthropometric equations provide useful starting points in the quest for novel formulas to estimate body fat content from ultrasound measurements.

For elite athletes, monitoring body composition is important for maximizing performance without health risks. Amplitude (A)-mode ultrasound (AUS) has attracted increasing attention as an alternative to skinfold thickness measurements commonly used for assessing the amount of body fat in athletes. AUS accuracy and precision, however, depend on the formula used to predict body fat percentage (%BF) from subcutaneous fat layer thicknesses. Therefore, this study evaluates the accuracy of the 1-point biceps (B1), 9-sites Parrillo, 3-sites Jackson and Pollock (JP3), and 7-sites Jackson and Pollock (JP7) formulas. Relying on the previous validation of the JP3 formula in college-aged male athletes, we took AUS measurements in 54 professional soccer players (aged 22.9 ± 3.83 y, mean ± SD) and compared the results given by different formulas. The Kruskal–Wallis test indicated significant differences (p < 10−6), and Conover’s post hoc test revealed that the JP3 and JP7 data come from the same distribution, whereas the data given by B1 and P9 differ from all the others. Lin’s concordance correlation coefficients for B1 vs. JP7, P9 vs. JP7, and JP3 vs. JP7 were 0.464, 0.341, and 0.909, respectively. The Bland–Altman analysis indicated mean differences of −0.5 %BF between JP3 and JP7, 4.7 %BF between P9 and JP7, and 3.1 %BF between B1 and JP7. This study suggests that JP7 and JP3 are equally valid, whereas P9 and B1 overestimate %BF in athletes.

Air displacement plethysmography (ADP) is a widespread technique for assessing global obesity in both health and disease. The reliability of ADP has been demonstrated by studies focused on duplicate trials. The present study was purported to evaluate learning effects on the reliability of body composition assessment using the BOD POD system, the sole commercially available ADP instrument. To this end, quadruplicate trials were performed on a group of 105 subjects (51 women and 54 men). We estimated measurement error from pairs of consecutive trials-(1,2), (2,3), and (3,4)-to test the hypothesis that early measurements are subject to larger errors. Indeed, statistical analysis revealed that measures of reliability inferred from the first two trials were inferior to those computed for the other pairs of contiguous trials: for percent body fat (%BF), the standard error of measurement (SEM) was 1.04% for pair (1,2), 0.71% for pair (2,3), and 0.66% for pair (3,4); the two-way random effects model intraclass correlation coefficient (ICC) was 0.991 for pair (1,2), and 0.996 for pairs (2,3) and (3,4). Our findings suggest that, at least for novice subjects, the first ADP test should be regarded as a practice trial. When the remaining trials were pooled together, the reliability indices of single ADP tests were the following: ICC = 0.996, SEM = 0.70%, and minimum detectable change (MDC) = 1.93% for %BF, and ICC = 0.999, SEM = 0.49 kg, and MDC = 1.35 kg for fat-free mass (FFM). Thus, the present study pleads for eliminating learning effects to further increase the reliability of ADP.

INTRODUCTION:This study sought to evaluate the impact of subject positioning on body composition assessments by air displacement plethysmography using the BOD POD®.METHODS:Eighty-two adults (42 men and 40 women), aged 26.1 ± 8.4 y (mean ± standard deviation), body mass index = 23.6 ± 4.8 kg/m2, were assessed by repeated measurements in two different positions: relaxed (legs apart, back away from the rear) and compact (legs together, arms near the body, back touching the rear). We relied on Bland-Altman analysis to quantify the agreement between results recorded in the two positions. Using body surface charts, we tested the hypothesis that posture-induced variability stems from differences in exposed skin area.RESULTS:Switching from compact to relaxed position resulted in a bias of -197 mL for body volume, -1.53% for percent body fat, and 1.085 kg for fat-free mass. The body surface area in contact with air was larger in relaxed position by 3632 ± 522 cm2. When body volume was expressed in terms of the actual area of exposed skin in the compact position, the percent body fat bias became 0.08%, with a 95% confidence interval of (-0.14, 0.29)%.CONCLUSIONS:Subject posture is a source of significant variability in air displacement plethysmography. The disagreement between results obtained in different positions can be eliminated by adjusting the surface area artifact, suggesting that subject positioning in the BOD POD® should be controlled to avoid changes in the amount of air maintained under isothermal conditions by the body.

Integer overflows have threatened software applications for decades. Thus, in this paper, we propose a novel technique to provide automatic repairs of integer overflows in C source code. Our technique, based on static symbolic execution, fuses detection, repair generation and validation. This technique is implemented in a prototype named IntRepair. We applied IntRepair to 2,052 C programs (approx. 1 million lines of code) contained in SAMATE's Juliet test suite and 50 synthesized programs that range up to 20 KLOC. Our experimental results show that IntRepair is able to effectively detect integer overflows and successfully repair them, while only increasing the source code (LOC) and binary (Kb) size by around 1 percent, respectively. Further, we present the results of a user study with 30 participants which shows that IntRepair repairs are more than 10x efficient as compared to manually generated code repairs.

Exploiting a program requires a security analyst to manipulate data in program memory with the goal to obtain control over the program counter and to escalate privileges. However, this is a tedious and lengthy process as: (1) the analyst has to massage program data such that a logical reliable data passing chain can be established, and (2) depending on the attacker goal certain in-place fine-grained protection mechanisms need to be bypassed. Previous work has proposed various techniques to facilitate exploit development. Unfortunately, none of them can be easily used to address the given challenges. This is due to the fact that data in memory is difficult to be massaged by an analyst who does not know the peculiarities of the program as the attack specification is most of the time only textually available, and not automated at all. In this paper, we present indirect transfer oriented programming (iTOP), a framework to automate the construction of control-flow hijacking attacks in the presence of strong protections including control flow integrity, data execution prevention, and stack canaries. Given a vulnerable program, iTOP automatically builds an exploit payload with a chain of viable gadgets with solved SMT-based memory constraints. One salient feature of iTOP is that it contains 13 attack primitives powered by a Turing complete payload specification language, ESL. It also combines virtual and non-virtual gadgets using COOP-like dispatchers. As such, when searching for gadget chains, iTOP can respect, for example, a previously enforced CFI policy, by using only legitimate control flow transfers. We have evaluated iTOP with a variety of programs and demonstrated that it can successfully generate exploits with the developed attack primitives.

Air displacement plethysmography (ADP) is fast, accurate, and reliable. Nevertheless, in about 3% of the cases, standard ADP tests provide rogue results. To spot these outliers and improve precision, repeated trials protocols have been devised, but few works have addressed their reliability. This study was conducted to evaluate the test–retest reliabilities of two known protocols and a new one, proposed here. Ninety-two healthy adults (46 men and 46 women) completed six consecutive ADP tests. To evaluate the reliability of single measurements, we used the results of the first two tests; for multiple measures protocols, we computed the test result from trials 1–3 and the retest result from trials 4–6. Bland–Altman analysis revealed that the bias and the width of the 95% interval of agreement were smaller for multiple trials than for single ones. For percent body fat (%BF)/fat-free mass, the technical error of measurement was 1% BF/0.68 kg for single trials and 0.62% BF/0.46 kg for the new protocol of multiple trials, which proved to be the most reliable. The minimal detectable change (MDC) was 2.77% BF/1.87 kg for single trials and 1.72% BF/1.26 kg for the new protocol.

In this paper, we propose reversed forward-edge mapper (ρFEM), a Clang/LLVM compiler-based tool, to protect the backward edges of a program’s control flow graph (CFG) against runtime control-flow hijacking (e.g., code reuse attacks). It protects backward-edge transfers in C/C++ originating from virtual and non-virtual functions by first statically constructing a precise virtual table hierarchy, with which to form a precise forward-edge mapping between callees and non-virtual calltargets based on precise function signatures, and then checks each instrumented callee return against the previously computed set at runtime. We have evaluated ρFEM using the Chrome browser, NodeJS, Nginx, Memcached, and the SPEC CPU2017 benchmark. Our results show that ρFEM enforces less than 2.77 return targets per callee in geomean, even for applications heavily relying on backward edges. ρFEM’s runtime overhead is less than 1% in geomean for the SPEC CPU2017 benchmark and 3.44% in geomean for the Chrome browser.

Background/Objectives Several studies have addressed the validity of ultrasound (US) for body composition assessment, but few have evaluated its reliability. This study aimed to determine the reliability of percent body fat (%BF) estimates using A-mode US in a heterogeneous sample. Subjects/Methods A group of 144 healthy adults (81 men and 63 women), 30.4 (10.1) years (mean (SD)), BMI 24.6 (4.7) kg/m 2 , completed 6 consecutive measurements of the subcutaneous fat layer thickness at 8 anatomical sites. The measurements were done, alternatively, by two testers, using a BodyMetrix™ instrument. To compute %BF, 4 formulas from the BodyView™ software were applied: 7-sites Jackson and Pollock, 3-sites Jackson and Pollock, 3-sites Pollock, and 1-point biceps. Results The formula with the most anatomic sites provided the best reliability quantified by the following measures: intraclass correlation coefficient (ICC) = 0.979 for Tester 1 (T1) and 0.985 for T2, technical error of measurement (TEM) = 1.07% BF for T1 and 0.89% BF for T2, and minimal detectable change (MDC) = 2.95% BF for T1, and 2.47% BF for T2. The intertester bias was −0.5% BF, whereas the intertester ICC was 0.972. The intertester MDC was 3.43% BF for the entire sample, 3.24% BF for men, and 3.65% BF for women. Conclusions A-mode US is highly reliable for %BF assessments, but it is more precise for men than for women. Examiner performance is a source of variability that needs to be mitigated to further improve the precision of this technique.

Control-flow hijacking attacks are used to perform malicious computations. Current solutions for assessing the attack surface after a control flow integrity (CFI) policy was applied can measure only indirect transfer averages in the best case without providing any insights w.r.t. the absolute calltarget reduction per callsite, and gadget availability. Further, tool comparison is underdeveloped or not possible at all. CFI has proven to be one of the most promising protections against control flow hijacking attacks, thus many efforts have been made to improve CFI in various ways. However, there is a lack of systematic assessment of existing CFI protections. In this paper, we present LLVM-CFI, a static source code analysis framework for analyzing state-of-the-art static CFI protections based on the Clang/LLVM compiler framework. LLVM-CFI works by precisely modeling a CFI policy and then evaluating it within a unified approach. LLVM-CFI helps determine the level of security offered by different CFI protections, after the CFI protections were deployed, thus providing an important step towards exploit creation/prevention and stronger defenses. We have used LLVM-CFI to assess eight state-of-the-art static CFI defenses on real-world programs such as Google Chrome and Apache Httpd. LLVM-CFI provides a precise analysis of the residual attack surfaces, and accordingly ranks CFI policies against each other. LLVM-CFI also successfully paves the way towards construction of COOP-like code reuse attacks and elimination of the remaining attack surface by disclosing protected calltargets under eight restrictive CFI policies.

Stack Overflow is the most popular discussion platform for software developers. However, recent research identified a large amount of insecure encryption code in production systems that has been inspired by examples given on Stack Overflow. By copying and pasting functional code, developers introduced exploitable software vulnerabilities into security-sensitive high-profile applications installed by millions of users every day. Proposed mitigations of this problem suffer from usability flaws and push developers to continue shopping for code examples on Stack Overflow once again. This motivates us to fight the proliferation of insecure code directly at the root before it even reaches the clipboard. By viewing Stack Overflow as a market, implementation of cryptography becomes a decision-making problem. In this context, our goal is to simplify the selection of helpful and secure examples. More specifically, we focus on supporting software developers in making better decisions on Stack Overflow by applying nudges, a concept borrowed from behavioral economics and psychology. This approach is motivated by one of our key findings: For 99.37% of insecure code examples on Stack Overflow, similar alternatives are available that serve the same use case and provide strong cryptography. Our system design that modifies Stack Overflow is based on several nudges that are controlled by a deep neural network. It learns a representation for cryptographic API usage patterns and classification of their security, achieving average AUC-ROC of 0.992. With a user study, we demonstrate that nudge-based security advice significantly helps tackling the most popular and error-prone cryptographic use cases in Android.

Protecting programs against control-flow hijacking attacks recently has become an arms race between defenders and attackers. While certain defenses, e.g., \textit{Control Flow Integrity} (CFI), restrict the targets of indirect control-flow transfers through static and dynamic analysis, attackers could search the program for available gadgets that fall into the legitimate target sets to bypass the defenses. There are several tools helping both attackers in developing exploits and analysts in strengthening their defenses. Yet, these tools fail to adequately (1) model the deployed defenses, (2) compare them in a head-to-head way, and (3) use program semantic information to help craft the attack and the countermeasures. Control Flow Integrity (CFI) has proved to be one of the promising defenses against control flow hijacks and tons of efforts have been made to improve CFI in various ways in the past decade. However, there is a lack of a systematic assessment of the existing CFI defenses. In this paper, we present Reckon, a static source code analysis tool for assessing state-of-the-art static CFI defenses, by first precisely modeling them and then evaluating them in a unified framework. Reckon helps determine the level of security offered by different CFI defenses, and find usable code gadgets even after the CFI defenses were applied, thus providing an important step towards successful exploits and stronger defenses. We have used Reckon to assess eight state-of-the-art static CFI defenses on real-world programs such as Google's Chrome and Apache Httpd. Reckon provides precise measurements of the residual attack surfaces, and accordingly ranks CFI policies against each other. It also successfully paves the way to construct code reuse attacks and to eliminate the remaining attack surface, by disclosing calltargets under one of the most restrictive CFI defenses.

C++ object type confusion vulnerabilities as the result of illegal object casting have been threatening systems’ security for decades. While there exist several solutions to address this type of vulnerability, none of them are sufficiently practical for adoption in production scenarios. Most competitive and recent solutions require object type tracking for checking polymorphic object casts, and all have prohibitively high runtime overhead. The main source of overhead is the need to track the object type during runtime for both polymorphic and non-polymorphic object casts. In this paper, we present CastSan, a C++ object type confusion detection tool for polymorphic objects only, which scales efficiently to large and complex code bases as well as to many concurrent threads. To considerably reduce the object type cast checking overhead, we employ a new technique based on constructing the whole virtual table hierarchy during program compile time. Since CastSan does not rely on keeping track of the object type during runtime, the overhead is drastically reduced. Our evaluation results show that complex applications run insignificantly slower when our technique is deployed, thus making CastSan a real-world usage candidate. Finally, we envisage that based on our object type confusion detection technique, which relies on ordered virtual tables (vtables), even non-polymorphic object casts could be precisely handled by constructing auxiliary non-polymorphic function table hierarchies for static classes as well.

Programs aiming for low runtime overhead and high availability draw on several object-oriented features available in the C/C++ programming language, such as dynamic object dispatch. However, there is an alarmingly high number of object dispatch (i.e., forward-edge) corruption vulnerabilities, which undercut security in significant ways and are in need of a thorough solution. In this paper, we propose \(\tau {\textsc {CFI}}\), an extended control flow integrity (CFI) model that uses both the types and numbers of function parameters to enforce forward- and backward-edge control flow transfers. At a high level, it improves the precision of existing forward-edge recognition approaches by considering the type information of function parameters, which are directly extracted from the application binaries. Therefore, \(\tau {\textsc {CFI}}\) can be used to harden legacy applications for which source code may not be available. We have evaluated \(\tau {\textsc {CFI}}\) on real-world binaries including Nginx, NodeJS, Lighttpd, MySql and the SPEC CPU2006 benchmark and demonstrate that \(\tau {\textsc {CFI}}\) is able to effectively protect these applications from forward- and backward-edge corruptions with low runtime overhead. In direct comparison with state-of-the-art tools, \(\tau {\textsc {CFI}}\) achieves higher forward-edge caller-callee matching precision.

Integer overflows in commodity software are a main source for software bugs, which can result in exploitable memory corruption vulnerabilities and may eventually contribute to powerful software based exploits, i.e., code reuse attacks (CRAs). In this paper, we present IntGuard , a tool that can repair integer overflows with high-quality source code repairs. Specifically, given the source code of a program, IntGuard first discovers the location of an integer overflow error by using static source code analysis and satisfiability modulo theories (SMT) solving. IntGuard then generates integer multi-precision code repairs based on modular manipulation of SMT constraints as well as an extensible set of customizable code repair patterns. We have implemented and evaluated IntGuard with 2052 C programs (approx. 1 Mil. LOC) available in the currently largest open- source test suite for C/C++ programs and with a benchmark containing large and complex programs. The evaluation results show that IntGuard can precisely (i.e., no false positives are accidentally repaired), with low computational and runtime overhead repair programs with very small binary and source code blow-up. In a controlled experiment, we show that IntGuard is more time-effective and achieves a higher repair success rate than manually generated code repairs.

Mobile robot navigation in total or partially unknown environments is still an open problem. The path planning algorithms lack completeness and/or performance. Thus, there is the need for complete (i.e., the algorithm determines in finite time either a solution or correctly reports that there is none) and performance (i.e., with low computational complexity) oriented algorithms which need to perform efficiently in real scenarios. In this paper we evaluate the efficiency of two versions of the A star algorithm for mobile robot navigation inside indoor environments with the help of two software applications and the Pioneer 2DX robot. We demonstrate that an improved version of the A star algorithm (we call this the fast A star algorithm) which (a different version of this algorithm is widely used in video games) can be successfully used for indoor mobile robot navigation. We evaluated the two versions of the A star algorithm first, by implementing the algorithms in source code and by testing them on a simulator and second, by comparing two operation modes of the fast A star algorithm w.r.t. path planning efficiency (i.e., completness) and performance (i.e., time need to complete the path traversing) for indoor navigation with the Pioneer 2DX robot. The results obtained with the fast A star algorithm are promising and we think that this results can be further improved by tweaking the algorithm and by using an advanced sensor fusion approach (i.e., combine the inputs of multiple robot sensors) for better dealing with partially known environments.

Information flow vulnerabilities in UML state charts and C code are detrimental as they can cause data leakages or unexpected program behavior. Detecting such vulnerabilities with static code analysis techniques is challenging because code is usually not available during the software design phase and previous knowledge about what should be annotated and tracked is needed. In this paper we propose textual annotations used to introduce information flow constraints in UML state charts and code which are afterwards automatically loaded by information flow checkers that check if imposed constraints hold or not. We evaluated our approach on 6 open source test cases available in the National Institute of Standards and Technology (NIST) Juliet test suite for C/C++. Our results show that our approach is effective and can be further applied to other types of UML models and programming languages as well, in order to detect different types of vulnerabilities.

Integer overflow errors in C programs are difficult to detect since the C language specification rules which govern how one can cast or promote integer types are not accompanied by any unambiguous set of formal rules. Thus, making it difficult for the programmer to understand and use the rules correctly causing vulnerabilities or costly errors. Although there are many static and dynamic tools used for integer overflow detection, the tools lack the capacity of efficiently filtering out false positives and false negatives. Better tools are needed to be constructed which are more precise in regard to bug detection and filtering out false positives. In this paper, we present an integer overflow checker which is based on precise modeling of C language semantics and symbolic function models. We developed our checker as an Eclipse plug-in and tested it on the open source C/C++ test case CWE-190 contained in the National Institute of Standards and Technology (NIST) Juliet test suite for C/C++. We ran our checker systematically on 2592 programs having in total 340 KLOC with a true positive rate of 95.49% for the contained C programs and with no false positives. We think our approach is effective to be applied in future to C++ programs as well, in order to detect other kinds of vulnerabilities related to integers.

In many C programs, debugging requires significant effort and can consume a lot of time. Even if the bug's cause is known, detecting a bug in such programs and generating a bug fix patch manually is a tedious task. In this paper, we present a novel approach used to generate bug fixes for buffer overflow automatically using static execution, code patch patterns, quick fix locations, user input saturation and Satisfiability Modulo Theories (SMT). The generated patches are syntactically correct, can be semi-automatically inserted into code and do not need additional human refinement. We evaluated our approach on 58C open source programs contained in the Juliet test suite and measured an overhead of 0.59% with respect to the bug detection time. We think that our approach is generalizable and can be applied with other bug checkers that we developed.