1. 整合master分支 [a96ba83d] 代码。

sbkpay/DataProcess/DataProcess.pri

+LIBS += -L"C:/openssl/openssl-1.0.1s/out32dll" -llibeay32
+LIBS += -L"C:/openssl/openssl-1.0.1s/out32dll" -lssleay32
+
+INCLUDEPATH += $$quote(C:/openssl/openssl-1.0.1s/inc32/)
+
+HEADERS += \
+    $$PWD/dataprocess.h \
+    $$PWD/fmglobal.h \
+    $$PWD/cretopt.h

sbkpay/DataProcess/cretopt.h

+#ifndef CRETOPT
+#define CRETOPT
+
+#include "dataprocess.h"
+
+#include <QFile>
+#include <QString>
+#include <QJsonObject>
+#include <QJsonDocument>
+
+#include <Windows.h>
+#include "QsLog.h"
+
+EXTERN_C IMAGE_DOS_HEADER __ImageBase;
+
+class CretOperate
+{
+public:
+    static void GetProcPath(char * pathBuf)
+    {
+        int curPos;
+
+        GetModuleFileNameA((HMODULE)&__ImageBase, pathBuf, MAX_PATH);
+
+        curPos = strlen(pathBuf) - 1;
+
+        while('\\' != pathBuf[curPos])
+        {
+            curPos--;
+        }
+
+        curPos++;
+
+        pathBuf[curPos] = '\0';
+    }
+
+    static bool GetSign(QJsonObject &json, QString &sign = QString())
+    {
+        QString serpbk, clipbk;
+
+        if(!GetCret(serpbk, clipbk))
+            return false;
+
+        QStringList list;
+        QString values;
+
+        DataProcess::GetJsonKeyArray(list, json);
+        DataProcess::SortString(list);
+        DataProcess::GetValueFromJson(list, json, values);
+
+        QByteArray array = values.toUtf8();
+
+        char tmp[MAX_SIGN_LEN] = { 0 };
+
+        if(DataProcess::RSASign(array.data(), tmp, MAX_SIGN_LEN, clipbk.toUtf8().data()) == 0)
+        {
+            QLOG_ERROR() << "get RSASign failed";
+            return false;
+        }
+
+        QLOG_INFO() << "get RSA sign:" << tmp;
+
+        sign = QString(tmp);
+        json.insert(JSON_KEY_SIGN, sign);
+
+        return false;
+    }
+
+    static bool SetRSACret(QString &des3text)
+    {
+
+    }
+
+private:
+    static bool GetCret(QString &serpublickey, QString &cleprivatekey)
+    {
+        char path[MAX_PATH] = { 0 };
+
+        GetProcPath(path);
+
+        QString p12path(path);
+
+        p12path.append(CRET_FILE_NAME);
+
+        QFile file(p12path);
+
+        if(!file.open(QFile::ReadOnly))
+        {
+            QLOG_ERROR() << QString("open %1 failed").arg(p12path);
+            return false;
+        }
+
+        QByteArray array = file.readAll();
+        file.close();
+
+        char rps[MAX_BUF_LEN] = {0};
+        char *buf = (char *)calloc(array.size() + 100, sizeof(char));
+
+        strcpy(buf, array.data());
+
+        if(DataProcess::DES3Decode((const unsigned char *)DES3_KEY, buf, strlen(buf), (unsigned char *)rps, MAX_BUF_LEN) == 0)
+        {
+            QLOG_ERROR() << "DES3Decode Client.p12 Failed";
+            return false;
+        }
+
+        QJsonDocument jsonDocument = QJsonDocument::fromJson(QByteArray(rps));
+
+        if( jsonDocument.isNull() )
+        {
+            QLOG_ERROR() << "DES3Decode not json:" << rps;
+            return false;
+        }
+
+        QJsonObject json = jsonDocument.object();
+
+        if(!json.contains(JSON_KEY_STATUS) || json[JSON_KEY_STATUS].toInt() != 100)
+        {
+            QLOG_ERROR() << "error client.p12 file:" << json;
+            return false;
+        }
+
+        serpublickey = json[JSON_KEY_SERPBLICKEY].toString();
+        cleprivatekey = json[JSON_KEY_CLIENTPRIKEY].toString();
+
+        QLOG_INFO() << "server public key : " << serpublickey;
+        QLOG_INFO() << "client private key : " << cleprivatekey;
+
+        return true;
+    }
+};
+
+#endif // CRETOPT
+

