webmoney 0.0.4.2

data/ChangeLog

@@ -0,0 +1,35 @@
+ChangeLog
+
+Tue Oct 14 2008 18:46:50 +0400
+----------------------------
+  V 0.0.4.2
+  * Remove ActiveSuport stupid dependency
+  * Remove Time.from_ms meaningless method
+  * Rename config file to ~/.wm/config.yml
+
+Tue Aug 19 11:31:53 2008 +0400
+----------------------------
+  V 0.0.4.1
+  * Fix error in parsing ms-data without ending zeros
+
+Wed Feb 27 19:09:00 MSK 2008
+----------------------------
+  V 0.0.4
+  * Redesign interfaces, BIG changes
+  * Add Messenger class for processing messages queue in new thread
+  * Add ResponseError on incorrect http response (404, 501, etc)
+
+Wed Oct 24 17:57:00 MSK 2007
+----------------------------
+  V 0.0.3 
+  * Add send_message interface
+  * Add specific Exceptions
+  * Add parse_retval for response
+  
+Tue Aug 7 14:34:00 MSK 2007
+----------------------------
+  V 0.0.2
+  * Bug fixes...
+
+  V 0.0.1
+  * Initial release

data/ext/wmsigner/base64.cpp

@@ -0,0 +1,144 @@
+/****************************************************************************************************************************
+ *  Usage this module :
+ *  size_t result = code64( JOB [ENCODE or DECODE], char *ASCII_Buffer, size_t ASCII_BUFFER_SIZE, 
+ *                          char *BASE64_Buffer,  size_t BASE64_BUFFER_SIZE );
+ *  Sample for decode from ascii to base64 : 
+ *  result = code64( DECODE, char *ASCII_Buffer, size_t ASCII_BUFFER_SIZE, char *BASE64_Buffer,  size_t BASE64_BUFFER_SIZE );
+ *  Parameter ASCII_BUFFER_SIZE - definition size input to decode sequence ! 
+ *  function strlen() - may be used ONLY for text buffers, otherwize - BINARY DATA, use really size !
+ *  Sample for encode from base64 to ascii : 
+ *  result = code64( ENCODE, char *ASCII_Buffer, size_t ASCII_BUFFER_SIZE, char *BASE64_Buffer,  size_t BASE64_BUFFER_SIZE );
+ *  Parameter BASE64_BUFFER_SIZE - definition size input to encode sequence !
+ *  function strlen() may be used for counting size for BASE64 array, if last symbol == '\0', otherwise use really size !
+ *  .........................................................................................................................
+ *  Return value:
+ *  size_t result - counter, number of bytes in OUTPUT array, whose successfully encoded/decoded.
+ *  if result == 0 - error found, abnormal terminating, nothing to encoding or decoding.
+ *  .........................................................................................................................
+ *  Internal function: idx64( char Ch ); Binary search index in Base64 array, for Ch character in parameter
+ *  .........................................................................................................................
+ *  This module present "AS IS", absolutely no warranty, if anybody modyfied this source.
+ ****************************************************************************************************************************/
+#include "base64.h"
+
+/* Base_64 characters  */
+const char Ch64[65] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+
+/*  Presort array for indexes  */
+const INDEX64 Id64[64] = {
+  {'+',62},{'/',63},{'0',52},{'1',53},{'2',54},{'3',55},{'4',56},{'5',57},{'6',58},{'7',59},{'8',60},{'9',61},
+  {'A',0},{'B',1},{'C',2},{'D',3},{'E',4},{'F',5},{'G',6},{'H',7},{'I',8},{'J',9},{'K',10},{'L',11},{'M',12},
+  {'N',13},{'O',14},{'P',15},{'Q',16},{'R',17},{'S',18},{'T',19},{'U',20},{'V',21},{'W',22},{'X',23},{'Y',24},{'Z',25},
+  {'a',26},{'b',27},{'c',28},{'d',29},{'e',30},{'f',31},{'g',32},{'h',33},{'i',34},{'j',35},{'k',36},{'l',37},{'m',38},
+  {'n',39},{'o',40},{'p',41},{'q',42},{'r',43},{'s',44},{'t',45},{'u',46},{'v',47},{'w',48},{'x',49},{'y',50},{'z',51}
+};
+  
+/*  Base64 ENCODE / DECODE function  */
+size_t code64( int job, char *buf_ascii, size_t ascii_size, char *buf_64, size_t buf_64_size ) 
+{
+  BASE64 b64;
+  size_t i = 0, j = 0, k = 0, i3 = 0; /*  job indexes */
+  size_t ask_len = 0;   /* Internal variable for size ascii buffer   */
+  size_t buf64_len = 0; /* Internal variable for size base64 buffer  */
+
+  b64.a[0] = 0; b64.a[1] = 0; b64.a[2] = 0;
+
+/*  Decoding to Base64 code  */
+  if( job == DECODE ) {
+    ask_len = ascii_size;
+    if( (ascii_size * 4 / 3) > buf_64_size ) return( CODE_ERR ); /* No enough space to decoding */
+    if( ask_len == 0 ) return( CODE_ERR );
+    i3 = (int) 3 * (ask_len / 3);      /* Dividing by 3       */
+    if( i3 > 0 ) k = 3 - ask_len + i3; /* End of seq (1 or 2) */
+    if( ask_len < 3 ) k = 3 - ask_len;
+
+    while( i < i3 ) {
+      b64.a[2] = buf_ascii[i];
+      b64.a[1] = buf_ascii[i+1];
+      b64.a[0] = buf_ascii[i+2];
+      buf_64[j++] = Ch64[b64.b.b0];
+      buf_64[j++] = Ch64[b64.b.b1];
+      buf_64[j++] = Ch64[b64.b.b2];
+      buf_64[j++] = Ch64[b64.b.b3];
+      i+=3;
+    }
+
+    if( k == 2 ) {
+      b64.a[2] = buf_ascii[i];
+      b64.a[1] = 0;
+      b64.a[0] = 0;
+      buf_64[j++] = Ch64[b64.b.b0];
+      buf_64[j++] = Ch64[b64.b.b1];
+      buf_64[j++] = '=';
+      buf_64[j++] = '=';
+    }
+
+    if( k == 1 ) {
+      b64.a[2] = buf_ascii[i];
+      b64.a[1] = buf_ascii[i+1];
+      b64.a[0] = 0;
+      buf_64[j++] = Ch64[b64.b.b0];
+      buf_64[j++] = Ch64[b64.b.b1];
+      buf_64[j++] = Ch64[b64.b.b2];
+      buf_64[j++] = '=';
+    }
+
+    return( j );
+  }
+
+/* Restoring original characters */
+  if( job == ENCODE ) {
+    buf64_len = buf_64_size;
+    if( buf64_len < 4 ) return( CODE_ERR ); /* Too small input buffer  */
+    if( (buf_64_size * 3 / 4) > ascii_size ) return( CODE_ERR ); /* No enough space to encoding */
+    i3 = buf64_len / 4;
+    k = buf64_len - i3 * 4;
+    if( k ) return( CODE_ERR ); /*  Illegal size for input sequence !! */
+    k = 0;                      /*  Counter original bytes for output  */
+
+    for( i = 0; i < buf64_len; i+=4 ) {
+      b64.b.b0 = idx64( buf_64[i] );
+      b64.b.b1 = idx64( buf_64[i+1] );
+      b64.b.b2 = 0; b64.b.b3 = 0;
+      if( buf_64[i+2] != '=' ) b64.b.b2 = idx64( buf_64[i+2] );
+      else k--;
+      if( buf_64[i+3] != '=' ) b64.b.b3 = idx64( buf_64[i+3] );
+      else k--;
+      buf_ascii[j++] = b64.a[2]; k++;
+      buf_ascii[j++] = b64.a[1]; k++;
+      buf_ascii[j++] = b64.a[0]; k++;
+    }
+
+    return( k );
+  }
+
+  return( CODE_ERR ); /*  Unknown command ! */
+}
+
+/*  Binary search character's index in array  */
+int idx64( char ch )
+{
+  int start = 0;
+  int pos   = 32;
+  int end   = 63;
+
+  while( (pos >= start) || (pos <= end) ) {
+     if( ch == Id64[start].Ch ) return( Id64[start].Id );
+     if( ch == Id64[pos].Ch )   return( Id64[pos].Id );
+     if( ch == Id64[end].Ch )   return( Id64[end].Id );
+
+     if( ch > Id64[pos].Ch ) {
+        start = pos;
+     }
+
+     if( ch < Id64[pos].Ch ) {
+        end = pos;
+     }
+
+     pos = (int) (start+end) / 2;
+  }
+
+/*  Illegal character found, task aborted !  */
+  fprintf( stderr, "\n\rBase64 Fatal Error: Illegal character found : '%c' [%d] - No Base64 legal character!!\n\r", ch, ch );
+  exit(1);
+}

