webmoney 0.0.4.2

data/ext/wmsigner/rsalib1.h

@@ -0,0 +1,81 @@
+#ifndef __RSALIB1_H_INCLUDE__
+#define __RSALIB1_H_INCLUDE__
+#include "stdafx.h"
+
+typedef unsigned char boolean;
+typedef unsigned char byte;
+typedef unsigned short word16;
+typedef word16 unit;
+typedef unit *unitptr;
+typedef short signedunit;
+typedef unsigned long int ulint;
+
+class CRSALib
+{
+public:
+
+  enum { MAX_BIT_PRECISION = 2048, MAX_UNIT_PRECISION = MAX_BIT_PRECISION/(sizeof(word16)*8) };
+private:
+  unit moduli_buf[16][(MAX_UNIT_PRECISION)];
+  unitptr moduli[16+1];
+
+  unit msu_moduli[16+1];
+  unit nmsu_moduli[16+1];
+  unit mpdbuf[16-1][(MAX_UNIT_PRECISION)];
+  unitptr mpd[16];
+
+public:
+  short global_precision;
+  void set_precision(short prec);
+  CRSALib(short glob_pres=0);
+
+  boolean mp_addc(register unitptr r1,register unitptr r2,register boolean carry);
+
+  boolean mp_subb(register unitptr r1,register unitptr r2,register boolean borrow);
+  boolean mp_rotate_left(register unitptr r1,register boolean carry);
+  boolean mp_rotate_right(register unitptr r1,register boolean carry);
+  short mp_compare(register unitptr r1,register unitptr r2);
+  boolean mp_inc(register unitptr r);
+  boolean mp_dec(register unitptr r);
+  void mp_neg(register unitptr r);
+  void mp_move(register unitptr dst,register unitptr src);
+  void mp_init(register unitptr r, word16 value);
+  short significance(register unitptr r);
+  void unitfill0(unitptr r,word16 unitcount);
+  int mp_udiv(register unitptr remainder,register unitptr quotient,
+    register unitptr dividend,register unitptr divisor);
+  int mp_div(register unitptr remainder,register unitptr quotient,
+    register unitptr dividend,register unitptr divisor);
+  word16 mp_shortdiv(register unitptr quotient,
+    register unitptr dividend,register word16 divisor);
+  int mp_mod(register unitptr remainder,
+    register unitptr dividend,register unitptr divisor);
+  word16 mp_shortmod(register unitptr dividend,register word16 divisor);
+  int mp_mult(register unitptr prod,
+    register unitptr multiplicand,register unitptr multiplier);
+
+private:
+  void mp_lshift_unit(register unitptr r1);
+  void stage_mp_images(unitptr images[16],unitptr r);
+
+public:
+  int stage_merritt_modulus(unitptr n);
+  int merritt_modmult(register unitptr prod,
+    unitptr multiplicand,register unitptr multiplier);
+
+private:
+  void merritt_burn(void);
+
+public:
+  int countbits(unitptr r);
+
+  int mp_modexp(register unitptr expout,register unitptr expin,
+  register unitptr exponent,register unitptr modulus);
+
+  int rsa_decrypt(unitptr M, unitptr C,	unitptr d, unitptr p, unitptr q, unitptr u);
+  int mp_sqrt(unitptr quotient,unitptr dividend);
+};
+
+inline void CRSALib::set_precision(short prec) {global_precision = prec;}
+#endif
+//---

data/ext/wmsigner/signer.cpp

