void Node::generateKeysAES(void){
	AutoSeededRandomPool rnd;
	aeskey=SecByteBlock(0x00, AES::DEFAULT_KEYLENGTH);
	rnd.GenerateBlock( aeskey, aeskey.size() );
	rnd.GenerateBlock(iv, AES::BLOCKSIZE);
	return;
}
Example #2
0
int main(int argc, char* argv[])
{
    (void)argc; (void)argv;
   
    AutoSeededRandomPool prng;
   
    SecByteBlock key(Blowfish::DEFAULT_KEYLENGTH);
    prng.GenerateBlock( key, key.size() );
   
    byte iv[ Blowfish::BLOCKSIZE ];
    prng.GenerateBlock( iv, sizeof(iv) );
   
    string ofilename = "puppy-and-teddy-orig.jpg";
    string efilename = "puppy-and-teddy.enc";
    string rfilename = "puppy-and-teddy-recovered.jpg";
   
    try {
       
        /*********************************\
         \*********************************/
       
    EAX< Blowfish >::Encryption e1;
    e1.SetKeyWithIV( key, key.size(), iv, sizeof(iv) );
   
    std::ifstream ifile("puppy-and-teddy-orig.jpg", ios::binary);
    std::ifstream::pos_type size = ifile.seekg(0, std::ios_base::end).tellg();
    ifile.seekg(0, std::ios_base::beg);
   
    string temp;
    temp.resize(size);
    ifile.read((char*)temp.data(), temp.size());
   
    StringSource ss1( temp, true,
                     new AuthenticatedEncryptionFilter( e1,
                                                       new FileSink( efilename.c_str() )
                                                       ) // StreamTransformationFilter
                     ); // StringSource
   
    /*********************************\
     \*********************************/
   
    EAX< Blowfish >::Decryption d2;
    d2.SetKeyWithIV( key, key.size(), iv, sizeof(iv) );
   
    FileSource fs2( efilename.c_str(), true,
                     new AuthenticatedDecryptionFilter( d2,
                                                       new FileSink( rfilename.c_str() ),
                                                       AuthenticatedDecryptionFilter::THROW_EXCEPTION
                                                       ) // StreamTransformationFilter
                     ); // StringSource
       
       
    } catch (const Exception& ex) {
        cerr << ex.what() << endl;
    }
   
    return 0;
}
bool CWSKey::Save(char *filename)
{
    int version = WSK_VERSION;
    char junk1[1234] = {0};
    char junk2[3456] = {0};
    char encrypt[sizeof(junk1)+sizeof(WSKey_key)+sizeof(junk2)] = {0};
    FILE *file = 0;

    // Set Seed Value
    srand(GetTickCount());  // set Seed Value for Pseudo Random Number Generator

    // Generate Junk Data
    for (int x = 0; x < sizeof(junk1); x++) {
        junk1[x] = (char) (-127 + (rand( ) % 127));
        junk2[x] = (char) (-127 + (rand( ) % 127));
    }
    for (int x = sizeof(junk1); x < sizeof(junk2); x++) {
        junk2[x] = (char) (0 + (rand( ) % 255));
    }

    // Encrypt ALL DATA BEFORE WRITE
    AutoSeededRandomPool rnd;
    // Generate a random key
    byte key[AES::DEFAULT_KEYLENGTH];
    rnd.GenerateBlock(key, AES::DEFAULT_KEYLENGTH);
    // Generate a random IV
    byte iv[AES::BLOCKSIZE];
    rnd.GenerateBlock(iv, AES::BLOCKSIZE);
    // Copy To Tmp Place, Then Encrypt
    WSKey_key encrypt_key = this->m_key;
    CFB_Mode<AES>::Encryption cfbEncryption(key, AES::DEFAULT_KEYLENGTH, iv);
    cfbEncryption.ProcessData((byte*)junk1, (byte*)junk1, sizeof(junk1));
    cfbEncryption.ProcessData((byte*)&encrypt_key, (byte*)&encrypt_key, sizeof(m_key));
    cfbEncryption.ProcessData((byte*)junk2, (byte*)junk2, sizeof(junk2));

    // Write Key File
    file = fopen(filename, "wb");
    if (file == 0) {
        WSK_LOG("Failed To Open The Key File");
        return false;
    }

    // Write Encrypted Key Data
    fwrite(&version, sizeof(version), 1, file);             // File Version
    fwrite(junk1, sizeof(junk1), 1, file);                  // write junk
    fwrite(&encrypt_key, sizeof(m_key), 1, file);   // Write Key
//	fwrite(&m_key, sizeof(m_key), 1, file);			// Unencrypted Key
    fwrite(key, sizeof(key), 1, file);                              // AES KEY
    fwrite(iv, sizeof(iv), 1, file);                                // AES iv
    fwrite(junk2, sizeof(junk2), 1, file);                  // write junk

    // Close file
    fclose(file);

    return true;
}
AESParams genAESParams(){
  AESParams params;
  AutoSeededRandomPool rnd;
  SecByteBlock key(0x00, AES::DEFAULT_KEYLENGTH);
  SecByteBlock iv(0x00, AES::BLOCKSIZE);
  rnd.GenerateBlock(iv, AES::BLOCKSIZE);
  rnd.GenerateBlock(key, AES::DEFAULT_KEYLENGTH);  
  params.key = key;
  params.iv = iv;
  return params;
}
Example #5
0
int main(){
	AutoSeededRandomPool rand;
	SecByteBlock key(AES::DEFAULT_KEYLENGTH);
	rand.GenerateBlock(key, key.size());

	byte iv[AES::BLOCKSIZE];
	rand.GenerateBlock(iv, sizeof(iv));

	encryptFile("test.txt", key, iv);
	decryptFile("encText.txt", key, iv);
}
Example #6
0
int main() {
	
	AutoSeededRandomPool rnd;

	byte key[AES_LENGTH];
	array<byte, AES_LENGTH> akey;
	vector<byte> vkey(AES_LENGTH);

	rnd.GenerateBlock(key, sizeof(key));
	rnd.GenerateBlock(akey.data(), akey.size());
	rnd.GenerateBlock(vkey.data(), vkey.size());

	for(int s = 0; s < 100000; s += 100){
		vector<byte> msg(s);
		rnd.GenerateBlock(msg.data(), msg.size());

		auto cipher = enc(key, msg);
		auto recovered = dec(key, cipher);

		if (recovered != msg) {
			cerr << "ERR key" << endl;
			return;
		}	
	}

	for(int s = 0; s < 100000; s += 100){
		vector<byte> msg(s);
		rnd.GenerateBlock(msg.data(), msg.size());

		auto cipher = enc(akey, msg);
		auto recovered = dec(akey, cipher);

		if (recovered != msg) {
			cerr << "ERR akey" << endl;
			return;
		}	
	}

	for(int s = 0; s < 100000; s += 100){
		vector<byte> msg(s);
		rnd.GenerateBlock(msg.data(), msg.size());

		auto cipher = enc(vkey, msg);
		auto recovered = dec(vkey, cipher);

		if (recovered != msg) {
			cerr << "ERR vkey" << endl;
			return;
		}	
	}


}
Example #7
0
void MyAES::GenerateKey()
{
    AutoSeededRandomPool rnd;
    byte key1[AES::DEFAULT_KEYLENGTH];
    rnd.GenerateBlock(key1, AES::DEFAULT_KEYLENGTH);

    // Generate a random IV
    byte iv1[AES::BLOCKSIZE];
    rnd.GenerateBlock(iv1, AES::BLOCKSIZE);

    SetKey(key1, iv1, 16);
}
Example #8
0
CryptoPP::Integer RandomQuadraticResidue(CryptoPP::Integer p) {
	AutoSeededRandomPool rng;
	byte randomBytes[64];
	rng.GenerateBlock(randomBytes, 64);
	Integer t = Integer(randomBytes, 64);
	return ModularExponentiation(t, 2, p);
}
Example #9
0
void CUIntX::SetRandomValue()
{
	using namespace CryptoPP;

	AutoSeededRandomPool rng;
	rng.GenerateBlock(GetData(), GetSize());
}
Example #10
0
std::string GenerateRandomSequence(size_t length) {
    AutoSeededRandomPool rnd;
    string result;
    result.resize(length);
    rnd.GenerateBlock((byte*)result.data(), length);
    return result;
}
Example #11
0
    static string DES3(const string & text, const char * passwd = "", const char * stored_iv = "", const bool & encryption = true) {
        const char * enhPwd(enhancePasswd(passwd, int(DES_EDE3::DEFAULT_KEYLENGTH)));
        SecByteBlock key(strlen(enhPwd));
        byte iv[DES_EDE3::BLOCKSIZE];

        for(int i(0); i < strlen(enhPwd); ++i)
            key[i] = enhPwd[i];

        if(stored_iv == "") {
            AutoSeededRandomPool prng;
            prng.GenerateBlock(iv, sizeof(iv));
        } else
            for(int i(0); i < DES_EDE3::BLOCKSIZE; ++i)
                iv[i] = (byte)stored_iv[i];

        string cipher("");
        try {
            if(encryption) {
                CBC_Mode< DES_EDE3 >::Encryption e;
                e.SetKeyWithIV(key, key.size(), iv);
                StringSource(text, true, new StreamTransformationFilter(e, new StringSink(cipher)));
                cipher.append("\n").append((char *)iv);
            } else {
                CBC_Mode< DES_EDE3 >::Decryption d;
                d.SetKeyWithIV(key, key.size(), iv);
                StringSource(text, true, new StreamTransformationFilter(d, new StringSink(cipher)));
            }
        } catch(const CryptoPP::Exception & e) {
            cerr << e.what() << endl;
            exit(1);
        }
        return cipher;
    }
