/*!
This slot is connected to the dropped signal.
If it is emitted, we need to construct a new snippet entry with
the data given
*/
void SnippetWidget::slotDropped(QDropEvent *e, QListViewItem *)
{
QListViewItem * item2 = itemAt(e->pos());
SnippetGroup *group = dynamic_cast<SnippetGroup *>(item2);
if (!group)
group = dynamic_cast<SnippetGroup *>(item2->parent());
QCString dropped;
QByteArray data = e->encodedData("text/plain");
if ( e->provides("text/plain") && data.size()>0 ) {
//get the data from the event...
QString encData(data.data());
kdDebug(9035) << "encData: " << encData << endl;
//... then fill the dialog with the given data
SnippetDlg dlg(this, "SnippetDlg", true);
dlg.snippetName->clear();
dlg.snippetText->setText(encData);
/*fill the combobox with the names of all SnippetGroup entries*/
for (SnippetItem *it=_list.first(); it; it=_list.next()) {
if (dynamic_cast<SnippetGroup*>(it)) {
dlg.cbGroup->insertItem(it->getName());
}
}
dlg.cbGroup->setCurrentText(group->getName());
if (dlg.exec() == QDialog::Accepted) {
/* get the group that the user selected with the combobox */
group = dynamic_cast<SnippetGroup*>(SnippetItem::findItemByName(dlg.cbGroup->currentText(), _list));
_list.append( new SnippetItem(group, dlg.snippetName->text(), dlg.snippetText->text()) );
}
}
}
int main()
try
{
cybozu::Mmap xmlFile("EncryptionInfo");
cybozu::MiniXml xml(xmlFile.get() + 8, xmlFile.get() + xmlFile.size());
const cybozu::minixml::Node *keyData = xml.get().getFirstTagByName("keyData");
const std::string keyData_saltValue(dec64(keyData->attr["saltValue"]));
const cybozu::minixml::Node *dataIntegrity = xml.get().getFirstTagByName("dataIntegrity");
const std::string encryptedHmacKey(dec64(dataIntegrity->attr["encryptedHmacKey"]));
const std::string encryptedHmacValue(dec64(dataIntegrity->attr["encryptedHmacValue"]));
// keyEncryptors
const cybozu::minixml::Node *p_encryptedKey = xml.get().getFirstTagByName("p:encryptedKey");
const int spinCount = cybozu::atoi(p_encryptedKey->attr["spinCount"]);
const std::string encryptedKey_saltValue(dec64(p_encryptedKey->attr["saltValue"]));
const std::string encryptedVerifierHashInput(dec64(p_encryptedKey->attr["encryptedVerifierHashInput"]));
const std::string encryptedVerifierHashValue(dec64(p_encryptedKey->attr["encryptedVerifierHashValue"]));
const std::string encryptedKeyValue(dec64(p_encryptedKey->attr["encryptedKeyValue"]));
std::string pass("t\x00""e\x00""s\x00""t\x00", 8);
const std::string kV("\xfe" "\xa7" "\xd2" "\x76" "\x3b" "\x4b" "\x9e" "\x79", 8);
const std::string kH("\xd7" "\xaa" "\x0f" "\x6d" "\x30" "\x61" "\x34" "\x4e", 8);
const std::string kC("\x14" "\x6e" "\x0b" "\xe7" "\xab" "\xac" "\xd0" "\xd6", 8);
puts("pass"); dump(pass);
const std::string pwHash = hashPassword(encryptedKey_saltValue, pass, spinCount);
const std::string iv = encryptedKey_saltValue;
const std::string skey1 = generateKey(pwHash, kV);
const std::string verifierHashInput = cipher(encryptedVerifierHashInput, skey1, iv);
puts("verifierHashInput");
dump(verifierHashInput);
const std::string hashedVerifier = hash(verifierHashInput);
puts("hashedVerifier"); dump(hashedVerifier);
const std::string skey2 = generateKey(pwHash, kH);
const std::string verifierHash = cipher(encryptedVerifierHashValue, skey2, iv).substr(0, hashedVerifier.size());
puts("verifierHash"); dump(verifierHash);
if (hashedVerifier != verifierHash) {
puts("miss");
return 1;
}
const std::string skey3 = generateKey(pwHash, kC);
std::string secretKey = cipher(encryptedKeyValue, skey3, iv);
puts("secretKey"); dump(secretKey);
cybozu::Mmap m("EncryptedPackage");
uint64_t fileSize = cybozu::Get64bitAsLE(m.get());
printf("fileSize=%d\n", (int)fileSize);
std::string encData(m.get() + 8, (int)m.size() - 8);
printf("encData.size=%d\n", (int)encData.size());
// decode
std::string decData = decContent(encData, secretKey, keyData_saltValue);
{
std::ofstream ofs("dec.pptx", std::ios::binary);
ofs.write(decData.c_str(), (int)fileSize);
}
// integrity
{
const std::string b1("\x5f" "\xb2" "\xad" "\x01" "\x0c" "\xb9" "\xe1" "\xf6", 8);
const std::string iv1 = generateIv(keyData_saltValue, b1);
const std::string salt = cipher(encryptedHmacKey, secretKey, iv1).substr(0, 20);
printf("salt=%s\n", hex(salt).c_str());
}
{
const std::string b2("\xa0" "\x67" "\x7f" "\x02" "\xb2" "\x2c" "\x84" "\x33", 8);
const std::string iv2 = generateIv(keyData_saltValue, b2);
const std::string r2 = cipher(encryptedHmacValue, secretKey, iv2).substr(0, 20);
printf(" r2=%s\n", hex(r2).c_str());
}
} catch (cybozu::Exception& e) {
printf("ERR %s\n", e.what());
}
