Example #1
0
void WFileProperties::OnButtonOK(wxCommandEvent& WXUNUSED(event))
{
    Enctain::Container cnt = wmain->container;

    cnt.SetSubFileProperty(subfileid, "Name", strWX2STL(textFilename->GetValue()));
    cnt.SetSubFileProperty(subfileid, "Author", strWX2STL(textAuthor->GetValue()));

    int ifiletype = choiceType->GetSelection();
    if (ifiletype == 1) {
        cnt.SetSubFileProperty(subfileid, "Filetype", "text");
    }
    else {
        cnt.SetSubFileProperty(subfileid, "Filetype", "");
    }

    Enctain::compression_type newcomp = (Enctain::compression_type)choiceCompression->GetSelection();
    Enctain::encryption_type newencr = (Enctain::encryption_type)choiceEncryption->GetSelection();

    if (newcomp != cnt.GetSubFileCompression(subfileid) ||
        newencr != cnt.GetSubFileEncryption(subfileid))
    {
        size_t oldsize = cnt.GetSubFileStorageSize(subfileid);
        size_t realsize = cnt.GetSubFileSize(subfileid);

        cnt.SetSubFileCompressionEncryption(subfileid, newcomp, newencr);

        size_t newsize = cnt.GetSubFileStorageSize(subfileid);

        wmain->UpdateStatusBar(
            wxString::Format(_("Recompressed and reencrypted %u subfile bytes into %u bytes (old size %u)."),
                             realsize, newsize, oldsize)
            );
    }

    cnt.SetSubFileProperty(subfileid, "Subject", strWX2STL(textSubject->GetValue()));
    cnt.SetSubFileProperty(subfileid, "Description", strWX2STL(textDescription->GetValue()));

    EndModal(wxID_OK);
}
Example #2
0
void test_enctain(const std::string& filedata, std::string filename)
{
    std::ostringstream memfile;
    filename.size();

    {
	Enctain::Container container;

	container.SetGlobalUnencryptedProperty("prop1", "test abc");

	container.SetGlobalEncryptedProperty("secret1", "blah");

	container.SetGlobalEncryptedProperty("prop2", std::string(255, 'a'));
	container.SetGlobalEncryptedProperty("prop3", std::string(256, 'b'));

	unsigned int sf1 = container.AppendSubFile();

	container.SetSubFileEncryption(sf1, Enctain::ENCRYPTION_NONE);
	container.SetSubFileCompression(sf1, Enctain::COMPRESSION_NONE);

	container.SetSubFileProperty(sf1, "Name", "test1.txt");
	container.SetSubFileProperty(sf1, "MIME-Type", "text/plain");
	container.SetSubFileData(sf1, filedata.data(), filedata.size());

	unsigned int sf2 = container.AppendSubFile();

	container.SetSubFileEncryption(sf2, Enctain::ENCRYPTION_NONE);
	container.SetSubFileCompression(sf2, Enctain::COMPRESSION_ZLIB);

	container.SetSubFileProperty(sf2, "Name", "test2.txt");
	container.SetSubFileProperty(sf2, "MIME-Type", "text/plain");
	container.SetSubFileData(sf2, filedata.data(), filedata.size());

	container.AddKeySlot("oYLiP4Td");

	unsigned int sf3 = container.AppendSubFile();

	container.SetSubFileEncryption(sf3, Enctain::ENCRYPTION_NONE);
	container.SetSubFileCompression(sf3, Enctain::COMPRESSION_BZIP2);

	container.SetSubFileProperty(sf3, "Name", "test3.txt");
	container.SetSubFileProperty(sf3, "MIME-Type", "text/plain");
	container.SetSubFileData(sf3, filedata.data(), filedata.size());

	unsigned int sf4 = container.AppendSubFile();

	container.SetSubFileEncryption(sf4, Enctain::ENCRYPTION_SERPENT256);
	container.SetSubFileCompression(sf4, Enctain::COMPRESSION_NONE);

	container.SetSubFileProperty(sf4, "Name", "test4.txt");
	container.SetSubFileProperty(sf4, "MIME-Type", "text/plain");
	container.SetSubFileData(sf4, filedata.data(), filedata.size());

	unsigned int sf5 = container.AppendSubFile();

	container.SetSubFileEncryption(sf5, Enctain::ENCRYPTION_SERPENT256);
	container.SetSubFileCompression(sf5, Enctain::COMPRESSION_ZLIB);

	container.SetSubFileProperty(sf5, "Name", "test5.txt");
	container.SetSubFileProperty(sf5, "MIME-Type", "text/plain");
	container.SetSubFileData(sf5, filedata.data(), filedata.size());

	container.AddKeySlot("ELO0Eia9");

	unsigned int sf6 = container.AppendSubFile();

	container.SetSubFileEncryption(sf6, Enctain::ENCRYPTION_SERPENT256);
	container.SetSubFileCompression(sf6, Enctain::COMPRESSION_BZIP2);

	container.SetSubFileProperty(sf6, "Name", "test6.txt");
	container.SetSubFileProperty(sf6, "MIME-Type", "text/plain");
	container.SetSubFileData(sf6, filedata.data(), filedata.size());

#if WRITEFILE == 0
	Enctain::DataOutputStream dataout(memfile);
#else
	std::ofstream outstream(filename.c_str());
	Enctain::DataOutputStream dataout(outstream);
#endif

	container.Save(dataout);
    }

    {
	Enctain::Container container;

#if WRITEFILE == 0
	std::istringstream instream(memfile.str());
#else
	std::ifstream instream(filename.c_str());
#endif

	Enctain::DataInputStream datain(instream);
	container.Load(datain, "ELO0Eia9");

	std::string key, val;
	assert( container.GetGlobalUnencryptedPropertyIndex(0, key, val) );
	assert( key == "prop1" && val == "test abc" );
	assert( !container.GetGlobalUnencryptedPropertyIndex(1, key, val) );

	assert( container.GetGlobalEncryptedPropertyIndex(0, key, val) );
	assert( key == "prop2" && val == std::string(255, 'a') );
	assert( container.GetGlobalEncryptedPropertyIndex(1, key, val) );
	assert( key == "prop3" && val == std::string(256, 'b') );
	assert( container.GetGlobalEncryptedPropertyIndex(2, key, val) );
	assert( key == "secret1" && val == "blah" );
	assert( !container.GetGlobalEncryptedPropertyIndex(3, key, val) );

	assert(container.CountSubFile() == 6);

	// subfile 0
	assert( container.GetSubFilePropertyIndex(0, 0, key, val) );
	assert( key == "MIME-Type" && val == "text/plain" );
	assert( container.GetSubFilePropertyIndex(0, 1, key, val) );
	assert( key == "Name" && val == "test1.txt" );
	assert( !container.GetSubFilePropertyIndex(0, 2, key, val) );

	std::string mb;
	container.GetSubFileData(0, mb);
	
	assert( mb == filedata );

	// subfile 1
	assert( container.GetSubFilePropertyIndex(1, 0, key, val) );
	assert( key == "MIME-Type" && val == "text/plain" );
	assert( container.GetSubFilePropertyIndex(1, 1, key, val) );
	assert( key == "Name" && val == "test2.txt" );
	assert( !container.GetSubFilePropertyIndex(1, 2, key, val) );

	container.GetSubFileData(1, mb);
	assert( mb == filedata );

	// subfile 2
	assert( container.GetSubFilePropertyIndex(2, 0, key, val) );
	assert( key == "MIME-Type" && val == "text/plain" );
	assert( container.GetSubFilePropertyIndex(2, 1, key, val) );
	assert( key == "Name" && val == "test3.txt" );
	assert( !container.GetSubFilePropertyIndex(2, 2, key, val) );

	container.GetSubFileData(2, mb);
	assert( mb == filedata );

	// subfile 3
	assert( container.GetSubFilePropertyIndex(3, 0, key, val) );
	assert( key == "MIME-Type" && val == "text/plain" );
	assert( container.GetSubFilePropertyIndex(3, 1, key, val) );
	assert( key == "Name" && val == "test4.txt" );
	assert( !container.GetSubFilePropertyIndex(3, 2, key, val) );

	container.GetSubFileData(3, mb);
	assert( mb == filedata );

	// subfile 4
	assert( container.GetSubFilePropertyIndex(4, 0, key, val) );
	assert( key == "MIME-Type" && val == "text/plain" );
	assert( container.GetSubFilePropertyIndex(4, 1, key, val) );
	assert( key == "Name" && val == "test5.txt" );
	assert( !container.GetSubFilePropertyIndex(4, 2, key, val) );

	container.GetSubFileData(4, mb);
	assert( mb == filedata );

	// subfile 5
	assert( container.GetSubFilePropertyIndex(5, 0, key, val) );
	assert( key == "MIME-Type" && val == "text/plain" );
	assert( container.GetSubFilePropertyIndex(5, 1, key, val) );
	assert( key == "Name" && val == "test6.txt" );
	assert( !container.GetSubFilePropertyIndex(5, 2, key, val) );

	container.GetSubFileData(5, mb);
	assert( mb == filedata );

	// subfile 5 (again)
	assert( container.GetSubFilePropertyIndex(5, 0, key, val) );
	assert( key == "MIME-Type" && val == "text/plain" );
	assert( container.GetSubFilePropertyIndex(5, 1, key, val) );
	assert( key == "Name" && val == "test6.txt" );
	assert( !container.GetSubFilePropertyIndex(5, 2, key, val) );

	container.GetSubFileData(5, mb);
	assert( mb == filedata );
    }
}