webmoney 0.0.4.2
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- data/ChangeLog +35 -0
- data/ext/wmsigner/base64.cpp +144 -0
- data/ext/wmsigner/base64.h +48 -0
- data/ext/wmsigner/cmdbase.cpp +417 -0
- data/ext/wmsigner/cmdbase.h +111 -0
- data/ext/wmsigner/crypto.cpp +155 -0
- data/ext/wmsigner/crypto.h +17 -0
- data/ext/wmsigner/extconf.rb +16 -0
- data/ext/wmsigner/md4.cpp +192 -0
- data/ext/wmsigner/md4.h +41 -0
- data/ext/wmsigner/rsalib1.cpp +838 -0
- data/ext/wmsigner/rsalib1.h +81 -0
- data/ext/wmsigner/signer.cpp +315 -0
- data/ext/wmsigner/signer.h +63 -0
- data/ext/wmsigner/stdafx.cpp +8 -0
- data/ext/wmsigner/stdafx.h +33 -0
- data/ext/wmsigner/wmsigner.cpp +119 -0
- data/lib/WebMoneyCA.crt +90 -0
- data/lib/messenger.rb +37 -0
- data/lib/passport.rb +44 -0
- data/lib/webmoney.rb +237 -0
- data/lib/wmid.rb +14 -0
- data/rakefile +63 -0
- data/spec/spec_helper.rb +20 -0
- data/spec/unit/messenger_spec.rb +23 -0
- data/spec/unit/passport_spec.rb +47 -0
- data/spec/unit/signer_spec.rb +35 -0
- data/spec/unit/time_spec.rb +14 -0
- data/spec/unit/webmoney_spec.rb +111 -0
- data/spec/unit/wmid_spec.rb +30 -0
- data/tools/rakehelp.rb +117 -0
- metadata +102 -0
@@ -0,0 +1,81 @@
|
|
1
|
+
#ifndef __RSALIB1_H_INCLUDE__
|
2
|
+
#define __RSALIB1_H_INCLUDE__
|
3
|
+
#include "stdafx.h"
|
4
|
+
|
5
|
+
typedef unsigned char boolean;
|
6
|
+
typedef unsigned char byte;
|
7
|
+
typedef unsigned short word16;
|
8
|
+
typedef word16 unit;
|
9
|
+
typedef unit *unitptr;
|
10
|
+
typedef short signedunit;
|
11
|
+
typedef unsigned long int ulint;
|
12
|
+
|
13
|
+
class CRSALib
|
14
|
+
{
|
15
|
+
public:
|
16
|
+
|
17
|
+
enum { MAX_BIT_PRECISION = 2048, MAX_UNIT_PRECISION = MAX_BIT_PRECISION/(sizeof(word16)*8) };
|
18
|
+
private:
|
19
|
+
unit moduli_buf[16][(MAX_UNIT_PRECISION)];
|
20
|
+
unitptr moduli[16+1];
|
21
|
+
|
22
|
+
unit msu_moduli[16+1];
|
23
|
+
unit nmsu_moduli[16+1];
|
24
|
+
unit mpdbuf[16-1][(MAX_UNIT_PRECISION)];
|
25
|
+
unitptr mpd[16];
|
26
|
+
|
27
|
+
public:
|
28
|
+
short global_precision;
|
29
|
+
void set_precision(short prec);
|
30
|
+
CRSALib(short glob_pres=0);
|
31
|
+
|
32
|
+
boolean mp_addc(register unitptr r1,register unitptr r2,register boolean carry);
|
33
|
+
|
34
|
+
boolean mp_subb(register unitptr r1,register unitptr r2,register boolean borrow);
|
35
|
+
boolean mp_rotate_left(register unitptr r1,register boolean carry);
|
36
|
+
boolean mp_rotate_right(register unitptr r1,register boolean carry);
|
37
|
+
short mp_compare(register unitptr r1,register unitptr r2);
|
38
|
+
boolean mp_inc(register unitptr r);
|
39
|
+
boolean mp_dec(register unitptr r);
|
40
|
+
void mp_neg(register unitptr r);
|
41
|
+
void mp_move(register unitptr dst,register unitptr src);
|
42
|
+
void mp_init(register unitptr r, word16 value);
|
43
|
+
short significance(register unitptr r);
|
44
|
+
void unitfill0(unitptr r,word16 unitcount);
|
45
|
+
int mp_udiv(register unitptr remainder,register unitptr quotient,
|
46
|
+
register unitptr dividend,register unitptr divisor);
|
47
|
+
int mp_div(register unitptr remainder,register unitptr quotient,
|
48
|
+
register unitptr dividend,register unitptr divisor);
|
49
|
+
word16 mp_shortdiv(register unitptr quotient,
|
50
|
+
register unitptr dividend,register word16 divisor);
|
51
|
+
int mp_mod(register unitptr remainder,
|
52
|
+
register unitptr dividend,register unitptr divisor);
|
53
|
+
word16 mp_shortmod(register unitptr dividend,register word16 divisor);
|
54
|
+
int mp_mult(register unitptr prod,
|
55
|
+
register unitptr multiplicand,register unitptr multiplier);
|
56
|
+
|
57
|
+
private:
|
58
|
+
void mp_lshift_unit(register unitptr r1);
|
59
|
+
void stage_mp_images(unitptr images[16],unitptr r);
|
60
|
+
|
61
|
+
public:
|
62
|
+
int stage_merritt_modulus(unitptr n);
|
63
|
+
int merritt_modmult(register unitptr prod,
|
64
|
+
unitptr multiplicand,register unitptr multiplier);
|
65
|
+
|
66
|
+
private:
|
67
|
+
void merritt_burn(void);
|
68
|
+
|
69
|
+
public:
|
70
|
+
int countbits(unitptr r);
|
71
|
+
|
72
|
+
int mp_modexp(register unitptr expout,register unitptr expin,
|
73
|
+
register unitptr exponent,register unitptr modulus);
|
74
|
+
|
75
|
+
int rsa_decrypt(unitptr M, unitptr C, unitptr d, unitptr p, unitptr q, unitptr u);
|
76
|
+
int mp_sqrt(unitptr quotient,unitptr dividend);
|
77
|
+
};
|
78
|
+
|
79
|
+
inline void CRSALib::set_precision(short prec) {global_precision = prec;}
|
80
|
+
#endif
|
81
|
+
//---
|
@@ -0,0 +1,315 @@
|
|
1
|
+
#include "stdafx.h"
|
2
|
+
#include <stdio.h>
|
3
|
+
#include <fcntl.h>
|
4
|
+
#include <stdlib.h>
|
5
|
+
#include <time.h>
|
6
|
+
#include "signer.h"
|
7
|
+
|
8
|
+
#ifdef _WIN32
|
9
|
+
#include <io.h>
|
10
|
+
#include <sys/types.h>
|
11
|
+
#include <sys/stat.h>
|
12
|
+
#include <errno.h>
|
13
|
+
#define __open _open
|
14
|
+
#define __read _read
|
15
|
+
#define __close _close
|
16
|
+
#else
|
17
|
+
#include <sys/types.h>
|
18
|
+
#include <sys/stat.h>
|
19
|
+
#include <sys/uio.h>
|
20
|
+
#include <unistd.h>
|
21
|
+
#include <errno.h>
|
22
|
+
#define __open open
|
23
|
+
#define __read read
|
24
|
+
#define __close close
|
25
|
+
#endif
|
26
|
+
|
27
|
+
#ifndef TRUE
|
28
|
+
#define TRUE 1
|
29
|
+
#endif
|
30
|
+
#ifndef FALSE
|
31
|
+
#define FALSE 0
|
32
|
+
#endif
|
33
|
+
|
34
|
+
bool Signer::SecureKeyByIDPW(char *buf, DWORD dwBuf)
|
35
|
+
{
|
36
|
+
if(((KeyFileFormat *)buf)->wSignFlag == 0)
|
37
|
+
{
|
38
|
+
m_siErrorCode = -2;
|
39
|
+
return false;
|
40
|
+
};
|
41
|
+
DWORD dwCRC[4];
|
42
|
+
szptr szIDPW = m_szUserName;
|
43
|
+
szIDPW += m_szPassword;
|
44
|
+
Keys::CountCrcMD4(dwCRC, szIDPW, szIDPW.strlen());
|
45
|
+
|
46
|
+
dwCRC[0] = SwitchIndian(dwCRC[0]);
|
47
|
+
dwCRC[1] = SwitchIndian(dwCRC[1]);
|
48
|
+
dwCRC[2] = SwitchIndian(dwCRC[2]);
|
49
|
+
dwCRC[3] = SwitchIndian(dwCRC[3]);
|
50
|
+
|
51
|
+
char *ptrKey = ((KeyFileFormat *)buf)->ptrBuffer;
|
52
|
+
DWORD dwKeyLen = dwBuf-(ptrKey-buf) - 6;
|
53
|
+
ptrKey += 6;
|
54
|
+
for(DWORD dwProc=0; dwProc<dwKeyLen; dwProc+=sizeof(dwCRC))
|
55
|
+
for(int k=0; k<sizeof(dwCRC)&&(dwProc+k)<dwKeyLen; k++)
|
56
|
+
*(ptrKey+dwProc+k) ^= ((char *)dwCRC)[k];
|
57
|
+
return true;
|
58
|
+
}
|
59
|
+
|
60
|
+
|
61
|
+
bool Signer::SecureKeyByIDPWHalf(char *buf, DWORD dwBuf)
|
62
|
+
{
|
63
|
+
if(((KeyFileFormat *)buf)->wSignFlag == 0)
|
64
|
+
{
|
65
|
+
m_siErrorCode = -2;
|
66
|
+
return false;
|
67
|
+
};
|
68
|
+
DWORD dwCRC[4];
|
69
|
+
szptr szIDPW = m_szUserName;
|
70
|
+
int len = (int) strlen(m_szPassword)/2 + 1;
|
71
|
+
if (len > 1)
|
72
|
+
{
|
73
|
+
char* pBuf = new char[len];
|
74
|
+
strncpy(pBuf, m_szPassword, len-1);
|
75
|
+
pBuf[len-1] = '\0';
|
76
|
+
szIDPW += pBuf;
|
77
|
+
|
78
|
+
delete [] pBuf;
|
79
|
+
}
|
80
|
+
Keys::CountCrcMD4(dwCRC, szIDPW, szIDPW.strlen());
|
81
|
+
|
82
|
+
dwCRC[0] = SwitchIndian(dwCRC[0]);
|
83
|
+
dwCRC[1] = SwitchIndian(dwCRC[1]);
|
84
|
+
dwCRC[2] = SwitchIndian(dwCRC[2]);
|
85
|
+
dwCRC[3] = SwitchIndian(dwCRC[3]);
|
86
|
+
|
87
|
+
char *ptrKey = ((KeyFileFormat *)buf)->ptrBuffer;
|
88
|
+
DWORD dwKeyLen = dwBuf-(ptrKey-buf) - 6;
|
89
|
+
ptrKey += 6;
|
90
|
+
for(DWORD dwProc=0; dwProc<dwKeyLen; dwProc+=sizeof(dwCRC))
|
91
|
+
for(int k=0; k<sizeof(dwCRC)&&(dwProc+k)<dwKeyLen; k++)
|
92
|
+
*(ptrKey+dwProc+k) ^= ((char *)dwCRC)[k];
|
93
|
+
return true;
|
94
|
+
}
|
95
|
+
//---------------------------------------------------------
|
96
|
+
void Signer::SetKeyFromCL( int flag, char *KeyBuf )
|
97
|
+
{
|
98
|
+
KeyFromCL = FALSE;
|
99
|
+
if( flag == TRUE ) KeyFromCL = TRUE;
|
100
|
+
memcpy( (void *) szKeyData, (const void *)KeyBuf, 164 );
|
101
|
+
}
|
102
|
+
//---------------------------------------------------------
|
103
|
+
|
104
|
+
int Signer::LoadKeys()
|
105
|
+
{
|
106
|
+
bool bKeysReaded = false, bNotOldFmt = false;
|
107
|
+
int nReaden;
|
108
|
+
int errLoadKey;
|
109
|
+
int fh = -1;
|
110
|
+
int st_size = 0;
|
111
|
+
const int nMaxBufLen = sizeof(Keys) + KeyFileFormat::sizeof_header;
|
112
|
+
char *pBufRead = new char[nMaxBufLen]; // Here Keys must be
|
113
|
+
m_siErrorCode = 0;
|
114
|
+
KeyFromCL = FALSE;
|
115
|
+
|
116
|
+
if( (!isIgnoreKeyFile) && (Key64Flag == FALSE) ) {
|
117
|
+
#ifdef O_BINARY
|
118
|
+
fh = __open( m_szKeyFileName, O_RDONLY | O_BINARY);
|
119
|
+
#else
|
120
|
+
fh = __open( m_szKeyFileName, O_RDONLY);
|
121
|
+
#endif
|
122
|
+
|
123
|
+
if( fh == -1 )
|
124
|
+
{
|
125
|
+
m_siErrorCode = errno;
|
126
|
+
return false;
|
127
|
+
}
|
128
|
+
|
129
|
+
st_size = lseek(fh, 0, SEEK_END);
|
130
|
+
lseek(fh, 0, SEEK_SET);
|
131
|
+
if (st_size == lMinKeyFileSize)
|
132
|
+
{
|
133
|
+
// load 164 bytes from "small" keys file
|
134
|
+
nReaden = __read( fh, pBufRead, nMaxBufLen );
|
135
|
+
bKeysReaded = (nReaden == lMinKeyFileSize);
|
136
|
+
}
|
137
|
+
__close( fh );
|
138
|
+
}
|
139
|
+
else {
|
140
|
+
bKeysReaded = true;
|
141
|
+
nReaden = lMinKeyFileSize;
|
142
|
+
memcpy( pBufRead, szKeyData, lMinKeyFileSize);
|
143
|
+
}
|
144
|
+
|
145
|
+
//*************************************************************************
|
146
|
+
|
147
|
+
if(bKeysReaded)
|
148
|
+
{
|
149
|
+
SecureKeyByIDPWHalf(pBufRead, lMinKeyFileSize);
|
150
|
+
WORD old_SignFlag;
|
151
|
+
old_SignFlag = ((KeyFileFormat *)pBufRead)->wSignFlag;
|
152
|
+
((KeyFileFormat *)pBufRead)->wSignFlag = 0;
|
153
|
+
errLoadKey = keys.LoadFromBuffer( pBufRead, lMinKeyFileSize );
|
154
|
+
if(errLoadKey)
|
155
|
+
{
|
156
|
+
// Restore for correct Loading (CRC) !
|
157
|
+
((KeyFileFormat *)pBufRead)->wSignFlag = old_SignFlag;
|
158
|
+
SecureKeyByIDPWHalf(pBufRead, lMinKeyFileSize); // restore buffer
|
159
|
+
|
160
|
+
SecureKeyByIDPW(pBufRead, lMinKeyFileSize);
|
161
|
+
|
162
|
+
((KeyFileFormat *)pBufRead)->wSignFlag = 0;
|
163
|
+
errLoadKey = keys.LoadFromBuffer( pBufRead, lMinKeyFileSize );
|
164
|
+
}
|
165
|
+
|
166
|
+
delete[] pBufRead;
|
167
|
+
if( !errLoadKey )
|
168
|
+
bKeysReaded = true;
|
169
|
+
else
|
170
|
+
{
|
171
|
+
Keys flushKey;
|
172
|
+
keys = flushKey;
|
173
|
+
m_siErrorCode = -3;
|
174
|
+
}
|
175
|
+
}
|
176
|
+
|
177
|
+
return bKeysReaded;
|
178
|
+
}
|
179
|
+
|
180
|
+
Signer::Signer(const char * szLogin, const char *szPassword, const char *szKeyFileName)
|
181
|
+
: m_szUserName(szLogin), m_szPassword(szPassword), m_szKeyFileName(szKeyFileName)
|
182
|
+
{
|
183
|
+
m_siErrorCode = 0;
|
184
|
+
isIgnoreKeyFile = false;
|
185
|
+
isIgnoreIniFile = false;
|
186
|
+
isKWMFileFromCL = false;
|
187
|
+
memset(szKeyData, 0, MAXBUF+1);
|
188
|
+
Key64Flag = FALSE;
|
189
|
+
}
|
190
|
+
|
191
|
+
short Signer::ErrorCode()
|
192
|
+
{
|
193
|
+
return m_siErrorCode;
|
194
|
+
}
|
195
|
+
|
196
|
+
bool Signer::Sign(const char *szIn, szptr& szSign)
|
197
|
+
{
|
198
|
+
DWORD dwCRC[14];
|
199
|
+
#ifdef _DEBUG
|
200
|
+
printf("\n\rSign - Start !");
|
201
|
+
#endif
|
202
|
+
|
203
|
+
if (!LoadKeys())
|
204
|
+
{
|
205
|
+
puts("!LoadKeys");
|
206
|
+
return false;
|
207
|
+
}
|
208
|
+
#ifdef _DEBUG
|
209
|
+
printf("\n\rSign - Load Keys");
|
210
|
+
#endif
|
211
|
+
|
212
|
+
if(!keys.wEKeyBase || !keys.wNKeyBase)
|
213
|
+
return false;
|
214
|
+
|
215
|
+
#ifdef _DEBUG
|
216
|
+
char *szInHex = new char [(strlen(szIn)+1)*2+1];
|
217
|
+
us2sz((const unsigned short *)szIn, (int)(strlen(szIn)+1)/2, szInHex);
|
218
|
+
puts("\n\rInput:\n");
|
219
|
+
puts(szIn);
|
220
|
+
puts("\nin hex:\n");
|
221
|
+
puts(szInHex);
|
222
|
+
puts("\n");
|
223
|
+
delete [] szInHex;
|
224
|
+
#endif
|
225
|
+
|
226
|
+
if(Keys::CountCrcMD4(dwCRC, szIn, (DWORD)strlen(szIn)))
|
227
|
+
{
|
228
|
+
DWORD dwCrpSize = GetCLenB(sizeof(dwCRC), keys.arwNKey);
|
229
|
+
char *ptrCrpBlock = new char[dwCrpSize];
|
230
|
+
#ifdef _DEBUG
|
231
|
+
for(int i=4; i<14; i++) dwCRC[i] = 0;
|
232
|
+
#else
|
233
|
+
srand((unsigned)time(NULL));
|
234
|
+
for(int i=4; i<14; i++) dwCRC[i] = rand();
|
235
|
+
#endif
|
236
|
+
dwCRC[0] = SwitchIndian(dwCRC[0]);
|
237
|
+
dwCRC[1] = SwitchIndian(dwCRC[1]);
|
238
|
+
dwCRC[2] = SwitchIndian(dwCRC[2]);
|
239
|
+
dwCRC[3] = SwitchIndian(dwCRC[3]);
|
240
|
+
#ifdef _DEBUG
|
241
|
+
for(int h=0;h<sizeof(dwCRC);h++)
|
242
|
+
{ printf("packing%d: %x\n", h, ((char*)dwCRC)[h]); }
|
243
|
+
#endif
|
244
|
+
#ifdef _DEBUG
|
245
|
+
printf("\n\rCalling CrpB() - start");
|
246
|
+
#endif
|
247
|
+
CrpB(ptrCrpBlock, (char *)dwCRC, sizeof(dwCRC), keys.arwEKey, keys.arwNKey);
|
248
|
+
#ifdef _DEBUG
|
249
|
+
printf("\n\rCalling CrpB() - end");
|
250
|
+
#endif
|
251
|
+
char *charCrpBlock = new char[dwCrpSize*2+1];
|
252
|
+
us2sz((const unsigned short *)ptrCrpBlock, dwCrpSize/2, charCrpBlock);
|
253
|
+
szSign = charCrpBlock;
|
254
|
+
#ifdef _DEBUG
|
255
|
+
printf("\n\rSign - prepare end");
|
256
|
+
#endif
|
257
|
+
|
258
|
+
delete [] charCrpBlock;
|
259
|
+
delete [] ptrCrpBlock;
|
260
|
+
|
261
|
+
#ifdef _DEBUG
|
262
|
+
printf("\n\rSign - end return true");
|
263
|
+
#endif
|
264
|
+
|
265
|
+
return true;
|
266
|
+
}
|
267
|
+
|
268
|
+
#ifdef _DEBUG
|
269
|
+
printf("\n\rSign - end return false");
|
270
|
+
#endif
|
271
|
+
return false;
|
272
|
+
}
|
273
|
+
|
274
|
+
Signer2::Signer2(const char *szLogin, const char *szPassword, const char *szKeyData)
|
275
|
+
:Signer(szLogin, szPassword, ""), m_strKeyData(szKeyData)
|
276
|
+
{
|
277
|
+
m_siErrorCode = 0;
|
278
|
+
}
|
279
|
+
|
280
|
+
int Signer2::LoadKeys()
|
281
|
+
{
|
282
|
+
bool bKeysReaded = false, bNotOldFmt = false;
|
283
|
+
int errLoadKey;
|
284
|
+
|
285
|
+
int nStrKeyDataLen = m_strKeyData.strlen();
|
286
|
+
const int nMaxBufLen = sizeof(Keys) + KeyFileFormat::sizeof_header;
|
287
|
+
if ((nStrKeyDataLen>0) && (nStrKeyDataLen < nMaxBufLen*2))
|
288
|
+
{
|
289
|
+
BYTE *bKeyData = new BYTE[nMaxBufLen];
|
290
|
+
sz2us(m_strKeyData, (unsigned short*)bKeyData);
|
291
|
+
SecureKeyByIDPW((char*)bKeyData, nStrKeyDataLen / 2);
|
292
|
+
((KeyFileFormat *)bKeyData)->wSignFlag = 0;
|
293
|
+
errLoadKey = keys.LoadFromBuffer((char*)bKeyData, nStrKeyDataLen / 2);
|
294
|
+
delete bKeyData;
|
295
|
+
if( !errLoadKey )
|
296
|
+
bKeysReaded = true;
|
297
|
+
else {
|
298
|
+
Keys flushKey;
|
299
|
+
keys = flushKey;
|
300
|
+
m_siErrorCode = -2;
|
301
|
+
}
|
302
|
+
}
|
303
|
+
else
|
304
|
+
{
|
305
|
+
errLoadKey = -1;
|
306
|
+
m_siErrorCode = -1;
|
307
|
+
}
|
308
|
+
return (bKeysReaded);
|
309
|
+
}
|
310
|
+
|
311
|
+
short Signer2::ErrorCode()
|
312
|
+
{
|
313
|
+
return m_siErrorCode;
|
314
|
+
}
|
315
|
+
//----
|
@@ -0,0 +1,63 @@
|
|
1
|
+
#ifndef __SIGNER_H_INCLUDE__
|
2
|
+
#define __SIGNER_H_INCLUDE__
|
3
|
+
#include "stdafx.h"
|
4
|
+
#include "cmdbase.h"
|
5
|
+
|
6
|
+
#define MAXBUF 4096
|
7
|
+
|
8
|
+
const long lMinKeyFileSize = 164;//smallest size of the keysfaile
|
9
|
+
const long lKiloByte = 1024;//1 kilobyte in bytes
|
10
|
+
const long lMegaByte = lKiloByte*lKiloByte;//1 megabyte in bytes
|
11
|
+
const long lScrollZoom = 100;
|
12
|
+
const long lMaxKeyFileSize = 10*lMegaByte;//10 Mb in this version
|
13
|
+
const szptr szOptionKeyFileSize = "KeyFileSize";
|
14
|
+
const unsigned int uiKWNHeaderOffset = 2;
|
15
|
+
const unsigned int uiKWNHeaderSize = uiKWNHeaderOffset + lMinKeyFileSize;
|
16
|
+
const unsigned int uiBlockSizeOffset = 1;
|
17
|
+
|
18
|
+
class Signer
|
19
|
+
{
|
20
|
+
|
21
|
+
public:
|
22
|
+
bool isIgnoreKeyFile;
|
23
|
+
bool isIgnoreIniFile;
|
24
|
+
bool isKWMFileFromCL;
|
25
|
+
char szKeyData[MAXBUF+1]; /* Buffer for Signre-s key */
|
26
|
+
int Key64Flag;
|
27
|
+
|
28
|
+
protected:
|
29
|
+
szptr m_szUserName;
|
30
|
+
szptr m_szPassword;
|
31
|
+
szptr m_szKeyFileName;
|
32
|
+
short m_siErrorCode;
|
33
|
+
Keys keys;
|
34
|
+
bool SecureKeyByIDPW(char *buf, DWORD dwBuf);
|
35
|
+
bool SecureKeyByIDPWHalf(char *buf, DWORD dwBuf);
|
36
|
+
int virtual LoadKeys();
|
37
|
+
|
38
|
+
public:
|
39
|
+
Signer(const char *szLogin, const char *szPassword, const char *szKeyFileName);
|
40
|
+
bool Sign(const char *szIn, szptr& szSign);
|
41
|
+
short ErrorCode();
|
42
|
+
//-------------------------------------------------
|
43
|
+
public:
|
44
|
+
int KeyFromCL;
|
45
|
+
char KeyBuffer[164];
|
46
|
+
void SetKeyFromCL( int flag, char *KeyBuf );
|
47
|
+
//-------------------------------------------------
|
48
|
+
};
|
49
|
+
|
50
|
+
class Signer2: public Signer
|
51
|
+
{
|
52
|
+
protected:
|
53
|
+
szptr m_strKeyData;
|
54
|
+
short m_siErrorCode;
|
55
|
+
int virtual LoadKeys();
|
56
|
+
|
57
|
+
public:
|
58
|
+
Signer2(const char *szLogin, const char *szPassword, const char *szKeyData);
|
59
|
+
short ErrorCode();
|
60
|
+
};
|
61
|
+
|
62
|
+
#endif
|
63
|
+
//-----
|