@@ -0,0 +1,315 @@
+#include "stdafx.h"
+#include <stdio.h>
+#include <fcntl.h>
+#include <stdlib.h>
+#include <time.h>
+#include "signer.h"
+
+#ifdef _WIN32
+#include <io.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <errno.h>
+#define __open _open
+#define __read _read
+#define __close _close
+#else
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/uio.h>
+#include <unistd.h>
+#include <errno.h>
+#define __open	open
+#define __read	read
+#define __close	close
+#endif
+
+#ifndef TRUE
+#define TRUE	1
+#endif
+#ifndef FALSE
+#define FALSE	0
+#endif
+
+bool Signer::SecureKeyByIDPW(char *buf, DWORD dwBuf)
+{
+  if(((KeyFileFormat *)buf)->wSignFlag == 0)
+  {
+    m_siErrorCode = -2;
+    return false;
+  };
+  DWORD dwCRC[4];
+  szptr szIDPW = m_szUserName;
+  szIDPW += m_szPassword;
+  Keys::CountCrcMD4(dwCRC, szIDPW, szIDPW.strlen());
+
+  dwCRC[0] = SwitchIndian(dwCRC[0]);
+  dwCRC[1] = SwitchIndian(dwCRC[1]);
+  dwCRC[2] = SwitchIndian(dwCRC[2]);
+  dwCRC[3] = SwitchIndian(dwCRC[3]);
+
+  char *ptrKey = ((KeyFileFormat *)buf)->ptrBuffer;
+  DWORD dwKeyLen = dwBuf-(ptrKey-buf) - 6;
+  ptrKey += 6;
+  for(DWORD dwProc=0; dwProc<dwKeyLen; dwProc+=sizeof(dwCRC))
+    for(int k=0; k<sizeof(dwCRC)&&(dwProc+k)<dwKeyLen; k++)
+      *(ptrKey+dwProc+k) ^= ((char *)dwCRC)[k];
+  return true;
+}
+
+
+bool Signer::SecureKeyByIDPWHalf(char *buf, DWORD dwBuf)
+{
+  if(((KeyFileFormat *)buf)->wSignFlag == 0)
+  {
+    m_siErrorCode = -2;
+    return false;
+  };
+  DWORD dwCRC[4];
+  szptr szIDPW = m_szUserName;
+  int len = (int) strlen(m_szPassword)/2 + 1;
+  if (len > 1)
+  {
+    char* pBuf = new char[len];
+    strncpy(pBuf, m_szPassword, len-1);
+    pBuf[len-1] = '\0';
+    szIDPW += pBuf;
+    
+    delete [] pBuf;
+  }
+  Keys::CountCrcMD4(dwCRC, szIDPW, szIDPW.strlen());
+
+  dwCRC[0] = SwitchIndian(dwCRC[0]);
+  dwCRC[1] = SwitchIndian(dwCRC[1]);
+  dwCRC[2] = SwitchIndian(dwCRC[2]);
+  dwCRC[3] = SwitchIndian(dwCRC[3]);
+
+  char *ptrKey = ((KeyFileFormat *)buf)->ptrBuffer;
+  DWORD dwKeyLen = dwBuf-(ptrKey-buf) - 6;
+  ptrKey += 6;
+  for(DWORD dwProc=0; dwProc<dwKeyLen; dwProc+=sizeof(dwCRC))
+    for(int k=0; k<sizeof(dwCRC)&&(dwProc+k)<dwKeyLen; k++)
+      *(ptrKey+dwProc+k) ^= ((char *)dwCRC)[k];
+  return true;
+}
+//---------------------------------------------------------
+void Signer::SetKeyFromCL( int flag, char *KeyBuf )
+{
+   KeyFromCL = FALSE;
+   if( flag == TRUE ) KeyFromCL = TRUE;
+   memcpy( (void *) szKeyData, (const void *)KeyBuf, 164 );
+}
+//---------------------------------------------------------
+
+int Signer::LoadKeys()
+{
+  bool bKeysReaded = false, bNotOldFmt = false;
+  int nReaden;
+  int errLoadKey;
+  int fh = -1;
+  int st_size = 0;
+  const int nMaxBufLen = sizeof(Keys) + KeyFileFormat::sizeof_header;
+  char *pBufRead = new char[nMaxBufLen];   // Here Keys must be
+  m_siErrorCode = 0;
+  KeyFromCL = FALSE;
+
+if( (!isIgnoreKeyFile) && (Key64Flag == FALSE) ) {
+  #ifdef O_BINARY
+  fh = __open( m_szKeyFileName, O_RDONLY | O_BINARY);
+  #else
+  fh = __open( m_szKeyFileName, O_RDONLY);
+  #endif
+
+  if( fh == -1 )
+  {
+    m_siErrorCode = errno;
+    return false;
+  }
+
+  st_size = lseek(fh, 0, SEEK_END);
+  lseek(fh, 0, SEEK_SET);
+  if (st_size == lMinKeyFileSize)
+  {
+    // load 164 bytes from "small" keys file
+    nReaden = __read( fh, pBufRead, nMaxBufLen );
+    bKeysReaded = (nReaden == lMinKeyFileSize);
+  }
+  __close( fh );
+} 
+else {
+   bKeysReaded = true;
+   nReaden = lMinKeyFileSize;
+   memcpy( pBufRead, szKeyData, lMinKeyFileSize);
+}
+
+  //*************************************************************************
+
+  if(bKeysReaded)
+  {
+    SecureKeyByIDPWHalf(pBufRead, lMinKeyFileSize);
+    WORD old_SignFlag;
+    old_SignFlag = ((KeyFileFormat *)pBufRead)->wSignFlag;
+    ((KeyFileFormat *)pBufRead)->wSignFlag = 0;
+    errLoadKey = keys.LoadFromBuffer( pBufRead, lMinKeyFileSize );
+    if(errLoadKey)
+    {
+      // Restore for correct Loading (CRC) !
+      ((KeyFileFormat *)pBufRead)->wSignFlag = old_SignFlag;
+      SecureKeyByIDPWHalf(pBufRead, lMinKeyFileSize); // restore buffer
+
+      SecureKeyByIDPW(pBufRead, lMinKeyFileSize);
+
+      ((KeyFileFormat *)pBufRead)->wSignFlag = 0;
+      errLoadKey = keys.LoadFromBuffer( pBufRead, lMinKeyFileSize );
+    }
+
+    delete[] pBufRead;
+    if( !errLoadKey )
+      bKeysReaded = true;
+    else
+    {
+      Keys flushKey;
+      keys = flushKey;
+      m_siErrorCode = -3;
+    }
+  }
+
+  return bKeysReaded;
+}
+
+Signer::Signer(const char * szLogin, const char *szPassword, const char *szKeyFileName)
+ : m_szUserName(szLogin), m_szPassword(szPassword), m_szKeyFileName(szKeyFileName)
+{
+  m_siErrorCode = 0;
+  isIgnoreKeyFile = false;
+  isIgnoreIniFile = false;
+  isKWMFileFromCL = false;
+  memset(szKeyData, 0, MAXBUF+1);
+  Key64Flag = FALSE;
+}
+
+short Signer::ErrorCode()
+{
+  return m_siErrorCode;
+}
+
+bool Signer::Sign(const char *szIn, szptr& szSign)
+{
+  DWORD dwCRC[14];
+#ifdef _DEBUG
+	printf("\n\rSign - Start !");
+#endif
+
+  if (!LoadKeys())
+  {
+    puts("!LoadKeys");
+    return false;
+  }
+#ifdef _DEBUG
+	printf("\n\rSign - Load Keys");
+#endif
+
+  if(!keys.wEKeyBase || !keys.wNKeyBase)
+    return false;
+
+#ifdef _DEBUG
+  char *szInHex = new char [(strlen(szIn)+1)*2+1];
+  us2sz((const unsigned short *)szIn, (int)(strlen(szIn)+1)/2, szInHex);
+  puts("\n\rInput:\n");
+  puts(szIn);
+  puts("\nin hex:\n");
+  puts(szInHex);
+  puts("\n");
+  delete [] szInHex;
+#endif
+
+  if(Keys::CountCrcMD4(dwCRC, szIn, (DWORD)strlen(szIn)))
+  {
+    DWORD dwCrpSize = GetCLenB(sizeof(dwCRC), keys.arwNKey);
+    char *ptrCrpBlock = new char[dwCrpSize];
+#ifdef _DEBUG
+    for(int i=4; i<14; i++) dwCRC[i] = 0;
+#else
+    srand((unsigned)time(NULL));
+  for(int i=4; i<14; i++) dwCRC[i] = rand();
+#endif
+    dwCRC[0] = SwitchIndian(dwCRC[0]);
+    dwCRC[1] = SwitchIndian(dwCRC[1]);
+    dwCRC[2] = SwitchIndian(dwCRC[2]);
+    dwCRC[3] = SwitchIndian(dwCRC[3]);
+#ifdef _DEBUG
+    for(int h=0;h<sizeof(dwCRC);h++)
+    { printf("packing%d: %x\n", h, ((char*)dwCRC)[h]); }
+#endif
+#ifdef _DEBUG
+	printf("\n\rCalling CrpB() - start");
+#endif
+    CrpB(ptrCrpBlock, (char *)dwCRC, sizeof(dwCRC), keys.arwEKey, keys.arwNKey);
+#ifdef _DEBUG
+	printf("\n\rCalling CrpB() - end");
+#endif
+    char *charCrpBlock = new char[dwCrpSize*2+1];
+    us2sz((const unsigned short *)ptrCrpBlock, dwCrpSize/2, charCrpBlock);
+    szSign = charCrpBlock;
+#ifdef _DEBUG
+	printf("\n\rSign - prepare end");
+#endif
+    
+    delete [] charCrpBlock;
+    delete [] ptrCrpBlock;
+
+#ifdef _DEBUG
+	printf("\n\rSign - end return true");
+#endif
+    
+    return true;
+  }
+
+#ifdef _DEBUG
+	printf("\n\rSign - end return false");
+#endif
+  return false;
+}
+
+Signer2::Signer2(const char *szLogin, const char *szPassword, const char *szKeyData)
+  :Signer(szLogin, szPassword, ""), m_strKeyData(szKeyData)
+{
+  m_siErrorCode = 0;
+}
+
+int Signer2::LoadKeys()
+{
+  bool bKeysReaded = false, bNotOldFmt = false;
+  int errLoadKey;
+
+  int nStrKeyDataLen = m_strKeyData.strlen();
+  const int nMaxBufLen = sizeof(Keys) + KeyFileFormat::sizeof_header;
+  if ((nStrKeyDataLen>0) && (nStrKeyDataLen < nMaxBufLen*2))
+  {
+    BYTE *bKeyData = new BYTE[nMaxBufLen];
+    sz2us(m_strKeyData, (unsigned short*)bKeyData);
+    SecureKeyByIDPW((char*)bKeyData, nStrKeyDataLen / 2);
+    ((KeyFileFormat *)bKeyData)->wSignFlag = 0;
+    errLoadKey = keys.LoadFromBuffer((char*)bKeyData, nStrKeyDataLen / 2);
+    delete bKeyData;
+    if( !errLoadKey )
+      bKeysReaded = true;
+    else {
+      Keys flushKey;
+      keys = flushKey;
+    m_siErrorCode = -2;
+    }
+  }
+  else
+  {
+    errLoadKey = -1;
+  m_siErrorCode = -1;
+  }
+  return (bKeysReaded);
+}
+
+short Signer2::ErrorCode()
+{
+  return m_siErrorCode;
+}
+//----