data/ext/wmsigner/base64.h

@@ -0,0 +1,48 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#ifndef __BASE64_DEFINED___
+#define __BASE64_DEFINED___
+#endif /* __BASE64_DEFINED___ */ 
+
+#define ENCODE  0
+#define DECODE  1
+
+#define CODE_ERR        0
+
+#ifndef TRUE
+#define TRUE            1
+#endif
+#ifndef FALSE
+#define FALSE           0
+#endif
+
+#define MAXBUFFER       4096  //  Don`t change this parameter !!!
+#define READBYTES       3072  //  Don`t change this parameter !!!
+
+/* Bits BASE64 structure */
+typedef struct __Bits64__ {
+  unsigned b3 : 6; /* 1 Base 64 character  */
+  unsigned b2 : 6; /* 2 Base 64 character  */
+  unsigned b1 : 6; /* 3 Base 64 character  */
+  unsigned b0 : 6; /* 4 Base 64 character  */
+} BITS, *BITSPTR;
+
+/* Union of Bits & Bytes */
+typedef union __Base64__ {
+  char a[3]; /* Byte array in the case  */
+  BITS b;    /* Bits fields in the case */
+} BASE64;
+
+/* Base_64 index structure */
+
+typedef struct __index64__ {
+  char Ch;
+  int Id;
+} INDEX64, *INDEX64PTR;
+
+/* Prototypes */                                                                                                                           
+size_t code64( int job, char *buf_ascii, size_t ascii_size, char *buf_64, size_t buf_64_size );                                            
+int idx64( char ch ); 
+

