webmoney 0.0.4.2

data/ext/wmsigner/cmdbase.h

@@ -0,0 +1,111 @@
+#ifndef __CMDBASE_INCLUDE__
+#define __CMDBASE_INCLUDE__
+#include "stdafx.h"
+#include "crypto.h"
+#include "md4.h"
+#include <stdio.h>
+#include "string.h"
+//--------------------
+
+#ifndef _WIN32
+#define _NOT_WIN32
+#endif
+
+#if defined(__FreeBSD__) && __FreeBSD__ < 5     /* for FreeBSD version <= 4 */
+#include <inttypes.h> 
+#elif defined(_NOT_WIN32)
+#include <stdint.h>
+#endif
+
+#ifndef _WIN32
+typedef uint32_t DWORD;
+typedef bool BOOL;
+typedef uint8_t BYTE;
+typedef uint16_t WORD;
+#endif
+
+
+//--------------------
+#define LOWBYTEFIRST
+#define EBITS     (48)
+#define KEYBITS   (528)
+
+#define MAX_BIT_PRECISION (2048)
+#define MAX_UNIT_PRECISION (MAX_BIT_PRECISION/(sizeof(unsigned short)*8))
+
+#define _CMDLOAD_ERR_CMD_CRIPTION_  1
+#define _CMDLOAD_ERR_CMD_CRC_       2
+#define _CMDLOAD_ERR_BUF_LEN_       3
+#define _CMDLOAD_ERR_CMD_DECODE_    4
+#define _CMDLOAD_ERR_CMD_CODE_      5
+#define _CMDLOAD_ERR_NULL_KEY_      6
+
+class szptr
+{
+  char *sz;
+
+public:
+  szptr() { sz = NULL; }
+  szptr(const char *csz);
+  szptr(const szptr& cszptr);
+  ~szptr();
+
+  char* operator = (char *csz);
+  szptr& operator = (const szptr& cszptr);
+  szptr& operator += (const szptr& cszptr);
+  inline void ReplaceIncluding(char *szp) { if(sz) delete sz; sz = szp; }
+  inline char operator*() { return sz ? *sz : '\0'; }
+  inline char operator[](int i) const { return sz ? *(sz+i) : '\0'; }
+  inline operator char const * const () const { return sz; }
+  int strlen() const {
+    if (sz) return (int)::strlen(sz);
+    else return 0;
+  }
+  inline bool operator==(const szptr& s) const { return (sz && s.sz) ? (strcmp(s.sz,sz)==0) : (sz == s.sz); }
+  inline bool operator!=(const szptr& s) const { return (sz && s.sz) ? (strcmp(s.sz,sz)!=0) : (sz != s.sz); }
+
+  szptr& TrimLeft();
+  szptr& TrimRight();
+};
+
+
+WORD SwitchIndian(WORD n1);
+DWORD SwitchIndian(DWORD n1);
+
+struct KeyFileFormat
+{
+  enum {sizeof_header = sizeof(WORD)*2 + sizeof(DWORD)*5, sizeof_crc = (sizeof(DWORD)*4)};
+  WORD  wReserved1;
+  WORD  wSignFlag;
+  DWORD dwCRC[4];
+  DWORD dwLenBuf;
+  char  ptrBuffer[1];
+};
+
+struct Keys
+{
+  DWORD dwReserv;
+  WORD arwEKey[MAX_UNIT_PRECISION];
+  WORD arwNKey[MAX_UNIT_PRECISION];
+  WORD wEKeyBase;
+  WORD wNKeyBase;
+
+  Keys();
+  Keys(const Keys& keysFrom);
+  Keys& operator=(const Keys& KeysFrom);
+  virtual DWORD GetMembersSize();
+  virtual char*  LoadMembers(char *BufPtr);
+  virtual int LoadFromBuffer(const char *Buf, DWORD dwBufLen);
+  virtual char*  SaveMembers(char *BufPtr);
+  virtual int SaveIntoBuffer(char **ptrAllocBuf, DWORD *dwBufLen);
+
+  static bool CountCrcMD4(DWORD *dwCRC, const char *Buf, DWORD dwBufLenBytes);
+  void RecalcBase();
+};
+
+
+bool us2sz(const unsigned short *buf, int len, char *szBuffer);
+char stohb(char s);
+bool sz2us(const char *szBuffer, unsigned short *usBuf);
+#endif
+//---

data/ext/wmsigner/crypto.cpp

