This post builds upon A Brief Introduction to
Crypto++. I suggest to have a quick look at it before
diving into Source and Sink classes.
Sources and sinks are quite similar, so we will review them together. Just a refresher: a source provides an input for a Crypto++ pipeline, while a sink terminates it by saving the result to an output. The input and output of a pipeline are usually data containers (e.g., arrays, vectors, strings) or files.
My first encounter with Crypto++ was at an old job. I remember struggling to find good material aimed at novice users. I managed to complete my tasks by reading the official documentation, the wiki (which is currently offline), and adapting the existing Crypto++ code in our codebase. However, I missed having a quick, beginner-friendly tutorial that explained the basics of the library and provided short examples of how to use its various algorithms.
To partially address this gap, I wrote a blog post that outlined some Crypto++ usage guidelines and demonstrated them with a code sample. The post garnered some interest, which inspired me to expand the idea into a book. Following the blog post's title, the book is named "Brief Introduction to Crypto++".
There are two interesting types in Rust which are implemented with enums (check the previous
post for more about enums).
They are Option and Result. Let's start with Option.
Rust enums are similar to the ones in C++ with one subtle difference - Rust ones allow you to bundle additional data with each variant. This feature combined with destructuring and pattern matching is very powerful. What I find interesting is that each feature is nothing special on its own but combining them together allows you to write very elegant code. In my opinion these are one of the coolest features of Rust. Let's start with enums.
This is the third post from my Rust for C++ developers series. With references and traits covered now is a good time to learn about ownership and borrowing. Rust is a system programming language and as such the memory management is a very important topic. I assume you are already familiar with what stack and heap is and how it works in general. If not - you can read this section from the Rust book. If you are not familiar with the references in Rust and you have missed part 2 I strongly recommend to read it now. You need to understand how references work in Rust to grasp this post. But before talking about borrowing let's discuss memory ownership.
This is the second post from my Rust for C++ developers post series and it will focus on structs, traits and some basic data structures embedded into the language. Similar to part 1 this post will continue exploring Rust's syntax and making parallels with C++. For each topic I'll provide links to the Rust book. You don't need a development environment for this post too. Rust Playground should be enough to run the examples and experiment with them. Let's get started.
This is the first post from my Rust for C++ developers post series and it will focus mainly on the basic syntax. This includes variables, functions, conditional operators and some common Rust patterns around them. I'll try to walk you through some syntactic and conceptual similarities and differences between the two languages based on my experience. To follow this post you don't need to setup a compiler or an editor. You can write code online at the Rust Playground and it should be enough to run the examples. For each topic discussed in the post I'll provide links to the Rust book where you can find more detailed information. Feel free to skip them if you are in a hurry but if you have got the time it's worth to at least skim through the sections.
If you want to learn Rust there are a lot of great and free resources online for you. My favourite one is The Rust Programming Language book also known as "The Rust Book". It's considered the official Rust tutorial and it's one of my favourite Rust books. Before picking up Rust I had around 10 years of C++ experience. While reading the book I noticed there are a lot of conceptual similarities between the two languages and I was thinking how nice it would be to have Rust explained by using the knowledge I already had from C++. It would have helped me to build an intuition for the language and how to write more idiomatic Rust code. The Rust book is definitely good but it doesn't make any assumptions about your background. If you already know what RAII is, how computer memory is organised, what a pointer/reference is you will find some of the material there redundant. When you read about something you already know you ask yourself "Is this the same as in C++ or there is a catch?" In this post I'll try to help you build intuition about how Rust works and how idiomatic Rust code looks like by sharing code samples, providing brief explanations and pointing you to the corresponding chapters from the Rust book to get the full picture. Where possible I'll make parallels with C++ and point out the differences and similarities between the two. I hope it will make your learning process a bit faster and a bit more comfortable.
Recently I started working professionally with Rust and it wasn't long before I stumbled upon proc macros. I had to make some changes to a relatively complex (for me) macro which generates traits and implementations for them. Reading about macros (and especially proc macros) in Rust created some associations with C++ metaprogramming which is not exactly my cup of tea. As a result I was determined not to enjoy the task. However it turned out that proc macros aren't that bad. They are very different from the regular Rust one sees every day but they are not black magic. And you can do useful stuff with them.
So why this post? There are a lot of resources for learning proc macros out there. I've read some of them but despite that there were things which just didn't click for me in the beginning. I needed something more to reach the 'now this makes sense' moment. So after gaining some knowledge I decided to write this post and share my experience. And more specifically - the things I didn't initially understand.
Should you read it? The short answer is NO :). If you aren't a complete proc macro newbie - there is nothing for you here. I'll be very grateful if you want to read it and share your feedback/advise. But don't be disappointed if you expect to learn something new and you only see obvious stuff. If you are just starting to learn proc macros this post might help. But people are different - hard things for me are maybe easy for you and the other way around.
At some point in your life as a software engineer you will have to write code involving cryptography (crypto for short). You might need to implement a password authentication system by keeping salted password hashes for your users or add encryption for your custom binary protocol implementation or save some files securely on disk, etc. This is usually harder than it sounds and you will have to use some crypto library to get the job done.
In this post I want to write a really quick and short introduction to Crypto++, a C++ cryptographic library. My first experience with it led a lot of questions. Reading the documentation and googling answers took me some time so I want to share my experience. Hopefully you will find the information in this post helpful and will save you some time.