Example #12
0
CUInt128& CUInt128::SetValueRandom()
{
	AutoSeededRandomPool rng;
	byte byRandomBytes[16];
	rng.GenerateBlock(byRandomBytes, 16);
	SetValueBE( byRandomBytes );
	return *this;
}
Example #13
0
std::vector<unsigned char> ContainerController::get_pseudo_seed()
{
	using namespace CryptoPP;
	SecByteBlock b(32);
	AutoSeededRandomPool prng;
	prng.GenerateBlock(b, b.size());
	return{ std::begin(b), std::end(b) };
}
Example #14
0
CUInt128& CUInt128::setValueRandom(void)
{
	AutoSeededRandomPool rng;
	byte randomBytes[16];
	rng.GenerateBlock(randomBytes, 16);
	setValueBE( randomBytes );
	return *this;
}
Example #15
0
unsigned int rcry_setCryptoContext(struct ree_ccontext_t *newContext)
{
	if (newContext == NULL) return 0x65;

	// This means that a new IV needs to be made. Yay!
	if (newContext->fresh != 0)
	{
		// TODO: Figure out how to make this code less ugly!
		AutoSeededRandomPool prng;

		if (target == RCRY_RIJNDAEL)
		{
			byte iv[AES::BLOCKSIZE];
			prng.GenerateBlock(iv, sizeof(iv));

			byte *final_iv = (byte*) malloc(sizeof(iv));
			memcpy(final_iv, iv, sizeof(final_iv) * 2);
			newContext->iv = final_iv;

			CryptoPP::SecureWipeArray(iv, sizeof(iv));

		}
		else if (target == RCRY_TWOFISH)
		{
			byte iv[Twofish::BLOCKSIZE];
			prng.GenerateBlock(iv, sizeof(iv));
			byte *final_iv = (byte*) malloc(sizeof(iv));
			memcpy(final_iv, iv, sizeof(final_iv));
			newContext->iv = final_iv;

			CryptoPP::SecureWipeArray(iv, sizeof(iv));
		}
		else return 0x66;

		// Make sure to update the fresh variable.
		newContext->fresh = 0;
	}

	// Now go ahead, zero the old context and write over the new!
	CryptoPP::SecureWipeArray(&context, sizeof(context));
	context = newContext;

	cout << "TARGET: " << target << endl;

	return 0;
}
Example #16
0
int main(int argc, char* argv[])
{
	std::clock_t start,finish;
	start=clock();
	AutoSeededRandomPool prng;
    
	/* generate key for mac */
	unsigned char key1[16];
	prng.GenerateBlock(key1, sizeof(key1));
	
	/* generate key for encrypt */
	unsigned char key2[AES::DEFAULT_KEYLENGTH];
	prng.GenerateBlock(key2, sizeof(key2));
    
	string encoded1,encoded2;
	encoded1.clear();
	encoded2.clear();
	
	StringSource(key1, sizeof(key1), true,
                 new HexEncoder(
                                new StringSink(encoded1)
                                )
                 );
	cout << "key for mac is:" << key1 <<endl;
	cout << "hexadecimal key for mac is: " << encoded1 << endl;
	
	StringSource(key2, sizeof(key2), true,
                 new HexEncoder(
                                new StringSink(encoded2)
                                )
                 );
	cout << "key for encrypt is:" << key2 <<endl;
	cout << "hexadecimal key for encrypto is: " << encoded2 << endl;
    
    
    std::fstream f("key.txt",std::ios::out);
    f<<encoded1<<endl;
    f<<encoded2<<endl;
    f.close();
    
    finish=clock();
    cout<< "the keygen running time is " << difftime(finish,start) << " ms" << endl;
    
    return 0;
}
void DaStorKeyGenerator::work()
{
    AutoSeededRandomPool rnd;

    cout << "gen key in memery." << endl;
    rnd.GenerateBlock(keyData, AES::DEFAULT_KEYLENGTH);
    saveKeyFile();
    saveKeyCpp();
}
Example #18
0
const QByteArray& AESAlgorithmCBCMode::generateKey(int keySize, int blockSize)
{
    byte *key;
    byte *iv;

    keySize = keySize < 0 ? m_allowedKeySizes.first() : keySize;
    blockSize = blockSize < 0 ? m_allowedBlockSizes.first() : blockSize;

    if (!m_allowedKeySizes.contains(keySize)
            || !m_allowedBlockSizes.contains(blockSize)) {
        throw SymmetricAlgorithmException("Unsupported IV or Key length");
    }
    m_key.clear();
    m_iv.clear();
    AutoSeededRandomPool prng;

    key = new byte[keySize];
    iv = new byte[blockSize];

    try {
        //generate random key and iv
        prng.GenerateBlock(key, keySize);
        prng.GenerateBlock(iv, blockSize);

        //try to set them
        m_aesEncryption.SetKeyWithIV(key, keySize, iv);
        m_aesDecryption.SetKeyWithIV(key, keySize, iv);

        m_key = QByteArray(reinterpret_cast<const char*>(key), keySize);
        m_iv = QByteArray(reinterpret_cast<const char*>(iv), blockSize);
    } catch (const CryptoPP::Exception& e) {
        delete[] key;
        delete[] iv;
        throw SymmetricAlgorithmException(e.what());
    }

    delete[] key;
    delete[] iv;

    return m_key;
}
Example #19
0
string RNEncryptor::generateIv(int length)
{
	AutoSeededRandomPool prng;

	byte iv[length + 1];
	prng.GenerateBlock(iv, length);

        iv[length] = '\0';

	string ivString = string((char *)iv);
	return ivString;
}
Example #20
0
byte* generateRandomSalt(int size=DEFAULT_SALT_SIZE)
{

    // Get a random number generator from the OS
    AutoSeededRandomPool rng;

    byte* salt = new byte[size];
    // fill the variable with zeros
    memset(salt, 0, size);

    rng.GenerateBlock(salt, size);
    return salt;
}
Example #21
0
byte*
CryptoBackend::generateIV()
{
	AutoSeededRandomPool rnd;
	byte *iv = (byte*) calloc(AES::BLOCKSIZE, sizeof(byte));

	if (iv == NULL) {

	}

	rnd.GenerateBlock(iv, AES::BLOCKSIZE);

	return iv;
}
Example #22
0
byte*
CryptoBackend::generateSalt()
{
	AutoSeededRandomPool rnd;
	byte *salt = (byte*) calloc(DEFAULT_SALT_LEN, sizeof(byte));

	if (salt == NULL) {

	}

	rnd.GenerateBlock(salt, DEFAULT_SALT_LEN);

	return salt;
}
Example #23
0
void initAES() {
    SecByteBlock key(0x00, AES::DEFAULT_KEYLENGTH);
    rng.GenerateBlock(key, key.size());

    byte initVector[AES::BLOCKSIZE];
    rng.GenerateBlock(initVector, AES::BLOCKSIZE);

    printf("sending aes... ");

    string aesInform;
    for (int i = 0; i < AES::DEFAULT_KEYLENGTH; i++)
        aesInform.push_back(*(key.BytePtr() + i));

    for (int i = 0; i < AES::BLOCKSIZE; i++)
        aesInform.push_back(initVector[i]);

    aesInform = encryptRSA(aesInform);
    aesInform = base64_encode((unsigned char*)(aesInform.c_str()), aesInform.size());

    send(mainSocket, aesInform.c_str(), aesInform.size(), 0);

    printf("sended\n");

    cfbEncryption = new CFB_Mode<AES>::Encryption(key, key.size(), initVector);
    cfbDecryption = new CFB_Mode<AES>::Decryption(key, key.size(), initVector);

    recvDecrypted();
    if (strncmp("vtyulb", buf, 6) == 0)
        printf("server authorized\n");
    else {
        printf("false server??\n");
        initNET();
        initAES();
        return;
    }
}
Example #24
0
unsigned int rcry_generateKey(ree_crypto_t ctype, byte **key)
{
	AutoSeededRandomPool prng;

	if (ctype == RCRY_RIJNDAEL)
	{
		(*key) = (byte*) malloc(AES::MAX_KEYLENGTH);
		prng.GenerateBlock((*key), sizeof((*key)));
	}
	else if (ctype == RCRY_TWOFISH)
	{
		(*key) = (byte*) malloc(AES::MAX_KEYLENGTH);
		prng.GenerateBlock((*key), sizeof((*key)));
	}
	else
	{
		cerr
				<< "Unknown encryption scheme. Please pick one from the available or go f**k yourself!"
				<< endl;
		return 0xFA;
	}

	return 0;
}
Example #25
0
int HASH224_message(char* message, int len, 
				char* hash_message, int hash_len)
{
	AutoSeededRandomPool prng;
	
	SecByteBlock key(16);
	prng.GenerateBlock(key, key.size());

	string plain;
	CharToString(plain, message, len);
	string mac, encoded;

	encoded.clear();
	StringSource(key, key.size(), true,
					new HexEncoder(
					new StringSink(encoded)
					)
				); //StringSource

	try
	{
		HMAC<SHA224> hmac(key, key.size());

		StringSource(plain, true, 
			new HashFilter(hmac, 
			new StringSink(mac)
			)
			);
	}
	catch(const CryptoPP::Exception& e)
	{
		cerr<<e.what()<<endl;
		return 0;
		exit(1);
	}

	encoded.clear();
	StringSource(mac, true, 
			new HexEncoder(
			new StringSink(encoded)
			)
			);

	if(hash_len <= encoded.length())
		return -1;
	StringToChar(encoded, hash_message);
	return (int)encoded.length();
}
	size_t CRandomPasswordGen::getRandomSymbolIndex(void) const
	{
		uint32_t RandomNumber;
		size_t const Symbols = mAlphabet.getMaxLength();
		size_t const MaxRandomNumber = ((uint64_t)1 << (uint64_t)sizeof(RandomNumber)*8)-1;
		size_t const Blocks =  MaxRandomNumber / Symbols;

		do
		{
			RandomGenerator.GenerateBlock(reinterpret_cast<uint8_t *>(&RandomNumber), sizeof(RandomNumber));
		} while(RandomNumber > (Blocks * Symbols)-1);

		size_t const Index = RandomNumber % Symbols;

		return Index;
	}
