DragonX/SilentDragonXLite
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 1 Wiki Activity

comments for debug issues

Browse Source
This commit is contained in:
DenioD
2020-05-31 00:29:03 +02:00
parent cb78f2432e
commit 55b1148047
1 changed files with 102 additions and 111 deletions
Download Patch File Download Diff File Expand all files Collapse all files

207
src/chatmodel.cpp
View File

@@ -372,19 +372,21 @@ Tx MainWindow::createTxFromChatPage() {
QString hmemo= createHeaderMemo(type,cid,myAddr); QString hmemo= createHeaderMemo(type,cid,myAddr);
/////////User input for chatmemos
QString memounencrypt = ui->memoTxtChat->toPlainText().trimmed(); QString memounencrypt = ui->memoTxtChat->toPlainText().trimmed();
/////////We convert the user input from QString to unsigned char*, so we can encrypt it later
int length = memounencrypt.length(); int length = memounencrypt.length();
char *sequence = NULL; char *sequence = NULL;
sequence = new char[length+1]; sequence = new char[length+1];
strncpy(sequence, memounencrypt.toLocal8Bit(), length +1); strncpy(sequence, memounencrypt.toLocal8Bit(), length +1);
////////////////////////////////////////////////////Important: If we can decrypt the output of QString memo, after we encrypt it, Bobs code must be in Controller.cpp //////////////////////////////////////////////////Lets create Alice keys for the conversation///////////////////////////////////
/////////////////Alice Pubkey /////////////////Alice Pubkey
#define MESSAGEAP ((const unsigned char *) "Ioesd") #define MESSAGEAP ((const unsigned char *) "Ioesd")///////////static atm, in future we will use the CID here
#define MESSAGEAP_LEN 5 #define MESSAGEAP_LEN 5
unsigned char alice_publickey[crypto_secretstream_xchacha20poly1305_KEYBYTES]; unsigned char alice_publickey[crypto_secretstream_xchacha20poly1305_KEYBYTES];
@@ -398,7 +400,7 @@ Tx MainWindow::createTxFromChatPage() {
/////////////////Alice Secretkey /////////////////Alice Secretkey
#define MESSAGEAS ((const unsigned char *) "Hallo") #define MESSAGEAS ((const unsigned char *) "Hallo")///////////static atm, in future we will use the Passphrase here
#define MESSAGEAS_LEN 5 #define MESSAGEAS_LEN 5
unsigned char alice_secretkey[crypto_secretstream_xchacha20poly1305_KEYBYTES]; unsigned char alice_secretkey[crypto_secretstream_xchacha20poly1305_KEYBYTES];
@@ -408,7 +410,7 @@ Tx MainWindow::createTxFromChatPage() {
NULL, 0); NULL, 0);
/////////////////Bob Pubkey that Alice creates /////////////////Bob Pubkey that Alice creates
#define MESSAGEBAP ((const unsigned char *) "Hal11") #define MESSAGEBAP ((const unsigned char *) "Hal11")///////////static atm, in future we will use the CID here
#define MESSAGEBAP_LEN 5 #define MESSAGEBAP_LEN 5
unsigned char bob_publickey[crypto_secretstream_xchacha20poly1305_KEYBYTES]; unsigned char bob_publickey[crypto_secretstream_xchacha20poly1305_KEYBYTES];
@@ -420,55 +422,67 @@ Tx MainWindow::createTxFromChatPage() {
qDebug()<<"Alice version of Bobs Pubkey created"; qDebug()<<"Alice version of Bobs Pubkey created";
////////////Alice creates the Shared key ////////////Now we create shared keys for the conversation//////////////////////////////
unsigned char server_rx[crypto_kx_SESSIONKEYBYTES], server_tx[crypto_kx_SESSIONKEYBYTES];
/* Generate the server's key pair */
crypto_kx_keypair(alice_publickey, alice_secretkey);
/* Prerequisite after this point: the client's public key must be known by the server */ unsigned char server_rx[crypto_kx_SESSIONKEYBYTES], server_tx[crypto_kx_SESSIONKEYBYTES];
/* Generate the server's key pair */
crypto_kx_keypair(alice_publickey, alice_secretkey);
/* Compute two shared keys using the client's public key and the server's secret key. /* Prerequisite after this point: the client's public key must be known by the server */
server_rx will be used by the server to receive data from the client,
server_tx will by used by the server to send data to the client. */ /* Compute two shared keys using the client's public key and the server's secret key.
if (crypto_kx_server_session_keys(server_rx, server_tx, server_rx will be used by the server to receive data from the client,
alice_publickey, alice_secretkey, bob_publickey) != 0) { server_tx will by used by the server to send data to the client. */
if (crypto_kx_server_session_keys(server_rx, server_tx,
alice_publickey, alice_secretkey, bob_publickey) != 0) {
/* Suspicious client public key, bail out */ /* Suspicious client public key, bail out */
} }
////////////Now lets encrypt the message Alice send to Bob//////////////////////////////
#define MESSAGE (const unsigned char *) sequence #define MESSAGE (const unsigned char *) sequence
#define MESSAGE_LEN length #define MESSAGE_LEN length
#define CIPHERTEXT_LEN (MESSAGE_LEN + crypto_secretstream_xchacha20poly1305_ABYTES) #define CIPHERTEXT_LEN (MESSAGE_LEN + crypto_secretstream_xchacha20poly1305_ABYTES)
crypto_secretstream_xchacha20poly1305_state state;
//unsigned char header[crypto_secretstream_xchacha20poly1305_HEADERBYTES]; crypto_secretstream_xchacha20poly1305_state state;
unsigned char c1[CIPHERTEXT_LEN]; /////The Header must be known by both, so we can use alice or bobs pubkey here
//unsigned char header[crypto_secretstream_xchacha20poly1305_HEADERBYTES];
unsigned char c1[CIPHERTEXT_LEN];
/* Shared secret key required to encrypt/decrypt the stream */
crypto_secretstream_xchacha20poly1305_keygen(alice_publickey);
/* Set up a new stream: initialize the state and create the header */
////////////Bobs pubkey will be use as header here, and alice_publickey as Key. Just for testing, we will switch to server_tx here //////////////////////////////
crypto_secretstream_xchacha20poly1305_init_push(&state, bob_publickey, alice_publickey);
////Now encrypt the Message///////////////////////////////////
crypto_secretstream_xchacha20poly1305_push
(&state, c1, NULL, MESSAGE, MESSAGE_LEN, NULL, 0, 0);
///////////Ciphertext is now in c1 as unsigned char*, we need it as QString, to send it as memo to Bob//////////////////////
/////This is not working. It seems the QString has not exact the ciphertext in it. It will not decrypt with it////////////////
QString memo( reinterpret_cast< char* >( c1 ) );
qDebug()<<"Size QString with encrypted data :"<< memo.length(); ////We check the length here, to compare it with the length our QString
///////Just for testing we convert the unsigned char* to std::string, to see if we can decrypt,and that works.////////////
std::string encryptedMemo(reinterpret_cast<char*>(c1), CIPHERTEXT_LEN);
/* Shared secret key required to encrypt/decrypt the stream */ qDebug()<<"Size std::string with encrypted data :"<< encryptedMemo.length(); ////We check the length here, to compare it with the length our QString
crypto_secretstream_xchacha20poly1305_keygen(alice_publickey);
/* Set up a new stream: initialize the state and create the header */
crypto_secretstream_xchacha20poly1305_init_push(&state, bob_publickey, alice_publickey);
/* Now, encrypt the first chunk. `c1` will contain an encrypted,
* authenticated representation of `MESSAGE_PART1`. */
crypto_secretstream_xchacha20poly1305_push
(&state, c1, NULL, MESSAGE, MESSAGE_LEN, NULL, 0, 0);
///////////get a std:string....QString will give us not good results
std::string encryptedMemo(reinterpret_cast<char*>(c1), CIPHERTEXT_LEN); /////////////////////////////////Now we create Bobs keys, just for testing at this place. If the encryption/decryption works we put it in Controller.cpp (RefreshTransactions)
qDebug()<<"Size Controller Memo :"<< encryptedMemo.length(); /////////////////Bob Pubkey/////////////////////////////////
#define MESSAGEBAP1 ((const unsigned char *) "Hal12")///////////static atm, in future we will use the CID here
QString memo = QString::fromUtf8( encryptedMemo.data(), encryptedMemo.size());
/////////////////Bob Pubkey
#define MESSAGEBAP1 ((const unsigned char *) "Hal12")
#define MESSAGEBAP1_LEN 5 #define MESSAGEBAP1_LEN 5
unsigned char bob1_publickey[crypto_secretstream_xchacha20poly1305_KEYBYTES]; unsigned char bob1_publickey[crypto_secretstream_xchacha20poly1305_KEYBYTES];
@@ -480,7 +494,7 @@ crypto_secretstream_xchacha20poly1305_push
qDebug()<<"Bobs Pubkey created"; qDebug()<<"Bobs Pubkey created";
/////////////////Bob Secretkey /////////////////Bob Secretkey
#define MESSAGEBS ((const unsigned char *) "Hal11") #define MESSAGEBS ((const unsigned char *) "Hal11")///////////static atm, in future we will use the Passphrase here
#define MESSAGEBS_LEN 5 #define MESSAGEBS_LEN 5
unsigned char bob_secretkey[crypto_secretstream_xchacha20poly1305_HEADERBYTES]; unsigned char bob_secretkey[crypto_secretstream_xchacha20poly1305_HEADERBYTES];
@@ -492,7 +506,7 @@ crypto_secretstream_xchacha20poly1305_push
qDebug()<<"Bobs Pubkey created"; qDebug()<<"Bobs Pubkey created";
/////////////////Alice Pubkey bob creates /////////////////Alice Pubkey bob creates
#define MESSAGEA121 ((const unsigned char *) "Ioesd") #define MESSAGEA121 ((const unsigned char *) "Ioesd")///////////static atm, in future we will use the CID here
#define MESSAGEAP121_LEN 5 #define MESSAGEAP121_LEN 5
unsigned char alice1_publickey[crypto_secretstream_xchacha20poly1305_KEYBYTES]; unsigned char alice1_publickey[crypto_secretstream_xchacha20poly1305_KEYBYTES];
@@ -507,104 +521,81 @@ crypto_secretstream_xchacha20poly1305_push
////////////BOB creates the Shared key ////////////Now we create the shared keys for Bob///////////////////////////////////////////////
//unsigned char bob_publickey[crypto_kx_PUBLICKEYBYTES], bob_secretkey[crypto_kx_SECRETKEYBYTES];
unsigned char client_rx[crypto_kx_SESSIONKEYBYTES], client_tx[crypto_kx_SESSIONKEYBYTES];
/* Generate the client's key pair */ unsigned char client_rx[crypto_kx_SESSIONKEYBYTES], client_tx[crypto_kx_SESSIONKEYBYTES];
crypto_kx_keypair(bob1_publickey, bob_secretkey);
/* Prerequisite after this point: the server's public key must be known by the client */ /* Generate the client's key pair */
crypto_kx_keypair(bob1_publickey, bob_secretkey);
/* Compute two shared keys using the server's public key and the client's secret key. /* Prerequisite after this point: the server's public key must be known by the client */
client_rx will be used by the client to receive data from the server,
client_tx will by used by the client to send data to the server. */
if (crypto_kx_client_session_keys(client_rx, client_tx,
bob1_publickey, bob_secretkey, alice1_publickey) != 0) {
/* Suspicious server public key, bail out */
}
qDebug()<<"1 : "; /* Compute two shared keys using the server's public key and the client's secret key.
client_rx will be used by the client to receive data from the server,
client_tx will by used by the client to send data to the server. */
if (crypto_kx_client_session_keys(client_rx, client_tx,
bob1_publickey, bob_secretkey, alice1_publickey) != 0) {
/* Suspicious server public key, bail out */
}
qDebug()<<"Size of QString memo send as Transaction:" << memo.length();
QString memo1 = QString::fromUtf8( encryptedMemo.data(), encryptedMemo.size());
int lenght1 = encryptedMemo.length();
qDebug()<<"std::string Memo size : "<<encryptedMemo.length();
///////////////Now we simuldate the decryption. Our memo comes as QString, so we have to convert it again to unsigned char*////////////////////
////QString to char+ (not working, it will not decrypt) ////QString to char+ (not working, it will not decrypt)
/*char *sequence1 = NULL; /*char *memoIncoming = NULL;
sequence1 = new char[lenght1-1]; memoIncoming = new char[lenght1+1];
strncpy(sequence1, memo1.toLocal8Bit(), lenght1-1);*/ strncpy(memoIncoming, memo.toLocal8Bit(), lenght1+1);*/
qDebug()<<" Memo Size from QString to std::string" << lenght1; ///////////////////////////if we take the std::string (of the encryption output) instead of QString memo, it will decrypt////////
///////////////////////////if we take the std::string (of the encryption output) instead of QString memo, it will decrypt
/////////////Convert std::string to unsigned char*/////////////////////
unsigned char *pwa=new unsigned char[encryptedMemo.length()]; unsigned char *pwa=new unsigned char[encryptedMemo.length()];
strncpy((char *)pwa,encryptedMemo.c_str(), encryptedMemo.length()); strncpy((char *)pwa,encryptedMemo.c_str(), encryptedMemo.length());
//////Message in std::string dann in char (Message ist Ciphertext!!!!) //////We set the values to decrypt the message///////////////////////////////
#define MESSAGE2 (const unsigned char *) pwa
#define CIPHERTEXT1_LEN lenght1
#define MESSAGE1_LEN lenght1 - crypto_secretstream_xchacha20poly1305_ABYTES
unsigned char tag;
unsigned char m2[lenght1 - crypto_secretstream_xchacha20poly1305_ABYTES]; //////unsigned char* as message from std::string
#define MESSAGE2 (const unsigned char *) pwa
///////// length of the encrypted message
//crypto_secretstream_xchacha20poly1305_state state; #define CIPHERTEXT1_LEN encryptedMemo.length()
///////Message length is smaller then the encrypted message
#define MESSAGE1_LEN encryptedMemo.length() - crypto_secretstream_xchacha20poly1305_ABYTES
///////we could use tags here
/* Shared secret key required to encrypt/decrypt the stream */ unsigned char tag;
//crypto_secretstream_xchacha20poly1305_keygen(alice1_publickey);
/* Set up a new stream: initialize the state and create the header */
//crypto_secretstream_xchacha20poly1305_init_push(&state, alice_publickey, client_rx);
//////Set the length of the decrypted message
unsigned char m[MESSAGE1_LEN];
///////In future we use the shared keys here//////
/* Shared secret key required to encrypt/decrypt the stream */
//crypto_secretstream_xchacha20poly1305_keygen(alice1_publickey);
/* Set up a new stream: initialize the state and create the header */
//crypto_secretstream_xchacha20poly1305_init_push(&state, alice_publickey, client_rx);
////////Again, we use Bobs pubkey as header and alice pubkey as key
/* Decrypt the stream: initializes the state, using the key and a header */ /* Decrypt the stream: initializes the state, using the key and a header */
if (crypto_secretstream_xchacha20poly1305_init_pull(&state, bob_publickey, alice_publickey) != 0) { if (crypto_secretstream_xchacha20poly1305_init_pull(&state, bob_publickey, alice_publickey) != 0) {
/* Invalid header, no need to go any further */ /* Invalid header, no need to go any further */
} }
//////And decrypt it
/* Decrypt the first chunk. A real application would probably use
* a loop, that reads data from the network or from disk, and exits after
* an error, or after the last chunk (with a `TAG_FINAL` tag) has been
* decrypted. */
if (crypto_secretstream_xchacha20poly1305_pull if (crypto_secretstream_xchacha20poly1305_pull
(&state, m2, NULL, &tag, MESSAGE2, encryptedMemo.length(), NULL, 0) != 0) { (&state, m, NULL, &tag, MESSAGE2, encryptedMemo.length(), NULL, 0) != 0) {
/* Invalid/incomplete/corrupted ciphertext - abort */ /* Invalid/incomplete/corrupted ciphertext - abort */
} }
/* The tag indicates that this is the final chunk, no need to read and decrypt more */ /////Our decrypted message is now in m. We need it as QString to render it
/////Only the QString gives weird data, so convert first to std::string
std::string decryptedMemo(reinterpret_cast<char*>(m),MESSAGE1_LEN);
//QString memodecrypt = QString::fromLocal8Bit((char*)m2); /////Now we can convert it to QString
std::string decryptedMemo(reinterpret_cast<char*>(m2),MESSAGE_LEN); QString memodecrypt = QString::fromUtf8( decryptedMemo.data(), decryptedMemo.size());
qDebug()<<"7: ";
QString memodecrypt = QString::fromUtf8( decryptedMemo.data(), decryptedMemo.size());
qDebug()<<"OUT decrypt:" << memodecrypt;
//////////////Give us the output of the decrypted message as debug to see if it was successfully
qDebug()<<"OUT decrypt:" << memodecrypt;
tx.toAddrs.push_back(ToFields{addr, amt, hmemo}); tx.toAddrs.push_back(ToFields{addr, amt, hmemo});
tx.toAddrs.push_back(ToFields{addr, amt, memo}); tx.toAddrs.push_back(ToFields{addr, amt, memo});