sbkpay/DataProcess/dataprocess.h

+#ifndef FM_DATA_PROCESS_H
+#define FM_DATA_PROCESS_H
+
+#include <string>
+
+#include <openssl/evp.h>  
+#include <openssl/bio.h>  
+#include <openssl/buffer.h>  
+#include <openssl/rsa.h>  
+#include <openssl/pem.h>  
+#include <openssl/err.h> 
+#include <openssl/des.h>
+#include <sstream>
+#include "fmglobal.h"
+
+#include <QJsonObject>
+
+#include <QString>
+
+#include <QStringList>
+
+class DataProcess
+{
+public:
+	static int base64(const char *input, size_t length, char *result, size_t size)  
+	{  
+		BIO * bmem = NULL;  
+		BIO * b64 = NULL;  
+		BUF_MEM * bptr = NULL; 
+		int len = 0;
+
+		if(input == NULL)
+			return 0;
+		//assert(NULL != input);  
+		b64 = BIO_new(BIO_f_base64());  
+		bmem = BIO_new(BIO_s_mem());  
+		if (NULL == b64 || NULL == bmem) {  
+			perror("BIO_new");  
+			return 0;  
+		}  
+		BIO_set_flags(b64, BIO_FLAGS_BASE64_NO_NL);  
+
+		b64 = BIO_push(b64, bmem);  
+		BIO_write(b64, input, length);  
+		BIO_flush(b64);  
+		BIO_get_mem_ptr(b64, &bptr);  
+
+		if ((unsigned int)(bptr->length + 1) > size) {  
+			BIO_free_all(b64);  
+			return 0;  
+		}  
+		memcpy(result, bptr->data, bptr->length);  
+		result[bptr->length] = 0;  
+		len = bptr->length;
+
+		BIO_free_all(b64);  
+
+		return len;  
+	}  
+	static int debase64(const char *input, size_t length, char *result, size_t size)  
+	{  
+		BIO * b64 = NULL;  
+		BIO * bmem = NULL;
+		int len;
+
+		if(input == NULL)
+			return 0;
+		//assert(NULL != input);  
+		if (length > size)  
+			return 0;  
+		memset(result, 0, size);  
+
+		b64 = BIO_new(BIO_f_base64());  
+		bmem = BIO_new_mem_buf((void *)input, length);  
+		BIO_set_flags(b64, BIO_FLAGS_BASE64_NO_NL);  
+		if (NULL == b64 || NULL == bmem) {  
+			perror("BIO_new");  
+			return 0;  
+		}  
+		bmem = BIO_push(b64, bmem);  
+		len = BIO_read(bmem, result, length);  
+
+		BIO_free_all(b64);  
+
+		return len;  
+	}
+	static int RSASign(const char *text, char *signature, size_t size,const char *private_key)  
+	{  
+		RSA *rsa;  
+		unsigned char *sig;  
+		unsigned int len;
+		unsigned int length = 0;
+		BIO* in = NULL; 
+		unsigned char sha1[20] = { '\0' }; 
+
+		char tmpprivatekey[MAX_RSA_KEY_LEN] = {0};
+
+		if(GetPEMKey(private_key, strlen(private_key), tmpprivatekey, MAX_RSA_KEY_LEN, 0) == 0)
+			return 0;
+
+		OpenSSL_add_all_algorithms(); 
+
+		in = BIO_new_mem_buf((void*)tmpprivatekey, -1);
+		if (in == NULL) {  
+			perror("read private failed");  
+			return 0;  
+		}  
+
+		rsa = PEM_read_bio_RSAPrivateKey(in, NULL, NULL, NULL);  
+		if (in != NULL)  
+			BIO_free(in);  
+		if (rsa == NULL) {  
+			perror("PEM_read_bio_RSAPrivateKey");  
+			return 0;  
+		}  
+		if (NULL == (sig = (unsigned char*)malloc(RSA_size(rsa)))) {  
+			RSA_free(rsa);  
+			return 0;  
+		}  
+
+		SHA1((const unsigned char *)text, strlen(text), sha1);  
+		if (1 != RSA_sign(NID_sha1, sha1, 20, sig, &len, rsa)) {  
+			free(sig);  
+			RSA_free(rsa);  
+			printf("RSA_sign error.\n");  
+			return 0;  
+		}  
+
+		if ((length= base64((char *)sig, 128, signature, size)) == 0) {  
+			free(sig);  
+			RSA_free(rsa);  
+			printf("base64 error.\n");  
+			return 0;  
+		}  
+		free(sig);  
+		RSA_free(rsa);  
+
+		return length;  
+	}
+
+	static int RSAVerify(const char *text,const char *signature, const char *public_key)  
+	{  
+		RSA *rsa;  
+		BIO* in = NULL;  
+		char * sig_debase = NULL;
+		unsigned char sha1[20];  
+
+		char tmppublickey[MAX_RSA_KEY_LEN] = {0};
+
+		if(GetPEMKey(public_key, strlen(public_key), tmppublickey, MAX_RSA_KEY_LEN, 1) == 0)
+			return 0;
+		
+		in = BIO_new_mem_buf((void*)tmppublickey, -1);
+		if (NULL == in) {  
+			printf("BIO_read_filename error.\n");  
+			return 0;  
+		}  
+
+		rsa = PEM_read_bio_RSA_PUBKEY(in, NULL, NULL, NULL);  
+
+		if (in != NULL) BIO_free(in);  
+		if (rsa == NULL) {  
+			printf("PEM_read_bio_RSA_PUBKEY error.\n");  
+			return 0;  
+		}  
+
+		sig_debase = (char *)malloc(250 * sizeof(char));  
+		if (NULL == debase64(signature, strlen((char *)signature), sig_debase, 250)) {  
+			RSA_free(rsa);  
+			printf("debase64 error.\n");  
+			return 0;  
+		}  
+
+
+		SHA1((const unsigned char *)text, strlen(text), sha1);  
+		if (1 != RSA_verify(NID_sha1, sha1, 20, (unsigned char *)sig_debase, 128, rsa)) {  
+			free(sig_debase);  
+			RSA_free(rsa);  
+			printf("RSA_verify error.\n");  
+			return 0;  
+		}  
+		free(sig_debase);  
+		RSA_free(rsa);  
+
+		return 1;  
+	}
+
+	static int DES3Encode(const unsigned char *key,const char *in, int inlen, unsigned char *out, int outmaxlen)
+	{
+		int iOutLen = 0;
+		int iTmpLen = 0;
+		int len;
+		char iv[KEY_SIZE] = {0}; 
+		unsigned char *tmp = (unsigned char *)malloc(outmaxlen * sizeof(unsigned char));
+
+	    memset(tmp, 0, outmaxlen);
+
+        EVP_CIPHER_CTX ctx;
+		EVP_CIPHER_CTX_init(&ctx);    
+        EVP_EncryptInit_ex(&ctx, EVP_des_ede3_ecb(), NULL, (const unsigned char *)key, (const unsigned char *)iv);
+		if(!EVP_EncryptUpdate(&ctx, (unsigned char*)tmp, &iOutLen, (const unsigned char *)in, inlen))    
+		{        
+			EVP_CIPHER_CTX_cleanup(&ctx);        
+			return 0;    
+        }
+		if(!EVP_EncryptFinal_ex(&ctx, (unsigned char *)(tmp + iOutLen), &iTmpLen))    
+		{        
+			EVP_CIPHER_CTX_cleanup(&ctx);        
+			return 0;    
+		}        
+		iOutLen += iTmpLen;      
+		EVP_CIPHER_CTX_cleanup(&ctx);
+		
+		len = base64((char *)tmp, iOutLen, (char *)out, outmaxlen);
+		
+		free(tmp);
+		return len;
+	}
+	static int DES3Decode(const unsigned char *key,const char * in, int inlen, unsigned char *out, int outmaxlen)
+	{
+		int iOutLen = 0;
+		int iTmpLen = 0; 
+		int length = 0;
+		char iv[KEY_SIZE] = {0};
+		unsigned char *tmp = (unsigned char *)malloc(outmaxlen * sizeof(unsigned char));
+
+		memset(tmp, 0, outmaxlen);
+		
+		if((length = debase64(in, inlen, (char *)tmp, outmaxlen)) == 0)
+		{
+			perror("debase64 failed");
+			return 0;
+		}
+		
+        EVP_CIPHER_CTX ctx;
+		EVP_CIPHER_CTX_init(&ctx);    
+		EVP_DecryptInit_ex(&ctx, EVP_des_ede3_ecb(), NULL, (const unsigned char *)key, (const unsigned char *)iv);   
+		if(!EVP_DecryptUpdate(&ctx, (unsigned char*)out, &iOutLen, (const unsigned char *)tmp, length))    
+		{        
+			EVP_CIPHER_CTX_cleanup(&ctx);        
+			return 0;    
+		}
+		if(!EVP_DecryptFinal_ex(&ctx, (unsigned char *)(out + iOutLen), &iTmpLen))    
+		{        
+			EVP_CIPHER_CTX_cleanup(&ctx);        
+			return 0;    
+		}        
+		iOutLen += iTmpLen;      
+		EVP_CIPHER_CTX_cleanup(&ctx);
+		out[iOutLen] = 0;
+
+		return iOutLen;
+
+	}
+	static int GetPEMKey(const char *key, int keylen, char *outpemkey, int outpemkeymaxlen, int ispublickey)
+	{
+		std::stringstream sstm;
+		std::string str(key, keylen);
+
+		if (keylen > outpemkeymaxlen)
+		{
+			return 0;
+		}
+
+		
+		if(ispublickey == 0)
+		{
+			int i = 0;
+
+
+			sstm << "-----BEGIN RSA PRIVATE KEY-----\n";
+
+			while(i + 64 < keylen)
+			{
+				sstm << str.substr(i, 64) << "\n";
+				i += 64;
+			}
+			if(keylen - i > 0)
+				sstm << str.substr(i, keylen - i) << "\n";
+			sstm << "-----END RSA PRIVATE KEY-----\n";
+		}
+		else
+		{
+			int i = 0;
+			sstm << "-----BEGIN PUBLIC KEY-----\n";
+
+			while(i + 64 < keylen)
+			{
+				sstm << str.substr(i, 64) << "\n";
+				i += 64;
+			}
+			if(keylen - i > 0)
+				sstm << str.substr(i, keylen - i) << "\n";
+			sstm << "-----END PUBLIC KEY-----\n";
+		}
+
+		if(strlen(sstm.str().c_str()) > outpemkeymaxlen)
+			return 0;
+
+		strcpy(outpemkey, sstm.str().c_str());
+		return 1;
+	}
+
+    static void GetJsonKeyArray(QStringList &keys, QJsonObject &json)
+	{
+        QJsonObject::Iterator it;
+
+        keys.clear();
+
+        for(it = json.begin(); it != json.end(); ++it)
+        {
+            if(it.value().isString() || it.value().isDouble())
+                keys.append(it.key());
+        }
+	}
+    static void SortString(QStringList &keys)
+    {
+        keys.removeOne(JSON_KEY_SIGN);
+        keys.sort();
+	}
+    static void GetValueFromJson(const QStringList &keys, const QJsonObject &json, QString &values)
+	{
+        values.clear();
+
+        for(int i = 0; i < keys.length(); ++i)
+        {
+            if(json[keys[i]].isString())
+            {
+                values.append(json[keys[i]].toString());
+                values.append("|");
+            }
+            else if(json[keys[i]].isDouble())
+            {
+                values.append(QString::number(json[keys[i]].toInt()));
+                values.append("|");
+            }
+        }
+
+        values = values.left(values.length() - 1);
+
+        qDebug() << values;
+	}
+};
+
+#endif