Example #27
0
void testPuzzle()
{
	Puzzle p(2);
	cout << "base: " << p.getBase() << endl;
	AutoSeededRandomPool rnd;
	SecByteBlock key(0x00, AES::MAX_KEYLENGTH);
	rnd.GenerateBlock(key, key.size());

	// setup & solve
	Integer n;
	auto ckey = p.setup(key, 10, n);
	auto keyback = p.solve(ckey, 10, n);
	assert(key == keyback);
	cout << "Key converted back successfully!" << endl;

	// funcdur
	auto samples = p.funcdur(1000, seconds(5), nanoseconds(1000));
	for (auto& s : samples)
		cout << s.first << ": " << s.second.count() << endl;
}
Example #28
0
string makeNonce() {

    const unsigned int BLOCKSIZE = 4;
    byte scratch[BLOCKSIZE];

    AutoSeededRandomPool prng;
    prng.GenerateBlock(scratch, BLOCKSIZE);

    unsigned int nonceInt = 0;

    for (int i = (BLOCKSIZE - 1); i >= 0; i--) {
        nonceInt += (nonceInt << 8) + scratch[i];
    }

    ostringstream oss;
    oss << nonceInt;
    string nonceStr = oss.str();

    return nonceStr;
}
Example #29
0
  void CTwofishModule::encrypt(Tools::CSecureMemory &rCypherText, Tools::CSecureMemory const &rPlainText) const
  {
  	FASSERT(mKey.getSize() == gKeySize);
  	FASSERT((rPlainText.getSize() % gBlockSize) == 0);

  	Tools::CSecureMemory IV;
  	IV.allocate(gIVSize);
  	RandomGenerator.GenerateBlock(&IV[0], IV.getSize());

    CBC_Mode<Twofish>::Encryption Cipher;
    Cipher.SetKeyWithIV(&mKey[0], mKey.getSize(), &IV[0], IV.getSize());

    rCypherText.allocate(rPlainText.getSize() + IV.getSize());
    std::memcpy(&rCypherText[0], &IV[0], IV.getSize());

    Cipher.ProcessData(&rCypherText[IV.getSize()], &rPlainText[0], rPlainText.getSize());

  	ASSERT(((rCypherText.getSize() - gIVSize) % gBlockSize) == 0);

  	return;
  }
