Convenience overloads for CT::poison()

[reneme]

This introduces a few convenience helpers for CT::poison(). For instance

CT::poison(some_integer_type);
CT::poison(some_range);
CT::poison(some_type_that_has_method_const_time_poison);
CT::poison_range(a_list_of_big_ints); // iterates the list and poisons each range element individually
CT::poison_all(some_int, some_range, some_type_with_const_time_poison);

auto scope = CT::scoped_poison(m_private); // will be unpoisoned at the end of scope

... and of course the respective CT::unpoison() functions.

[reneme]

We saw that BigInt::const_time_poison() was a thing already and just extended the idea to general types. This will be convenient for the PQC stuff in particular, as it often has helper-structures that could encapsulate their poisoning.

Ideally, this method should be _const_time_poison(), I guess, but we didn't want to break the existing BigInt API.

[randombit]

We could alternately name it _const_time_poison and on BigInt just define const_time_poison as a deprecated forward.

Or just define another instance and handle both cases --

template <typename T>
   requires requires(const T& x) { x._const_time_unpoison(); }
constexpr void unpoison(const T& x) {
   x._const_time_unpoison();
}

[reneme]

I'll rename them to _.... which is anyway the new convention.

[coveralls]

coverage: 91.708% (+0.002%) from 91.706%
when pulling 85b06f4 on Rohde-Schwarz:ct/poison_overloads
into 1af5545 on randombit:master.

[randombit]

Wait, this doesn't seem right. Are we poisoning/unpoisoning the masks currently somewhere?

[reneme]

Yes. Here:

botan/src/lib/pk_pad/iso9796/iso9796.cpp

Line 192 in 1af5545

CT::unpoison(bad_input);

botan/src/lib/tls/tls12/tls_cbc/tls_cbc.cpp

Line 452 in 1af5545

CT::unpoison(ok_mask);

[randombit]

Ah ok, fallout from not having CT::Choice for this kind of logic.

Fine to merge this then, it's just keeping status quo. These should be fixed though.

[reneme]

I applied all review suggestions and tweaked the requirements for the overloads a little. Most notably: poison(Range&&) now requires that the range's members are trivially copyable. Otherwise a (hypothetical) range of complex objects would have unexpected outcomes. Say poison(std::vector<std::vector<uint8_t>>) would have worked and (probably) poisoned the inner vectors' meta-data, which is certainly not what we would have expected.

Additionally, I added poison_range(R&&) which iterates any range of poisonable objects and poisons them individually. I deliberately decided to not make this an overload of poison() to avoid inadvertently binding to the wrong overload for some unforeseen reason.

Also note that I replaced the existing calls to something.const_time_poison() with CT::poison(something) for convention's sake (to avoid calling the "internal" _const_time_poison()).