Abstract
Jasmin is a programming language for high-speed and high-assurance cryptography. Correctness proofs of Jasmin programs are typically carried out deductively in EasyCrypt. This allows generality, modularity and composable reasoning, but does not scale well for low-level architecture-specific routines. CryptoLine offers a semi-automatic approach to formally verify algebraically-rich low-level cryptographic routines. CryptoLine proofs are self-contained: they are not integrated into higher-level formal verification developments. This paper shows how to soundly use CryptoLine to discharge subgoals in functional correctness proofs for complex Jasmin programs. We extend Jasmin with annotations and provide an automatic translation into a CryptoLine model, where most complex transformations are certified. We also formalize and implement the automatic extraction of the semantics of a CryptoLine proof to EasyCrypt. Our motivating use-case is the X-Wing hybrid KEM, for which we present the first formally verified implementation.

Abstract
We propose a hybrid formal verification approach that combines high-level deductive reasoning and circuit-based reasoning and apply it to highly optimized cryptographic assembly code. Our approach permits scaling up formal verification in two complementary directions: 1) it reduces the proof effort required for low-level functions where the computation logics are obfuscated by the intricate use of architecture-specific instructions and 2) it permits amortizing the effort of proving one implementation by using equivalence checking to propagate the guarantees to other implementations of the same computation using different optimizations or targeting different architectures. We demonstrate our approach via an extension to the EasyCrypt proof assistant and by revisiting formally verified implementations of ML-KEM in Jasmin. As a result, we obtain the first formally verified implementation of ML-KEM that offers performance comparable to the fastest non-verified implementation in x86-64 architectures.

Abstract
This paper presents a semantic characterization of leakage-freeness through timing side-channels for Jasmin programs. Our characterization covers probabilistic Jasmin programs that are not constant-time. In addition, we provide a characterization in terms of probabilistic relational Hoare logic and prove the equivalence between both definitions. We also prove that our new characterizations are compositional and relate our new definitions to existing ones from prior work, which could only be applied to deterministic programs. To provide practical evidence, we use the Jasmin framework to develop a rejection sampling algorithm and provide an EasyCrypt proof that ensures the algorithm's implementation is leakage-free while not being constant-time.

Abstract
User-centred design is an iterative process that involves ideation, testing, and refinement to enhance usability, functionality, and overall user experience. However, there is still a need to code the final design. This transition from design to implementation is a time-consuming task. In this paper, we propose an approach and its supporting tool to generate a web application's front-end code from a prototype of its user interface. Our goal is to generate code that can be easily integrated into the overall application development. The results demonstrate that the proposed tool can achieve visual fidelity comparable to that of existing commercial plugins, while producing higher-quality code that better reflects the behaviour specified in the prototype.

Abstract

Abstract
Formal verification can be a complementary approach to UCD, offering a systematic and repeatable process to address the demands of designing safety and mission-critical interactive systems. However, the practical application of formal verification often encounters barriers to accessibility for non-technical stakeholders. In the case of model checking, although the verification step is fully automated, developing the required specifications and interpreting the verification results requires considerable technical expertise in formal methods. Recent developments in generative Artificial Intelligence (AI) have driven proposals for Large Language Models (LLMs) to be applied throughout various phases of software engineering. This begs the question of whether LLMs might be used to help bridge the gap between formal techniques and tools and stakeholders lacking technical expertise. This paper explores how these questions might be addressed in the context of an ongoing effort aimed at translating model-checking counter-examples into natural language explanations, making them accessible to designers and domain experts.