Example #30
0
int Cryption::encrypt(int fd){
  AutoSeededRandomPool prng;
  string encryptedBytes, encodedKey, decodedKey;

  encodedKey = getKey();
  cout<<"Encode: "<<encodedKey<<endl;
  StringSource(encodedKey, true, new HexDecoder(new StringSink(decodedKey)));
  cout<<"Decode: "<<decodedKey<<endl;
  const byte* ebyteKey = (const byte*) decodedKey.data();

  string encodedIV;
  //createIV
  byte IVBytes[AES::BLOCKSIZE];
  prng.GenerateBlock(IVBytes, sizeof(IVBytes));
  StringSource(IVBytes, sizeof(IVBytes), true, new HexEncoder(new StringSink(encodedIV)));

  encryptedBytes = read(fd);

  string encryptedContents;
  //Encrypting the file contents
  try{
    CBC_Mode< AES >::Encryption e;
    e.SetKeyWithIV(ebyteKey, CryptoPP::AES::DEFAULT_KEYLENGTH, IVBytes);
    StringSource file(encryptedBytes, true, new StreamTransformationFilter(e,new StringSink(encryptedContents)));
  }
  catch( const CryptoPP::Exception& e ){
    cerr << e.what() << endl;
    exit(1);
  }

  string output = encodedIV + encryptedContents;
  const char *bufContents = output.c_str();
  ssize_t WriteLength = pwrite(fd, bufContents, output.length(), 0);
  ftruncate(fd, output.length());
  
  return 0;
}