sbkpay/DataProcess/fmglobal.h

+#ifndef FM_GLOBAL_H
+#define FM_GLOBAL_H
+
+#define NUM_SIZE					60
+#define KEY_SIZE					24
+#define MAX_LOG_LINE_NUM			1024
+#define MAX_RSA_KEY_LEN				2048
+#define MAX_BUF_LEN					25600
+#define MAX_JSON_KEY_LEN			128
+#define MAX_SIGN_LEN				256
+#define CFG_FILE_NAME				"fmclient.cfg"
+#define RBG_FILE_NAME				"fmclient.rbk"
+
+#define DES3_KEY					"ABCD@#9876DFSAAWKLDEOPDD"
+#define CRET_FILE_NAME				"client.p12"
+#define JSON_KEY_ONLY				"partnerOrderId"
+#define JSON_KEY_MAC				"mac"
+#define JSON_KEY_SIGN				"sign"
+#define JSON_KEY_FMTEST		        "test"
+#define JSON_KEY_STATUS		        "statusCode"
+#define JSON_KEY_SERPBLICKEY		"serverPublicKey"
+#define JSON_KEY_CLIENTPRIKEY		"clientPrivateKey"
+
+#define CFG_KEY						"template"
+#define TMP_JSON					"json.ini"
+#define DB_ORDER					"order.db"
+#define DB_TABLE_NAME				"orderlist"
+#define MAX_ORDERID_LEN				200
+
+#endif

