void Widget::on_keyErr_clicked()
{
DWORD keyBlobLen, blockLen = 0;
BYTE *keyBlob, *srcData, *newData, *blockData1, *blockData2;
HCRYPTPROV hCryptProv;
HCRYPTKEY hKey, dhKey;
QVector<int> values;
QFile myFile(fName);
plot->clear();
if (myFile.exists())
myFile.open(QIODevice::ReadOnly);
else
{
QMessageBox::critical(0, "Ошибка", "Файл не выбран", QMessageBox::Ok);
return;
}
CryptAcquireContext(&hCryptProv, NULL, MS_DEF_RSA_SCHANNEL_PROV, PROV_RSA_SCHANNEL, CRYPT_VERIFYCONTEXT);
CryptGenKey(hCryptProv, CALG_AES_256, 0, &hKey);
CryptEncrypt(hKey, 0, true, 0, NULL, &blockLen, myFile.size());
srcData = new BYTE[block * blockLen];
newData = new BYTE[block * blockLen];
blockData1 = new BYTE[blockLen];
blockData2 = new BYTE[blockLen];
myFile.read((char*)srcData, block * blockLen);
myFile.close();
memcpy((char*)newData, (char*)srcData, block * blockLen);
newData[0] = -newData[0];
CryptDuplicateKey(hKey, NULL, 0, &dhKey);
CryptExportKey(dhKey, 0, SIMPLEBLOB, 0, NULL, &keyBlobLen);
keyBlob = new BYTE[keyBlobLen];
CryptExportKey(dhKey, 0, SIMPLEBLOB, 0, keyBlob, &keyBlobLen);
keyBlob[0] = -keyBlob[0];
CryptImportKey(hCryptProv, keyBlob, keyBlobLen, 0, 0, &dhKey);
for (uint i = 0; i < (block * blockLen); i++)
{
CryptEncrypt(hKey, 0, i < 2, 0, srcData + i, &blockLen, block * blockLen);
CryptEncrypt(dhKey, 0, i < 2, 0, newData + i, &blockLen, block * blockLen);
}
for(uint i = 0; i < (block * blockLen); i += blockLen)
{
int k = 0;
memcpy(blockData1, srcData + i, blockLen);
memcpy(blockData2, newData + i, blockLen);
for (uint j = i; j < (i + blockLen); j++)
k += trueBitsCount(srcData[j] ^ newData[j]);
values.push_back(k);
}
delete[] newData;
delete[] srcData;
delete[] blockData1;
delete[] blockData2;
delete[] keyBlob;
CryptReleaseContext(hCryptProv, 0);
CryptDestroyKey(hKey);
CryptDestroyKey(dhKey);
DrawPlot(plot, values);
plot->show();
}
// Called by sqlite and sqlite3_key_interop to attach a key to a database.
int sqlite3CodecAttach(sqlite3 *db, int nDb, const void *pKey, int nKeyLen)
{
int rc = SQLITE_ERROR;
HCRYPTKEY hKey = 0;
// No key specified, could mean either use the main db's encryption or no encryption
if (!pKey || !nKeyLen)
{
if (!nDb)
{
return SQLITE_OK; // Main database, no key specified so not encrypted
}
else // Attached database, use the main database's key
{
// Get the encryption block for the main database and attempt to duplicate the key
// for use by the attached database
Pager *p = sqlite3BtreePager(db->aDb[0].pBt);
LPCRYPTBLOCK pBlock = (LPCRYPTBLOCK)sqlite3pager_get_codecarg(p);
if (!pBlock) return SQLITE_OK; // Main database is not encrypted so neither will be any attached database
if (!pBlock->hReadKey) return SQLITE_OK; // Not encrypted
if (!CryptDuplicateKey(pBlock->hReadKey, NULL, 0, &hKey))
return rc; // Unable to duplicate the key
}
}
else // User-supplied passphrase, so create a cryptographic key out of it
{
hKey = DeriveKey(pKey, nKeyLen);
if (hKey == MAXDWORD)
{
sqlite3Error(db, rc, SQLITECRYPTERROR_PROVIDER);
return rc;
}
}
// Create a new encryption block and assign the codec to the new attached database
if (hKey)
{
Pager *p = sqlite3BtreePager(db->aDb[nDb].pBt);
LPCRYPTBLOCK pBlock = CreateCryptBlock(hKey, p, -1, NULL);
if (!pBlock) return SQLITE_NOMEM;
sqlite3PagerSetCodec(p, sqlite3Codec, sqlite3CodecSizeChange, sqlite3CodecFree, pBlock);
//db->aDb[nDb].pAux = pBlock;
//db->aDb[nDb].xFreeAux = DestroyCryptBlock;
rc = SQLITE_OK;
}
return rc;
}
// @pymethod <o PyCRYPTKEY>|PyCRYPTKEY|CryptDuplicateKey|Creates an independent copy of the key
PyObject *PyCRYPTKEY::PyCryptDuplicateKey(PyObject *self, PyObject *args, PyObject *kwargs)
{
static char *keywords[]={"Reserved", "Flags", NULL};
PyObject *ret=NULL;
DWORD dwFlags=0, dwReserved=0;
HCRYPTKEY hcryptkey, hcryptkeydup;
hcryptkey=((PyCRYPTKEY *)self)->GetHCRYPTKEY();
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|kk:CryptDuplicateKey", keywords,
&dwReserved, // @pyparm int|Reserved|0|Use 0 if passed in
&dwFlags)) // @pyparm int|Flags|0|Also reserved, use 0
return NULL;
if (CryptDuplicateKey(hcryptkey, &dwReserved, dwFlags, &hcryptkeydup))
ret = new PyCRYPTKEY(hcryptkeydup, ((PyCRYPTKEY *)self)->obcryptprov);
else
PyWin_SetAPIError("CryptDuplicateKey",GetLastError());
return ret;
}
/*
* Class: org_company_security_csp_NativeCrypto
* Method: encryptDecrypt
* Signature: ([BIJJZ)[B
*/
JNIEXPORT jbyteArray JNICALL Java_org_company_security_csp_NativeCrypto_encryptDecrypt(
JNIEnv *env, jclass clazz,
jbyteArray jData, jint jDataOffset, jint jDataSize,
jlong hKey, jboolean doEncrypt, jboolean doFinal,
jint jPaddingLength) {
jbyteArray result = NULL;
jbyte* pData = NULL;
DWORD dwDataLen = (DWORD) jDataSize;
DWORD dwBufLen = dwDataLen;
DWORD i;
BYTE tmp;
HCRYPTKEY hDuplicateKey = (HCRYPTKEY) NULL;
DWORD dwOffset;
{
if (! CryptDuplicateKey(hKey, NULL, 0, &hDuplicateKey)) {
#ifdef DEBUG
fprintf(stderr, "error CryptDuplicateKey\n");
#endif
ThrowException(env, INVALID_KEY_EXCEPTION, GetLastError());
goto _m_leave;
}
if(jPaddingLength <= 0)
jPaddingLength = 512;
dwOffset = dwDataLen % jPaddingLength;
if(dwOffset)
dwBufLen = dwDataLen - dwOffset + jPaddingLength;
// Copy data from Java buffer to native buffer
pData = (jbyte*) malloc(dwBufLen);
(*env)->GetByteArrayRegion(env, jData, jDataOffset, jDataSize, pData);
if (doEncrypt == JNI_TRUE) {
// encrypt
if (! CryptEncrypt((HCRYPTKEY) hDuplicateKey, 0, doFinal, 0, (BYTE *)pData,
&dwDataLen, dwBufLen)) {
#ifdef DEBUG
fprintf(stderr, "error CryptEncrypt %x\n", GetLastError());
#endif
ThrowException(env, INVALID_KEY_EXCEPTION, GetLastError());
goto _m_leave;
}
dwBufLen = dwDataLen;
// convert from little-endian
for (i = 0; i < dwBufLen / 2; i++) {
tmp = pData[i];
pData[i] = pData[dwBufLen - i -1];
pData[dwBufLen - i - 1] = tmp;
}
} else {
// convert to little-endian
for (i = 0; i < dwBufLen / 2; i++) {
tmp = pData[i];
pData[i] = pData[dwBufLen - i -1];
pData[dwBufLen - i - 1] = tmp;
}
// decrypt
if (! CryptDecrypt((HCRYPTKEY) hKey, 0, TRUE, 0, (BYTE *)pData, &dwBufLen)) {
#ifdef DEBUG
fprintf(stderr, "error CryptDecrypt %x\n", GetLastError());
#endif
ThrowException(env, INVALID_KEY_EXCEPTION, GetLastError());
goto _m_leave;
}
}
// Create new byte array
result = (*env)->NewByteArray(env, dwBufLen);
// Copy data from native buffer to Java buffer
(*env)->SetByteArrayRegion(env, result, 0, dwBufLen, (jbyte*) pData);
}
_m_leave:
{
if (pData)
free(pData);
if (hDuplicateKey)
CryptDestroyKey(hDuplicateKey);
}
return result;
}
BOOL kull_m_crypto_aesCTSDecrypt(HCRYPTKEY hKey, PBYTE data, DWORD szData, PBYTE pbIV)
{
BOOL status = FALSE;
DWORD nbBlock, lastLen, i;
BYTE buffer[32], *ptr;
HCRYPTKEY hKeyNoIV;
if(szData > 16)
{
if(CryptDuplicateKey(hKey, NULL, 0, &hKeyNoIV))
{
if(CryptSetKeyParam(hKey, KP_IV, pbIV, 0))
{
nbBlock = (szData + 15) >> 4;
lastLen = (szData & 0xf) ? (szData & 0xf) : 16;
if (nbBlock <= 2 || kull_m_crypto_aesBlockEncryptDecrypt(hKey, data, nbBlock - 2, FALSE))
{
ptr = &data[16 * (nbBlock - 2)];
RtlCopyMemory(buffer, ptr, lastLen + 16);
RtlZeroMemory(&buffer[lastLen + 16], 16 - lastLen);
if(kull_m_crypto_aesBlockEncryptDecrypt(hKeyNoIV, buffer, 1, FALSE))
{
for(i = 0; i < 16; i++)
buffer[i] ^= buffer[i + 16];
RtlCopyMemory(&buffer[lastLen + 16], &buffer[lastLen], 16 - lastLen);
if(status = kull_m_crypto_aesBlockEncryptDecrypt(hKey, buffer + 16, 1, FALSE))
{
RtlCopyMemory(ptr, buffer + 16, 16);
RtlCopyMemory(&data[16 * nbBlock - 16], buffer, lastLen);
}
}
}
}
CryptDestroyKey(hKeyNoIV);
}
}
