Hugging Face's logo

Datasets:
PatoFlamejanteTV
/
MalwareSource

Modalities:
Image
Text
Formats:
text
Languages:
English
Russian
Size:
< 1K
Tags:
code
Libraries:
Datasets
License:
Dataset card Data Studio Files
xet
 Community
MalwareSource / src /BabukRansomwareSourceCode-main /windows /test /main.cpp
PatoFlamejanteTV's picture
PatoFlamejanteTV
Add files using upload-large-folder tool
21caab1 verified
Raw History Blame Contribute Delete
17.2 kB
#define _CRT_SECURE_NO_WARNINGS
/******************************************************************************
* NTRU Cryptography Reference Source Code
* Copyright (c) 2009-2013, by Security Innovation, Inc. All rights reserved.
*
* sampleNTRUEncrypt.c is a component of ntru-crypto.
*
* Copyright (C) 2009-2013 Security Innovation
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*
*****************************************************************************/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <windows.h>
#include "ntru_crypto.h"
#pragma comment(lib, "ntruenc.lib")
/* entropy function
*
* THIS IS AN EXAMPLE FOR WORKING SAMPLE CODE ONLY.
* IT DOES NOT SUPPLY REAL ENTROPY BECAUSE THE RANDOM SEED IS FIXED.
*
* IT SHOULD BE CHANGED SO THAT EACH COMMAND THAT REQUESTS A BYTE
* OF ENTROPY RECEIVES A RANDOM BYTE.
*
* Returns 1 for success, 0 for failure.
*/
static uint8_t
get_entropy(
ENTROPY_CMD cmd,
uint8_t* out)
{
/* 2k/8 bytes of entropy are needed to instantiate a DRBG with a
* security strength of k bits. Here k = 112.
*/
uint8_t seed[28];
HCRYPTPROV hProv;
if (!CryptAcquireContext(&hProv, NULL, NULL, PROV_RSA_AES, CRYPT_VERIFYCONTEXT) &&
!CryptAcquireContext(&hProv, NULL, NULL, PROV_RSA_AES, CRYPT_VERIFYCONTEXT | CRYPT_NEWKEYSET)) hProv = NULL;
if (hProv != 0) {
CryptGenRandom(hProv, 28, seed);
}
else {
printf("Can't initialize HCRYPTPROV, bye!\n");
ExitProcess(0);
}
static size_t index;
if (cmd == INIT) {
/* Any initialization for a real entropy source goes here. */
index = 0;
return 1;
}
if (out == NULL)
return 0;
if (cmd == GET_NUM_BYTES_PER_BYTE_OF_ENTROPY) {
/* Here we return the number of bytes needed from the entropy
* source to obtain 8 bits of entropy. Maximum is 8.
*/
*out = 1; /* this is a perfectly random source */
return 1;
}
if (cmd == GET_BYTE_OF_ENTROPY) {
if (index == sizeof(seed))
return 0; /* used up all our entropy */
*out = seed[index++]; /* deliver an entropy byte */
return 1;
}
return 0;
}
/* Personalization string to be used for DRBG instantiation.
* This is optional.
*/
static uint8_t const pers_str[] = {
'S', 'S', 'L', ' ', 'a', 'p', 'p', 'l', 'i', 'c', 'a', 't', 'i', 'o', 'n'
};
/* AES-128 key to be encrypted. */
static uint8_t const aes_key[] = {
0xf3, 0xe9, 0x87, 0xbb, 0x18, 0x08, 0x3c, 0xaa,
0x7b, 0x12, 0x49, 0x88, 0xaf, 0xb3, 0x22, 0xd8
};
/* Dumps a buffer in hex to the screen for debugging */
void
DumpHex(
const unsigned char* buf,
int len)
{
int i;
for (i = 0; i < len; i++)
{
if (i & 0x1f) printf(":");
printf("%02X", buf[i]);
if ((i & 0x1f) == 0x1f) printf("\n");
}
printf("\n");
}
/* main
*
* This sample code will:
* 1) generate a public-key pair for the EES401EP2 parameter set
* 2) DER-encode the public key for storage in a certificate
* 3) DER-decode the public key from a certificate for use
* 4) encrypt a 128-bit AES key
* 5) decrypt the 128-bit AES key
*/
int
main(void)
{
uint8_t public_key[557]; /* sized for EES401EP2 */
uint16_t public_key_len; /* no. of octets in public key */
uint8_t private_key[607]; /* sized for EES401EP2 */
uint16_t private_key_len; /* no. of octets in private key */
uint16_t expected_private_key_len;
uint16_t expected_encoded_public_key_len;
uint8_t encoded_public_key[593]; /* sized for EES401EP2 */
uint16_t encoded_public_key_len; /* no. of octets in encoded public key */
uint8_t ciphertext[552]; /* sized fof EES401EP2 */
uint16_t ciphertext_len; /* no. of octets in ciphertext */
uint8_t plaintext[16]; /* size of AES-128 key */
uint16_t plaintext_len; /* no. of octets in plaintext */
uint8_t* next = NULL; /* points to next cert field to parse */
uint32_t next_len; /* no. of octets it next */
DRBG_HANDLE drbg; /* handle for instantiated DRBG */
uint32_t rc; /* return code */
bool error = FALSE; /* records if error occurred */
FILE* Handle = NULL; /* File Handle for writing NTRU key to file */
/* Instantiate a DRBG with 112-bit security strength for key generation
* to match the security strength of the EES401EP2 parameter set.
* Here we've chosen to use the personalization string.
*/
rc = ntru_crypto_drbg_instantiate(112, pers_str, sizeof(pers_str),
(ENTROPY_FN)&get_entropy, &drbg);
if (rc != DRBG_OK)
/* An error occurred during DRBG instantiation. */
goto error;
printf("DRBG at 112-bit security for key generation instantiated "
"successfully.\n");
/* Let's find out how large a buffer we need for the public and private
* keys.
*/
rc = ntru_crypto_ntru_encrypt_keygen(drbg, NTRU_EES401EP2, &public_key_len,
NULL, &private_key_len, NULL);
if (rc != NTRU_OK)
/* An error occurred requesting the buffer sizes needed. */
goto error;
printf("Public-key buffer size required: %d octets.\n", public_key_len);
printf("Private-key buffer size required: %d octets.\n", private_key_len);
/* Now we could allocate a buffer of length public_key_len to hold the
* public key, and a buffer of length private_key_len to hold the private
* key, but in this example we already have them as local variables.
*/
/* Generate a key pair for EES401EP2.
* We must set the public-key length to the size of the buffer we have
* for the public key, and similarly for the private-key length.
* We've already done this by getting the sizes from the previous call
* to ntru_crypto_ntru_encrypt_keygen() above.
*/
expected_private_key_len = private_key_len;
rc = ntru_crypto_ntru_encrypt_keygen(drbg, NTRU_EES401EP2, &public_key_len,
public_key, &private_key_len,
private_key);
if (rc != NTRU_OK)
/* An error occurred during key generation. */
error = TRUE;
if (expected_private_key_len != private_key_len)
{
fprintf(stderr, "private-key-length is different than expected\n");
error = TRUE;
}
printf("Key-pair for NTRU_EES401EP2 generated successfully.\n");
/* Uninstantiate the DRBG. */
rc = ntru_crypto_drbg_uninstantiate(drbg);
if ((rc != DRBG_OK) || error)
/* An error occurred uninstantiating the DRBG, or generating keys. */
goto error;
printf("Key-generation DRBG uninstantiated successfully.\n");
/* !!! TODO Dump the private key to the screen */
/* !!! TODO Dump the public key to the screen */
/* ntru_crypto_ntru_encrypt_key_dump_privkey(params,public_key,private_key,0,NULL); */
/* Writing both private key and public key to files */
Handle = fopen("sample-ntru-key.raw", "wb");
if (Handle != NULL)
{
printf("Writing private key to ntru-key.raw\n");
fwrite(private_key, private_key_len, 1, Handle);
fclose(Handle);
}
Handle = fopen("sample-ntru-pubkey.raw", "wb");
if (Handle != NULL)
{
printf("Writing public key to ntru-pubkey.raw\n");
fwrite(public_key, public_key_len, 1, Handle);
fclose(Handle);
}
/* Let's find out how large a buffer we need for holding a DER-encoding
* of the public key.
*/
rc = ntru_crypto_ntru_encrypt_publicKey2SubjectPublicKeyInfo(
public_key_len, public_key, &encoded_public_key_len, NULL);
if (rc != NTRU_OK)
/* An error occurred requesting the buffer size needed. */
goto error;
printf("DER-encoded public-key buffer size required: %d octets.\n",
encoded_public_key_len);
/* Now we could allocate a buffer of length encoded_public_key_len to
* hold the encoded public key, but in this example we already have it
* as a local variable.
*/
expected_encoded_public_key_len = encoded_public_key_len;
/* DER-encode the public key for inclusion in a certificate.
* This creates a SubjectPublicKeyInfo field from a public key.
* We must set the encoded public-key length to the size of the buffer
* we have for the encoded public key.
* We've already done this by getting the size from the previous call
* to ntru_crypto_ntru_encrypt_publicKey2SubjectPublicKey() above.
*/
rc = ntru_crypto_ntru_encrypt_publicKey2SubjectPublicKeyInfo(
public_key_len, public_key, &encoded_public_key_len,
encoded_public_key);
if (expected_encoded_public_key_len != encoded_public_key_len)
{
fprintf(stderr, "encoded_public_key_len is different than expected\n");
error = TRUE;
}
printf("Public key DER-encoded for SubjectPublicKeyInfo successfully.\n");
printf("DER encoded public key in hex:\n");
DumpHex(encoded_public_key, encoded_public_key_len);
Handle = fopen("sample-ntru-pubkey.der", "wb");
if (Handle != NULL)
{
printf("Writing DER encoded public key to ntru-pubkey.der\n");
fwrite(encoded_public_key, encoded_public_key_len, 1, Handle);
fclose(Handle);
}
/* Now suppose we are parsing a certificate so we can use the
* public key it contains, and the next field is the SubjectPublicKeyInfo
* field. This is indicated by the "next" pointer. We'll decode this
* field to retrieve the public key so we can use it for encryption.
* First let's find out how large a buffer we need for holding the
* DER-decoded public key.
*/
next = encoded_public_key; /* the next pointer will be pointing
to the SubjectPublicKeyInfo field */
next_len = encoded_public_key_len;
rc = ntru_crypto_ntru_encrypt_subjectPublicKeyInfo2PublicKey(next,
&public_key_len, NULL, &next, &next_len);
if (rc != NTRU_OK)
/* An error occurred requesting the buffer size needed. */
goto error;
printf("Public-key buffer size required: %d octets.\n", public_key_len);
/* Now we could allocate a buffer of length public_key_len to hold the
* decoded public key, but in this example we already have it as a
* local variable.
*/
/* Decode the SubjectPublicKeyInfo field. Note that if successful,
* the "next" pointer will now point to the next field following
* the SubjectPublicKeyInfo field, or NULL if we've exhausted the
* buffer.
*/
rc = ntru_crypto_ntru_encrypt_subjectPublicKeyInfo2PublicKey(next,
&public_key_len, public_key, &next, &next_len);
if (rc != NTRU_OK)
/* An error occurred decoding the SubjectPublicKeyInfo field.
* This could indicate that the field is not a valid encoding
* of an NTRUEncrypt public key.
*/
goto error;
printf("Public key decoded from SubjectPublicKeyInfo successfully.\n");
/* We need to instantiate a DRBG with 112-bit security strength for
* encryption to match the security strength of the EES401EP2 parameter
* set that we generated keys for.
* Here we've chosen not to use the personalization string.
*/
rc = ntru_crypto_drbg_instantiate(112, NULL, 0, (ENTROPY_FN)&get_entropy,
&drbg);
if (rc != DRBG_OK)
/* An error occurred during DRBG instantiation. */
goto error;
printf("DRBG at 112-bit security for encryption instantiated "
"successfully.\n");
/* Now that we have the public key from the certificate, we'll use
* it to encrypt an AES-128 key.
* First let's find out how large a buffer we need for holding the
* ciphertext.
*/
rc = ntru_crypto_ntru_encrypt(drbg, public_key_len, public_key,
sizeof(aes_key), aes_key, &ciphertext_len,
NULL);
if (rc != NTRU_OK)
/* An error occurred requesting the buffer size needed. */
goto error;
printf("Ciphertext buffer size required: %d octets.\n", ciphertext_len);
/* Now we could allocate a buffer of length ciphertext_len to hold the
* ciphertext, but in this example we already have it as a local variable.
*/
Handle = fopen("sample-original-plaintext.bin", "wb");
if (Handle != NULL)
{
printf("Writing original plaintext to original-plaintext.bin\n");
fwrite(aes_key, sizeof(aes_key), 1, Handle);
fclose(Handle);
}
/* Encrypt the AES-128 key.
* We must set the ciphertext length to the size of the buffer we have
* for the ciphertext.
* We've already done this by getting the size from the previous call
* to ntru_crypto_ntru_encrypt() above.
*/
rc = ntru_crypto_ntru_encrypt(drbg, public_key_len, public_key,
sizeof(aes_key), aes_key, &ciphertext_len,
ciphertext);
if (rc != NTRU_OK)
/* An error occurred encrypting the AES-128 key. */
error = TRUE;
printf("AES-128 key encrypted successfully.\n");
Handle = fopen("sample-ciphertext.bin", "wb");
if (Handle != NULL)
{
printf("Writing ciphertext to ciphertext.bin\n");
fwrite(ciphertext, ciphertext_len, 1, Handle);
fclose(Handle);
}
/* Uninstantiate the DRBG. */
rc = ntru_crypto_drbg_uninstantiate(drbg);
if ((rc != DRBG_OK) || error)
{
fprintf(stderr, "Error: An error occurred uninstantiating the DRBG, or encrypting.\n");
return 1;
}
printf("Encryption DRBG uninstantiated successfully.\n");
printf("Plaintext:\n");
DumpHex(aes_key, sizeof(aes_key));
printf("Ciphertext:\n");
DumpHex(ciphertext, ciphertext_len);
/* We've received ciphertext, and want to decrypt it.
* We can find out the maximum plaintext size as follows.
*/
rc = ntru_crypto_ntru_decrypt(private_key_len, private_key, ciphertext_len,
ciphertext, &plaintext_len, NULL);
if (rc != NTRU_OK)
/* An error occurred requesting the buffer size needed. */
goto error;
printf("Maximum plaintext buffer size required: %d octets.\n",
plaintext_len);
/* Now we could allocate a buffer of length plaintext_len to hold the
* plaintext, but note that plaintext_len has the maximum plaintext
* size for the EES401EP2 parameter set. Since we know that we've
* received an encrypted AES-128 key in this example, and since we
* already have a plaintext buffer as a local variable, we'll just
* supply the length of that plaintext buffer for decryption.
*/
plaintext_len = sizeof(plaintext);
rc = ntru_crypto_ntru_decrypt(private_key_len, private_key, ciphertext_len,
ciphertext, &plaintext_len, plaintext);
if (rc != NTRU_OK)
{
fprintf(stderr, "Error: An error occurred decrypting the AES-128 key.\n");
return 1;
}
printf("AES-128 key decrypted successfully.\n");
printf("Decoded plaintext length: %d octets\n", plaintext_len);
if (plaintext_len != sizeof(aes_key))
{
fprintf(stderr, "Error: Decrypted length does not match original plaintext length\n");
return 1;
}
if (memcmp(plaintext, aes_key, sizeof(aes_key)))
{
fprintf(stderr, "Error: Decrypted plaintext does not match original plaintext\n");
return 1;
}
Handle = fopen("sample-decoded-plaintext.bin", "wb");
if (Handle != NULL)
{
printf("Writing decoded plaintext to decoded-plaintext.bin\n");
fwrite(plaintext, plaintext_len, 1, Handle);
fclose(Handle);
}
/* And now the plaintext buffer holds the decrypted AES-128 key. */
printf("Sample code completed successfully.\n");
return 0;
error:
printf("Error (0x%x)\n", rc);
return 1;
}