Key distillation, also referred to as classical post-processing, plays a pivotal role in Quantum Key Distribution (QKD) protocols. Key distillation encompasses numerous subroutines, making the analysis of its overall security implications potentially challenging for those outside the research community. In this paper, we elucidate the role of the key distillation phase in QKD from a security standpoint. We begin by analyzing the different components of the key distillation phase individually, followed by an examination of the process as a whole. We then calculate the bit strength of the produced key, assuming that an attacker is executing an intercept and resend attack. For our analysis, we employ a practical key distillation implementation linked to a decoy state BB84 protocol as a case study. Our findings suggest that the security of the final key, post the key distillation phase, hinges on several factors. These include the theoretical security of the implemented subroutines, the total information leakage throughout the process, and the choices of subroutine parameters. Given these assumptions, we can distill 287 secure bits for every 1000 bits that undergo the key distillation procedure.

Abstract Commercial multicore central processing units (CPU) integrate a number of processor cores on a single chip to support parallel execution of computational tasks. Multicore CPUs can possibly improve performance over single cores for independent parallel tasks nearly linearly as long as sufficient bandwidth is available. Ideal speedup is, however, difficult to achieve when dense intercommunication between the cores or complex memory access patterns is required. This is caused by expensive synchronization and thread switching, and insufficient latency toleration. These facts guide programmers away from straight-forward parallel processing patterns toward complex and error-prone programming techniques. To address these problems, we have introduced the Thick control flow (TCF) Processor Architecture. TCF is an abstraction of parallel computation that combines self-similar threads into computational entities. In this paper, we compare the performance and programmability of an entry-level TCF processor and two Intel Skylake multicore CPUs on commonly used parallel kernels to find out how well our architecture solves these issues that greatly reduce the productivity of parallel software development. Code examples are given and programming experiences recorded.

Our digital lives rely on modern cryptography that is based on complicated mathematics average human users cannot follow. Previous attempts at adding the human user into the cryptographic loop include things like Human Authenticated Key Exchange and visualizable cryptography. This paper presents our proof-of-concept implementation of these ideas as a system called EEVEHAC. It utilizes human capabilities to achieve an end-to-end encrypted channel between a user and a server that is authenticated with human senses and can be used through untrusted environments. The security of this complete system is analyzed. We find that the combination of the two different systems into EEVEHAC on a theoretical level retains the security of the individual systems. We also identify the weaknesses of this implementation and discuss options for overcoming them.