@@ -0,0 +1,155 @@
+#include "stdafx.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include "crypto.h"
+#include "rsalib1.h"
+#include <memory.h>
+
+
+unsigned short SwitchIndian(unsigned short n1);
+
+unsigned int GetCLenB(int len, const unsigned short *n, short KeyBits)
+{
+  CRSALib rsalib((KeyBits + 15)>> 4);
+  rsalib.set_precision((KeyBits + 15) >> 4);
+  int blocksize = rsalib.significance((unsigned short *)n);
+  int workblocksize = blocksize-1;
+  int len_and_sizeW = (len+sizeof(short)+1) >> 1;
+  int hvost = (len_and_sizeW)%workblocksize;
+  if (hvost) hvost = 1;
+  int newLen = (((len_and_sizeW) / (workblocksize)) + hvost) * blocksize;
+  return (newLen*2);
+}
+
+unsigned int CrpB(char* crp, char* p, int len, const unsigned short * e, const unsigned short *n, short KeyBits)
+{
+
+  CRSALib rsalib((KeyBits + 15)>> 4);
+  rsalib.set_precision((KeyBits + 15) >> 4);
+  int blocksize = rsalib.significance((unsigned short *)n)*2;
+  int workblocksize = blocksize-2;
+  int ostb = 2;
+  int i=0, stP=0, endP=0, stC=0;
+  char pb[CRSALib::MAX_UNIT_PRECISION*2], cb[CRSALib::MAX_UNIT_PRECISION*2];
+  char *buf = (char *)malloc(len+ostb);
+  memcpy(buf+sizeof(short), p, len);
+  *(short*)buf = SwitchIndian((short)len);
+  int iLen = len+sizeof(short);
+  stP = 0;
+  stC = 0;
+  int res = 0, res1 = 0;
+
+  do
+  {
+    memset(cb, 0, CRSALib::MAX_UNIT_PRECISION*2);
+    memset(pb, 0, CRSALib::MAX_UNIT_PRECISION*2);
+
+    endP = ((workblocksize < iLen) ? workblocksize : iLen);
+    memcpy(pb, buf+stP, endP);
+    for(int h=0;h<endP/2;h++)
+    {
+    	((unsigned short*)pb)[h] = SwitchIndian(((unsigned short*)pb)[h]);
+    }
+#ifdef _DEBUG
+    for(int h=0;h<endP/2;h++)
+    {
+    	printf("X:%d ", ((unsigned short*)pb)[h]);
+    }
+#endif
+
+    if ((res = rsalib.mp_modexp((unsigned short*)cb, (unsigned short*)pb, (unsigned short *)e, (unsigned short *)n)) != 0)
+    {
+      res1 = res;
+    }
+
+	memcpy(crp+stC, cb, blocksize);
+
+    stP += endP;
+    stC += blocksize;
+    iLen -= (workblocksize);
+  } while (iLen > 0);
+
+  free(buf);
+
+  return GetCLenB(len, n);
+}
+
+unsigned int DCrpB(char* dcrp, int* dlen, char* c, int len, const unsigned short * d, const unsigned short *n, short KeyBits)
+{
+  CRSALib rsalib((KeyBits + 15)>> 4);
+  rsalib.set_precision((KeyBits + 15) >> 4);
+  int blocksize = rsalib.significance((unsigned short *)n)*2;
+  if (0==blocksize)
+  {
+    *dlen = 0;
+    return 0;
+  }
+  if (len < blocksize)
+  {
+    *dlen = 0;
+    return 0;
+  }
+  int workblocksize = blocksize-2;
+  int rcLen = 0, iLen = len;
+  int stP = 0, stC = 0;
+
+  char *buf = (char *)malloc(len);
+  memset(buf, 0, len);
+
+  char pb[CRSALib::MAX_UNIT_PRECISION*2], cb[CRSALib::MAX_UNIT_PRECISION*2];
+
+  int res = 0, res1 = 0;
+  do
+  {
+    memset(cb, 0, CRSALib::MAX_UNIT_PRECISION*2);
+    memset(pb, 0, CRSALib::MAX_UNIT_PRECISION*2);
+
+    memcpy(cb, c+stC, blocksize);
+
+    if ((res = rsalib.mp_modexp((unsigned short*)pb, (unsigned short*)cb, (unsigned short *)d, (unsigned short *)n))!=0)
+    {
+         res1 = res;
+
+    }
+
+
+    memcpy(buf+stP, pb, workblocksize);
+
+    stC += blocksize;
+    stP += workblocksize;
+    iLen -= blocksize;
+  } while ((iLen > 0)&&(iLen >= blocksize));
+
+  rcLen = *(unsigned short*)buf;
+
+  if (len >= rcLen)
+  {
+    *dlen = rcLen;
+    memcpy(dcrp, buf+sizeof(short), rcLen);
+  }
+  else
+  {
+    rcLen = 0;
+  }
+  free(buf);
+  return rcLen;
+}
+
+unsigned int GetKeyBase(const unsigned short *n)
+{
+  if(!n) return 0;
+  CRSALib rsalib(CRSALib::MAX_UNIT_PRECISION);
+  rsalib.set_precision(CRSALib::MAX_UNIT_PRECISION);
+  int blocksize = rsalib.significance((unsigned short *)n);
+  return blocksize;
+}
+
+unsigned int GetKeyBaseB(const unsigned short *n)
+{
+  if(!n) return 0;
+  CRSALib rsalib(CRSALib::MAX_UNIT_PRECISION);
+  rsalib.set_precision(CRSALib::MAX_UNIT_PRECISION);
+  int blocksize = rsalib.significance((unsigned short *)n);
+  return blocksize * 2;
+}
+//---