sbkpay/control.cpp

@@ -5,7 +5,6 @@
 #include "QsLog.h"
 #include "jsonfactory.h"
 #include "rspfactory.h"
-#include "xmlreader.h"
 
 #include <QtConcurrent>
 #include <QSettings>
@@ -315,26 +314,6 @@ bool Control::SendMessageToSBKAPI(const QJsonObject &json, QByteArray &outdata,
                         return QByteArray();
                     }
                     return returnStr.toUtf8();
-
-//                    XMLReader reader;
-//                    if(!reader.parser(QString::fromUtf8(out))) {
-//                        error = "OLTP return xml parser error: " + reader.errorString;
-//                        QLOG_ERROR() << error;
-//                        return QByteArray();
-//                    } else {
-
-//                        QList<QDomNode> outElements = reader.findElements("ns0:AP");
-//                        if(outElements.length() != 1) {
-//                            error = "OLTP return xml can't find ns0:AP";
-//                            return QByteArray();
-//                        } else {
-//                            QDomNode node = outElements.first().firstChild();
-//                            QString text = node.nodeValue();
-//                            QLOG_INFO() << "OLTP JSON: " << text;
-//                            return text.toUtf8();
-//                        }
-//                    }
-
                 }
 
                 return QByteArray(out);

sbkpay/jsonfactory.h

