namespace mbedcrypto {
  using buffer_t = std::string;
}

try {
  //
  // mbedcrypto codes ...
  //
} catch ( mbedcrypto::exception& cerr ) {
  std::cerr << "the expanded error message is: "
      << cerr.what() << std::endl;
  int c_error_code = cerr.code(); // the underlying error code
}

int ret = an_object.a_low_level_method(...);
if ( ret != 0 ) {
  std::cout << "underlying error code: "
      << mbedcrypto::mbedtls_error_string(ret) << std::endl;
}

using namespace mbedcrypto;

auto hashes = installed_hashes(); // returns std::vector<mbedcrypto::hasht_t>
std::cout << "supports " << hashes.size() << " hash algorithms: ";
for ( auto h : hashes ) { // print all installed hashes
  // convert type to string
  std::cout << to_string(h) << " , ";
}

// similarly
auto paddings = installed_paddings();
auto bmodes   = installed_block_modes();
auto ciphers  = installed_ciphers();
auto pks      = installed_pks();
auto curves   = installed_curves();

// convert from string to a type
auto htype = from_string<hash_t>("sha256");
if ( htype != hash_t::none ) {
}

// check by type (enum class)
if ( supports(cipher_t::aes_256_cbc)   &&   supports(pk_t::rsa) ) {
  // do stuff
}
// check by algorithm name
if ( supports_hash("sha1")    &&    supports_pk("rsa") ) {
  // sign a message ...
}
// both upper and lower case are supported
if ( supports_cipher("CAMELLIA_128_CBC") ) {
}

// to check a single feature
if ( suppurts(features::aes_ni) ) {
  std::cout << "this system supports AESNI (hardware accelerated AES)" << std::endl;
}

if ( supports(features::aead)    &&    supports(cipher_bm::gcm) ) {
  // do GCM authenticated encryption with additional data
}

using namespace mbedcrypto;

std::fstream fpng = open_a_png_file(...);
std::string bin_data; // binary data
fpng >> bin_data;

auto png_hex = to_hex(bin_data);
auto png_b64 = to_base64(bin_data);

REQUIRE( from_hex(png_hex) == from_base64(png_b64) );

// to get the required base64 size
size_t encode_size = base64::encode_size(bin_data);
png_b64 = base64::encode(bin_data);

REQUIRE( base64::decode_size(png_b64) == bin_data.size() );

REQUIRE_THROWS( base64::decode("invalid base64 string @#$%#^$") );

using namespace mbedcrypto;

// by single shot functions
auto hash_value = make_hash(hash_t::sha256, source_data);
auto hmac_value = hmac::make(hash_t::sha1, key_data, source_data);

std::cout << to_base64(hash_value) << std::endl;

hash h0(hash_t::ripemd160);
hash h1(from_string<hash_t>("sha1"));

h1.start();
while ( ... ) {
  h1.update(read_some_data());
}
auto hash_value = h1.finish();

// re-use
h1.start();
h1.update(...); // single or multiple updates
hash_value = h1.finish();

using namespace mbedcrypto;

std::string source_plain_data = read_from_somewhere();

// encrypt and decrypt by single-shot functions
auto ciphered_buffer = cipher::encrypt(
    cipher_t::aes_256_cbc,
    padding_t::pkcs7,
    initial_vector_data,  // get iv size from cipher::iv_size()
    key_data,             // get key length in bit by cipher::key_bitlen()
    source_plain_data     // could be in any size because of cbc block mode
    );

auto decrypted_buffer = cipher::decrypt(
    cipher_t::aes_256_cbc,
    padding_t::pkcs7,
    initial_vector_data,
    key_data,
    ciphered_buffer
    );

REQUIRE( source_plain_data == decrypted_buffer );

std::string the_additional_data = ...;

auto encr = cipher::encrypt_aead(
    cipher_t::aes_256_ccm,
    iv_data,
    key_data,
    the_additional_data,
    source_plain_data
    );  ///< returns a std::tuple< computed_tag, encrypted_data >


auto decr = cipher::decrypt_aead(
    cipher_t::aes_256_ccm,
    iv_data,
    key_data,
    the_additional_data,
    encr
    );  ///< returns a std::tuple< authentication_status, decrypted_data >


  REQUIRE( std::get<0>(decr) == true ); // authenticated?
  REQUIRE( std::get<1>(decr) == source_plain_data );

// construct and setup properties
cipher cipdec(cipher_t::aes_256_cbc);
cipdec
  .padding(padding_t::pkcs7)
  .iv(iv_data)
  .key(key_data, cipher::decrypt_mode);

// by start() / update()s / finish()
cipdec.start();
std::string decrypted_data;
while ( ... ) {
  decrypted_data += cipdec.update(read_some_encrypted_data());
}
decrypted_data += cipdec.finish();
REQUIRE( source_plain_data == decrypted_data );

