Waiting the X-Mas Holidays

After publishing the story behind my last job-nightmare, I got a lot of messages, views, comforting replies and opinions. Well… thank you all for all the inputs, I really appreciated the time you took to see how I was doing ❤️ Thank you! 🍪

That’s why I’m writing this post, to let you all know that things are fine and which new projects are currently being prepared for cooking!

tl;dr: everything is fine. Currently working on some small projects and some job opportunities, waiting for the winter holidays!

---

Leaning 🇫🇷

As many might know, I’m (slowly) learning French. Sadly, the struggle is real 😅 however I found QIOZ, an (slightly gamified) online language(s) course(s) freely available to the residents of Île-de-France.

I have to admit that I’m enjoying a lot the harshness of some of these exercises!

Kangaroos and Elliptic Curves

Recently, I ported a Python implementation of (some peculiar variations) Pollard’s kangaroo for interval discrete logarithm (IDLog) in Rust.

The reimplementation is nonsensically faster than the Python one, like 50-100x faster. However, after some thoughts, I started refactoring the code and reducing¹ the number of dependency, especially for handling long-long finite fields number, elliptic curves and casting between these.

That is why, I believe I found the best crate ever: Malachite. It is extremely fast (3x faster than using num-bigint) and the documentation quality is… 💋❤️

Implementing the minimal amount of elliptic curve over finite fields arithmetic was a gentle breeze, casting in/out from other structure was easy and, whenever something was weird, debugging and finding the problem was a pleasure. Highly, highly, highly recommended!

Additionally, I decided to go full vanilla and handle the multi-threading myself, to further reduce the number of crates introduced in my code.

Was all of this a good idea? Definitely! The multi-threading does its job with some additional cost and allows the computation of some additional points that wouldn’t be computable without the added help of “sharing the workload”!

The code is currently a private repo. However, I have plans to release it in a bigger project…

Elliptical Runner

After looking around, I noticed that there are plentiful of elliptic-curve-crypto (ECC) crates/modules/packages all designed for constructing signatures schemes, key agreement protocols and similar. This is fine, don’t get me wrong…

…but what about attacks on ECC?

Looking around, there are here and there some repositories implementing Pollard’s “offenders” (kangaroos and Greek letters) but many other attacks (e.g. Cheon’s auxiliary inputs attacks) are not implemented or, if they are, they are mainly academic-code. Plus, other attacks on IDlog can easily be improved with some minor clever tweaks.

That is why, I put a note on collecting some of these attacks and get them implemented. The final goal would be to compare them all and, maybe, found out some new improvements!

FlyESP

Born from a real paranoid-necessity of mine, I started the journey to design a friendly companion to check the status of the planes during the journey.

Travelling can be stressful especially when you don’t know where your plane is or if you will be able to catch the next one. Airports always provide a tentative timing for departure but sometimes you might know in advance if a flight might be delayed further more because the plane is not yet in the air. What I want to do is to build a ESP32-powered device that displays where the journey’s planes are!

As you might expect, there are several steps in this journey and quite a lot to learn. So, let’s see how this project goes!

Improving Other Projects

With the added Rust knowledge gained in these months, I will definitely refactor some code in LeakSolver with the idea of bringing some good multi-threading tricks and improve the efficiency of that solving algorithm.

---

Well, if you landed in this conclusion section, I hope you had a good time! Thank you for reading!

---

Footnotes