@@ -189,9 +189,12 @@ private:
         json.insert(JSON_KEY_STATIONID, FMTool::GetString((const void *)&(request.DeviceNo), 6));
         json.insert(JSON_KEY_ENDTIME, FMTool::GetString((const void *)&(request.BusinessDay), 8).append( FMTool::GetString((const void *)&(request.TransTime), 6)));
         json.insert(JSON_KEY_PARTORDERID, FMTool::GetString((const void *)&(request.Reserved1), 64));
+        json.insert(JSON_KEY_PRINTACTION, QString("103"));
 
         return true;
     }
+
+	
     static bool GetEnddayJson(QJsonObject &json, const QJsonObject &request, QStringList list)
     {
         Q_UNUSED(list)

sbkpay/main.cpp

@@ -77,6 +77,9 @@ extern "C" __declspec(dllexport) void Start(const char *indata, char *outdata)
 #include "rspfactory.h"
 #include <QDir>
 #include <QApplication>
+#include <QStringList>
+#include "DataProcess/dataprocess.h"
+#include "DataProcess/cretopt.h"
 
 void TestSetString()
 {
@@ -198,6 +201,62 @@ void TestDllFmclient()
 
 }
 
+void TestDataProcess()
+{
+    QJsonObject json;
+    QJsonObject obj;
+
+    json.insert("awqwe", 2);
+    json.insert("Sklhfwj", "hello");
+    json.insert("oiueqw","");
+    json.insert("sign","jeqweqwje287398217");
+
+    obj.insert("ldd", "hahahah");
+
+    json.insert("lcd", obj);
+
+    qDebug() << json;
+
+    QStringList list;
+
+    DataProcess::GetJsonKeyArray(list, json);
+
+    qDebug() << "not sort" << list;
+
+    DataProcess::SortString(list);
+
+    qDebug() << "sort" << list;
+
+    QString value;
+
+    DataProcess::GetValueFromJson(list, json, value);
+
+    qDebug() << value;
+
+}
+
+void TestCret()
+{
+    QJsonObject json;
+    QJsonObject obj;
+    QString sign;
+
+    json.insert("awqwe", 2);
+    json.insert("Sklhfwj", "hello");
+    json.insert("oiueqw","");
+    json.insert("sign","jeqweqwje287398217");
+
+    obj.insert("ldd", "hahahah");
+
+    json.insert("lcd", obj);
+
+    qDebug() << json;
+
+    CretOperate::GetSign(json, sign);
+
+    qDebug() << json;
+}
+
 int main(int argc, char *argv[])
 {
 
@@ -232,6 +291,11 @@ int main(int argc, char *argv[])
     //
     //TestDllFmclient();
 
+    //pass
+    TestDataProcess();
+
+    TestCret();
+
     qDebug() << "1212367123";
 
     AlipayRequest req;
@@ -244,9 +308,9 @@ int main(int argc, char *argv[])
     FMTool::SetString(req.DeviceNo, 6 , QString("1"));
     FMTool::SetString(req.CashierNo, 6 , QString("0123"));
     FMTool::SetString(req.CashTraceNo, 6 , QString("16723"));
-    FMTool::SetString(req.OriginTrace, 64 , QString("7871170818A00002005"));
+    FMTool::SetString(req.OriginTrace, 64 , QString(""));
     FMTool::SetString(req.Amount, 12, QString("1"));
-    FMTool::SetString(req.Reserved1, 48 , QString("12411235821335894422"));
+    FMTool::SetString(req.Reserved1, 48 , QString("1365670843098735894422"));
     req.item_line_qty[0] = '2';
     req.item_line_qty[1] = ' ';
 

sbkpay/sbkpay.pro

@@ -4,14 +4,14 @@
 #
 #-------------------------------------------------
 
-QT       += core gui concurrent xml
+QT       += core gui concurrent sql
 
 greaterThan(QT_MAJOR_VERSION, 4): QT += widgets
 
 TARGET = sbkpay
 
 include("./QsLog/QsLog.pri")
-
+include("./DataProcess/DataProcess.pri")
 
 CONFIG += C++11 SBKDLL1
 
@@ -37,8 +37,7 @@ release {
 SOURCES += main.cpp\
         hostwidget.cpp \
     control.cpp \
-    labelstimer.cpp \
-    xmlreader.cpp
+    labelstimer.cpp
 
 HEADERS  += hostwidget.h \
     fmp_window.h \
@@ -51,8 +50,7 @@ HEADERS  += hostwidget.h \
     jsonfactory.h \
     labelstimer.h \
     rspfactory.h \
-    reqfactory.h \
-    xmlreader.h
+    reqfactory.h
 
 FORMS    += hostwidget.ui