// re-use the object
cipdec.start();
cipdec.update(...); // or multiple updates
cipdec.finish();

// single shot re-use
decrypted_data = cipdec.crypt(encrypted_data);

rnd_generator rgen;
auto random_data1 = rgen.make(256); // in bytes
// entropy and ctr_drbg are not so cheap, reuse them:
auto random_data2 = rgen.make(32);  // in bytes

// update internal state with custom data (may helps entropy)
rgen.update(some_random_volatile_data);
auto nonce = rgen.make(64);

using namespace mbedcrypto;

rsa pri_key;
// import from data buffer
pri_key.import_key(private_key_data, optional_password);
// or load from a file by file-name
pri_key.load_key("private_key.pem");

rsa pub_key;
pub_key.import_public_key(public_key_data);

// [optional] check matching public/private pair
REQUIRE( check_pair(pub_key, pri_key) == true );

// export keys
if ( supports(features::pk_export) ) {
    auto der_data = pub_key.export_public_key(pk::der_format);
    // write or share
}

// key generation
if ( supports(features::rsa_keygen) ) {
    rsa pri_key;
    pri_key.generate_key(2048); // a 2048bit key
    // do stuff
}

auto af = pub_key.what_can_do(); // what can i do with this key?
// returns pk::action_flags (key capabilities) with following data:
// af.encrypt = true
// af.decrypt = false
// af.sign    = false
// af.verify  = true
// because pub_key is a valid rsa public-key

auto kinfo = pri_key.key_info();
// kinfo.N  :  public modulus
// kinfo.E  :  public exponent
// only valid if the key is a private key
// kinfo.D  :  private exponent
// kinfo.P  :  1st prime factor
// kinfo.Q  :  2nd prime factor
// kinfo.DP  : D % (P - 1)
// kinfo.DQ  : D % (Q - 1)
// kinfo.QP  : 1 / (Q % P)

// signature & verification
std::string message = read_message_from_somewhere();
auto signature      = pri_key.sign(message, hash_t::sha256);
REQUIRE( pub_key.verify(signature, message, hash_t::sha256);

const auto hvalue = hash::make(hash_t::sha256, message);

auto encv = pub_key.encrypt(hvalue);
auto decv = pri_key.decrypt(encv);
REQUIRE( decv == hvalue );

// or
auto encv = pub_key.encrypt(message, hash_t::sha256);
auto decv = pri_key.decrypt(encv);
REQUIRE( decv == hash::make(hash_t::sha256, message) );

using namespace mbedcrypto;

if ( supports(features::pk_export)  &&  supports(pk_t::eckey) ) {
    ecp gen; // elliptic curve public key infrastructure
    gen.generate_key(curve_t::secp224k1); // or any other supported curves
    auto pri_data = gen.export_key(pk::pem_format);
    auto pub_data = gen.export_public_key(pk::pem_format);
    // do stuff

    auto kinfo = gen.key_info(); // ecurve points and secret
    std::cout
        << "\nQx (" << kinfo.Qx.bitlen() << "): " << kinfo.Qx.to_string()
        << "\nQy (" << kinfo.Qy.bitlen() << "): " << kinfo.Qy.to_string()
        << "\nQz (" << kinfo.Qz.bitlen() << "): " << kinfo.Qz.to_string()
        << "\nd  (" << kinfo.D.bitlen()  << "): " << kinfo.d.to_string()
        << std::endl;
}

using namespace mbedcrypto;

if ( supports(pk_t::ecdsa)  &&  supports(features::ec_keygen) ) {
    ecdsa pri_key; // both pk_t::eckey and pk_t::ecdsa works
    pri_key.generate_key(curve_t::secp192k1);
    auto sig = pri_key.sign(message, hash_t::sha384);

    ecdsa pub_key;
    pub_key.import_public_key(
            pri_key.export_public_key(pk::pem_format)
            );

    REQUIRE( pub_key.verify(sig, message, hash_t::sha384) );
}

using namespace mbedcrypto;
// const auto ctype = curve_t::secp224r1 // both know the curve type

ecdh server;
auto srv_pub = server.make_peer_key(ctype);
// send srv_pub to client

ecdh client;
client.generate_key(ctype); // alternative approach to make_peer_key()
auto cli_pub = client.peer_key();
// send cli_pub to server

auto sss = server.shared_secret(cli_pub); // on server
auto css = client.shared_secret(srv_pub); // on client

REQUIRE( (sss == css) );

using namespace mbedcrypto;

ecdh server;
// (only) server defines the curve type
auto skex = server.make_server_key_exchange(curve_t::secp192k1);
// send server's key exchange params to client

ecdh client;
auto cli_pub = client.make_client_peer_key(skex);
auto css     = client.shared_secret();
// send cli_pub to server

auto sss     = server.shared_secret(cli_pub); // on server

REQUIRE( (sss == css) );