Nelze vybrat více než 25 témat Téma musí začínat písmenem nebo číslem, může obsahovat pomlčky („-“) a může být dlouhé až 35 znaků.

onetimepad.cpp 11KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157
  1. // onetimepad.cpp
  2. // Copyright (C) 2006-2007 MicroNeil Research Corporation
  3. #include "onetimepad.hpp"
  4. #include "timing.hpp"
  5. /*
  6. class OneTimePad { // One Time Pad generator.
  7. private:
  8. MANGLER PagGenerator; // MANGLER as a PRNG.
  9. PadBuffer Entropy(int Length = 1024); // System entropy source.
  10. public:
  11. ** OneTimePad(); // Constructor initializes w/ Entropy.
  12. ** PadBuffer Pad(int Length); // Get a pad of Length.
  13. ** void addEntropy(); // Add entropy from the system source.
  14. ** void addEntropy(PadBuffer Entropy); // Add entropy from this source.
  15. };
  16. */
  17. ////////////////////////////////////////////////////////////////////////////////
  18. // Platform specific strong entropy sourcing.
  19. #ifdef WIN32
  20. //// WIN32 Strong Entropy Source == CryptGenRandom() ///////////////////////////
  21. #include <windows.h>
  22. #include <wincrypt.h>
  23. PadBuffer OneTimePad::Entropy(int Length) { // Get a PadBuffer full of randomness.
  24. PadBuffer Buffer(Length, 0); // Start by initializing the buffer.
  25. HCRYPTPROV provider = 0; // We will need a handle for the source.
  26. if( // Try a two different sources.
  27. !CryptAcquireContext( // If we can get a hardware source
  28. &provider, NULL, NULL, PROV_INTEL_SEC, CRYPT_VERIFYCONTEXT)) { // from an intel CPU then use that first.
  29. if( // If we can't use get that
  30. !CryptAcquireContext( // entropy source for some reason then
  31. &provider, NULL, NULL, PROV_RSA_FULL, CRYPT_VERIFYCONTEXT)) { // try to use the RSA source. That should
  32. // always work, but if it doesn't we need
  33. provider = 0; // to know about it so we'll have a zero
  34. } // handle.
  35. }
  36. if(0 != provider) { // If we did get a good source then
  37. CryptGenRandom (provider, Length, (BYTE*)&Buffer[0]); // grab the random bit required and
  38. CryptReleaseContext(provider,0); // then let the provider go.
  39. StrongEntropyFlag = true; // We DID get strong entropy.
  40. }
  41. else { // If we did not get a good source
  42. StrongEntropyFlag = false; // then we are not strong.
  43. }
  44. return Buffer; // Return the data we got.
  45. }
  46. #else
  47. //// *NIX Strong Entropy Source == /dev/urandom ////////////////////////////////
  48. #include <fstream>
  49. PadBuffer OneTimePad::Entropy(int Length) { // Get Length bytes of strong entropy.
  50. PadBuffer Buffer(Length, 0); // Initialize a buffer to hold them.
  51. try { // Handle this in a try block.
  52. ifstream Source("/dev/urandom", ios::binary); // Open /dev/urandom if possible.
  53. Source.read(reinterpret_cast<char*>(&Buffer[0]), Length); // Read data into the buffer.
  54. if(!Source.bad() && Source.gcount() == Length) { // If we got what we came for then
  55. StrongEntropyFlag = true; // we have strong cryptography.
  56. } else { // If we didn't then we are not
  57. StrongEntropyFlag = false; // strong, and don't have things
  58. } // to make us go.
  59. Source.close(); // We're done, so close the stream.
  60. }
  61. catch(...) { // If we had an exception then we
  62. StrongEntropyFlag = false; // did not get strong entropy.
  63. }
  64. return Buffer; // Return the buffer.
  65. }
  66. #endif
  67. // End Platform Specific Bits
  68. ////////////////////////////////////////////////////////////////////////////////
  69. // Lightweight entropy is built from a combination of the time in ms UTC that
  70. // the application was started, the number of milliseconds since that time in
  71. // milliseconds, the number and times of calls to addLightweightEntropy(), and
  72. // the state of the MANGLER engine at each call -- that state is effected by
  73. // the combined previous use of the MANGLER and any other entropy that was
  74. // added including the timing of those events (since they all trigger the
  75. // addLightweightEntropy() function.
  76. Timer OneTimePadRunTimer; // Millisecond entropy source.
  77. msclock LightweightEntropyBuffer; // Lightweight entropy bucket.
  78. void OneTimePad::addLightweightEntropy() { // Add entropy based on the
  79. msclock StartFill = OneTimePadRunTimer.getStartClock(); // initial start time of the app
  80. msclock ElapsedFill = OneTimePadRunTimer.getElapsedTime(); // and the number of millisecs since.
  81. msclock CombinedFill = StartFill ^ ElapsedFill; // XOR the two together to combine.
  82. CombinedFill = CombinedFill ^ LightweightEntropyBuffer; // Pick up some previous state entropy.
  83. unsigned char* PrimerBuffer = (unsigned char*) &CombinedFill; // Treat the value as a bunch of bytes.
  84. unsigned char* EntropyBuffer = (unsigned char*) &LightweightEntropyBuffer; // Likewise with the entropy buffer.
  85. for(int i = 0; i < sizeof(msclock); i++) { // Fold bytes into the mangler one
  86. EntropyBuffer[i] += // byte at a time, capturing the
  87. PadGenerator.Encrypt( // the results and using one extra
  88. PadGenerator.Encrypt(PrimerBuffer[i])); // round per byte to increase the
  89. } // amount of guessing an attacker
  90. } // needs to do.
  91. void OneTimePad::addEntropy() { // Add strong entropy if available.
  92. PadBuffer Fill = Entropy(); // Grab the entropy bits to add.
  93. for(int i = 0; i < Fill.size(); i++) { // Pump them in one byte at a
  94. PadGenerator.Encrypt( // time and then run an extra
  95. PadGenerator.Encrypt(Fill.at(i))); // round per byte to increase the
  96. } // amount of guessing an attacker
  97. } // needs to do.
  98. void OneTimePad::addEntropy(PadBuffer Entropy) { // Add entropy from a given source.
  99. addLightweightEntropy(); // Start with some lightweight entropy.
  100. for(int i = 0; i < Entropy.size(); i++) { // Then loop through the provided
  101. PadGenerator.Encrypt( // entropy and mix it in with one
  102. PadGenerator.Encrypt(Entropy.at(i))); // extra round per byte to increase
  103. } // the amount of guessing an attacker
  104. } // needs to do.
  105. PadBuffer OneTimePad::Pad(int Length) { // Grab a pad of a specific length.
  106. addLightweightEntropy(); // Add some lightweight entropy.
  107. PadBuffer Output; Output.reserve(Length); // Create a buffer the right size.
  108. unsigned char x; // Starting with an uninitialized
  109. for(int i = 0; i < Length; i++) // char, fill the buffer with
  110. Output.push_back(x = PadGenerator.Encrypt(x)); // random bytes from the mangler.
  111. return Output; // Return the new pad.
  112. }
  113. void* OneTimePad::fill(void* Object, int Size) { // Fill *Object with random bytes.
  114. PadBuffer FillData = Pad(Size); // Get a Pad of the correct size.
  115. unsigned char* Ptr = reinterpret_cast<unsigned char*>(Object); // Reinterpret the pointer type.
  116. for(int i = 0; i < Size; i++) Ptr[i] = FillData.at(i); // Fill the object with the Pad.
  117. return Object; // Return the object.
  118. }
  119. bool OneTimePad::isStrong() { return StrongEntropyFlag; } // Tell them if I'm strong!
  120. OneTimePad::OneTimePad() { // Initialize the one time pad.
  121. addLightweightEntropy(); // Add lightweight entropy.
  122. addEntropy(); // Add cryptographic entropy.
  123. unsigned char x; // Starting with an uninitialized
  124. for(int i = 0; i < 1024; i++) { // character, run 1024 rounds to
  125. x = PadGenerator.Encrypt(x); // reduce the predictability of the
  126. } // initial Mangler state.
  127. } // The OneTimePad object is ready.