C++ (Cpp) mega_aes_key_new_from_ubase64 Examples

Example #1

File: test-rsa.c Project: aaam/megatools

void test_rsa(void)
{
  // my keys
  MegaAesKey* mk = mega_aes_key_new_from_ubase64(MY_MASTER_KEY);
  MegaRsaKey* rk = mega_rsa_key_new();
  
  g_assert(mega_rsa_key_load_enc_privk(rk, MY_PRIVK_ENC, mk));
  g_assert(mega_rsa_key_load_pubk(rk, MY_PUBK));

  GBytes* sid_bytes = mega_rsa_key_decrypt(rk, MY_CSID);
  g_assert_cmpuint(g_bytes_get_size(sid_bytes), >=, 43);
  gchar* sid = mega_base64urlencode(g_bytes_get_data(sid_bytes, NULL), 43);
  g_assert_cmpstr(sid, ==, MY_SID);

  g_assert_cmpstr(mega_rsa_key_get_pubk(rk), ==, MY_PUBK);
  // last block can be different, because it's random padded
  g_assert_cmpstr(trim_last_block(mega_rsa_key_get_enc_privk(rk, mk)), ==, trim_last_block(MY_PRIVK_ENC));

  // test encryption

  guchar plain[16] = {0xff};
  gchar* cipher = mega_rsa_key_encrypt(rk, plain, 16);
  GBytes* plain_bytes = mega_rsa_key_decrypt(rk, cipher);
  g_assert(plain_bytes != NULL);
  g_assert_cmpuint(g_bytes_get_size(plain_bytes), >, 16);
  g_assert(memcmp(g_bytes_get_data(plain_bytes, NULL), plain, 16) == 0);

  // Mega BUG: Plaintext can't start with zero!
  memset(plain, 0, 16);
  cipher = mega_rsa_key_encrypt(rk, plain, 16);
  plain_bytes = mega_rsa_key_decrypt(rk, cipher);
  g_assert(plain_bytes != NULL);
  g_assert_cmpuint(g_bytes_get_size(plain_bytes), >, 16);
  g_assert(memcmp(g_bytes_get_data(plain_bytes, NULL), plain, 16) == 0);

  // generate key

  g_assert(mega_rsa_key_generate(rk));
  gchar* privk1 = mega_rsa_key_get_enc_privk(rk, mk);
  gchar* pubk1 = mega_rsa_key_get_pubk(rk);

  g_assert(mega_rsa_key_generate(rk));
  gchar* privk2 = mega_rsa_key_get_enc_privk(rk, mk);
  gchar* pubk2 = mega_rsa_key_get_pubk(rk);

  g_assert_cmpstr(pubk1, !=, pubk2);
  // last block can be different, because it's random padded
  g_assert_cmpstr(trim_last_block(privk1), !=, trim_last_block(privk2));

  // INVALID USES

  g_assert(!mega_rsa_key_load_enc_privk(rk, MY_CSID, mk));
  g_assert(!mega_rsa_key_load_pubk(rk, MY_CSID));
  g_assert(!mega_rsa_key_load_enc_privk(rk, KEY_INVALID, mk));
  g_assert(!mega_rsa_key_load_pubk(rk, KEY_INVALID));
  g_assert(!mega_rsa_key_load_enc_privk(rk, KEY_NULL, mk));
  g_assert(!mega_rsa_key_load_pubk(rk, KEY_NULL));
}

Example #2

File: test-aes.c Project: evandrix/megatools

void test_aes_construction(void)
{
  MegaAesKey *k, *ek;

  // VALID USES:
  
  // create empty key, check that it is not laoded
  k = mega_aes_key_new();
  g_assert(MEGA_IS_AES_KEY(k));
  g_assert(!mega_aes_key_is_loaded(k));
  g_object_unref(k);

  // create key from UBase64
  k = mega_aes_key_new_from_ubase64(KEY_UBASE64);
  g_assert(MEGA_IS_AES_KEY(k));
  g_assert(mega_aes_key_is_loaded(k));
  g_assert_cmpstr(KEY_UBASE64, ==, mega_aes_key_get_ubase64(k));
  g_object_unref(k);

  // create key from Binary data (use as dec_key below)
  ek = mega_aes_key_new_from_binary(KEY_BINARY);
  g_assert(MEGA_IS_AES_KEY(ek));
  g_assert(mega_aes_key_is_loaded(ek));
  g_assert(memcmp(KEY_BINARY, mega_aes_key_get_binary(ek), 16) == 0);
  g_assert_cmpstr(KEY_UBASE64, ==, mega_aes_key_get_ubase64(ek));

  // create key from encrypted UBase64
  k = mega_aes_key_new_from_enc_ubase64(KEY_UBASE64, ek);
  g_assert(MEGA_IS_AES_KEY(k));
  g_assert(mega_aes_key_is_loaded(k));
  g_assert_cmpstr(KEY_UBASE64, ==, mega_aes_key_get_enc_ubase64(k, ek));
  g_object_unref(k);

  // create key from encrypted Binary data
  k = mega_aes_key_new_from_enc_binary(KEY_BINARY, ek);
  g_assert(MEGA_IS_AES_KEY(k));
  g_assert(mega_aes_key_is_loaded(k));
  g_assert(memcmp(KEY_BINARY, mega_aes_key_get_enc_binary(k, ek), 16) == 0);
  g_object_unref(k);

  g_object_unref(ek);

  // INVALID USES

  k = mega_aes_key_new_from_ubase64(KEY_LONG);
  g_assert(MEGA_IS_AES_KEY(k));
  g_assert(!mega_aes_key_is_loaded(k));
  g_object_unref(k);

  k = mega_aes_key_new_from_ubase64(KEY_SHORT);
  g_assert(MEGA_IS_AES_KEY(k));
  g_assert(!mega_aes_key_is_loaded(k));
  g_object_unref(k);

  k = mega_aes_key_new_from_ubase64(KEY_INVALID);
  g_assert(MEGA_IS_AES_KEY(k));
  g_assert(!mega_aes_key_is_loaded(k));
  g_object_unref(k);

  k = mega_aes_key_new_from_ubase64(KEY_NULL);
  g_assert(MEGA_IS_AES_KEY(k));
  g_assert(!mega_aes_key_is_loaded(k));
  g_object_unref(k);

  g_test_expect_message(G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL, "*data != NULL*");
  k = mega_aes_key_new_from_ubase64(NULL);
  g_test_assert_expected_messages();
  g_assert(MEGA_IS_AES_KEY(k));
  g_assert(!mega_aes_key_is_loaded(k));
  g_object_unref(k);
}