C / C++ / MFC

DEBUG: [Passes = 5000] 311191.953 Byte/s
RESULT:  303.90 KB/sec

DEBUG: [Passes = 5000] 734956.927 Byte/s
RESULT:  717.73 KB/sec

DEBUG: [Passes = 5000] 391962.053 Byte/s
RESULT:  382.78 KB/sec

DEBUG: [Passes = 5000] 274082.350 Byte/s
RESULT:  267.66 KB/sec

DEBUG: [Passes = 5000] 281520.063 Byte/s
RESULT:  274.92 KB/sec

saiyuk6=7 wrote:

double seconds = ((double)(iValue - iBaseTime) * dbFreq);

<br />
DEBUG: 1074556249.047 Byte/s<br />
MEMSET:  0.00/sec  0.98/ms  1.00 GB/sec<br />
RESULT:  6.91/sec 6905.56/ms 72.41 MB/sec<br />

class CTimer {
public:
   CTimer() {
	   m_TimeStart.QuadPart = 0;
	   m_TimeStop.QuadPart = 0;
	    QueryPerformanceFrequency(&m_Frequency);
   }

   void Start(void) {
      QueryPerformanceCounter(&m_TimeStart);
   }

   void Stop(void) {
      QueryPerformanceCounter(&m_TimeStop);
   }

   double Seconds() const {
      return (double)(m_TimeStop.QuadPart - m_TimeStart.QuadPart) / (double)m_Frequency.QuadPart;;
   }

   double Milliseconds() const {
      return Seconds() * 1000.0;
   }

private:
   double m_dbFreq;
   LARGE_INTEGER m_Frequency;
   LARGE_INTEGER m_TimeStart;
   LARGE_INTEGER m_TimeStop;
};

#define MUL_BYTES 1024.0
#define MUL_KB (MUL_BYTES*1024.0)
#define MUL_MB (MUL_KB*1024.0)
#define MUL_GB (MUL_MB*1024.0)

std::string BPStoString(double dbPerSec)
{
   char *pTemp[] = {
      "Bytes", "KB", "MB",
      "GB", "TB", "PB",
      "EB", "ZB", "YB"
   };
   char szTemp[30];

   int i = 0;
   while (dbPerSec >= 0.9 * MUL_BYTES) {
      dbPerSec /= MUL_BYTES;
      i++;
   }

   sprintf(szTemp, "%5.2f %s/sec", dbPerSec, pTemp[i]);
   return std::string(szTemp);
}

void Benchmark_MD5(void)
{
   CTimer tm;

   tm.Start();
   unsigned long ulSize = MUL_KB;
   unsigned char *bzBuffer = new unsigned char[ulSize];
   if (bzBuffer != NULL) {
      memset(bzBuffer, 0, ulSize);
      tm.Stop();
      <code>double bps = (double)((ulSize * 1) / tm.Seconds());</code>
      printf("DEBUG: %5.3f Byte/s\n", bps);
      printf("MEMSET: %5.2f/sec %5.2f/ms %s\n", tm.Seconds(), tm.Milliseconds(),BPStoString(bps).c_str());
   }

   tm.Start();

   MD5_CTX md5;
   int iPasses = 500;
   for (int i = 0; i < iPasses; i++) {
      MD5Init(&md5);
      MD5Update(&md5, bzBuffer, ulSize);
      MD5Final(&md5);
   }
   tm.Stop();
  <code> double bps = (double)((ulSize * iPasses) / tm.Seconds());</code>
   printf("RESULT: %5.2f/sec %5.2f/ms %s\n", tm.Seconds(), tm.Milliseconds(),BPStoString(bps).c_str());

   delete bzBuffer;
}

saiyuk6=7 wrote:

unsigned char *bzBuffer = new unsigned char[ulSize];

unsigned char bzBuffer[MUL_KB];

bm.cpp
bm.cpp(40) : error C2057: expected constant expression
bm.cpp(40) : error C2466: cannot allocate an array of constant size 0
bm.cpp(40) : error C2133: 'bzBuffer' : unknown size