data/ext/wmsigner/crypto.h

@@ -0,0 +1,17 @@
+#ifndef __CRYPTO_H__
+#define __CRYPTO_H__
+#include "stdafx.h"
+
+#ifndef keybits
+  #define ebits 48
+  #define keybits 528
+#endif
+
+unsigned int CrpB(char* crp, char* p, int len, const unsigned short * e, const unsigned short *n, short KeyBits=keybits);
+unsigned int DCrpB(char* dcrp, int* dlen, char* c, int len, const unsigned short * d, const unsigned short *n, short KeyBits=keybits);
+unsigned int GetCLenB(int len, const unsigned short *n, short KeyBits=keybits);
+unsigned int GetKeyBaseB(const unsigned short *n);
+unsigned int GetKeyBase(const unsigned short *n);
+
+#endif
+//---

data/ext/wmsigner/extconf.rb

@@ -0,0 +1,16 @@
+# Loads mkmf which is used to make makefiles for Ruby extensions
+require 'mkmf'
+
+CONFIG["CC"] = "g++ "
+#CONFIG["CPP"] = "g++ -E "
+#CONFIG["LDSHARED"].gsub!(/^cc /,"g++ ")
+
+# Give it a name
+extension_name = 'wmsigner'
+
+# The destination
+dir_config(extension_name)
+
+# Do the work
+create_makefile(extension_name)
+

data/ext/wmsigner/md4.cpp