data/ext/wmsigner/signer.h

@@ -0,0 +1,63 @@
+#ifndef __SIGNER_H_INCLUDE__
+#define __SIGNER_H_INCLUDE__
+#include "stdafx.h"
+#include "cmdbase.h"
+
+#define MAXBUF  4096 
+
+const long lMinKeyFileSize	= 164;//smallest size of the keysfaile
+const long lKiloByte		= 1024;//1 kilobyte in bytes
+const long lMegaByte		= lKiloByte*lKiloByte;//1 megabyte in bytes
+const long lScrollZoom		= 100;
+const long lMaxKeyFileSize	= 10*lMegaByte;//10 Mb in this version
+const szptr szOptionKeyFileSize = "KeyFileSize";
+const unsigned int uiKWNHeaderOffset = 2;
+const unsigned int uiKWNHeaderSize = uiKWNHeaderOffset + lMinKeyFileSize;
+const unsigned int uiBlockSizeOffset = 1;
+
+class Signer
+{
+
+public:
+ bool isIgnoreKeyFile;
+ bool isIgnoreIniFile;
+ bool isKWMFileFromCL;
+ char szKeyData[MAXBUF+1];       /* Buffer for Signre-s key      */
+ int Key64Flag;
+
+protected:
+  szptr m_szUserName;
+  szptr m_szPassword;
+  szptr m_szKeyFileName;
+  short m_siErrorCode;
+  Keys keys;
+  bool SecureKeyByIDPW(char *buf, DWORD dwBuf);
+	bool SecureKeyByIDPWHalf(char *buf, DWORD dwBuf);
+  int virtual LoadKeys();
+
+public:
+  Signer(const char *szLogin, const char *szPassword, const char *szKeyFileName);
+  bool Sign(const char *szIn, szptr& szSign);
+  short ErrorCode();
+//-------------------------------------------------
+public:
+  int KeyFromCL;
+  char KeyBuffer[164];
+  void SetKeyFromCL( int flag, char *KeyBuf );
+//-------------------------------------------------
+};
+
+class Signer2: public Signer
+{
+protected:
+  szptr m_strKeyData;
+  short m_siErrorCode;
+  int virtual LoadKeys();
+
+public:
+  Signer2(const char *szLogin, const char *szPassword, const char *szKeyData);
+  short ErrorCode();
+};
+
+#endif
+//-----