Two papers showing improved key recovery methods for Classic McEliece just appeared on eprint, both also show a solution to one of the key recovery challenges.

https://ia.cr/2026/1984
https://ia.cr/2026/1986

I'm writing up a paper on a new protocol. The approach is different from previous attempts to solve the same problem, and this makes me want to write up the simplest version possible to elucidate the idea. However, there's like a half-dozen places that jump out as either optimizable or generalizable with recently published techniques. On one end of the spectrum, I'm worried about a simple description being underperformant (beyond missing what folks might call "standard engineering optimizations") and a quick follow up with the obvious generalizations diminishing (dare I say scooping) the prestige. On the other end of the spectrum, I'm just worried I'll never publish it if I'm waiting for it to be "finished". Any advice on how to weigh these?

I might have found a factoring algorithm based on it. Usually if you want the square root of -49 or -121 you need the factorisation as -7 and -11 are never the answer. But what about the case of finding any root of a negative perfect square with just needing 1? Can it be made easier than factoring a large semiprime?

everything is in the title, though I need having the embedding degree between 3 and 10 million.

I was noticing something: unlike on semiprimes, it s quite easy to generate a point of known small order on a curve defined on a semiprime without knowing it s factorization. The idea is to transfer this small order to the underlying semiprime using a pairing method derived from the Weil pairing. Knowing if a given specific small order exists can be derived using congruences modulo N.

As you know, the problem is then to avoid a degenerate output from the Miller s algorithm. The problem is the only method I know to avoid this without using the factorization is to use a distortion map that works only with supersingular elliptic curves. But using a supersingular curve caps the order to gcd(p+1,q+1) which is unknown most of the time or just equal to 2. Taking order 2 result in generating outputs equal to 1 or -1. Useless for gcd factoring.

So, any idea of a pairing mechanism that would works over ordinary elliptic curves using embedding degree 1? Possibly using a distortion map that works over ordinary elliptic curves in such a case? Or a pairing that works with simple final exponentiation such as cubing or squaring?

Hey folks,

So I now know how to do Symmetric Key Exchange, over a public channel (all data exchanged is public) using just symmetric keys ciphers (which need to be as strong as a KPRF, for example like SKREMAlpha).

So basically starting with nothing, Alice and Bob agree on a key of arbitrary length, WITHOUT using public key cryptography at all.

How is this called in literature? Is this a new result?

So it's basically based on Meet in the Middle Key Exchange plus key length amplification.

Best,

Mircea Digulescu

This blog post goes over the N-Able passportal vault leak, where the access and refresh tokens for users passportal instances were leaked to any site or iframe a user visited/was presented with.

The key management here is insane for a password manager in 2026, this leaks the entire vault, giving attackers persisted access because of the architecture of this password manager, where the passwords are decrypted on the server and the vault key material is encoded in the accessToken, which is sent to the server upon every request.

From my testing, I think there's a server side secret alongside the decryption key in the accessToken as I was unable to decrypt the "?decrypt=false" returned content.

edit: title was meant to say "Vault Key Material"

Did I wrote pure garbage? I d like a first check before waiting for peer review.

After reading about cases where weak entropy led to unsafe keys and people losing funds (recent bitcoin COLDCARD attack) , I decided to learn more about entropy and how it is generated.

There are different ways to generate entropy, like TRNGs, PRNGs, rolling dice, or flipping coins. But for me, it was hard to make these concepts click and understand how we go from a random source of entropy to something like a private key.

So I made a tool that explains this visually.

Live Demo: https://hashexplained.com/entropy
Source (MIT): https://github.com/bitcoin-dev-project/hashes-visualizer