unsigned char *bzBuffer;
for (int i = HT_MD5; i < (HT_WHIRLPOOL + 1); i++) {
   hash.Init(i);
   bzBuffer = new unsigned char[hash.DigestSize()];
   if (bzBuffer == NULL) {
      //err code here
      return 0;
   }
   hash.Update(hashTest[i].buffer, hashTest[i].length);
   hash.Final(bzBuffer);
   for (int h = 0; h < hash.DigestSize(); h++)
      printf("%02.2%", bzBuffer[i]);
   delete bzBuffer;
}

Pascal Ganaye wrote:

Going to the zoo now. Perhaps the monkeys will have a clue,

Fareed Rizkalla wrote:

Cause my application uses UNICODE

2 bugs found.
> recompile ...
65534 bugs found.

if (tl->_1 == pBuffer[0] && tl->_2 == pBuffer[1] &&
    tl->_3 == pBuffer[2] && tl->_4 == pBuffer[4])
   bResult = true;

int _ustrlen(unsigned char *pbz)
{
   const unsigned char *ptr;
   for (ptr = pbz; *ptr; ++ptr);
   return (ptr - pbz);
}

void SignBuffer(unsigned char *pbzKey, unsigned char *pbzBuffer,
                unsigned int iSize, unsigned long *pSignature)
{
   MD5_CTX md5, md5key;
   BLOWFISH_CTX bf;

   MD5Init(&md5);
   MD5Update(&md5, pbzBuffer, iSize);
   MD5Final(&md5);

   _2LONG *tl = (_2LONG*) md5.digest;

   printf("BLE 1\t\t %x %x %x %x\n", tl->_1, tl->_2, tl->_3, tl->_4);

   MD5Init(&md5key);
   MD5Update(&md5key, pbzKey, _ustrlen(pbzKey));
   MD5Final(&md5key);

   Blowfish_Init(&bf, md5key.digest, 16);
   Blowfish_Encrypt(&bf, &tl->_1, &tl->_2);
   Blowfish_Encrypt(&bf, &tl->_3, &tl->_4);

   pSignature[0] = tl->_1;
   pSignature[1] = tl->_2;
   pSignature[2] = tl->_3;
   pSignature[3] = tl->_4;

   printf("BLE 2\t\t %x %x %x %x\n", pSignature[0], pSignature[1],
          pSignature[2], pSignature[3]);
}

bool VerifyBuffer(unsigned char *pbzKey, unsigned char *pSignature,
                  unsigned int iSize, unsigned long *pBuffer)
{
   BLOWFISH_CTX bf;
   MD5_CTX md5, md5key;
   bool bResult = false;

   printf("BLD 1\t\t %x %x %x %x\n", pBuffer[0], pBuffer[1],
          pBuffer[2], pBuffer[3]);

   MD5Init(&md5key);
   MD5Update(&md5key, pbzKey, _ustrlen(pbzKey));
   MD5Final(&md5key);

   Blowfish_Init(&bf, md5key.digest, 16);
   Blowfish_Decrypt(&bf, &pBuffer[0], &pBuffer[1]);
   Blowfish_Decrypt(&bf, &pBuffer[2], &pBuffer[3]);

   printf("BLD 2\t\t %x %x %x %x\n", pBuffer[0], pBuffer[1],
          pBuffer[2], pBuffer[3]);

   MD5Init(&md5);
   MD5Update(&md5, pSignature, iSize);
   MD5Final(&md5);

   _2LONG *tl = (_2LONG*) md5.digest;
   printf("BLD 3\t\t %x %x %x %x\n", tl->_1, tl->_2, tl->_3, tl->_4);

   if (tl->_1 == pBuffer[0] && tl->_2 == pBuffer[1] &&
       tl->_3 == pBuffer[2] && tl->_4 == pBuffer[3])
      bResult = true;

   return bResult;
}

void main(void)
{
   unsigned char bszBuffer[2] = {'A', 'B'};
   unsigned long ulSig[4];
   SignBuffer((unsigned char*)"key", bszBuffer, 2, ulSig);
   printf("\n");
   if (VerifyBuffer((unsigned char*)"key", bszBuffer, 2, ulSig))
      printf("\nok");
   else printf("\nerr");
}

BLE 2            f12b0ed9 782fae18 a87960ac f37b342e