Random number generators, or RNGs, are a fundamental part of many cryptographic algorithms, so it's no surprise that Crypto++ provides several RNG implementations. The index of the documentation lists the following algorithms:
This posts explores the hashing algorithms available in Crypto++. We will examine how to use them
independently and how to integrate them into a pipeline. First, let's review the available
implementations. These are listed in the "Hash Functions" section of the documentation index.
Notable examples include Blake2s/2b, Keccak, and SHA3. Some algorithms, such as MD5 and MD4, are
located in the Weak namespace. As the name implies, these are not secure for production use and
are included only for reference.
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.
EDIT (Jun 5, 2025): Update the details about the book.
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:
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.