@@ -0,0 +1,192 @@
+#include "stdafx.h"
+#include <stdio.h>
+#include "md4.h"
+#include "cmdbase.h"
+
+#define TRUE  1
+#define FALSE 0
+
+#define I0  0x67452301L
+#define I1  0xefcdab89L
+#define I2  0x98badcfeL
+#define I3  0x10325476L
+#define C2  013240474631L
+#define C3  015666365641L
+
+#define fs1  3
+#define fs2  7
+#define fs3 11
+#define fs4 19
+#define gs1  3
+#define gs2  5
+#define gs3  9
+#define gs4 13
+#define hs1  3
+#define hs2  9
+#define hs3 11
+#define hs4 15
+
+
+#define f(X,Y,Z)             ((X&Y) | ((~X)&Z))
+#define g(X,Y,Z)             ((X&Y) | (X&Z) | (Y&Z))
+#define h(X,Y,Z)             (X^Y^Z)
+#define rot(X,S)             (tmp=X,(tmp<<S) | (tmp>>(32-S)))
+#define ff(A,B,C,D,i,s)      A = rot((A + f(B,C,D) + X[i]),s)
+#define gg(A,B,C,D,i,s)      A = rot((A + g(B,C,D) + X[i] + C2),s)
+#define hh(A,B,C,D,i,s)      A = rot((A + h(B,C,D) + X[i] + C3),s)
+
+void MDprint(MDptr MDp)
+{
+  int i,j;
+  for (i=0;i<4;i++)
+    for (j=0;j<32;j=j+8)
+      printf("%02x",(MDp->buffer[i]>>j) & 0xFF);
+}
+
+void MDbegin(MDptr MDp)
+{
+  int i;
+  MDp->buffer[0] = I0;
+  MDp->buffer[1] = I1;
+  MDp->buffer[2] = I2;
+  MDp->buffer[3] = I3;
+  for (i=0;i<8;i++)
+    MDp->count[i] = 0;
+  MDp->done = 0;
+}
+
+#define revx { t = (*X << 16) | (*X >> 16); *X++ = ((t & 0xFF00FF00L) >> 8) | ((t & 0x00FF00FFL) << 8); }
+
+void MDreverse(Word32Type *X)
+{
+  register Word32Type t;
+  revx; revx; revx; revx; revx; revx; revx; revx;
+  revx; revx; revx; revx; revx; revx; revx; revx;
+}
+
+static void MDblock(MDptr MDp, Word32Type *X)
+{
+  register Word32Type tmp, A, B, C, D;
+#ifndef LOWBYTEFIRST
+  MDreverse(X);
+#endif
+  A = MDp->buffer[0];
+  B = MDp->buffer[1];
+  C = MDp->buffer[2];
+  D = MDp->buffer[3];
+  ff(A , B , C , D ,  0 , fs1);
+  ff(D , A , B , C ,  1 , fs2);
+  ff(C , D , A , B ,  2 , fs3);
+  ff(B , C , D , A ,  3 , fs4);
+  ff(A , B , C , D ,  4 , fs1);
+  ff(D , A , B , C ,  5 , fs2);
+  ff(C , D , A , B ,  6 , fs3);
+  ff(B , C , D , A ,  7 , fs4);
+  ff(A , B , C , D ,  8 , fs1);
+  ff(D , A , B , C ,  9 , fs2);
+  ff(C , D , A , B , 10 , fs3);
+  ff(B , C , D , A , 11 , fs4);
+  ff(A , B , C , D , 12 , fs1);
+  ff(D , A , B , C , 13 , fs2);
+  ff(C , D , A , B , 14 , fs3);
+  ff(B , C , D , A , 15 , fs4);
+  gg(A , B , C , D ,  0 , gs1);
+  gg(D , A , B , C ,  4 , gs2);
+  gg(C , D , A , B ,  8 , gs3);
+  gg(B , C , D , A , 12 , gs4);
+  gg(A , B , C , D ,  1 , gs1);
+  gg(D , A , B , C ,  5 , gs2);
+  gg(C , D , A , B ,  9 , gs3);
+  gg(B , C , D , A , 13 , gs4);
+  gg(A , B , C , D ,  2 , gs1);
+  gg(D , A , B , C ,  6 , gs2);
+  gg(C , D , A , B , 10 , gs3);
+  gg(B , C , D , A , 14 , gs4);
+  gg(A , B , C , D ,  3 , gs1);
+  gg(D , A , B , C ,  7 , gs2);
+  gg(C , D , A , B , 11 , gs3);
+  gg(B , C , D , A , 15 , gs4);
+  hh(A , B , C , D ,  0 , hs1);
+  hh(D , A , B , C ,  8 , hs2);
+  hh(C , D , A , B ,  4 , hs3);
+  hh(B , C , D , A , 12 , hs4);
+  hh(A , B , C , D ,  2 , hs1);
+  hh(D , A , B , C , 10 , hs2);
+  hh(C , D , A , B ,  6 , hs3);
+  hh(B , C , D , A , 14 , hs4);
+  hh(A , B , C , D ,  1 , hs1);
+  hh(D , A , B , C ,  9 , hs2);
+  hh(C , D , A , B ,  5 , hs3);
+  hh(B , C , D , A , 13 , hs4);
+  hh(A , B , C , D ,  3 , hs1);
+  hh(D , A , B , C , 11 , hs2);
+  hh(C , D , A , B ,  7 , hs3);
+  hh(B , C , D , A , 15 , hs4);
+  MDp->buffer[0] += A;
+  MDp->buffer[1] += B;
+  MDp->buffer[2] += C;
+  MDp->buffer[3] += D;
+
+#ifndef LOWBYTEFIRST
+  MDreverse(X);
+#endif
+}
+
+void MDupdate(MDptr MDp, unsigned char *X, Word32Type count)
+{
+  int i, byte ;
+  Word32Type tmp, bit, mask;
+  unsigned char XX[64];
+  unsigned char *p;
+  if(count == 0 && MDp->done)
+    return;
+  if (MDp->done)
+  {
+    return;
+  }
+  tmp = count;
+  p = MDp->count;
+  while (tmp)
+  {
+    tmp += *p;
+    *p++ = (unsigned char) tmp;
+    tmp = tmp >> 8;
+  }
+  if (count == 512)
+  {
+    MDblock(MDp,(Word32Type *)X);
+  }
+  else
+    if (count > 512)
+    {
+      return;
+    }
+    else
+    {
+      byte = (int) count >> 3;
+      bit =  count & 7;
+      for (i=0;i<=byte;i++)
+        XX[i] = X[i];
+      for (i=byte+1;i<64;i++)
+        XX[i] = 0;
+      mask = 1 << (7 - bit);
+      XX[byte] = (unsigned char) (XX[byte] | (unsigned char)mask) & ~((unsigned char)mask - 1);
+      if (byte <= 55)
+      {
+        for (i=0;i<8;i++)
+          XX[56+i] = MDp->count[i];
+        MDblock(MDp,(Word32Type *)XX);
+      }
+      else
+      {
+        MDblock(MDp,(Word32Type *)XX);
+        for (i=0;i<56;i++)
+          XX[i] = 0;
+        for (i=0;i<8;i++)
+          XX[56+i] = MDp->count[i];
+        MDblock(MDp,(Word32Type *)XX);
+      }
+      MDp->done = 1;
+    }
+}
+//----