add easy-encryption as files

Author: RichardGe

contrib/easy-encryption/.github/FUNDING.yml

@@ -0,0 +1 @@
+github: [philipperemy]

contrib/easy-encryption/.gitignore

@@ -0,0 +1,34 @@
+# Prerequisites
+*.d
+
+# Compiled Object files
+*.slo
+*.lo
+*.o
+*.obj
+
+# Precompiled Headers
+*.gch
+*.pch
+
+# Compiled Dynamic libraries
+*.so
+*.dylib
+*.dll
+
+# Fortran module files
+*.mod
+*.smod
+
+# Compiled Static libraries
+*.lai
+*.la
+*.a
+*.lib
+
+# Executables
+*.exe
+*.out
+*.app
+
+a.out

contrib/easy-encryption/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2018 Philippe Rémy
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

contrib/easy-encryption/README.md

@@ -0,0 +1,101 @@
+# Easy Encryption
+A very simple standalone C++ module (API) to obfuscate/deobfuscate strings based on B64 and Vigenere ciper (symmetric cipher).
+
+**DISCLAIMER: This encryption is NOT secure and can be used as a "cheap way" to obfuscate some messages in a communication channel. If you need a solid and unbreakable encryption, please use a widely adopted standard and well researched cipher like AES-GCM.** You can find more information there: [pyca](https://github.com/pyca/cryptography).
+
+
+It works as follows:
+
+- Alice encodes in base64 the message, then uses the Vigenere private key to encrypt the message.
+- The encrypted message is sent through an unsecured channel.
+- Bob gets the message and decrypts it with the Vigenere private key. He then decodes it with base64.
+
+Diagram summary:
+_______________________________________________________________________________________________________________
+**Message -> B64 ENCODE -> VIGENERE ENCRYPT -> encrypted message -> VIGENERE DECRYPT -> B64 DECODE -> Message**
+_______________________________________________________________________________________________________________
+
+The reason why we apply b64 encode BEFORE Vigenere is because it's very easy for somebody to apply a b64 decode and see about the structure of the message. For example, if we send `{"hello":123}`, an attacker can sniff the message, b64 decode the message and get `{"qsggn":ygf}`. Of course the attacker still needs the Vigenere cipher key, but at least, he can get a pretty clear idea that JSON format messages are sent in the communication channel. The way to avoid this is to encode first in b64 then encrypt it with the Vigenere key. If the attacker tries to b64 decode first, it will see a random string of weird characters.
+
+## API
+
+### C++
+
+- **Encrypt message**
+```c++
+std::string encrypt(std::string& msg, std::string& key)
+```
+
+- **Decrypt message**
+```c++
+std::string decrypt(std::string& encrypted_msg, std::string& key)
+```
+
+### Python
+
+- **Encrypt message**
+```python
+wrapper.encrypt(message, key): returns encrypted message
+```
+
+- **Decrypt message**
+```python
+wrapper.decrypt(encrypted_message, key): returns decrypted message
+```
+
+## Compilation and execution
+```bash
+g++ cl.cpp
+./a.out "Hello world" MYPRIVATEKEY 0
+```
+
+The encrypted message is: `ttz9JqxZHBClNtu=`.
+
+```bash
+./a.out ttz9JqxZHBClNtu= MYPRIVATEKEY 1
+```
+
+The decrypted message is `Hello world`.
+
+## Python wrapper
+
+```bash
+rm a.out
+g++ cl.cpp
+python3 wrapper.py
+```
+
+## Example - Encoding/Decoding JSON format
+
+### Source code
+```c++
+#include <stdio.h>
+#include <string.h>
+#include <string>
+#include <iostream>
+#include <stdio.h>
+#include <ctype.h>
+#include "encrypt.h"
+
+using namespace std;
+
+int main() {
+ 	// std::string msg = "HELLO WORLD";
+ 	std::string msg = "{\"id\":1,\"method\":\"service.subscribe\",\"params\":[\"myapp/0.1c\", null,\"0.0.0.0\",\"80\"]}";
+ 	std::string key = "THISISMYKEY";
+ 	std::cout << "  message to send: " << msg << std::endl;
+ 	std::string encrypted_msg = encrypt(msg, key);
+ 	std::cout << "encrypted message: " << encrypted_msg << std::endl;
+ 	std::string decrypted_msg = decrypt(encrypted_msg, key);
+ 	std::cout << "decrypted message: " << decrypted_msg << std::endl;
+    return 0;
+}
+
+```
+
+### Output
+```
+  message to send: {"id":1,"method":"service.subscribe","params":["myapp/0.1c", null,"0.0.0.0","80"]}
+encrypted message: X5g7wjjTllj1ItCxShWUb77PKJsfP VNMAB7VtqaLCccGTr0ijkjxqw0IutQvXfSFK4OKo8cnpD1Lge0pdMCZf0fqQ8bjjFjkNn1h pBtdwNJD==
+decrypted message: {"id":1,"method":"service.subscribe","params":["myapp/0.1c", null,"0.0.0.0","80"]}
+```

contrib/easy-encryption/b64.h

@@ -0,0 +1,47 @@
+#include <string>
+#include <sstream>
+#include <iostream>
+#include <vector>
+
+using namespace std;
+
+
+static std::string base64_encode(const std::string &in) {
+
+    std::string out;
+
+    int val=0, valb=-6;
+    for (int jj = 0; jj < in.size(); jj++) {
+    	char c = in[jj];
+        val = (val<<8) + c;
+        valb += 8;
+        while (valb>=0) {
+            out.push_back("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"[(val>>valb)&0x3F]);
+            valb-=6;
+        }
+    }
+    if (valb>-6) out.push_back("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"[((val<<8)>>(valb+8))&0x3F]);
+    while (out.size()%4) out.push_back('=');
+    return out;
+}
+
+static std::string base64_decode(const std::string &in) {
+
+    std::string out;
+
+    std::vector<int> T(256,-1);
+    for (int i=0; i<64; i++) T["ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"[i]] = i; 
+
+    int val=0, valb=-8;
+    for (int jj = 0; jj < in.size(); jj++) {
+    	char c = in[jj];
+        if (T[c] == -1) break;
+        val = (val<<6) + T[c];
+        valb += 6;
+        if (valb>=0) {
+            out.push_back(char((val>>valb)&0xFF));
+            valb-=8;
+        }
+    }
+    return out;
+}

contrib/easy-encryption/bin/centos7/ee64

@@ -0,0 +1,67 @@
+#include <stdio.h>
+#include <string.h>
+#include <string>
+#include <iostream>
+#include <stdio.h>
+#include <ctype.h>
+#include <fstream>
+#include "encrypt.h"
+
+using namespace std;
+
+string load( const char* path )
+{
+    FILE* src = fopen(path, "rb");
+    string res;
+
+    fseek(src,0,SEEK_END);
+    int size = ftell(src);
+	rewind( src );
+	res.resize(size);
+    fread(const_cast<char*>(res.data()), size, 1, src);
+    fclose(src);
+    return res;
+}
+
+void write( const char* path, string& str )
+{
+# if 1
+    FILE* fp = fopen( path, "wb" );
+    fwrite( str.c_str(), strlen( str.c_str() ), 1, fp );
+    fclose( fp );
+#else
+    ofstream ofs(path);
+    ofs << str;
+    ofs.close();    
+#endif
+}
+
+int main(int argc, char** argv) 
+{
+//ee64 src.txt dst.txt key 0
+#if 1
+    std::string key = argv[3];
+    int encrypt_flag = atoi(argv[4]);
+
+    string src = load( argv[1] );
+    string dst;
+    if(encrypt_flag == 0) {
+        dst = encrypt(src, key);
+    } else {
+        dst = decrypt(src, key);
+    }
+
+    write( argv[2], dst );
+#else
+ 	std::string msg = argv[1];
+ 	std::string key = argv[2];
+ 	int encrypt_flag = atoi(argv[3]);
+
+ 	if(encrypt_flag == 0) {
+ 	    std::cout << encrypt(msg, key) << std::endl;
+ 	} else {
+ 	    std::cout << decrypt(msg, key) << std::endl;
+ 	}
+#endif
+    return 0;
+}

contrib/easy-encryption/bin/linux/ee64

@@ -0,0 +1,17 @@
+#include "b64.h"
+#include "vigenere.h"
+
+std::string encrypt(std::string& msg, std::string& key) {
+	std::string b64_str = base64_encode(msg);
+	std::string vigenere_msg = encrypt_vigenere(b64_str, key);
+	// std::cout << vigenere_msg << std::endl;
+	return vigenere_msg;
+}
+
+
+std::string decrypt(std::string& encrypted_msg, std::string& key) {
+	std::string newKey = extend_key(encrypted_msg, key);
+	std::string b64_encoded_str = decrypt_vigenere(encrypted_msg, newKey);
+	std::string b64_decode_str = base64_decode(b64_encoded_str);
+	return b64_decode_str;
+}