data/ext/wmsigner/cmdbase.cpp

@@ -0,0 +1,417 @@
+#include "stdafx.h"
+#include <stdio.h>
+#include <stdlib.h>
+//#include <io.h>
+#include <string.h>
+#include "ctype.h"
+#include "cmdbase.h"
+
+WORD SwitchIndian(WORD n1)
+{
+#ifndef LOWBYTEFIRST
+  WORD n2;
+
+  char* ps=(char*)&n1;
+  char* pd=(char*)&n2;
+  pd[1] = ps[0];
+  pd[0] = ps[1];
+
+  return n2;
+#else
+  return n1;
+#endif
+}
+
+DWORD SwitchIndian(DWORD n1)
+{
+#ifndef LOWBYTEFIRST
+  DWORD n2;
+
+  char* ps=(char*)&n1;
+  char* pd=(char*)&n2;
+  pd[3] = ps[0];
+  pd[2] = ps[1];
+  pd[1] = ps[2];
+  pd[0] = ps[3];
+
+  return n2;
+#else
+  return n1;
+#endif
+}
+
+szptr::szptr(const char *csz)
+{
+  if (csz)
+  {
+    sz = new char[::strlen(csz)+4];
+    strcpy(sz, csz);
+  }
+  else
+    sz = NULL;
+}
+
+szptr::szptr(const szptr& cszptr)
+{
+  if ((const char *)cszptr)
+  {
+    sz = new char[cszptr.strlen()+4];
+    sz = strcpy(sz, cszptr);
+  }
+  else
+    sz = (const char *)cszptr ? strcpy(new char[cszptr.strlen()+4], cszptr) : NULL;
+}
+
+szptr::~szptr()
+{
+  if(sz) delete[] sz;
+}
+
+char* szptr::operator = (char *csz)
+{
+  if(sz && csz)
+  {
+    if(!strcmp(csz,sz))
+      return sz;
+  }
+
+  char *szprev = sz;
+  if(csz)
+  {
+    sz = new char[::strlen(csz)+4];
+    sz = strcpy(sz, csz);
+  }
+  else
+    sz = NULL;
+
+  if(szprev)
+    delete[] szprev;
+
+  return sz;
+}
+
+szptr& szptr::operator = (const szptr& cszptr)
+{
+  if(sz && cszptr.sz)
+    if(!strcmp(cszptr,sz))
+      return *this;
+
+  char *szprev = sz;
+  if(cszptr)
+  {
+    sz = new char[::strlen(cszptr)+4];
+    sz = strcpy(sz, cszptr);
+  }
+  else
+    sz = NULL;
+  if(szprev)
+    delete[] szprev;
+  return *this;
+}
+
+szptr& szptr::operator += (const szptr& cszptr)
+{
+  if(!&cszptr) return *this;
+  if(!cszptr.strlen()) return *this;
+
+  char *szprev = sz;
+  sz = new char[strlen()+cszptr.strlen()+4];
+  if(szprev)
+  {
+    strcpy(sz, szprev);
+    delete[] szprev;
+  }
+  else
+    sz[0] = '\0';
+
+  strcat(sz, cszptr);
+  return *this;
+}
+
+szptr& szptr::TrimRight()
+{
+  if (NULL== this->sz)
+    return *this;
+  char* lpsz = this->sz;
+  char* lpszLast = NULL;
+
+  while (*lpsz != '\0')
+  {
+    if (*lpsz == ' ')
+    {
+      if (lpszLast == NULL)
+        lpszLast = lpsz;
+    }
+    else
+      lpszLast = NULL;
+    lpsz = ((char*)lpsz)+1;
+  }
+
+  if (lpszLast != NULL)
+  {
+    *lpszLast = '\0';
+  }
+  return *this;
+}
+
+szptr& szptr::TrimLeft()
+{
+  if (NULL== this->sz)
+    return *this;
+  char* lpsz = this->sz;
+  int nLen = (int)::strlen(sz);
+  while ((*lpsz==' '))
+    lpsz = ((char*)lpsz)+1;
+
+  if (lpsz != sz)
+  {
+    int nDataLength = (int)nLen - (int)(lpsz - sz);
+    memmove(sz, lpsz, (nDataLength+1)*sizeof(char));
+  }
+  return *this;
+}
+
+static char *dwordFromBuf(DWORD *wMember, char *szNextElemBufPtr)
+{
+  *wMember = SwitchIndian(*((DWORD*)szNextElemBufPtr));
+  return (szNextElemBufPtr+sizeof(DWORD));
+}
+
+static char *wordFromBuf(WORD *wMember, char *szNextElemBufPtr)
+{
+  *wMember = SwitchIndian(*((WORD*)szNextElemBufPtr));
+  return (szNextElemBufPtr+sizeof(WORD));
+}
+
+static char *dwordToBuf(char *szNextElemBufPtr, DWORD wMember)
+{
+  *((DWORD*)szNextElemBufPtr) = wMember;
+  return (szNextElemBufPtr+sizeof(DWORD));
+}
+
+static char *wordToBuf(char *szNextElemBufPtr, WORD wMember)
+{
+  *((WORD*)szNextElemBufPtr) = wMember;
+  return (szNextElemBufPtr+sizeof(WORD));
+}
+
+
+/**/
+Keys::Keys()
+  :dwReserv(0)
+{
+  memset(arwEKey, 0, (MAX_UNIT_PRECISION) * 2);
+  memset(arwNKey, 0, (MAX_UNIT_PRECISION) * 2);
+  wEKeyBase= wNKeyBase = 0;
+}
+
+Keys::Keys(const Keys& keysFrom)
+{
+  dwReserv = keysFrom.dwReserv;
+  wEKeyBase= wNKeyBase = 0;
+  memcpy(arwEKey, keysFrom.arwEKey, (MAX_UNIT_PRECISION) * 2);
+  memcpy(arwNKey, keysFrom.arwEKey, (MAX_UNIT_PRECISION) * 2);
+  wEKeyBase = keysFrom.wEKeyBase;
+  wNKeyBase = keysFrom.wNKeyBase;
+}
+
+Keys& Keys::operator=(const Keys& keysFrom)
+{
+  dwReserv = keysFrom.dwReserv;
+  memcpy(arwEKey, keysFrom.arwEKey, (MAX_UNIT_PRECISION) * 2);
+  memcpy(arwNKey, keysFrom.arwNKey, (MAX_UNIT_PRECISION) * 2);
+  wEKeyBase = keysFrom.wEKeyBase;
+  wNKeyBase = keysFrom.wNKeyBase;
+  return *this;
+}
+
+DWORD Keys::GetMembersSize()
+{
+  return (
+      sizeof(dwReserv)
+    + GetKeyBaseB(arwEKey)
+    + GetKeyBaseB(arwNKey)
+    + sizeof(wEKeyBase)
+    + sizeof(wNKeyBase));
+}
+
+char *Keys::LoadMembers(char *BufPtr)
+{
+  char *ptrNextMemb = dwordFromBuf(&dwReserv, BufPtr);
+
+  ptrNextMemb = wordFromBuf(&wEKeyBase, ptrNextMemb);
+  memcpy(arwEKey, ptrNextMemb, wEKeyBase);
+  for(WORD i=0;i<wEKeyBase/sizeof(arwEKey[0]);i++)
+  { arwEKey[i] = SwitchIndian(arwEKey[i]); }
+
+  ptrNextMemb += wEKeyBase;
+
+  ptrNextMemb = wordFromBuf(&wNKeyBase, ptrNextMemb);
+  memcpy(arwNKey, ptrNextMemb, wNKeyBase);
+  for(unsigned int i=0;i<wNKeyBase/sizeof(arwNKey[0]);i++)
+  { arwNKey[i] = SwitchIndian(arwNKey[i]); }
+
+  ptrNextMemb += wNKeyBase;
+
+  return ptrNextMemb;
+}
+
+char *Keys::SaveMembers(char *BufPtr)
+{
+  char *ptrNextMemb = dwordToBuf(BufPtr, dwReserv);
+
+  wEKeyBase = GetKeyBaseB(arwEKey);
+  ptrNextMemb = wordToBuf(ptrNextMemb, wEKeyBase);
+  memcpy(ptrNextMemb, arwEKey, wEKeyBase);
+  ptrNextMemb += wEKeyBase;
+
+  wNKeyBase = GetKeyBaseB(arwNKey);
+  ptrNextMemb = wordToBuf(ptrNextMemb, wNKeyBase);
+  memcpy(ptrNextMemb, arwNKey, wNKeyBase);
+  ptrNextMemb += wNKeyBase;
+
+  return ptrNextMemb;
+}
+
+
+void Keys::RecalcBase()
+{
+  wEKeyBase = GetKeyBaseB(arwEKey);
+  wNKeyBase = GetKeyBaseB(arwNKey);
+}
+
+int Keys::LoadFromBuffer(const char *Buf, DWORD dwBufLen)
+{
+  if(dwBufLen < KeyFileFormat::sizeof_header)
+    return _CMDLOAD_ERR_BUF_LEN_;
+
+  KeyFileFormat *keyFmt = (KeyFileFormat *)Buf;
+  DWORD ardwRecievedCRC[4], ardwCheckedCRC[4], i;
+
+  if(dwBufLen-2*sizeof(DWORD) >= SwitchIndian(keyFmt->dwLenBuf))
+  {
+    for(i=0; i<4; i++)
+      ardwRecievedCRC[i] = SwitchIndian(keyFmt->dwCRC[i]);
+    for(i=0; i<4; i++)  keyFmt->dwCRC[i] = 0;
+    CountCrcMD4(ardwCheckedCRC, Buf, SwitchIndian(keyFmt->dwLenBuf)+KeyFileFormat::sizeof_header);
+
+    for(i=0; i<4; i++)  keyFmt->dwCRC[i] = SwitchIndian(ardwRecievedCRC[i]);
+
+    bool bCrcGood = true;
+    for(i=0; i<4; i++)
+      if(ardwCheckedCRC[i]!=ardwRecievedCRC[i])
+      {
+        bCrcGood = false;
+        break;
+      }
+
+    if(bCrcGood)
+    {
+      LoadMembers(keyFmt->ptrBuffer);
+      return 0;
+    }
+    else
+      return _CMDLOAD_ERR_CMD_CRC_;
+  }
+  else
+    return _CMDLOAD_ERR_BUF_LEN_;
+}
+
+int Keys::SaveIntoBuffer(char **ptrAllocBuf, DWORD *dwBufLen)
+{
+  char *Buf;
+  KeyFileFormat *cmdFmt;
+  DWORD dwMembersSize;
+  DWORD dwBufSize, i;
+  BOOL bRC = false;
+
+  dwMembersSize = GetMembersSize();
+
+  dwBufSize = dwMembersSize+KeyFileFormat::sizeof_header;
+  Buf = new char[dwBufSize];
+  memset(Buf, 0, dwBufSize);  // Clear for Trail...
+  cmdFmt = (KeyFileFormat *)Buf;
+  if(Buf)
+  {
+    char *BufMemb;
+    BufMemb = cmdFmt->ptrBuffer;
+
+    if(SaveMembers(BufMemb))
+    {
+      cmdFmt->wReserved1 = 0x81;
+      cmdFmt->wSignFlag = 0;
+      cmdFmt->dwLenBuf = dwMembersSize;
+
+      for(i=0; i<4; i++)  cmdFmt->dwCRC[i] = 0;
+      CountCrcMD4(cmdFmt->dwCRC, Buf, dwBufSize); //*((WORD *)(Buf+sizeof(WORD)))=
+      *dwBufLen = dwBufSize;
+      *ptrAllocBuf = Buf;
+      bRC = true;
+    }
+  }
+  else
+    bRC = false;   // NOT_ENOUGH_MEMORY
+
+  return bRC;
+}
+
+ bool Keys::CountCrcMD4(DWORD *dwCRC, const char *Buf, DWORD dwBufLenBytes)
+{
+  int b,bitcount;
+  MDstruct MD;
+
+  MDbegin(&MD);
+  for(b=0,bitcount=512; (unsigned int)b<dwBufLenBytes/64+1; b++)
+  {
+    if((unsigned int)b==dwBufLenBytes/64) bitcount = (dwBufLenBytes%64)<<3;
+    MDupdate(&MD, (unsigned char *)(Buf+b*64), bitcount);
+  }
+  MDupdate(&MD, (unsigned char *)Buf, 0);
+
+  for(b=0; b<4; b++) dwCRC[b] = MD.buffer[b];
+
+  return true;
+}
+
+bool us2sz(const unsigned short *buf, int len, char *szBuffer)
+{
+  char tmp[5];
+  szBuffer[0] = '\0';
+
+  for(int i=0;i<len;i++)
+  {
+    sprintf(tmp, "%04x", buf[i]);
+    strcat(szBuffer, tmp);
+  }
+  return true;
+}
+
+char stohb(char s)
+{
+  if ( s>='0' && s<='9') return (s-'0');
+  else
+    if ( s>='A' && s<='F') return (s-'A'+0xA);
+    else
+      if ( s>='a' && s<='f') return (s-'a'+0xA);
+  return 0;
+}
+
+bool sz2us(const char *szBuffer, unsigned short *usBuf)
+{
+  const char* p = szBuffer;
+  int l = (int)strlen(szBuffer);
+  unsigned short cell = 0;
+  for(int i=0,k=0; i<l; i+=4) {
+    cell = 0;
+    cell = stohb(*p++);
+    cell <<= 4;
+    cell |= stohb(*p++);
+    cell <<= 4;
+    cell |= stohb(*p++);
+    cell <<= 4;
+    cell |= stohb(*p++);
+    usBuf[k++] = cell;
+  }
+  return true;
+}
+//----