dataesr/scientific-paragraphs-categorization huggingface dataset:
Data availability The raw data have been deposited at Gene Expression Omnibus GEO (https://www. ncbi. nlm. nih. gov/geo/query/acc. cgi?acc=GSE186857). Bisulfite sequencing raw data and bigwig files showing methylation rates (#methylated C/#total number of C) in the context of CHH, CHG and CpG, where H: is A, C or T in the WT, M23 and M25 are under the accession number GSE186855. The raw RNA sequencing data and the TPM counting table are under accession GSE186856. Source data underlying figures are presented in Supplementary Data 6 (Fig. 3b ), Supplementary Data 9 (Fig. 3d ), Supplementary Data 10 (Fig. 3e ), Supplementary Data 11 (Fig. 4b ), Supplementary Data 12-13 (Fig. 4d, e ), Supplementary Data 17 (Fig. 5e ). A list of primers used in the study is presented in Supplementary Data 19. A full uncropped blot of the dot blot shown in Supplementary Fig.
Introduction Since the formation of comets, asteroids, planetesimals, and planets is expected to start with the aggregation of the smallest interstellar dust particles  (Weidenschilling & Cuzzi 1993; Li & Greenberg 2003; Tielens et al. 2005; Blum & Wurm 2008) , the properties of the smallest dust grains in the early solar system are of great importance. These have been the focus of various studies, for example, the sample return mission flying by comet ⋆ Full Table  A. 1 is available at the CDS via anonymous ftp to cdsarc. cds. unistra. fr  (130. 79. 128. 5)  or via https:// cdsarc. cds. unistra. fr/viz-bin/cat/J/A+A/678/A179 ⋆⋆ MIDAS dust coverage, clustering, and shape descriptor maps can be found at https://minjaegasparkim. github. io/ Rosetta-MIDAS_dust_maps 81P/Wild 2, Chondritic Porous Interplanetary Dust Particles collected in the stratosphere, as well as the ultracarbonaceous Antarctic micrometeorites  (Brownlee et al.
Rastering over the particles' surface, a 3D image of cometary dust was created, which enabled the determination of the particle structure, and thus an insight into the properties of micro-to nanometer-sized dust particles. In particular, the high-resolution MIDAS images allow us to determine particle shape factors and descriptors. We note that the volume estimate in MIDAS may be susceptible to over-estimation due to several factors (e. g. , tip dilation and concave surfaces; see Sect. 3. 1. 1), which can lead to incomplete imaging of certain particles, potentially resulting in inaccuracies in the volume measurements. In the retrieved scans identifying dust grains and marking them with a mask is performed by hand with the open-source package Gwyddion  (Nečas & Klapetek 2012). More detailed information about MIDAS and its dataset can be found in previous MIDAS studies (e.
5 and 2. 7 ± 0. 3 m s -1 , respectively), while the velocities of the particles collected on target 14 and 15 are faster (i. e. , 7. 21 ± 0. 09 and 7. 2 ± 0. 2 m s -1 , respectively;  Longobardo et al. 2022). The standard deviation range corresponds to each MIDAS target 1-2 m s -1. Furthermore, the standard deviation of the entire GIADA-MIDAS dataset is 6 m s -1. The detailed list of target exposure history and duration can be found in Table  B. 1. in  Kim et al. (2023). Assuming the same source region of particles detected by GIADA and MIDAS in the same period,  Longobardo et al. (2022)  determined which MIDAS particles stem from which source area of the comet based on a traceback algorithm applied to GIADA data  (Longobardo et al. 2020). In particular, MIDAS particles on target 14 originated from rough terrains (or deeper layers), implying that these particles are expected to be more pristine.
Development of MIDAS particle shape descriptors Since particle shape descriptors represent a range of properties, for instance, a spatial variation on a large scale or irregularity/surface textures on a small scale  (Berrezueta et al. 2019) , they are well suited to evaluate and classify our particle collection. Thus, we develop MIDAS particle shape descriptors to determine particles preserving their pristineness. We start from 3523 MIDAS particle identifications based on the updated MIDAS particle catalog V6  (Kim et al. 2023). For further investigation, we select particles only usable for further investigation (e. g. , only particles of cometary origin, particles with a preferably low amount of alteration, particles not shown to be fragments of particles, particles were not susceptible to being multiple fragments, particles not suspected to have fallen off a tip), which is necessary to ensure the integrity and reliability of the dataset.
Additionally, we remove duplicates as many MIDAS dust particles were scanned several times and thus select the best representation of particles  (Kim et al. 2023). Next, we again exclude particles with a very small number of pixels in images (e. g. , <10) due to the physical difficulties of further analysis with a small number of pixel particles. After applying these selection criteria, 1082 MIDAS particles are used for the analysis of shape descriptors in total. These selected particles will serve as the basis for our in-depth analysis and study of cometary particles and their properties including shape descriptors. More detailed information about MIDAS particle selection for further investigation can be found in previous MIDAS studies (e. g. ,  Kim et al. 2023). For the development of MIDAS particle shape descriptors, we first apply several pre-processing procedures, most importantly, rotation of the data to align the scan direction to the horizontal direction, correction of horizontal scars in scan files, alignment of rows in scan files using the median of differences algorithm, leveling of the data by means of a plane subtraction, and the rotation of scan files in the opposite direction of the first rotation with the Gwyddion Python module called Pygwy 4  to all scan files to clean up the MIDAS data.
MIDAS cluster/particle classification We investigate possible similarities between the MIDAS dataset and previous studies that classified shapes of cometary dust particles (e. g. ,  Langevin et al. 2016; Ellerbroek et al. 2017). This classification work is a cornerstone to determine particle pristineness because particle properties that were already connected to alteration or pristineness in other studies could be identified in MIDAS data as well and be similarly interpreted. Ellerbroek et al. (2017)  investigated the footprint of cometary dust analogs in laboratory experiments using low-velocity A179, page 4 of 38 impacts of analog materials and compared these with COSIMA and MIDAS data. They found that the degree of alteration is strongly determined by the initial particle size and the impact velocity.
This has the effect of making protruding features appear wide, while holes appear smaller with a broader tip. More specifically, the variation in particle height leads to considerable uncertainties in tip convolution  (Mannel et al. 2019) , with a calculated uncertainty ranging from 0. 4 to 178% (using the equation in  Mannel et al. 2019)  for the dataset of all MIDAS particles. The smallest and largest uncertainties are associated with the flattest and roughest particles, respectively. Therefore, due to the broad tip used in the MIDAS instrument (with a half-opening angle of 25 • ± 5 • ), very small fringes on the particles may not be effectively imaged. 3. 1. 2. Relation between shape descriptors and particle characteristics, collection target, and cluster morphology, and MIDAS shape descriptor maps In the present section, we investigate possible relationships between the discussed shape descriptors and particle characteristics (e.
2. 1). Most importantly, we find that 11 'MIDAS Pile' particles were included in moderately pristine particles (pristineness rated '4'). Given that the appearance of MIDAS Pile particles is expected to result from the target impact, we thus exclude 11 'MIDAS Pile' particles from the final list of most pristine particles (particle rated '4' and '5') and thus reasonably rescale the pristineness score (i. e. , 19 most pristine MIDAS particles in total). On the other hand, we find that there are 474 particles rated '1', indicating that nearly half of the MIDAS particles have undergone significant alteration due to impact, while 222 and 354 particles were rated '3' and '2', respectively. Overall, our findings reveal the presence of only one highly pristine particle, a small number of moderately pristine particles, and a substantial proportion of altered particles within the MIDAS dataset.
We also found that there are 474 particles rated as severely altered. This finding indicates dust alteration is inevitable even at the slow collection speeds that were available at the Rosetta spacecraft. The particle catalog  (Kim et al. 2023)  and shape descriptor in the present study will serve as references for future scientific projects such as the development of more realistic analog materials, and the design of dust particles in simulations for comets and early solar system studies. The database will also be a landmark for any future cometary or interplanetary dust investigation, be it a re-consideration of Stardust data, the analysis of returned material of asteroids, or even -in the far future -of a comet. Gas flow properties are significantly influenced by the shape of the grains.
Acknowledgements. This paper is dedicated to the memory of MIDAS Co-I  Prof. Anny-Chantal Levasseur-Regourd , a true Renaissance person. The authors gratefully thank our referee and editor for the constructive comments and recommendations which definitely help to improve the readability and quality of the paper. M. K. and T. M. acknowledge funding by the  ESA  project " Primitiveness of cometary dust collected by MIDAS on-board Rosetta " (Contract No. 4000129476 ). M. K. also acknowledges the funding from the  Royal Society. J. L. acknowledges funding by  CNES  and the  PNP INSU CNRS  for working on the Rosetta data. This research was supported by the  International Space Science Institute (ISSI)  through the  ISSI International Team  " Characterization of cometary activity of 67P/Churyumov-Gerasimenko comet ".
In this paper we revisit the problem of erasing sensitive data from memory and registers during return from a cryptographic routine. While the problem and related attacker model is fairly easy to phrase, it turns out to be surprisingly hard to guarantee security in this model when implementing cryptography in common languages such as C/C++ or Rust. We revisit the issues surrounding zeroization and then present a principled solution in the sense that it guarantees that sensitive data is erased and it clearly defines when this happens. We implement our solution as extension to the formally verified Jasmin compiler and extend the correctness proof of the compiler to cover zeroization. We show that the approach seamlessly integrates with state-of-the-art protections against microarchitectural attacks by integrating zeroization into Libjade, a cryptographic library written in Jasmin with systematic protections against timing and Spectre-v1 attacks.
]]", where TSF stands for the security functionality of the product under evaluation and RBG stands for "random bit generator". Defense in depth. Cryptographic libraries are used by a plethora of applications and the application-level code is typically not under control of the library programmer. Bugs in the application that allow out-of-bound reads of memory may be used to obtain memory content from the whole address space of the application, including, of course, all stack content. The most prominent example for such a bug is HeartBleed  [Syn14, CVE14]. While this bug was part of the OpenSSL library (and not some application), it was not a bug in any of the cryptographic components. Zeroization helps to limit the damage that an attacker can do when exploiting such a vulnerability. Forward secrecy.
The main contribution of this paper is presented in Section 4. We describe our principled approach to stack (and register) zeroization for the Jasmin framework for high-assurance cryptography [ABB + 17, ABB + 20]. The three main components of the Jasmin framework are its programming language, which can be used for writing high-speed implementations using the "assembly in the head" paradigm, its compiler, which comes with formal proofs of functional correctness and of preservation of side-channel protection (specifically preservation of constant-time), and its verification infrastructure, which can be used to prove functional correctness, constant-timeness, and reductionist security via an embedding to EasyCrypt. The Jasmin framework has been used for writing efficient and formally verified implementations of several key cryptographic primitives; in particular, it has been used to develop the Libjade library for post-quantum cryptography.
Yang, Johannesmeyer, Olesen, Lerner, and Levchenko [YJO + 17] provide a detailed analysis of the issue of dead-store elimination and of some popular scrubbing techniques; their analysis can be seen as much more in-depth review of what we briefly recall in Section 2. 1. In addition, they provide a scrubbing function secure_memzero that combines different scrubbing techniques, and evaluated the use of the function with GCC, LLVM, and Visual C. Last, they implement a scrubbing safe dead-store elimination option in LLVM. Our work is most closely related to  [SCA18]. In that work, Simon, Chisnall, and Anderson first investigate how mainstream compilers make it actively hard to achieve certain security-related properties including zeroization. They then propose three approaches to perform zeroization in the LLVM compilers-all approaches are implemented and publicly available from https://github.
Failure modes One might think that overwriting used stack space and erasing values in registers before returning from a cryptographic routine should not be a difficult thing to do. Unfortunately this is not the case in many programming languages. In this section we look into different failure modes when attempting to protect cryptographic software in the attacker model we introduced in Section 1. We investigate approaches for stack zeroization taken by 9 popular open-source crypto libraries written in C/C++ (possibly with assembly), namely BearSSL 0. 6  [Por23] , GnuTLS 3. 6. 12 [Gnu23], libsodium 1. 0. 18 [Lib23], mbedtls 3. 3  [Mbe23] , NSS 3. 91  [NSS23] , OpenSSL 3. 1. 1  [Ope23] , TinyDTLS 0. 9  [Tin23] , and WolfSSL 5. 6. 3  [Wol23]. We also consider two libraries written in Rust, namely ring 0.
17  [Smi23]  and Dalek 2. 0 (RC3)  [Dal23]. While many of these libraries make an attempt to zeroize sensitive data, none of them explicitly claims security in the attacker model we use in this paper. It should thus not surprise that none of the libraries is actually secure in this attacker model. In his reply to our disclosure e-mail, Denis, maintainer of libsodium, describes their approach as follows: "Overwriting all secrets after use is not a goal of libsodium. It's silently done in a couple places where it's simple and cheap to do, but this is not a guarantee documented anywhere, and not something that's planned to be become one. " In the subsequent subsections, we build up a hierarchy of failure modes and explain why languages like C/C++ or Rust and existing mainstream compilers make it close to impossible to not hit at least one of them.
Perform no zeroization A common technique of implementers is to ignore or shift the problem of memory scrubbing. The BearSSL crypto library, for example, recommends to overwrite the stack with garbage data after BearSSL was used. This shifts the responsibility of memory scrubbing to the application developer employing BearSSL. Unfortunately, this is not at all apparent to users of the library. Besides, even if an application developer was aware of their responsibility to clear the stack, they would probably fail to do so. This is simply because on a source code level it is completely unclear how much stack space was used by BearSSL. The popular ring implementation of cryptographic primitives employs the same approach, and does not wipe sensitive data from memory either. Even though it is written in the memory-safe language Rust, it can be employed by C/C++ programs.
Zeroization falling prey to compiler optimizations A straightforward way to overwrite memory in C/C++ programs is to overwrite the desired memory region in a loop or by calling the memset function. Both approaches are inherently flawed when it comes to zeroization of sensitive data. The reason is that compilers will commonly apply an optimization called dead-store elimination (DSE), i. e. , removing stores of variables that will not be read anymore during their life time. Since zeroization occurs precisely once sensitive data is no longer needed, it is a textbook target for DSE. From the libraries we investigated, TinyDTLS and NSS contain examples of attempts to zeroize sensitive data using memset. TinyDTLS calls memset directly to scrub memory from sensitive data, such as key material. NSS calls the macro PORT_Memset, which expands to memset on all platforms and, as demonstrated by [YJO + 17], is eliminated by common compilers.
However, inside chacha20_encrypt_bytes, the entire context, including the encryption key, is copied onto the stack:. uint32_t j0, j1, j2, j3, j4, j5, j6, j7, \ j8, j9, j10, j11, j12, j13, j14, j15;. j0 = ctx->input[0]; j1 = ctx->input[1];. j15 = ctx->input[15]; So even though the developer was actively zeroizing sensitive data in memory, the stack still contains a full copy of the secret key after libsodium returns control to the caller. To show that this is indeed an exploitable behavior, we developed a small example program with a memory-corruption bug that employs libsodium and leaks secret keys. 1. The implementation of ChaCha20 in OpenSSL suffers from the exact same behavior. The difficulties developers face by trying to identify all variables containing sensitive data is best described by the following commit message of Brian Smith, maintainer of the ring library  [Smi23].
Benchmarks and validation This section evaluates the cost of zeroization. As a starting point, we use the artifact from [SBG + 22], which protects cryptographic implementations from Libjade [For23] against Spectre v1. We produced the data in this section with a machine with Linux Debian 5. 10. 0-21-amd64, GCC 10. 2. 1, and equipped with an Intel Core i7-10700K (Comet Lake) with hyperthreading and TurboBoost disabled. Table  1  reports the cycle counts for six cryptographic primitives and nine implementations. For implementations with variable-input-length, such as ChaCha20 and Poly1305, we include the measurements for 128, 1024, and 16384 bytes. Each reported value in Table  1  corresponds to a median of 10000 executions. Given that the overhead of zeroization from our approach is small (from an absolute perspective), we repeated the experiment a total of eleven times, and included in the table the median of these (which can be interpreted as an approximation of the median of 110000 executions).
However, for projects that can integrate assembly code generated by the Jasmin compiler, switching to Jasmin implementations comes with additional benefits like certified compilation, timing-attack and Spectre-v1 protection [SBG + 22], and an interface to EasyCrypt  [BGHZ11]  proofs of functional correctness and reductionist proofs of security. One obvious line of future work is to extend Jasmin's set of supported target architectures, including the zeroization support we presented here. Furthermore, recall that our proposed approach erases all data and does so only when returning from an export function. One can imagine investigating more fine-grained approaches in two different senses: First, as Jasmin features a information-flow type system, one could decide to erase secret data only. While the information about secrecy is in principle available, it is not trivial to decide at the end of an export function for each address in the used stack space, if the last write contained secret data or not.
Again, given on our benchmarks of fast functions on short inputs, we expect such an approach to be quite expensive in terms of performance. The Jasmin compiler is an ideal context for developing security-aware compilation techniques, for three reasons. First, Jasmin is primarily targeted to cryptographic software, which mandates the use of these transformations. Second, the Jasmin compiler is arguably simpler than a mainstream compiler, making the implementation and integration of these transformations much simpler. Last, the overarching goal of the Jasmin/EasyCrypt approach to high-assurance cryptography is to derive assembly-level guarantees against implementation adversaries. As noted by Percival, proving properties such as forward secrecy at assembly-level mandates the use of a formally verified zeroing compiler, so there is a very strong motivation to adopt and maintain zeroization in the Jasmin compiler.
Acknowledgements This research was supported by the  Deutsche Forschungsgemeinschaft (DFG, German research Foundation)  as part of the  Excellence Strategy of   the German Federal  and  State Governments  - EXC 2092 CASA -390781972 ; the  German Federal Ministry of Education and Research (BMBF)  in the course of the 6GEM research hub under grant number  16KISK038 ; the  European Commission  through the  ERC Starting Grant   805031  (EPOQUE); and the  Agence Nationale de la Recherche (ANR ,  French National Research Agency)  as part of the  France 2030 programme  - ANR-22-PECY-0006.
Training and validation of the methods were performed on challenging image datasets acquired in a robotised high-throughput phenotyping platform. Berries were detected on various genotypes with a F1-score of 91. 8%, and segmented with a mean absolute error of 4. 1% on their area. Tracking allowed to label and retrieve the temporal identity of more than half of the segmented berries, with an accuracy of 98. 1%. This method was used to extract individual growth and colour kinetics of various berries from the same bunch, allowing us to propose the first statistically relevant analysis of berry ripening kinetics, with a time resolution lower than one day.
In this paper, we introduce a fully automated method to measure and track the size and colour of individual berries on time-lapse images of grapevine bunches. The method starts with a detection model to recognize berries that are sufficiently visible to reasonably infer their size. Second, a segmentation model was trained to infer both the visible and hidden contours of individual berries, using a training dataset derived from a fast and original annotation method. Ellipses are further fitted on the segmented contours to compute position and shape parameters for each berry. Finally, we adapted a tracking algorithm to assign time-consistent labels to the detected berries while handling global deformations of the bunch. This method was tested on image time-series acquired at the PhenoArch platform  [Cabrera-Bosquet et al.
Plant material, image acquisition and dataset composition The complete pipeline (segmentation and tracking) was tested on an image dataset from two independent experiments conducted in 2020 and 2021, spanning 51 and 32 days respectively, each containing 9 grapevine (Vitis vinifera L. ) plants. For each plant, images of a selected grapevine bunch were taken every 8 hours. An additional dataset including bunch images of 78 grapevine genotypes from a diversity panel maximising genetic diversity  [Nicolas et al. , 2016]  was used to robustify the training and evaluation of the berry segmentation pipeline (without tracking). All experiments were conducted in the PhenoArch phenotyping platform (https://www6. montpellier. inrae. fr/lepse_eng/Phenotyping-platforms-M3P/Montpellier-Plant-Phenotyping-Platforms-M3P/PhenoArch), hosted at the M3P (Montpellier Plant Phenotyping Platforms)  [Cabrera-Bosquet et al.