|
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157 |
- // onetimepad.cpp
- // Copyright (C) 2006-2007 MicroNeil Research Corporation
-
- #include "onetimepad.hpp"
- #include "timing.hpp"
-
- /*
- class OneTimePad { // One Time Pad generator.
- private:
- MANGLER PagGenerator; // MANGLER as a PRNG.
- PadBuffer Entropy(int Length = 1024); // System entropy source.
-
- public:
- ** OneTimePad(); // Constructor initializes w/ Entropy.
- ** PadBuffer Pad(int Length); // Get a pad of Length.
- ** void addEntropy(); // Add entropy from the system source.
- ** void addEntropy(PadBuffer Entropy); // Add entropy from this source.
-
- };
- */
-
- ////////////////////////////////////////////////////////////////////////////////
- // Platform specific strong entropy sourcing.
-
- #ifdef WIN32
-
- //// WIN32 Strong Entropy Source == CryptGenRandom() ///////////////////////////
-
- #include <windows.h>
- #include <wincrypt.h>
-
- PadBuffer OneTimePad::Entropy(int Length) { // Get a PadBuffer full of randomness.
- PadBuffer Buffer(Length, 0); // Start by initializing the buffer.
- HCRYPTPROV provider = 0; // We will need a handle for the source.
-
- if( // Try a two different sources.
- !CryptAcquireContext( // If we can get a hardware source
- &provider, NULL, NULL, PROV_INTEL_SEC, CRYPT_VERIFYCONTEXT)) { // from an intel CPU then use that first.
-
- if( // If we can't use get that
- !CryptAcquireContext( // entropy source for some reason then
- &provider, NULL, NULL, PROV_RSA_FULL, CRYPT_VERIFYCONTEXT)) { // try to use the RSA source. That should
- // always work, but if it doesn't we need
- provider = 0; // to know about it so we'll have a zero
- } // handle.
- }
-
- if(0 != provider) { // If we did get a good source then
- CryptGenRandom (provider, Length, (BYTE*)&Buffer[0]); // grab the random bit required and
- CryptReleaseContext(provider,0); // then let the provider go.
- StrongEntropyFlag = true; // We DID get strong entropy.
- }
- else { // If we did not get a good source
- StrongEntropyFlag = false; // then we are not strong.
- }
-
- return Buffer; // Return the data we got.
- }
-
- #else
-
- //// *NIX Strong Entropy Source == /dev/urandom ////////////////////////////////
-
- #include <fstream>
-
- PadBuffer OneTimePad::Entropy(int Length) { // Get Length bytes of strong entropy.
- PadBuffer Buffer(Length, 0); // Initialize a buffer to hold them.
- try { // Handle this in a try block.
- ifstream Source("/dev/urandom", ios::binary); // Open /dev/urandom if possible.
- Source.read(reinterpret_cast<char*>(&Buffer[0]), Length); // Read data into the buffer.
- if(!Source.bad() && Source.gcount() == Length) { // If we got what we came for then
- StrongEntropyFlag = true; // we have strong cryptography.
- } else { // If we didn't then we are not
- StrongEntropyFlag = false; // strong, and don't have things
- } // to make us go.
- Source.close(); // We're done, so close the stream.
- }
-
- catch(...) { // If we had an exception then we
- StrongEntropyFlag = false; // did not get strong entropy.
- }
- return Buffer; // Return the buffer.
- }
-
- #endif
-
- // End Platform Specific Bits
- ////////////////////////////////////////////////////////////////////////////////
-
- // Lightweight entropy is built from a combination of the time in ms UTC that
- // the application was started, the number of milliseconds since that time in
- // milliseconds, the number and times of calls to addLightweightEntropy(), and
- // the state of the MANGLER engine at each call -- that state is effected by
- // the combined previous use of the MANGLER and any other entropy that was
- // added including the timing of those events (since they all trigger the
- // addLightweightEntropy() function.
-
- Timer OneTimePadRunTimer; // Millisecond entropy source.
- msclock LightweightEntropyBuffer; // Lightweight entropy bucket.
-
- void OneTimePad::addLightweightEntropy() { // Add entropy based on the
- msclock StartFill = OneTimePadRunTimer.getStartClock(); // initial start time of the app
- msclock ElapsedFill = OneTimePadRunTimer.getElapsedTime(); // and the number of millisecs since.
- msclock CombinedFill = StartFill ^ ElapsedFill; // XOR the two together to combine.
- CombinedFill = CombinedFill ^ LightweightEntropyBuffer; // Pick up some previous state entropy.
- unsigned char* PrimerBuffer = (unsigned char*) &CombinedFill; // Treat the value as a bunch of bytes.
- unsigned char* EntropyBuffer = (unsigned char*) &LightweightEntropyBuffer; // Likewise with the entropy buffer.
- for(int i = 0; i < sizeof(msclock); i++) { // Fold bytes into the mangler one
- EntropyBuffer[i] += // byte at a time, capturing the
- PadGenerator.Encrypt( // the results and using one extra
- PadGenerator.Encrypt(PrimerBuffer[i])); // round per byte to increase the
- } // amount of guessing an attacker
- } // needs to do.
-
- void OneTimePad::addEntropy() { // Add strong entropy if available.
- PadBuffer Fill = Entropy(); // Grab the entropy bits to add.
- for(int i = 0; i < Fill.size(); i++) { // Pump them in one byte at a
- PadGenerator.Encrypt( // time and then run an extra
- PadGenerator.Encrypt(Fill.at(i))); // round per byte to increase the
- } // amount of guessing an attacker
- } // needs to do.
-
- void OneTimePad::addEntropy(PadBuffer Entropy) { // Add entropy from a given source.
- addLightweightEntropy(); // Start with some lightweight entropy.
- for(int i = 0; i < Entropy.size(); i++) { // Then loop through the provided
- PadGenerator.Encrypt( // entropy and mix it in with one
- PadGenerator.Encrypt(Entropy.at(i))); // extra round per byte to increase
- } // the amount of guessing an attacker
- } // needs to do.
-
- PadBuffer OneTimePad::Pad(int Length) { // Grab a pad of a specific length.
- addLightweightEntropy(); // Add some lightweight entropy.
- PadBuffer Output; Output.reserve(Length); // Create a buffer the right size.
- unsigned char x; // Starting with an uninitialized
- for(int i = 0; i < Length; i++) // char, fill the buffer with
- Output.push_back(x = PadGenerator.Encrypt(x)); // random bytes from the mangler.
- return Output; // Return the new pad.
- }
-
- void* OneTimePad::fill(void* Object, int Size) { // Fill *Object with random bytes.
- PadBuffer FillData = Pad(Size); // Get a Pad of the correct size.
- unsigned char* Ptr = reinterpret_cast<unsigned char*>(Object); // Reinterpret the pointer type.
- for(int i = 0; i < Size; i++) Ptr[i] = FillData.at(i); // Fill the object with the Pad.
- return Object; // Return the object.
- }
-
- bool OneTimePad::isStrong() { return StrongEntropyFlag; } // Tell them if I'm strong!
-
- OneTimePad::OneTimePad() { // Initialize the one time pad.
- addLightweightEntropy(); // Add lightweight entropy.
- addEntropy(); // Add cryptographic entropy.
- unsigned char x; // Starting with an uninitialized
- for(int i = 0; i < 1024; i++) { // character, run 1024 rounds to
- x = PadGenerator.Encrypt(x); // reduce the predictability of the
- } // initial Mangler state.
- } // The OneTimePad object is ready.
-
|
