mirror of
https://github.com/DoubleLabyrinth/navicat-keygen.git
synced 2019-12-02 05:10:56 +00:00
Compare commits
| Author | SHA1 | Date | |
|---|---|---|---|
 Double Sine
|
432e647fe1 | ||
|
Double Sine
|
618190dde3 | ||
|
Double Sine
|
e1f5900770 | ||
|
Double Sine
|
a15d77bfc9 | ||
|
Double Sine
|
93f355e604 | ||
|
Double Sine
|
8f0986e00e | ||
|
Double Sine
|
286f48c9e0 | ||
|
Double Sine
|
4af61a272b | ||
|
Double Sine
|
0b3bb309b2 | ||
|
Double Sine
|
2f04767075 |
@@ -22,6 +22,92 @@
|
||||
|
||||
If you have the corresponding private key, please tell me. I would be very appreciated for your generous.
|
||||
|
||||
__NOTICE:__
|
||||
|
||||
Start from __Navicat Premium 12.0.25__, Navicat do not load this public key from resource in `navicat.exe`. Actually the public key is stored in `libcc.dll` and encrypted. And to avoid being replaced easily, the public key is split into 5 parts:
|
||||
|
||||
The content below is discovered from `libcc.dll` of Navicat Premium x64 12.0.25 Simplified Chinese version. SHA256 value is `607e0a84c75966b00f3d12fa833e91d159e4f51ac51b6ba66f98d0c3cbefdce0`. I do not guaranteed that __offset__ value is absolutely correct in other versions. But __char string__ and __immediate values__ is highly possible to be found.
|
||||
|
||||
1. At file offset `+ 0x1A12090` in `libcc.dll`, stored as __char string__:
|
||||
|
||||
> "D75125B70767B94145B47C1CB3C0755E
|
||||
> 7CCB8825C5DCE0C58ACF944E08280140
|
||||
> 9A02472FAFFD1CD77864BB821AE36766
|
||||
> FEEDE6A24F12662954168BFA314BD950
|
||||
> 32B9D82445355ED7BC0B880887D650F5"
|
||||
|
||||
2. At file offset `+ 0x59D799` in `libcc.dll`, stored as __immediate value__ in a instruction:
|
||||
|
||||
> 0xFE 0xEA 0xBC 0x01
|
||||
|
||||
In decimal: `29158142`
|
||||
|
||||
3. At file offset `+ 0x1A11DA0` in `libcc.dll`, stored as __char string__:
|
||||
|
||||
> "E1CED09B9C2186BF71A70C0FE2F1E0AE
|
||||
> F3BD6B75277AAB20DFAF3D110F75912B
|
||||
> FB63AC50EC4C48689D1502715243A79F
|
||||
> 39FF2DE2BF15CE438FF885745ED54573
|
||||
> 850E8A9F40EE2FF505EB7476F95ADB78
|
||||
> 3B28CA374FAC4632892AB82FB3BF4715
|
||||
> FCFE6E82D03731FC3762B6AAC3DF1C3B
|
||||
> C646FE9CD3C62663A97EE72DB932A301
|
||||
> 312B4A7633100C8CC357262C39A2B3A6
|
||||
> 4B224F5276D5EDBDF0804DC3AC4B8351
|
||||
> 62BB1969EAEBADC43D2511D6E0239287
|
||||
> 81B167A48273B953378D3D2080CC0677
|
||||
> 7E8A2364F0234B81064C5C739A8DA28D
|
||||
> C5889072BF37685CBC94C2D31D0179AD
|
||||
> 86D8E3AA8090D4F0B281BE37E0143746
|
||||
> E6049CCC06899401264FA471C016A96C
|
||||
> 79815B55BBC26B43052609D9D175FBCD
|
||||
> E455392F10E51EC162F51CF732E6BB39
|
||||
> 1F56BBFD8D957DF3D4C55B71CEFD54B1
|
||||
> 9C16D458757373E698D7E693A8FC3981
|
||||
> 5A8BF03BA05EA8C8778D38F9873D62B4
|
||||
> 460F41ACF997C30E7C3AF025FA171B5F
|
||||
> 5AD4D6B15E95C27F6B35AD61875E5505
|
||||
> 449B4E"
|
||||
|
||||
4. At file offset `+ 0x59D77F` in `libcc.dll`, stored as __immediate value__ in a instruction:
|
||||
|
||||
> 0x59 0x08 0x01 0x00 (in decimal )
|
||||
|
||||
In decimal: `67673`
|
||||
|
||||
5. At file offset `+ 0x1A11D8C` in `libcc.dll`, stored as __char string__:
|
||||
|
||||
> "92933"
|
||||
|
||||
Then output encrypted public key with format `"%s%d%s%d%s"`, the order is the same as it list:
|
||||
|
||||
> D75125B70767B94145B47C1CB3C0755E7CCB8825C5DCE0C58ACF944E082801409A02472FAFFD1CD77864BB821AE36766FEEDE6A24F12662954168BFA314BD95032B9D82445355ED7BC0B880887D650F529158142E1CED09B9C2186BF71A70C0FE2F1E0AEF3BD6B75277AAB20DFAF3D110F75912BFB63AC50EC4C48689D1502715243A79F39FF2DE2BF15CE438FF885745ED54573850E8A9F40EE2FF505EB7476F95ADB783B28CA374FAC4632892AB82FB3BF4715FCFE6E82D03731FC3762B6AAC3DF1C3BC646FE9CD3C62663A97EE72DB932A301312B4A7633100C8CC357262C39A2B3A64B224F5276D5EDBDF0804DC3AC4B835162BB1969EAEBADC43D2511D6E023928781B167A48273B953378D3D2080CC06777E8A2364F0234B81064C5C739A8DA28DC5889072BF37685CBC94C2D31D0179AD86D8E3AA8090D4F0B281BE37E0143746E6049CCC06899401264FA471C016A96C79815B55BBC26B43052609D9D175FBCDE455392F10E51EC162F51CF732E6BB391F56BBFD8D957DF3D4C55B71CEFD54B19C16D458757373E698D7E693A8FC39815A8BF03BA05EA8C8778D38F9873D62B4460F41ACF997C30E7C3AF025FA171B5F5AD4D6B15E95C27F6B35AD61875E5505449B4E6767392933
|
||||
|
||||
This encrypted public key can be decrypted by my another repo: [how-does-navicat-encrypt-password](https://github.com/DoubleLabyrinth/how-does-navicat-encrypt-password), while the key used is `b'23970790'`
|
||||
|
||||
Example:
|
||||
|
||||
```cmd
|
||||
E:\GitHub>git clone https://github.com/DoubleLabyrinth/how-does-navicat-encrypt-password.git
|
||||
...
|
||||
E:\GitHub>cd how-does-navicat-encrypt-password\python3
|
||||
E:\GitHub\how-does-navicat-encrypt-password\python3>python
|
||||
Python 3.6.3 (v3.6.3:2c5fed8, Oct 3 2017, 18:11:49) [MSC v.1900 64 bit (AMD64)] on win32
|
||||
Type "help", "copyright", "credits" or "license" for more information.
|
||||
>>> from NavicatCrypto import *
|
||||
>>> cipher = Navicat11Crypto(b'23970790')
|
||||
>>> print(cipher.DecryptString('D75125B70767B94145B47C1CB3C0755E7CCB8825C5DCE0C58ACF944E082801409A02472FAFFD1CD77864BB821AE36766FEEDE6A24F12662954168BFA314BD95032B9D82445355ED7BC0B880887D650F529158142E1CED09B9C2186BF71A70C0FE2F1E0AEF3BD6B75277AAB20DFAF3D110F75912BFB63AC50EC4C48689D1502715243A79F39FF2DE2BF15CE438FF885745ED54573850E8A9F40EE2FF505EB7476F95ADB783B28CA374FAC4632892AB82FB3BF4715FCFE6E82D03731FC3762B6AAC3DF1C3BC646FE9CD3C62663A97EE72DB932A301312B4A7633100C8CC357262C39A2B3A64B224F5276D5EDBDF0804DC3AC4B835162BB1969EAEBADC43D2511D6E023928781B167A48273B953378D3D2080CC06777E8A2364F0234B81064C5C739A8DA28DC5889072BF37685CBC94C2D31D0179AD86D8E3AA8090D4F0B281BE37E0143746E6049CCC06899401264FA471C016A96C79815B55BBC26B43052609D9D175FBCDE455392F10E51EC162F51CF732E6BB391F56BBFD8D957DF3D4C55B71CEFD54B19C16D458757373E698D7E693A8FC39815A8BF03BA05EA8C8778D38F9873D62B4460F41ACF997C30E7C3AF025FA171B5F5AD4D6B15E95C27F6B35AD61875E5505449B4E6767392933'))
|
||||
-----BEGIN PUBLIC KEY-----
|
||||
MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAw1dqF3SkCaAAmMzs889I
|
||||
qdW9M2dIdh3jG9yPcmLnmJiGpBF4E9VHSMGe8oPAy2kJDmdNt4BcEygvssEfginv
|
||||
a5t5jm352UAoDosUJkTXGQhpAWMF4fBmBpO3EedG62rOsqMBgmSdAyxCSPBRJIOF
|
||||
R0QgZFbRnU0frj34fiVmgYiLuZSAmIbs8ZxiHPdp1oD4tUpvsFci4QJtYNjNnGU2
|
||||
WPH6rvChGl1IRKrxMtqLielsvajUjyrgOC6NmymYMvZNER3htFEtL1eQbCyTfDmt
|
||||
YyQ1Wt4Ot12lxf0wVIR5mcGN7XCXJRHOFHSf1gzXWabRSvmt1nrl7sW6cjxljuuQ
|
||||
awIDAQAB
|
||||
-----END PUBLIC KEY-----
|
||||
```
|
||||
|
||||
* __Request Code__
|
||||
|
||||
It is a Base64 string that represents 256-bytes-long data, while the 256-bytes-long data is the cipher text of the __offline activation information__ encrypted by __Navicat Activation Public Key__.
|
||||
@@ -66,10 +152,19 @@
|
||||
~~_`May change when Navicat product changes. Uncertain yet.`_~~
|
||||
_`Must change when Navicat product changes. Confirmed yet.`_
|
||||
|
||||
For __Navicat 12 x64 English version__: They must be `0xAC` and `0x88` respectively.
|
||||
For __Navicat 12 x64 Simplified Chinese version__: They must be `0xCE` and `0x32` respectively.
|
||||
For __Navicat 12 x64 Traditional Chinese version__: They must be `0xAA` and `0x99` respectively.
|
||||
For __Navicat 11 x64 Simplified Chinese version__: They must be `0xCE` and `0x32` respectively.
|
||||
| Language | data[5] | data[6] | Discoverer |
|
||||
|------------|-----------|-----------|-----------------|
|
||||
| English | 0xAC | 0x88 | |
|
||||
| 简体中文 | 0xCE | 0x32 | |
|
||||
| 繁體中文 | 0xAA | 0x99 | |
|
||||
| 日本語 | 0xAD | 0x82 | @dragonflylee |
|
||||
| Polski | 0xBB | 0x55 | @dragonflylee |
|
||||
| Español | 0xAE | 0x10 | @dragonflylee |
|
||||
| Français | 0xFA | 0x20 | @Deltafox79 |
|
||||
| Deutsch | 0xB1 | 0x60 | @dragonflylee |
|
||||
| 한국어 | 0xB5 | 0x60 | @dragonflylee |
|
||||
| Русский | 0xEE | 0x16 | @dragonflylee |
|
||||
| Português | 0xCD | 0x49 | @dragonflylee |
|
||||
|
||||
According to __Navicat 12 for Mac x64__ version, what IDA 7.0 indicates is that this two bytes are product signature.
|
||||
|
||||
@@ -157,20 +252,35 @@
|
||||
5. Input __Activation Code__, then offline activation is done.
|
||||
|
||||
## 4. How to use
|
||||
1. Build patcher and keygen.
|
||||
1. Build patcher and keygen in Release configuration or download the latest release.
|
||||
|
||||
2. Replace __Navicat Activation Public Key__ in `navicat.exe`.
|
||||
2. Replace __Navicat Activation Public Key__ in `navicat.exe` or `libcc.dll`.
|
||||
Example:
|
||||
|
||||
```bash
|
||||
E:\GitHub\navicat-keygen\x64\Release>navicat-patcher.exe "D:\Program Files\PremiumSoft\Navicat Premium 12\navicat.exe"
|
||||
D:\Program Files\PremiumSoft\Navicat Premium 12\navicat.exe has been backed up.
|
||||
Public key has been replaced.
|
||||
Success!
|
||||
* For Navicat Premium version < 12.0.25
|
||||
```bash
|
||||
E:\GitHub\navicat-keygen\x64\Release>navicat-patcher.exe "D:\Program Files\PremiumSoft\Navicat Premium 12"
|
||||
D:\Program Files\PremiumSoft\Navicat Premium 12\navicat.exe has been backed up.
|
||||
Public key has been replaced.
|
||||
Success!
|
||||
```
|
||||
|
||||
```
|
||||
* For Navicat Premium version >= 12.0.25
|
||||
```bash
|
||||
E:\GitHub\navicat-keygen\x64\Release>navicat-patcher.exe "D:\Program Files\PremiumSoft\Navicat Premium 12"
|
||||
D:\Program Files\PremiumSoft\Navicat Premium 12\libcc.dll has been backed up.
|
||||
Public key has been replaced.
|
||||
Success!
|
||||
```
|
||||
You may wait for a few seconds or even longer, because patcher is search for a appropriate RSA key. Finally you will get `RegPrivateKey.pem` file at current directory.
|
||||
|
||||
You will get `RegPrivateKey.pem` file at current directory.
|
||||
If you do not want to search, use `RegPrivateKey.pem` in my latest release, then:
|
||||
```bash
|
||||
E:\GitHub\navicat-keygen\x64\Release>navicat-patcher.exe "D:\Program Files\PremiumSoft\Navicat Premium 12" RegPrivateKey.pem
|
||||
D:\Program Files\PremiumSoft\Navicat Premium 12\libcc.dll has been backed up.
|
||||
Public key has been replaced.
|
||||
Success!
|
||||
```
|
||||
|
||||
3. Then in console:
|
||||
|
||||
|
||||
+167
-34
@@ -1,4 +1,4 @@
|
||||
#include <tchar.h>
|
||||
#include <tchar.h>
|
||||
#include <windows.h>
|
||||
#include <wincrypt.h>
|
||||
|
||||
@@ -11,13 +11,37 @@
|
||||
#include <openssl/pem.h>
|
||||
#include <openssl/des.h>
|
||||
|
||||
#pragma comment(lib, "Crypt32.lib")
|
||||
#pragma comment(lib, "libcrypto.lib")
|
||||
// OpenSSL precompiled lib, download from https://www.npcglib.org/~stathis/blog/precompiled-openssl/, MSVC2015 version
|
||||
// direct link https://www.npcglib.org/~stathis/downloads/openssl-1.1.0f-vs2015.7z
|
||||
// x86: "D:\openssl-1.1.0f-vs2015\include" has been add to include path. (modify it at project properties if necessary)
|
||||
// "D:\openssl-1.1.0f-vs2015\lib" has been add to library path. (modify it at project properties if necessary)
|
||||
// x64: "D:\openssl-1.1.0f-vs2015\include64" has been add to include path. (modify it at project properties if necessary)
|
||||
// "D:\openssl-1.1.0f-vs2015\lib64" has been add to library path. (modify it at project properties if necessary)
|
||||
#ifdef _DEBUG
|
||||
#pragma comment(lib, "libcryptoMTd.lib")
|
||||
#else
|
||||
#pragma comment(lib, "libcryptoMT.lib")
|
||||
#endif
|
||||
#pragma comment(lib, "WS2_32.lib") // some symbol are used in OpenSSL static lib
|
||||
#pragma comment(lib, "Crypt32.lib") // some symbol are used in OpenSSL static lib
|
||||
|
||||
#define NAVICAT_12
|
||||
#define NAVICAT_CHS
|
||||
|
||||
void GenerateSnKey(char(&SnKey)[16]) {
|
||||
enum NavicatLanguage {
|
||||
English,
|
||||
SimplifiedChinese,
|
||||
TraditionalChinese,
|
||||
Japanese,
|
||||
Polish,
|
||||
Spanish,
|
||||
French,
|
||||
German,
|
||||
Korean,
|
||||
Russian,
|
||||
Portuguese
|
||||
};
|
||||
|
||||
void GenerateSnKey(char(&SnKey)[16], NavicatLanguage _language) {
|
||||
static char EncodeTable[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567";
|
||||
static DES_cblock DESKey = { 0x64, 0xAD, 0xF3, 0x2F, 0xAE, 0xF2, 0x1A, 0x27 };
|
||||
|
||||
@@ -26,18 +50,54 @@ void GenerateSnKey(char(&SnKey)[16]) {
|
||||
temp_SnKey[3] = rand();
|
||||
temp_SnKey[4] = rand();
|
||||
|
||||
#if defined(NAVICAT_ENG)
|
||||
temp_SnKey[5] = 0xAC; // Must be 0xAC for English version.
|
||||
temp_SnKey[6] = 0x88; // Must be 0x88 for English version.
|
||||
#elif defined(NAVICAT_CHS)
|
||||
temp_SnKey[5] = 0xCE; // Must be 0xCE for Simplified Chinese version.
|
||||
temp_SnKey[6] = 0x32; // Must be 0x32 for Simplified Chinese version.
|
||||
#elif defined(NAVICAT_CHT)
|
||||
temp_SnKey[5] = 0xAA; // Must be 0xAA for Traditional Chinese version.
|
||||
temp_SnKey[6] = 0x99; // Must be 0x99 for Traditional Chinese version.
|
||||
#else
|
||||
#error "Navicat product type is not specified."
|
||||
#endif
|
||||
switch (_language) {
|
||||
case English:
|
||||
temp_SnKey[5] = 0xAC; // Must be 0xAC for English version.
|
||||
temp_SnKey[6] = 0x88; // Must be 0x88 for English version.
|
||||
break;
|
||||
case SimplifiedChinese:
|
||||
temp_SnKey[5] = 0xCE; // Must be 0xCE for Simplified Chinese version.
|
||||
temp_SnKey[6] = 0x32; // Must be 0x32 for Simplified Chinese version.
|
||||
break;
|
||||
case TraditionalChinese:
|
||||
temp_SnKey[5] = 0xAA; // Must be 0xAA for Traditional Chinese version.
|
||||
temp_SnKey[6] = 0x99; // Must be 0x99 for Traditional Chinese version.
|
||||
break;
|
||||
case Japanese:
|
||||
temp_SnKey[5] = 0xAD; // Must be 0xAD for Japanese version. Discoverer: @dragonflylee
|
||||
temp_SnKey[6] = 0x82; // Must be 0x82 for Japanese version. Discoverer: @dragonflylee
|
||||
break;
|
||||
case Polish:
|
||||
temp_SnKey[5] = 0xBB; // Must be 0xBB for Polish version. Discoverer: @dragonflylee
|
||||
temp_SnKey[6] = 0x55; // Must be 0x55 for Polish version. Discoverer: @dragonflylee
|
||||
break;
|
||||
case Spanish:
|
||||
temp_SnKey[5] = 0xAE; // Must be 0xAE for Spanish version. Discoverer: @dragonflylee
|
||||
temp_SnKey[6] = 0x10; // Must be 0x10 for Spanish version. Discoverer: @dragonflylee
|
||||
break;
|
||||
case French:
|
||||
temp_SnKey[5] = 0xFA; // Must be 0xFA for French version. Discoverer: @Deltafox79
|
||||
temp_SnKey[6] = 0x20; // Must be 0x20 for French version. Discoverer: @Deltafox79
|
||||
break;
|
||||
case German:
|
||||
temp_SnKey[5] = 0xB1; // Must be 0xB1 for German version. Discoverer: @dragonflylee
|
||||
temp_SnKey[6] = 0x60; // Must be 0x60 for German version. Discoverer: @dragonflylee
|
||||
break;
|
||||
case Korean:
|
||||
temp_SnKey[5] = 0xB5; // Must be 0xB5 for Korean version. Discoverer: @dragonflylee
|
||||
temp_SnKey[6] = 0x60; // Must be 0x60 for Korean version. Discoverer: @dragonflylee
|
||||
break;
|
||||
case Russian:
|
||||
temp_SnKey[5] = 0xEE; // Must be 0xB5 for Russian version. Discoverer: @dragonflylee
|
||||
temp_SnKey[6] = 0x16; // Must be 0x60 for Russian version. Discoverer: @dragonflylee
|
||||
break;
|
||||
case Portuguese:
|
||||
temp_SnKey[5] = 0xCD; // Must be 0xCD for Portuguese version. Discoverer: @dragonflylee
|
||||
temp_SnKey[6] = 0x49; // Must be 0x49 for Portuguese version. Discoverer: @dragonflylee
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
||||
#if defined(NAVICAT_12)
|
||||
temp_SnKey[7] = 0x65; // 0x65 - commercial, 0x66 - non-commercial
|
||||
@@ -138,6 +198,59 @@ BOOL GenerateLicense(RSA* RSAPrivateKey,
|
||||
#endif
|
||||
}
|
||||
|
||||
RSA* ReadRSAPrivateKeyFromFile(LPCTSTR filename) {
|
||||
#ifdef UNICODE
|
||||
int req_size = WideCharToMultiByte(CP_ACP, 0, filename, -1, nullptr, 0, nullptr, nullptr);
|
||||
if (req_size == 0) {
|
||||
_tprintf_s(TEXT("Failed to convert wchar* to char*. CODE: 0x%08x @[ReadRSAPrivateKeyFromFile -> WideCharToMultiByte]\r\n"), GetLastError());
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
char* temp_filename = new char[req_size]();
|
||||
WideCharToMultiByte(CP_ACP, 0, filename, -1, temp_filename, req_size, nullptr, nullptr);
|
||||
|
||||
BIO* b = BIO_new(BIO_s_file());
|
||||
if (b == nullptr) {
|
||||
_tprintf_s(TEXT("Failed to create BIO object. CODE: 0x%08x @[ReadRSAPrivateKeyFromFile -> BIO_new]\r\n"), ERR_get_error());
|
||||
delete[] temp_filename;
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
if (1 != BIO_read_filename(b, temp_filename)) {
|
||||
_tprintf_s(TEXT("Failed to set target file of BIO. CODE: 0x%08x @[ReadRSAPrivateKeyFromFile -> BIO_read_filename]\r\n"), ERR_get_error());
|
||||
|
||||
BIO_free_all(b);
|
||||
delete[] temp_filename;
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
delete[] temp_filename;
|
||||
#else
|
||||
BIO* b = BIO_new(BIO_s_file());
|
||||
if (b == nullptr) {
|
||||
_tprintf_s(TEXT("Failed to create BIO object. CODE: 0x%08x @[ReadRSAPrivateKeyFromFile -> BIO_new]\r\n"), ERR_get_error());
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
if (1 != BIO_read_filename(b, filename)) {
|
||||
_tprintf_s(TEXT("Failed to set target file of BIO. CODE: 0x%08x @[ReadRSAPrivateKeyFromFile -> BIO_read_filename]\r\n"), ERR_get_error());
|
||||
|
||||
BIO_free_all(b);
|
||||
return FALSE;
|
||||
}
|
||||
#endif
|
||||
RSA* ret = PEM_read_bio_RSAPrivateKey(b, nullptr, nullptr, nullptr);
|
||||
if (ret == nullptr) {
|
||||
_tprintf_s(TEXT("Failed to read RSA private key. CODE: 0x%08x @[ReadRSAPrivateKeyFromFile -> PEM_read_bio_RSAPrivateKey]\r\n"), ERR_get_error());
|
||||
|
||||
BIO_free_all(b);
|
||||
return nullptr;
|
||||
} else {
|
||||
BIO_free_all(b);
|
||||
return ret;
|
||||
}
|
||||
}
|
||||
|
||||
int _tmain(int argc, TCHAR* argv[]) {
|
||||
if (argc != 2) {
|
||||
_tprintf_s(TEXT("Usage:\r\n"));
|
||||
@@ -146,28 +259,48 @@ int _tmain(int argc, TCHAR* argv[]) {
|
||||
}
|
||||
|
||||
srand(static_cast<unsigned int>(time(nullptr)));
|
||||
#ifdef UNICODE
|
||||
char pem_file_path[MAX_PATH] = { };
|
||||
sprintf_s(pem_file_path, "%S", argv[1]);
|
||||
#else
|
||||
char* pem_file_path = argv[1];
|
||||
#endif
|
||||
|
||||
RSA* PrivateKey = nullptr;
|
||||
{
|
||||
BIO* PrivateKeyFile = BIO_new(BIO_s_file());
|
||||
BIO_read_filename(PrivateKeyFile, pem_file_path);
|
||||
PrivateKey = PEM_read_bio_RSAPrivateKey(PrivateKeyFile, nullptr, nullptr, nullptr);
|
||||
BIO_free_all(PrivateKeyFile);
|
||||
}
|
||||
RSA* PrivateKey = ReadRSAPrivateKeyFromFile(argv[1]);
|
||||
if (PrivateKey == nullptr)
|
||||
return 0;
|
||||
|
||||
if (PrivateKey == nullptr) {
|
||||
_tprintf_s(TEXT("Failed to load private key.\r\n"));
|
||||
return -1;
|
||||
std::cout
|
||||
<< "Which is your Navicat language?" << std::endl
|
||||
<< "0. English" << std::endl
|
||||
<< "1. Simplified Chinese" << std::endl
|
||||
<< "2. Traditional Chinese" << std::endl
|
||||
<< "3. Japanese" << std::endl
|
||||
<< "4. Polish" << std::endl
|
||||
<< "5. Spanish" << std::endl
|
||||
<< "6. French" << std::endl
|
||||
<< "7. German" << std::endl
|
||||
<< "8. Korean" << std::endl
|
||||
<< "9. Russian" << std::endl
|
||||
<< "10. Portuguese" << std::endl
|
||||
<< std::endl;
|
||||
|
||||
int LanguageIndex = -1;
|
||||
while (true) {
|
||||
std::cout << "(input index)>";
|
||||
|
||||
std::string temp;
|
||||
if (!std::getline(std::cin, temp)) {
|
||||
RSA_free(PrivateKey);
|
||||
return 0;
|
||||
}
|
||||
try {
|
||||
LanguageIndex = std::stoi(temp);
|
||||
if (LanguageIndex < 0 || LanguageIndex > 10)
|
||||
throw std::invalid_argument("Invalid index");
|
||||
break;
|
||||
} catch (...) {
|
||||
std::cout << "Invalid index." << std::endl;
|
||||
continue;
|
||||
}
|
||||
}
|
||||
|
||||
char SnKey[16] = { };
|
||||
GenerateSnKey(SnKey);
|
||||
GenerateSnKey(SnKey, static_cast<NavicatLanguage>(LanguageIndex));
|
||||
|
||||
std::string strName;
|
||||
std::string strOrganization;
|
||||
|
||||
@@ -28,26 +28,26 @@
|
||||
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
|
||||
<ConfigurationType>Application</ConfigurationType>
|
||||
<UseDebugLibraries>true</UseDebugLibraries>
|
||||
<PlatformToolset>v140</PlatformToolset>
|
||||
<PlatformToolset>v140_xp</PlatformToolset>
|
||||
<CharacterSet>Unicode</CharacterSet>
|
||||
</PropertyGroup>
|
||||
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
|
||||
<ConfigurationType>Application</ConfigurationType>
|
||||
<UseDebugLibraries>false</UseDebugLibraries>
|
||||
<PlatformToolset>v140</PlatformToolset>
|
||||
<PlatformToolset>v140_xp</PlatformToolset>
|
||||
<WholeProgramOptimization>true</WholeProgramOptimization>
|
||||
<CharacterSet>Unicode</CharacterSet>
|
||||
</PropertyGroup>
|
||||
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
|
||||
<ConfigurationType>Application</ConfigurationType>
|
||||
<UseDebugLibraries>true</UseDebugLibraries>
|
||||
<PlatformToolset>v140</PlatformToolset>
|
||||
<PlatformToolset>v140_xp</PlatformToolset>
|
||||
<CharacterSet>Unicode</CharacterSet>
|
||||
</PropertyGroup>
|
||||
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
|
||||
<ConfigurationType>Application</ConfigurationType>
|
||||
<UseDebugLibraries>false</UseDebugLibraries>
|
||||
<PlatformToolset>v140</PlatformToolset>
|
||||
<PlatformToolset>v140_xp</PlatformToolset>
|
||||
<WholeProgramOptimization>true</WholeProgramOptimization>
|
||||
<CharacterSet>Unicode</CharacterSet>
|
||||
</PropertyGroup>
|
||||
@@ -71,23 +71,23 @@
|
||||
<PropertyGroup Label="UserMacros" />
|
||||
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
|
||||
<LinkIncremental>true</LinkIncremental>
|
||||
<IncludePath>D:\OpenSSL-Win32\include;$(IncludePath)</IncludePath>
|
||||
<LibraryPath>D:\OpenSSL-Win32\lib;$(LibraryPath)</LibraryPath>
|
||||
<IncludePath>D:\openssl-1.1.0f-vs2015\include;$(IncludePath)</IncludePath>
|
||||
<LibraryPath>D:\openssl-1.1.0f-vs2015\lib;$(LibraryPath)</LibraryPath>
|
||||
</PropertyGroup>
|
||||
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
|
||||
<LinkIncremental>true</LinkIncremental>
|
||||
<IncludePath>D:\OpenSSL-Win64\include;$(IncludePath)</IncludePath>
|
||||
<LibraryPath>D:\OpenSSL-Win64\lib;$(LibraryPath)</LibraryPath>
|
||||
<IncludePath>D:\openssl-1.1.0f-vs2015\include64;$(IncludePath)</IncludePath>
|
||||
<LibraryPath>D:\openssl-1.1.0f-vs2015\lib64;$(LibraryPath)</LibraryPath>
|
||||
</PropertyGroup>
|
||||
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
|
||||
<LinkIncremental>false</LinkIncremental>
|
||||
<IncludePath>D:\OpenSSL-Win32\include;$(IncludePath)</IncludePath>
|
||||
<LibraryPath>D:\OpenSSL-Win32\lib;$(LibraryPath)</LibraryPath>
|
||||
<IncludePath>D:\openssl-1.1.0f-vs2015\include;$(IncludePath)</IncludePath>
|
||||
<LibraryPath>D:\openssl-1.1.0f-vs2015\lib;$(LibraryPath)</LibraryPath>
|
||||
</PropertyGroup>
|
||||
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
|
||||
<LinkIncremental>false</LinkIncremental>
|
||||
<IncludePath>D:\OpenSSL-Win64\include;$(IncludePath)</IncludePath>
|
||||
<LibraryPath>D:\OpenSSL-Win64\lib;$(LibraryPath)</LibraryPath>
|
||||
<IncludePath>D:\openssl-1.1.0f-vs2015\include64;$(IncludePath)</IncludePath>
|
||||
<LibraryPath>D:\openssl-1.1.0f-vs2015\lib64;$(LibraryPath)</LibraryPath>
|
||||
</PropertyGroup>
|
||||
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
|
||||
<ClCompile>
|
||||
|
||||
@@ -0,0 +1,12 @@
|
||||
// to avoid "AES_KEY" definaition conflict
|
||||
#include "NavicatCrypto/NavicatCrypto.hpp"
|
||||
|
||||
namespace patcher {
|
||||
|
||||
std::string EncryptPublicKey(const char* public_key, size_t len) {
|
||||
Navicat11Crypto cipher("23970790", 8);
|
||||
auto&& temp = cipher.EncryptString(public_key, len);
|
||||
return std::string(temp.begin(), temp.end());
|
||||
}
|
||||
|
||||
}
|
||||
@@ -0,0 +1,291 @@
|
||||
#pragma once
|
||||
#include "aes.h"
|
||||
#include "blowfish.h"
|
||||
#include "SHA1.h"
|
||||
|
||||
#include <vector>
|
||||
|
||||
class Navicat11Crypto {
|
||||
protected:
|
||||
BLOWFISH_KEY BlowfishKey;
|
||||
|
||||
void BytesToHex(const void* src, size_t len, char* dst) {
|
||||
for (size_t i = 0; i < len; ++i) {
|
||||
char h = reinterpret_cast<const uint8_t*>(src)[i] >> 4;
|
||||
char l = reinterpret_cast<const uint8_t*>(src)[i] & 0x0F;
|
||||
|
||||
h += h >= 10 ? 'A' - 10 : '0';
|
||||
l += l >= 10 ? 'A' - 10 : '0';
|
||||
dst[2 * i] = h;
|
||||
dst[2 * i + 1] = l;
|
||||
}
|
||||
}
|
||||
|
||||
bool CheckHex(const char* src, size_t len) {
|
||||
if (len % 2 != 0)
|
||||
return false;
|
||||
|
||||
for (size_t i = 0; i < len; i += 2) {
|
||||
char h = src[i];
|
||||
char l = src[i + 1];
|
||||
|
||||
if (src[i] < '0' || src[i] > 'F')
|
||||
return false;
|
||||
if (src[i] < 'A' && src[i] > '9')
|
||||
return false;
|
||||
if (src[i + 1] < '0' || src[i + 1] > 'F')
|
||||
return false;
|
||||
if (src[i + 1] < 'A' && src[i + 1] > '9')
|
||||
return false;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
void HexToBytes(const char* src, size_t len, void* dst) {
|
||||
for (size_t i = 0; i < len; i += 2) {
|
||||
uint8_t h = src[i];
|
||||
uint8_t l = src[i + 1];
|
||||
|
||||
h -= h > '9' ? 'A' - 10 : '0';
|
||||
l -= l > '9' ? 'A' - 10 : '0';
|
||||
|
||||
reinterpret_cast<uint8_t*>(dst)[i / 2] = (h << 4 )^ l;
|
||||
}
|
||||
}
|
||||
|
||||
public:
|
||||
|
||||
Navicat11Crypto() {
|
||||
const uint8_t DefaultKey[8] = {
|
||||
'3', 'D', 'C', '5', 'C', 'A', '3', '9'
|
||||
};
|
||||
SHA1_DIGEST KeyHash;
|
||||
accelc_SHA1(DefaultKey, sizeof(DefaultKey), &KeyHash);
|
||||
accelc_Blowfish_set_key(KeyHash.byte, sizeof(KeyHash), &BlowfishKey);
|
||||
}
|
||||
|
||||
Navicat11Crypto(const void* srcBytes, size_t srclen) {
|
||||
if (srclen == 0)
|
||||
srclen = BLOWFISH_MIN_KEY_LENGTH;
|
||||
if (srclen > BLOWFISH_MAX_KEY_LENGTH)
|
||||
srclen = BLOWFISH_MAX_KEY_LENGTH;
|
||||
SHA1_DIGEST KeyHash;
|
||||
accelc_SHA1(srcBytes, srclen, &KeyHash);
|
||||
accelc_Blowfish_set_key(KeyHash.byte, sizeof(KeyHash), &BlowfishKey);
|
||||
}
|
||||
|
||||
std::vector<char> EncryptString(const void* srcBytes, size_t srclen) {
|
||||
std::vector<char> ret;
|
||||
if (srclen == 0)
|
||||
return ret;
|
||||
|
||||
ret.resize(srclen * 2 + 1);
|
||||
ret[srclen * 2] = 0;
|
||||
|
||||
uint8_t CV[BLOWFISH_BLOCK_SIZE] = {
|
||||
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
|
||||
};
|
||||
accelc_Blowfish_encrypt(CV, &BlowfishKey, BLOWFISH_BIG_ENDIAN);
|
||||
|
||||
const uint64_t* blocks = reinterpret_cast<const uint64_t*>(srcBytes);
|
||||
size_t blocks_len = srclen / BLOWFISH_BLOCK_SIZE;
|
||||
for (size_t i = 0; i < blocks_len; ++i) {
|
||||
union {
|
||||
uint8_t byte[8];
|
||||
uint64_t qword;
|
||||
} temp;
|
||||
|
||||
temp.qword = blocks[i];
|
||||
temp.qword ^= *reinterpret_cast<uint64_t*>(CV);
|
||||
accelc_Blowfish_encrypt(temp.byte, &BlowfishKey, BLOWFISH_BIG_ENDIAN);
|
||||
*reinterpret_cast<uint64_t*>(CV) ^= temp.qword;
|
||||
|
||||
BytesToHex(temp.byte, 8, ret.data() + 16 * i);
|
||||
}
|
||||
|
||||
if (srclen % BLOWFISH_BLOCK_SIZE) {
|
||||
accelc_Blowfish_encrypt(CV, &BlowfishKey, BLOWFISH_BIG_ENDIAN);
|
||||
for (size_t i = 0; i < srclen % BLOWFISH_BLOCK_SIZE; ++i)
|
||||
CV[i] ^= reinterpret_cast<const uint8_t*>(blocks + blocks_len)[i];
|
||||
BytesToHex(CV, srclen % BLOWFISH_BLOCK_SIZE, ret.data() + 16 * blocks_len);
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
std::vector<uint8_t> DecryptString(const char* srchex, size_t srclen) {
|
||||
std::vector<uint8_t> ret;
|
||||
if (CheckHex(srchex, srclen) == false)
|
||||
return ret;
|
||||
|
||||
ret.resize(srclen / 2);
|
||||
uint8_t CV[BLOWFISH_BLOCK_SIZE] = {
|
||||
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
|
||||
};
|
||||
accelc_Blowfish_encrypt(CV, &BlowfishKey, BLOWFISH_BIG_ENDIAN);
|
||||
|
||||
const char (*blocks)[16] = reinterpret_cast<const char (*)[16]>(srchex);
|
||||
size_t blocks_len = srclen / 16;
|
||||
for (size_t i = 0; i < blocks_len; ++i) {
|
||||
union {
|
||||
uint8_t byte[8];
|
||||
uint64_t qword;
|
||||
} temp, temp2;
|
||||
|
||||
HexToBytes(blocks[i], 16, temp.byte);
|
||||
std::memcpy(temp2.byte, temp.byte, 8);
|
||||
accelc_Blowfish_decrypt(temp.byte, &BlowfishKey, BLOWFISH_BIG_ENDIAN);
|
||||
temp.qword ^= *reinterpret_cast<uint64_t*>(CV);
|
||||
*reinterpret_cast<uint64_t*>(ret.data() + 8 * i) = temp.qword;
|
||||
*reinterpret_cast<uint64_t*>(CV) ^= temp2.qword;
|
||||
}
|
||||
|
||||
if (srclen % 16) {
|
||||
union {
|
||||
uint8_t byte[8];
|
||||
uint64_t qword;
|
||||
} temp = { };
|
||||
HexToBytes(blocks[blocks_len], srclen % 16, temp.byte);
|
||||
|
||||
accelc_Blowfish_encrypt(CV, &BlowfishKey, BLOWFISH_BIG_ENDIAN);
|
||||
for (size_t i = 0; i < (srclen % 16) / 2; ++i)
|
||||
ret[blocks_len * 8 + i] = temp.byte[i] ^ CV[i];
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
class Navicat12Crypto : public Navicat11Crypto {
|
||||
protected:
|
||||
AES_KEY AES128Key;
|
||||
public:
|
||||
|
||||
Navicat12Crypto() : Navicat11Crypto() {
|
||||
uint8_t DefaultKey[16] = {
|
||||
'l', 'i', 'b', 'c', 'c', 'k', 'e', 'y',
|
||||
'l', 'i', 'b', 'c', 'c', 'k', 'e', 'y'
|
||||
};
|
||||
accelc_AES128_set_key(DefaultKey, &AES128Key);
|
||||
}
|
||||
|
||||
Navicat12Crypto(const void* srcBytes, size_t srclen) :
|
||||
Navicat11Crypto(srcBytes, srclen) {
|
||||
|
||||
uint8_t DefaultKey[16] = {
|
||||
'l', 'i', 'b', 'c', 'c', 'k', 'e', 'y',
|
||||
'l', 'i', 'b', 'c', 'c', 'k', 'e', 'y'
|
||||
};
|
||||
accelc_AES128_set_key(DefaultKey, &AES128Key);
|
||||
}
|
||||
|
||||
std::vector<char> EncryptString(const void* srcBytes, size_t srclen) {
|
||||
std::vector<char> ret;
|
||||
if (srclen == 0)
|
||||
return ret;
|
||||
|
||||
ret.resize((srclen / AES_BLOCK_SIZE + 1) * AES_BLOCK_SIZE * 2);
|
||||
union {
|
||||
uint8_t byte[AES_BLOCK_SIZE];
|
||||
uint64_t qword[2];
|
||||
} CV = {
|
||||
'l', 'i', 'b', 'c', 'c', 'i', 'v', ' ',
|
||||
'l', 'i', 'b', 'c', 'c', 'i', 'v', ' '
|
||||
};
|
||||
|
||||
const uint8_t (*blocks)[AES_BLOCK_SIZE] = reinterpret_cast<const uint8_t (*)[AES_BLOCK_SIZE]>(srcBytes);
|
||||
size_t blocks_len = srclen / AES_BLOCK_SIZE;
|
||||
for (size_t i = 0; i < blocks_len; ++i) {
|
||||
union {
|
||||
uint8_t byte[AES_BLOCK_SIZE];
|
||||
uint64_t qword[2];
|
||||
} temp;
|
||||
|
||||
std::memcpy(temp.byte, blocks[i], AES_BLOCK_SIZE);
|
||||
temp.qword[0] ^= CV.qword[0];
|
||||
temp.qword[1] ^= CV.qword[1];
|
||||
accelc_AES128_encrypt(temp.byte, &AES128Key);
|
||||
BytesToHex(temp.byte, AES_BLOCK_SIZE, ret.data() + 2 * AES_BLOCK_SIZE * i);
|
||||
CV.qword[0] = temp.qword[0];
|
||||
CV.qword[1] = temp.qword[1];
|
||||
}
|
||||
|
||||
uint8_t padding = AES_BLOCK_SIZE - srclen % AES_BLOCK_SIZE;
|
||||
union {
|
||||
uint8_t byte[AES_BLOCK_SIZE];
|
||||
uint64_t qword[2];
|
||||
} temp;
|
||||
|
||||
std::memcpy(temp.byte, blocks[blocks_len], srclen % AES_BLOCK_SIZE);
|
||||
for (size_t i = srclen % AES_BLOCK_SIZE; i < AES_BLOCK_SIZE; ++i)
|
||||
temp.byte[i] = padding;
|
||||
|
||||
temp.qword[0] ^= CV.qword[0];
|
||||
temp.qword[1] ^= CV.qword[1];
|
||||
accelc_AES128_encrypt(temp.byte, &AES128Key);
|
||||
BytesToHex(temp.byte, AES_BLOCK_SIZE, ret.data() + 2 * AES_BLOCK_SIZE * blocks_len);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
std::vector<uint8_t> DecryptString(const char* srchex, size_t srclen) {
|
||||
std::vector<uint8_t> ret;
|
||||
if (srclen % (2 * AES_BLOCK_SIZE) != 0 || CheckHex(srchex, srclen) == false)
|
||||
return ret;
|
||||
|
||||
ret.reserve(srclen / 2);
|
||||
ret.resize(srclen / 2 - AES_BLOCK_SIZE);
|
||||
union {
|
||||
uint8_t byte[AES_BLOCK_SIZE];
|
||||
uint64_t qword[2];
|
||||
} CV = {
|
||||
'l', 'i', 'b', 'c', 'c', 'i', 'v', ' ',
|
||||
'l', 'i', 'b', 'c', 'c', 'i', 'v', ' '
|
||||
};
|
||||
|
||||
const char (*blocks)[2 * AES_BLOCK_SIZE] = reinterpret_cast<const char(*)[2 * AES_BLOCK_SIZE]>(srchex);
|
||||
size_t blocks_len = srclen / (2 * AES_BLOCK_SIZE);
|
||||
for (size_t i = 0; i < blocks_len; ++i) {
|
||||
union {
|
||||
uint8_t byte[AES_BLOCK_SIZE];
|
||||
uint64_t qword[2];
|
||||
} temp, NextVector;
|
||||
|
||||
HexToBytes(blocks[i], 2 * AES_BLOCK_SIZE, temp.byte);
|
||||
std::memcpy(NextVector.byte, temp.byte, AES_BLOCK_SIZE);
|
||||
accelc_AES128_decrypt(temp.byte, &AES128Key);
|
||||
temp.qword[0] ^= CV.qword[0];
|
||||
temp.qword[1] ^= CV.qword[1];
|
||||
|
||||
std::memcpy(ret.data() + AES_BLOCK_SIZE * i, temp.byte, AES_BLOCK_SIZE);
|
||||
std::memcpy(CV.byte, NextVector.byte, AES_BLOCK_SIZE);
|
||||
}
|
||||
|
||||
union {
|
||||
uint8_t byte[AES_BLOCK_SIZE];
|
||||
uint64_t qword[2];
|
||||
} temp;
|
||||
HexToBytes(blocks[blocks_len], 2 * AES_BLOCK_SIZE, temp.byte);
|
||||
accelc_AES128_decrypt(temp.byte, &AES128Key);
|
||||
temp.qword[0] ^= CV.qword[0];
|
||||
temp.qword[1] ^= CV.qword[1];
|
||||
|
||||
if (temp.byte[AES_BLOCK_SIZE - 1] > AES_BLOCK_SIZE) {
|
||||
ret.clear();
|
||||
return ret;
|
||||
} else {
|
||||
uint8_t padding = temp.byte[AES_BLOCK_SIZE - 1];
|
||||
for (int i = AES_BLOCK_SIZE - padding; i < AES_BLOCK_SIZE; ++i)
|
||||
if (temp.byte[i] != padding) {
|
||||
ret.clear();
|
||||
return ret;
|
||||
}
|
||||
for (int i = 0; i < (AES_BLOCK_SIZE - padding); ++i)
|
||||
ret.emplace_back(temp.byte[i]);
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
};
|
||||
@@ -0,0 +1,438 @@
|
||||
#include "aes.h"
|
||||
|
||||
#if defined(_MSC_VER)
|
||||
#include <intrin.h>
|
||||
#else
|
||||
#include <x86intrin.h>
|
||||
#endif
|
||||
|
||||
extern const uint32_t accelc_aes_rcon[11];
|
||||
|
||||
extern const uint8_t accelc_aes_SBox[256];
|
||||
extern const uint8_t accelc_aes_InverseSBox[256];
|
||||
|
||||
extern const uint8_t accelc_aes_GF2p8_Mul_0x02[256];
|
||||
extern const uint8_t accelc_aes_GF2p8_Mul_0x03[256];
|
||||
extern const uint8_t accelc_aes_GF2p8_Mul_0x09[256];
|
||||
extern const uint8_t accelc_aes_GF2p8_Mul_0x0B[256];
|
||||
extern const uint8_t accelc_aes_GF2p8_Mul_0x0D[256];
|
||||
extern const uint8_t accelc_aes_GF2p8_Mul_0x0E[256];
|
||||
|
||||
#define Swap(X, Y, Temp) \
|
||||
Temp = X; \
|
||||
X = Y; \
|
||||
Y = Temp;
|
||||
|
||||
void accelc_AES128_encrypt(uint8_t srcBytes[AES_BLOCK_SIZE], const AES_KEY* srcKey) {
|
||||
|
||||
((uint64_t*)srcBytes)[0] ^= srcKey->qword[0];
|
||||
((uint64_t*)srcBytes)[1] ^= srcKey->qword[1];
|
||||
|
||||
uint8_t ShiftTemp = 0;
|
||||
for (int i = 1; i < 10; ++i) {
|
||||
|
||||
for (int j = 0; j < 16; ++j)
|
||||
srcBytes[j] = accelc_aes_SBox[srcBytes[j]];
|
||||
|
||||
//Shift rows starts;
|
||||
//Shift the second row;
|
||||
Swap(srcBytes[1], srcBytes[5], ShiftTemp)
|
||||
Swap(srcBytes[5], srcBytes[9], ShiftTemp)
|
||||
Swap(srcBytes[9], srcBytes[13], ShiftTemp)
|
||||
//Shift the third row;
|
||||
Swap(srcBytes[2], srcBytes[10], ShiftTemp)
|
||||
Swap(srcBytes[6], srcBytes[14], ShiftTemp)
|
||||
//Shift the fourth row;
|
||||
Swap(srcBytes[3], srcBytes[15], ShiftTemp)
|
||||
Swap(srcBytes[15], srcBytes[11], ShiftTemp)
|
||||
Swap(srcBytes[11], srcBytes[7], ShiftTemp)
|
||||
//Shift rows ends;
|
||||
|
||||
|
||||
for (int j = 0; j < 16; j += 4) {
|
||||
uint8_t temp[4];
|
||||
*(uint32_t*)temp = ((uint32_t*)srcBytes)[j / 4];
|
||||
|
||||
srcBytes[j] = (uint8_t)(accelc_aes_GF2p8_Mul_0x02[temp[0]] ^ accelc_aes_GF2p8_Mul_0x03[temp[1]] ^ temp[2] ^ temp[3]);
|
||||
srcBytes[j + 1] = (uint8_t)(temp[0] ^ accelc_aes_GF2p8_Mul_0x02[temp[1]] ^ accelc_aes_GF2p8_Mul_0x03[temp[2]] ^ temp[3]);
|
||||
srcBytes[j + 2] = (uint8_t)(temp[0] ^ temp[1] ^ accelc_aes_GF2p8_Mul_0x02[temp[2]] ^ accelc_aes_GF2p8_Mul_0x03[temp[3]]);
|
||||
srcBytes[j + 3] = (uint8_t)(accelc_aes_GF2p8_Mul_0x03[temp[0]] ^ temp[1] ^ temp[2] ^ accelc_aes_GF2p8_Mul_0x02[temp[3]]);
|
||||
}
|
||||
|
||||
((uint64_t*)(srcBytes))[0] ^= srcKey->qword[i * 2];
|
||||
((uint64_t*)(srcBytes))[1] ^= srcKey->qword[i * 2 + 1];
|
||||
}
|
||||
|
||||
for (int j = 0; j < 16; ++j)
|
||||
srcBytes[j] = accelc_aes_SBox[srcBytes[j]];
|
||||
|
||||
//Shift rows starts;
|
||||
//Shift the second row;
|
||||
Swap(srcBytes[1], srcBytes[5], ShiftTemp)
|
||||
Swap(srcBytes[5], srcBytes[9], ShiftTemp)
|
||||
Swap(srcBytes[9], srcBytes[13], ShiftTemp)
|
||||
//Shift the third row;
|
||||
Swap(srcBytes[2], srcBytes[10], ShiftTemp)
|
||||
Swap(srcBytes[6], srcBytes[14], ShiftTemp)
|
||||
//Shift the fourth row;
|
||||
Swap(srcBytes[3], srcBytes[15], ShiftTemp)
|
||||
Swap(srcBytes[15], srcBytes[11], ShiftTemp)
|
||||
Swap(srcBytes[11], srcBytes[7], ShiftTemp)
|
||||
//Shift rows ends;
|
||||
|
||||
((uint64_t*)srcBytes)[0] ^= srcKey->qword[20];
|
||||
((uint64_t*)srcBytes)[1] ^= srcKey->qword[21];
|
||||
}
|
||||
|
||||
void accelc_AES128_decrypt(uint8_t srcBytes[AES_BLOCK_SIZE], const AES_KEY* srcKey) {
|
||||
((uint64_t*)srcBytes)[0] ^= srcKey->qword[20];
|
||||
((uint64_t*)srcBytes)[1] ^= srcKey->qword[21];
|
||||
|
||||
uint8_t ShiftTemp = 0;
|
||||
|
||||
for (int i = 9; i > 0; --i) {
|
||||
//Inverse Shift rows starts;
|
||||
//Inverse shift the second row;
|
||||
Swap(srcBytes[13], srcBytes[9], ShiftTemp)
|
||||
Swap(srcBytes[9], srcBytes[5], ShiftTemp)
|
||||
Swap(srcBytes[5], srcBytes[1], ShiftTemp)
|
||||
//Inverse shift the third row;
|
||||
Swap(srcBytes[14], srcBytes[6], ShiftTemp)
|
||||
Swap(srcBytes[10], srcBytes[2], ShiftTemp)
|
||||
//Inverse shift the fourth row;
|
||||
Swap(srcBytes[3], srcBytes[7], ShiftTemp)
|
||||
Swap(srcBytes[7], srcBytes[11], ShiftTemp)
|
||||
Swap(srcBytes[11], srcBytes[15], ShiftTemp)
|
||||
|
||||
for (int j = 0; j < 16; ++j)
|
||||
srcBytes[j] = accelc_aes_InverseSBox[srcBytes[j]];
|
||||
|
||||
((uint64_t*)srcBytes)[0] ^= srcKey->qword[i * 2];
|
||||
((uint64_t*)srcBytes)[1] ^= srcKey->qword[i * 2 + 1];
|
||||
|
||||
for (int j = 0; j < 16; j += 4) {
|
||||
uint8_t temp[4];
|
||||
*(uint32_t*)temp = ((uint32_t*)srcBytes)[j / 4];
|
||||
srcBytes[j] = (uint8_t)(accelc_aes_GF2p8_Mul_0x0E[temp[0]] ^ accelc_aes_GF2p8_Mul_0x0B[temp[1]] ^ accelc_aes_GF2p8_Mul_0x0D[temp[2]] ^ accelc_aes_GF2p8_Mul_0x09[temp[3]]);
|
||||
srcBytes[j + 1] = (uint8_t)(accelc_aes_GF2p8_Mul_0x09[temp[0]] ^ accelc_aes_GF2p8_Mul_0x0E[temp[1]] ^ accelc_aes_GF2p8_Mul_0x0B[temp[2]] ^ accelc_aes_GF2p8_Mul_0x0D[temp[3]]);
|
||||
srcBytes[j + 2] = (uint8_t)(accelc_aes_GF2p8_Mul_0x0D[temp[0]] ^ accelc_aes_GF2p8_Mul_0x09[temp[1]] ^ accelc_aes_GF2p8_Mul_0x0E[temp[2]] ^ accelc_aes_GF2p8_Mul_0x0B[temp[3]]);
|
||||
srcBytes[j + 3] = (uint8_t)(accelc_aes_GF2p8_Mul_0x0B[temp[0]] ^ accelc_aes_GF2p8_Mul_0x0D[temp[1]] ^ accelc_aes_GF2p8_Mul_0x09[temp[2]] ^ accelc_aes_GF2p8_Mul_0x0E[temp[3]]);
|
||||
}
|
||||
}
|
||||
|
||||
//Inverse Shift rows starts;
|
||||
//Inverse shift the second row;
|
||||
Swap(srcBytes[13], srcBytes[9], ShiftTemp)
|
||||
Swap(srcBytes[9], srcBytes[5], ShiftTemp)
|
||||
Swap(srcBytes[5], srcBytes[1], ShiftTemp)
|
||||
//Inverse shift the third row;
|
||||
Swap(srcBytes[14], srcBytes[6], ShiftTemp)
|
||||
Swap(srcBytes[10], srcBytes[2], ShiftTemp)
|
||||
//Inverse shift the fourth row;
|
||||
Swap(srcBytes[3], srcBytes[7], ShiftTemp)
|
||||
Swap(srcBytes[7], srcBytes[11], ShiftTemp)
|
||||
Swap(srcBytes[11], srcBytes[15], ShiftTemp)
|
||||
|
||||
for (int j = 0; j < 16; ++j)
|
||||
srcBytes[j] = accelc_aes_InverseSBox[srcBytes[j]];
|
||||
|
||||
((uint64_t*)srcBytes)[0] ^= srcKey->qword[0];
|
||||
((uint64_t*)srcBytes)[1] ^= srcKey->qword[1];
|
||||
}
|
||||
|
||||
void accelc_AES128_set_key(const uint8_t srcUserKey[16], AES_KEY* dstKey) {
|
||||
dstKey->qword[0] = ((const uint64_t*)srcUserKey)[0];
|
||||
dstKey->qword[1] = ((const uint64_t*)srcUserKey)[1];
|
||||
|
||||
for (int i = 4; i < 44; ++i) {
|
||||
uint32_t temp = dstKey->dword[i - 1];
|
||||
if (i % 4 == 0) {
|
||||
temp = _rotr(temp, 8);
|
||||
((uint8_t*)&temp)[0] = accelc_aes_SBox[((uint8_t*)&temp)[0]];
|
||||
((uint8_t*)&temp)[1] = accelc_aes_SBox[((uint8_t*)&temp)[1]];
|
||||
((uint8_t*)&temp)[2] = accelc_aes_SBox[((uint8_t*)&temp)[2]];
|
||||
((uint8_t*)&temp)[3] = accelc_aes_SBox[((uint8_t*)&temp)[3]];
|
||||
temp ^= accelc_aes_rcon[i / 4];
|
||||
}
|
||||
dstKey->dword[i] = dstKey->dword[i - 4] ^ temp;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
void accelc_AES192_encrypt(uint8_t srcBytes[AES_BLOCK_SIZE], const AES_KEY* srcKey) {
|
||||
((uint64_t*)srcBytes)[0] ^= srcKey->qword[0];
|
||||
((uint64_t*)srcBytes)[1] ^= srcKey->qword[1];
|
||||
|
||||
uint8_t ShiftTemp = 0;
|
||||
for (int i = 1; i < 12; ++i) {
|
||||
|
||||
for (int j = 0; j < 16; ++j)
|
||||
srcBytes[j] = accelc_aes_SBox[srcBytes[j]];
|
||||
|
||||
//Shift rows starts;
|
||||
//Shift the second row;
|
||||
Swap(srcBytes[1], srcBytes[5], ShiftTemp)
|
||||
Swap(srcBytes[5], srcBytes[9], ShiftTemp)
|
||||
Swap(srcBytes[9], srcBytes[13], ShiftTemp)
|
||||
//Shift the third row;
|
||||
Swap(srcBytes[2], srcBytes[10], ShiftTemp)
|
||||
Swap(srcBytes[6], srcBytes[14], ShiftTemp)
|
||||
//Shift the fourth row;
|
||||
Swap(srcBytes[3], srcBytes[15], ShiftTemp)
|
||||
Swap(srcBytes[15], srcBytes[11], ShiftTemp)
|
||||
Swap(srcBytes[11], srcBytes[7], ShiftTemp)
|
||||
//Shift rows ends;
|
||||
|
||||
for (int j = 0; j < 16; j += 4) {
|
||||
uint8_t temp[4];
|
||||
*(uint32_t*)temp = ((uint32_t*)srcBytes)[j / 4];
|
||||
|
||||
srcBytes[j] = (uint8_t)(accelc_aes_GF2p8_Mul_0x02[temp[0]] ^ accelc_aes_GF2p8_Mul_0x03[temp[1]] ^ temp[2] ^ temp[3]);
|
||||
srcBytes[j + 1] = (uint8_t)(temp[0] ^ accelc_aes_GF2p8_Mul_0x02[temp[1]] ^ accelc_aes_GF2p8_Mul_0x03[temp[2]] ^ temp[3]);
|
||||
srcBytes[j + 2] = (uint8_t)(temp[0] ^ temp[1] ^ accelc_aes_GF2p8_Mul_0x02[temp[2]] ^ accelc_aes_GF2p8_Mul_0x03[temp[3]]);
|
||||
srcBytes[j + 3] = (uint8_t)(accelc_aes_GF2p8_Mul_0x03[temp[0]] ^ temp[1] ^ temp[2] ^ accelc_aes_GF2p8_Mul_0x02[temp[3]]);
|
||||
}
|
||||
|
||||
((uint64_t*)srcBytes)[0] ^= srcKey->qword[i * 2];
|
||||
((uint64_t*)srcBytes)[1] ^= srcKey->qword[i * 2 + 1];
|
||||
}
|
||||
|
||||
for (int j = 0; j < 16; ++j)
|
||||
srcBytes[j] = accelc_aes_SBox[srcBytes[j]];
|
||||
|
||||
//Shift rows starts;
|
||||
//Shift the second row;
|
||||
Swap(srcBytes[1], srcBytes[5], ShiftTemp) //Swap is a MACRO, no need to add ';'.
|
||||
Swap(srcBytes[5], srcBytes[9], ShiftTemp)
|
||||
Swap(srcBytes[9], srcBytes[13], ShiftTemp)
|
||||
//Shift the third row;
|
||||
Swap(srcBytes[2], srcBytes[10], ShiftTemp)
|
||||
Swap(srcBytes[6], srcBytes[14], ShiftTemp)
|
||||
//Shift the fourth row;
|
||||
Swap(srcBytes[3], srcBytes[15], ShiftTemp)
|
||||
Swap(srcBytes[15], srcBytes[11], ShiftTemp)
|
||||
Swap(srcBytes[11], srcBytes[7], ShiftTemp)
|
||||
//Shift rows ends;
|
||||
|
||||
((uint64_t*)srcBytes)[0] ^= srcKey->qword[24];
|
||||
((uint64_t*)srcBytes)[1] ^= srcKey->qword[25];
|
||||
}
|
||||
|
||||
void accelc_AES192_decrypt(uint8_t srcBytes[AES_BLOCK_SIZE], const AES_KEY* srcKey) {
|
||||
((uint64_t*)srcBytes)[0] ^= srcKey->qword[24];
|
||||
((uint64_t*)srcBytes)[1] ^= srcKey->qword[25];
|
||||
|
||||
uint8_t ShiftTemp = 0;
|
||||
|
||||
for (int i = 11; i > 0; --i) {
|
||||
//Inverse Shift rows starts;
|
||||
//Inverse shift the second row;
|
||||
Swap(srcBytes[13], srcBytes[9], ShiftTemp)
|
||||
Swap(srcBytes[9], srcBytes[5], ShiftTemp)
|
||||
Swap(srcBytes[5], srcBytes[1], ShiftTemp)
|
||||
//Inverse shift the third row;
|
||||
Swap(srcBytes[14], srcBytes[6], ShiftTemp)
|
||||
Swap(srcBytes[10], srcBytes[2], ShiftTemp)
|
||||
//Inverse shift the fourth row;
|
||||
Swap(srcBytes[3], srcBytes[7], ShiftTemp)
|
||||
Swap(srcBytes[7], srcBytes[11], ShiftTemp)
|
||||
Swap(srcBytes[11], srcBytes[15], ShiftTemp)
|
||||
|
||||
for (int j = 0; j < 16; ++j)
|
||||
srcBytes[j] = accelc_aes_InverseSBox[srcBytes[j]];
|
||||
|
||||
((uint64_t*)srcBytes)[0] ^= srcKey->qword[i * 2];
|
||||
((uint64_t*)srcBytes)[1] ^= srcKey->qword[i * 2 + 1];
|
||||
|
||||
for (int j = 0; j < 16; j += 4) {
|
||||
uint8_t temp[4];
|
||||
*(uint32_t*)temp = ((uint32_t*)srcBytes)[j / 4];
|
||||
srcBytes[j] = (uint8_t)(accelc_aes_GF2p8_Mul_0x0E[temp[0]] ^ accelc_aes_GF2p8_Mul_0x0B[temp[1]] ^ accelc_aes_GF2p8_Mul_0x0D[temp[2]] ^ accelc_aes_GF2p8_Mul_0x09[temp[3]]);
|
||||
srcBytes[j + 1] = (uint8_t)(accelc_aes_GF2p8_Mul_0x09[temp[0]] ^ accelc_aes_GF2p8_Mul_0x0E[temp[1]] ^ accelc_aes_GF2p8_Mul_0x0B[temp[2]] ^ accelc_aes_GF2p8_Mul_0x0D[temp[3]]);
|
||||
srcBytes[j + 2] = (uint8_t)(accelc_aes_GF2p8_Mul_0x0D[temp[0]] ^ accelc_aes_GF2p8_Mul_0x09[temp[1]] ^ accelc_aes_GF2p8_Mul_0x0E[temp[2]] ^ accelc_aes_GF2p8_Mul_0x0B[temp[3]]);
|
||||
srcBytes[j + 3] = (uint8_t)(accelc_aes_GF2p8_Mul_0x0B[temp[0]] ^ accelc_aes_GF2p8_Mul_0x0D[temp[1]] ^ accelc_aes_GF2p8_Mul_0x09[temp[2]] ^ accelc_aes_GF2p8_Mul_0x0E[temp[3]]);
|
||||
}
|
||||
}
|
||||
|
||||
//Inverse Shift rows starts;
|
||||
//Inverse shift the second row;
|
||||
Swap(srcBytes[13], srcBytes[9], ShiftTemp)
|
||||
Swap(srcBytes[9], srcBytes[5], ShiftTemp)
|
||||
Swap(srcBytes[5], srcBytes[1], ShiftTemp)
|
||||
//Inverse shift the third row;
|
||||
Swap(srcBytes[14], srcBytes[6], ShiftTemp)
|
||||
Swap(srcBytes[10], srcBytes[2], ShiftTemp)
|
||||
//Inverse shift the fourth row;
|
||||
Swap(srcBytes[3], srcBytes[7], ShiftTemp)
|
||||
Swap(srcBytes[7], srcBytes[11], ShiftTemp)
|
||||
Swap(srcBytes[11], srcBytes[15], ShiftTemp)
|
||||
|
||||
for (uint8_t j = 0; j < 16; ++j)
|
||||
srcBytes[j] = accelc_aes_InverseSBox[srcBytes[j]];
|
||||
|
||||
((uint64_t*)srcBytes)[0] ^= srcKey->qword[0];
|
||||
((uint64_t*)srcBytes)[1] ^= srcKey->qword[1];
|
||||
}
|
||||
|
||||
void accelc_AES192_set_key(const uint8_t srcUserKey[24], AES_KEY* dstKey) {
|
||||
dstKey->qword[0] = ((const uint64_t*)srcUserKey)[0];
|
||||
dstKey->qword[1] = ((const uint64_t*)srcUserKey)[1];
|
||||
dstKey->qword[2] = ((const uint64_t*)srcUserKey)[2];
|
||||
|
||||
for (int i = 6; i < 52; ++i) {
|
||||
uint32_t temp = dstKey->dword[i - 1];
|
||||
if (i % 6 == 0) {
|
||||
temp = _rotr(temp, 8);
|
||||
((uint8_t*)&temp)[0] = accelc_aes_SBox[((uint8_t*)&temp)[0]];
|
||||
((uint8_t*)&temp)[1] = accelc_aes_SBox[((uint8_t*)&temp)[1]];
|
||||
((uint8_t*)&temp)[2] = accelc_aes_SBox[((uint8_t*)&temp)[2]];
|
||||
((uint8_t*)&temp)[3] = accelc_aes_SBox[((uint8_t*)&temp)[3]];
|
||||
temp ^= accelc_aes_rcon[i / 6];
|
||||
}
|
||||
dstKey->dword[i] = dstKey->dword[i - 6] ^ temp;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
void accelc_AES256_encrypt(uint8_t srcBytes[AES_BLOCK_SIZE], const AES_KEY* srcKey) {
|
||||
((uint64_t*)srcBytes)[0] ^= srcKey->qword[0];
|
||||
((uint64_t*)srcBytes)[1] ^= srcKey->qword[1];
|
||||
|
||||
uint8_t ShiftTemp = 0;
|
||||
for (int i = 1; i < 14; ++i) {
|
||||
|
||||
for (int j = 0; j < 16; ++j)
|
||||
srcBytes[j] = accelc_aes_SBox[srcBytes[j]];
|
||||
|
||||
//Shift rows starts;
|
||||
//Shift the second row;
|
||||
Swap(srcBytes[1], srcBytes[5], ShiftTemp)
|
||||
Swap(srcBytes[5], srcBytes[9], ShiftTemp)
|
||||
Swap(srcBytes[9], srcBytes[13], ShiftTemp)
|
||||
//Shift the third row;
|
||||
Swap(srcBytes[2], srcBytes[10], ShiftTemp)
|
||||
Swap(srcBytes[6], srcBytes[14], ShiftTemp)
|
||||
//Shift the fourth row;
|
||||
Swap(srcBytes[3], srcBytes[15], ShiftTemp)
|
||||
Swap(srcBytes[15], srcBytes[11], ShiftTemp)
|
||||
Swap(srcBytes[11], srcBytes[7], ShiftTemp)
|
||||
//Shift rows ends;
|
||||
|
||||
for (int j = 0; j < 16; j += 4) {
|
||||
uint8_t temp[4];
|
||||
*(uint32_t*)temp = ((uint32_t*)srcBytes)[j / 4];
|
||||
|
||||
srcBytes[j] = (uint8_t)(accelc_aes_GF2p8_Mul_0x02[temp[0]] ^ accelc_aes_GF2p8_Mul_0x03[temp[1]] ^ temp[2] ^ temp[3]);
|
||||
srcBytes[j + 1] = (uint8_t)(temp[0] ^ accelc_aes_GF2p8_Mul_0x02[temp[1]] ^ accelc_aes_GF2p8_Mul_0x03[temp[2]] ^ temp[3]);
|
||||
srcBytes[j + 2] = (uint8_t)(temp[0] ^ temp[1] ^ accelc_aes_GF2p8_Mul_0x02[temp[2]] ^ accelc_aes_GF2p8_Mul_0x03[temp[3]]);
|
||||
srcBytes[j + 3] = (uint8_t)(accelc_aes_GF2p8_Mul_0x03[temp[0]] ^ temp[1] ^ temp[2] ^ accelc_aes_GF2p8_Mul_0x02[temp[3]]);
|
||||
}
|
||||
|
||||
((uint64_t*)srcBytes)[0] ^= srcKey->qword[i * 2];
|
||||
((uint64_t*)srcBytes)[1] ^= srcKey->qword[i * 2 + 1];
|
||||
}
|
||||
|
||||
for (int j = 0; j < 16; ++j)
|
||||
srcBytes[j] = accelc_aes_SBox[srcBytes[j]];
|
||||
|
||||
//Shift rows starts;
|
||||
//Shift the second row;
|
||||
Swap(srcBytes[1], srcBytes[5], ShiftTemp)
|
||||
Swap(srcBytes[5], srcBytes[9], ShiftTemp)
|
||||
Swap(srcBytes[9], srcBytes[13], ShiftTemp)
|
||||
//Shift the third row;
|
||||
Swap(srcBytes[2], srcBytes[10], ShiftTemp)
|
||||
Swap(srcBytes[6], srcBytes[14], ShiftTemp)
|
||||
//Shift the fourth row;
|
||||
Swap(srcBytes[3], srcBytes[15], ShiftTemp)
|
||||
Swap(srcBytes[15], srcBytes[11], ShiftTemp)
|
||||
Swap(srcBytes[11], srcBytes[7], ShiftTemp)
|
||||
//Shift rows ends;
|
||||
|
||||
((uint64_t*)srcBytes)[0] ^= srcKey->qword[28];
|
||||
((uint64_t*)srcBytes)[1] ^= srcKey->qword[29];
|
||||
}
|
||||
|
||||
void accelc_AES256_decrypt(uint8_t srcBytes[AES_BLOCK_SIZE], const AES_KEY* srcKey) {
|
||||
((uint64_t*)srcBytes)[0] ^= srcKey->qword[28];
|
||||
((uint64_t*)srcBytes)[1] ^= srcKey->qword[29];
|
||||
|
||||
uint8_t ShiftTemp = 0;
|
||||
for (int i = 13; i > 0; --i) {
|
||||
//Inverse Shift rows starts;
|
||||
//Inverse shift the second row;
|
||||
Swap(srcBytes[13], srcBytes[9], ShiftTemp)
|
||||
Swap(srcBytes[9], srcBytes[5], ShiftTemp)
|
||||
Swap(srcBytes[5], srcBytes[1], ShiftTemp)
|
||||
//Inverse shift the third row;
|
||||
Swap(srcBytes[14], srcBytes[6], ShiftTemp)
|
||||
Swap(srcBytes[10], srcBytes[2], ShiftTemp)
|
||||
//Inverse shift the fourth row;
|
||||
Swap(srcBytes[3], srcBytes[7], ShiftTemp)
|
||||
Swap(srcBytes[7], srcBytes[11], ShiftTemp)
|
||||
Swap(srcBytes[11], srcBytes[15], ShiftTemp)
|
||||
|
||||
for (int j = 0; j < 16; ++j)
|
||||
srcBytes[j] = accelc_aes_InverseSBox[srcBytes[j]];
|
||||
|
||||
((uint64_t*)srcBytes)[0] ^= srcKey->qword[i * 2];
|
||||
((uint64_t*)srcBytes)[1] ^= srcKey->qword[i * 2 + 1];
|
||||
|
||||
for (int j = 0; j < 16; j += 4) {
|
||||
uint8_t temp[4];
|
||||
*(uint32_t*)temp = ((uint32_t*)srcBytes)[j / 4];
|
||||
|
||||
srcBytes[j] = (uint8_t)(accelc_aes_GF2p8_Mul_0x0E[temp[0]] ^ accelc_aes_GF2p8_Mul_0x0B[temp[1]] ^ accelc_aes_GF2p8_Mul_0x0D[temp[2]] ^ accelc_aes_GF2p8_Mul_0x09[temp[3]]);
|
||||
srcBytes[j + 1] = (uint8_t)(accelc_aes_GF2p8_Mul_0x09[temp[0]] ^ accelc_aes_GF2p8_Mul_0x0E[temp[1]] ^ accelc_aes_GF2p8_Mul_0x0B[temp[2]] ^ accelc_aes_GF2p8_Mul_0x0D[temp[3]]);
|
||||
srcBytes[j + 2] = (uint8_t)(accelc_aes_GF2p8_Mul_0x0D[temp[0]] ^ accelc_aes_GF2p8_Mul_0x09[temp[1]] ^ accelc_aes_GF2p8_Mul_0x0E[temp[2]] ^ accelc_aes_GF2p8_Mul_0x0B[temp[3]]);
|
||||
srcBytes[j + 3] = (uint8_t)(accelc_aes_GF2p8_Mul_0x0B[temp[0]] ^ accelc_aes_GF2p8_Mul_0x0D[temp[1]] ^ accelc_aes_GF2p8_Mul_0x09[temp[2]] ^ accelc_aes_GF2p8_Mul_0x0E[temp[3]]);
|
||||
}
|
||||
}
|
||||
|
||||
//Inverse Shift rows starts;
|
||||
//Inverse shift the second row;
|
||||
Swap(srcBytes[13], srcBytes[9], ShiftTemp)
|
||||
Swap(srcBytes[9], srcBytes[5], ShiftTemp)
|
||||
Swap(srcBytes[5], srcBytes[1], ShiftTemp)
|
||||
//Inverse shift the third row;
|
||||
Swap(srcBytes[14], srcBytes[6], ShiftTemp)
|
||||
Swap(srcBytes[10], srcBytes[2], ShiftTemp)
|
||||
//Inverse shift the fourth row;
|
||||
Swap(srcBytes[3], srcBytes[7], ShiftTemp)
|
||||
Swap(srcBytes[7], srcBytes[11], ShiftTemp)
|
||||
Swap(srcBytes[11], srcBytes[15], ShiftTemp)
|
||||
|
||||
for (int j = 0; j < 16; ++j)
|
||||
srcBytes[j] = accelc_aes_InverseSBox[srcBytes[j]];
|
||||
|
||||
((uint64_t*)srcBytes)[0] ^= srcKey->qword[0];
|
||||
((uint64_t*)srcBytes)[1] ^= srcKey->qword[1];
|
||||
}
|
||||
|
||||
void accelc_AES256_set_key(const uint8_t srcUserKey[32], AES_KEY* dstKey) {
|
||||
dstKey->qword[0] = ((const uint64_t*)srcUserKey)[0];
|
||||
dstKey->qword[1] = ((const uint64_t*)srcUserKey)[1];
|
||||
dstKey->qword[2] = ((const uint64_t*)srcUserKey)[2];
|
||||
dstKey->qword[3] = ((const uint64_t*)srcUserKey)[3];
|
||||
|
||||
for (int i = 8; i < 60; ++i) {
|
||||
uint32_t temp = dstKey->dword[i - 1];
|
||||
if (i % 8 == 0) {
|
||||
temp = _rotr(temp, 8);
|
||||
((uint8_t*)&temp)[0] = accelc_aes_SBox[((uint8_t*)&temp)[0]];
|
||||
((uint8_t*)&temp)[1] = accelc_aes_SBox[((uint8_t*)&temp)[1]];
|
||||
((uint8_t*)&temp)[2] = accelc_aes_SBox[((uint8_t*)&temp)[2]];
|
||||
((uint8_t*)&temp)[3] = accelc_aes_SBox[((uint8_t*)&temp)[3]];
|
||||
temp ^= accelc_aes_rcon[i / 8];
|
||||
}
|
||||
if (i % 8 == 4) {
|
||||
((uint8_t*)&temp)[0] = accelc_aes_SBox[((uint8_t*)&temp)[0]];
|
||||
((uint8_t*)&temp)[1] = accelc_aes_SBox[((uint8_t*)&temp)[1]];
|
||||
((uint8_t*)&temp)[2] = accelc_aes_SBox[((uint8_t*)&temp)[2]];
|
||||
((uint8_t*)&temp)[3] = accelc_aes_SBox[((uint8_t*)&temp)[3]];
|
||||
}
|
||||
dstKey->dword[i] = dstKey->dword[i - 8] ^ temp;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,82 @@
|
||||
#pragma once
|
||||
#include <stdint.h>
|
||||
#include <stddef.h>
|
||||
|
||||
#if defined(__cplusplus)
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#define AES_BLOCK_SIZE 16
|
||||
#define AES128_USERKEY_LENGTH 16
|
||||
#define AES192_USERKEY_LENGTH 24
|
||||
#define AES256_USERKEY_LENGTH 32
|
||||
|
||||
typedef struct _AES_KEY {
|
||||
union {
|
||||
uint8_t byte[240];
|
||||
uint16_t word[120];
|
||||
uint32_t dword[60];
|
||||
uint64_t qword[30];
|
||||
};
|
||||
} AES_KEY;
|
||||
|
||||
//
|
||||
// encrypt
|
||||
//
|
||||
void accelc_AES128_encrypt(uint8_t srcBytes[AES_BLOCK_SIZE], const AES_KEY* srcKey);
|
||||
void accelc_AES192_encrypt(uint8_t srcBytes[AES_BLOCK_SIZE], const AES_KEY* srcKey);
|
||||
void accelc_AES256_encrypt(uint8_t srcBytes[AES_BLOCK_SIZE], const AES_KEY* srcKey);
|
||||
|
||||
//
|
||||
// dncrypt
|
||||
//
|
||||
void accelc_AES128_decrypt(uint8_t srcBytes[AES_BLOCK_SIZE], const AES_KEY* srcKey);
|
||||
void accelc_AES192_decrypt(uint8_t srcBytes[AES_BLOCK_SIZE], const AES_KEY* srcKey);
|
||||
void accelc_AES256_decrypt(uint8_t srcBytes[AES_BLOCK_SIZE], const AES_KEY* srcKey);
|
||||
|
||||
//
|
||||
// set_key
|
||||
//
|
||||
void accelc_AES128_set_key(const uint8_t srcUserKey[AES128_USERKEY_LENGTH], AES_KEY* dstKey);
|
||||
void accelc_AES192_set_key(const uint8_t srcUserKey[AES192_USERKEY_LENGTH], AES_KEY* dstKey);
|
||||
void accelc_AES256_set_key(const uint8_t srcUserKey[AES256_USERKEY_LENGTH], AES_KEY* dstKey);
|
||||
|
||||
//
|
||||
// encrypt_aesni
|
||||
//
|
||||
void accelc_AES128_encrypt_aesni(uint8_t srcBytes[AES_BLOCK_SIZE], const AES_KEY* srcKey);
|
||||
void accelc_AES192_encrypt_aesni(uint8_t srcBytes[AES_BLOCK_SIZE], const AES_KEY* srcKey);
|
||||
void accelc_AES256_encrypt_aesni(uint8_t srcBytes[AES_BLOCK_SIZE], const AES_KEY* srcKey);
|
||||
|
||||
//
|
||||
// decrypt_aesni
|
||||
//
|
||||
void accelc_AES128_decrypt_aesni(uint8_t srcBytes[AES_BLOCK_SIZE], const AES_KEY* srcKey);
|
||||
void accelc_AES192_decrypt_aesni(uint8_t srcBytes[AES_BLOCK_SIZE], const AES_KEY* srcKey);
|
||||
void accelc_AES256_decrypt_aesni(uint8_t srcBytes[AES_BLOCK_SIZE], const AES_KEY* srcKey);
|
||||
|
||||
//
|
||||
// decrypt_aesni_fast
|
||||
//
|
||||
void accelc_AES128_decrypt_aesni_fast(uint8_t srcBytes[AES_BLOCK_SIZE], const AES_KEY* srcInverseKey);
|
||||
void accelc_AES192_decrypt_aesni_fast(uint8_t srcBytes[AES_BLOCK_SIZE], const AES_KEY* srcInverseKey);
|
||||
void accelc_AES256_decrypt_aesni_fast(uint8_t srcBytes[AES_BLOCK_SIZE], const AES_KEY* srcInverseKey);
|
||||
|
||||
//
|
||||
// set_key_aesni
|
||||
//
|
||||
void accelc_AES128_set_key_aesni(const uint8_t srcUserKey[AES128_USERKEY_LENGTH], AES_KEY* dstKey);
|
||||
void accelc_AES192_set_key_aesni(const uint8_t srcUserKey[AES128_USERKEY_LENGTH], AES_KEY* dstKey);
|
||||
void accelc_AES256_set_key_aesni(const uint8_t srcUserKey[AES256_USERKEY_LENGTH], AES_KEY* dstKey);
|
||||
|
||||
//
|
||||
// set_invkey_aesni
|
||||
//
|
||||
void accelc_AES128_set_invkey_aesni(const AES_KEY* __restrict srcKey, AES_KEY* __restrict dstInverseKey);
|
||||
void accelc_AES192_set_invkey_aesni(const AES_KEY* __restrict srcKey, AES_KEY* __restrict dstInverseKey);
|
||||
void accelc_AES256_set_invkey_aesni(const AES_KEY* __restrict srcKey, AES_KEY* __restrict dstInverseKey);
|
||||
|
||||
#if defined(__cplusplus)
|
||||
}
|
||||
#endif
|
||||
|
||||
@@ -0,0 +1,157 @@
|
||||
#include <stdint.h>
|
||||
|
||||
const uint8_t accelc_aes_SBox[256] = {
|
||||
0x63, 0x7C, 0x77, 0x7B, 0xF2, 0x6B, 0x6F, 0xC5, 0x30, 0x01, 0x67, 0x2B, 0xFE, 0xD7, 0xAB, 0x76,
|
||||
0xCA, 0x82, 0xC9, 0x7D, 0xFA, 0x59, 0x47, 0xF0, 0xAD, 0xD4, 0xA2, 0xAF, 0x9C, 0xA4, 0x72, 0xC0,
|
||||
0xB7, 0xFD, 0x93, 0x26, 0x36, 0x3F, 0xF7, 0xCC, 0x34, 0xA5, 0xE5, 0xF1, 0x71, 0xD8, 0x31, 0x15,
|
||||
0x04, 0xC7, 0x23, 0xC3, 0x18, 0x96, 0x05, 0x9A, 0x07, 0x12, 0x80, 0xE2, 0xEB, 0x27, 0xB2, 0x75,
|
||||
0x09, 0x83, 0x2C, 0x1A, 0x1B, 0x6E, 0x5A, 0xA0, 0x52, 0x3B, 0xD6, 0xB3, 0x29, 0xE3, 0x2F, 0x84,
|
||||
0x53, 0xD1, 0x00, 0xED, 0x20, 0xFC, 0xB1, 0x5B, 0x6A, 0xCB, 0xBE, 0x39, 0x4A, 0x4C, 0x58, 0xCF,
|
||||
0xD0, 0xEF, 0xAA, 0xFB, 0x43, 0x4D, 0x33, 0x85, 0x45, 0xF9, 0x02, 0x7F, 0x50, 0x3C, 0x9F, 0xA8,
|
||||
0x51, 0xA3, 0x40, 0x8F, 0x92, 0x9D, 0x38, 0xF5, 0xBC, 0xB6, 0xDA, 0x21, 0x10, 0xFF, 0xF3, 0xD2,
|
||||
0xCD, 0x0C, 0x13, 0xEC, 0x5F, 0x97, 0x44, 0x17, 0xC4, 0xA7, 0x7E, 0x3D, 0x64, 0x5D, 0x19, 0x73,
|
||||
0x60, 0x81, 0x4F, 0xDC, 0x22, 0x2A, 0x90, 0x88, 0x46, 0xEE, 0xB8, 0x14, 0xDE, 0x5E, 0x0B, 0xDB,
|
||||
0xE0, 0x32, 0x3A, 0x0A, 0x49, 0x06, 0x24, 0x5C, 0xC2, 0xD3, 0xAC, 0x62, 0x91, 0x95, 0xE4, 0x79,
|
||||
0xE7, 0xC8, 0x37, 0x6D, 0x8D, 0xD5, 0x4E, 0xA9, 0x6C, 0x56, 0xF4, 0xEA, 0x65, 0x7A, 0xAE, 0x08,
|
||||
0xBA, 0x78, 0x25, 0x2E, 0x1C, 0xA6, 0xB4, 0xC6, 0xE8, 0xDD, 0x74, 0x1F, 0x4B, 0xBD, 0x8B, 0x8A,
|
||||
0x70, 0x3E, 0xB5, 0x66, 0x48, 0x03, 0xF6, 0x0E, 0x61, 0x35, 0x57, 0xB9, 0x86, 0xC1, 0x1D, 0x9E,
|
||||
0xE1, 0xF8, 0x98, 0x11, 0x69, 0xD9, 0x8E, 0x94, 0x9B, 0x1E, 0x87, 0xE9, 0xCE, 0x55, 0x28, 0xDF,
|
||||
0x8C, 0xA1, 0x89, 0x0D, 0xBF, 0xE6, 0x42, 0x68, 0x41, 0x99, 0x2D, 0x0F, 0xB0, 0x54, 0xBB, 0x16
|
||||
};
|
||||
|
||||
const uint32_t accelc_aes_rcon[11] = {
|
||||
0x00, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1B, 0x36
|
||||
};
|
||||
|
||||
const uint8_t accelc_aes_GF2p8_Mul_0x02[256] = {
|
||||
0x00, 0x02, 0x04, 0x06, 0x08, 0x0A, 0x0C, 0x0E, 0x10, 0x12, 0x14, 0x16, 0x18, 0x1A, 0x1C, 0x1E,
|
||||
0x20, 0x22, 0x24, 0x26, 0x28, 0x2A, 0x2C, 0x2E, 0x30, 0x32, 0x34, 0x36, 0x38, 0x3A, 0x3C, 0x3E,
|
||||
0x40, 0x42, 0x44, 0x46, 0x48, 0x4A, 0x4C, 0x4E, 0x50, 0x52, 0x54, 0x56, 0x58, 0x5A, 0x5C, 0x5E,
|
||||
0x60, 0x62, 0x64, 0x66, 0x68, 0x6A, 0x6C, 0x6E, 0x70, 0x72, 0x74, 0x76, 0x78, 0x7A, 0x7C, 0x7E,
|
||||
0x80, 0x82, 0x84, 0x86, 0x88, 0x8A, 0x8C, 0x8E, 0x90, 0x92, 0x94, 0x96, 0x98, 0x9A, 0x9C, 0x9E,
|
||||
0xA0, 0xA2, 0xA4, 0xA6, 0xA8, 0xAA, 0xAC, 0xAE, 0xB0, 0xB2, 0xB4, 0xB6, 0xB8, 0xBA, 0xBC, 0xBE,
|
||||
0xC0, 0xC2, 0xC4, 0xC6, 0xC8, 0xCA, 0xCC, 0xCE, 0xD0, 0xD2, 0xD4, 0xD6, 0xD8, 0xDA, 0xDC, 0xDE,
|
||||
0xE0, 0xE2, 0xE4, 0xE6, 0xE8, 0xEA, 0xEC, 0xEE, 0xF0, 0xF2, 0xF4, 0xF6, 0xF8, 0xFA, 0xFC, 0xFE,
|
||||
0x1B, 0x19, 0x1F, 0x1D, 0x13, 0x11, 0x17, 0x15, 0x0B, 0x09, 0x0F, 0x0D, 0x03, 0x01, 0x07, 0x05,
|
||||
0x3B, 0x39, 0x3F, 0x3D, 0x33, 0x31, 0x37, 0x35, 0x2B, 0x29, 0x2F, 0x2D, 0x23, 0x21, 0x27, 0x25,
|
||||
0x5B, 0x59, 0x5F, 0x5D, 0x53, 0x51, 0x57, 0x55, 0x4B, 0x49, 0x4F, 0x4D, 0x43, 0x41, 0x47, 0x45,
|
||||
0x7B, 0x79, 0x7F, 0x7D, 0x73, 0x71, 0x77, 0x75, 0x6B, 0x69, 0x6F, 0x6D, 0x63, 0x61, 0x67, 0x65,
|
||||
0x9B, 0x99, 0x9F, 0x9D, 0x93, 0x91, 0x97, 0x95, 0x8B, 0x89, 0x8F, 0x8D, 0x83, 0x81, 0x87, 0x85,
|
||||
0xBB, 0xB9, 0xBF, 0xBD, 0xB3, 0xB1, 0xB7, 0xB5, 0xAB, 0xA9, 0xAF, 0xAD, 0xA3, 0xA1, 0xA7, 0xA5,
|
||||
0xDB, 0xD9, 0xDF, 0xDD, 0xD3, 0xD1, 0xD7, 0xD5, 0xCB, 0xC9, 0xCF, 0xCD, 0xC3, 0xC1, 0xC7, 0xC5,
|
||||
0xFB, 0xF9, 0xFF, 0xFD, 0xF3, 0xF1, 0xF7, 0xF5, 0xEB, 0xE9, 0xEF, 0xED, 0xE3, 0xE1, 0xE7, 0xE5
|
||||
};
|
||||
|
||||
const uint8_t accelc_aes_GF2p8_Mul_0x03[256] = {
|
||||
0x00, 0x03, 0x06, 0x05, 0x0C, 0x0F, 0x0A, 0x09, 0x18, 0x1B, 0x1E, 0x1D, 0x14, 0x17, 0x12, 0x11,
|
||||
0x30, 0x33, 0x36, 0x35, 0x3C, 0x3F, 0x3A, 0x39, 0x28, 0x2B, 0x2E, 0x2D, 0x24, 0x27, 0x22, 0x21,
|
||||
0x60, 0x63, 0x66, 0x65, 0x6C, 0x6F, 0x6A, 0x69, 0x78, 0x7B, 0x7E, 0x7D, 0x74, 0x77, 0x72, 0x71,
|
||||
0x50, 0x53, 0x56, 0x55, 0x5C, 0x5F, 0x5A, 0x59, 0x48, 0x4B, 0x4E, 0x4D, 0x44, 0x47, 0x42, 0x41,
|
||||
0xC0, 0xC3, 0xC6, 0xC5, 0xCC, 0xCF, 0xCA, 0xC9, 0xD8, 0xDB, 0xDE, 0xDD, 0xD4, 0xD7, 0xD2, 0xD1,
|
||||
0xF0, 0xF3, 0xF6, 0xF5, 0xFC, 0xFF, 0xFA, 0xF9, 0xE8, 0xEB, 0xEE, 0xED, 0xE4, 0xE7, 0xE2, 0xE1,
|
||||
0xA0, 0xA3, 0xA6, 0xA5, 0xAC, 0xAF, 0xAA, 0xA9, 0xB8, 0xBB, 0xBE, 0xBD, 0xB4, 0xB7, 0xB2, 0xB1,
|
||||
0x90, 0x93, 0x96, 0x95, 0x9C, 0x9F, 0x9A, 0x99, 0x88, 0x8B, 0x8E, 0x8D, 0x84, 0x87, 0x82, 0x81,
|
||||
0x9B, 0x98, 0x9D, 0x9E, 0x97, 0x94, 0x91, 0x92, 0x83, 0x80, 0x85, 0x86, 0x8F, 0x8C, 0x89, 0x8A,
|
||||
0xAB, 0xA8, 0xAD, 0xAE, 0xA7, 0xA4, 0xA1, 0xA2, 0xB3, 0xB0, 0xB5, 0xB6, 0xBF, 0xBC, 0xB9, 0xBA,
|
||||
0xFB, 0xF8, 0xFD, 0xFE, 0xF7, 0xF4, 0xF1, 0xF2, 0xE3, 0xE0, 0xE5, 0xE6, 0xEF, 0xEC, 0xE9, 0xEA,
|
||||
0xCB, 0xC8, 0xCD, 0xCE, 0xC7, 0xC4, 0xC1, 0xC2, 0xD3, 0xD0, 0xD5, 0xD6, 0xDF, 0xDC, 0xD9, 0xDA,
|
||||
0x5B, 0x58, 0x5D, 0x5E, 0x57, 0x54, 0x51, 0x52, 0x43, 0x40, 0x45, 0x46, 0x4F, 0x4C, 0x49, 0x4A,
|
||||
0x6B, 0x68, 0x6D, 0x6E, 0x67, 0x64, 0x61, 0x62, 0x73, 0x70, 0x75, 0x76, 0x7F, 0x7C, 0x79, 0x7A,
|
||||
0x3B, 0x38, 0x3D, 0x3E, 0x37, 0x34, 0x31, 0x32, 0x23, 0x20, 0x25, 0x26, 0x2F, 0x2C, 0x29, 0x2A,
|
||||
0x0B, 0x08, 0x0D, 0x0E, 0x07, 0x04, 0x01, 0x02, 0x13, 0x10, 0x15, 0x16, 0x1F, 0x1C, 0x19, 0x1A
|
||||
};
|
||||
|
||||
const uint8_t accelc_aes_InverseSBox[256] = {
|
||||
0x52, 0x09, 0x6A, 0xD5, 0x30, 0x36, 0xA5, 0x38, 0xBF, 0x40, 0xA3, 0x9E, 0x81, 0xF3, 0xD7, 0xFB,
|
||||
0x7C, 0xE3, 0x39, 0x82, 0x9B, 0x2F, 0xFF, 0x87, 0x34, 0x8E, 0x43, 0x44, 0xC4, 0xDE, 0xE9, 0xCB,
|
||||
0x54, 0x7B, 0x94, 0x32, 0xA6, 0xC2, 0x23, 0x3D, 0xEE, 0x4C, 0x95, 0x0B, 0x42, 0xFA, 0xC3, 0x4E,
|
||||
0x08, 0x2E, 0xA1, 0x66, 0x28, 0xD9, 0x24, 0xB2, 0x76, 0x5B, 0xA2, 0x49, 0x6D, 0x8B, 0xD1, 0x25,
|
||||
0x72, 0xF8, 0xF6, 0x64, 0x86, 0x68, 0x98, 0x16, 0xD4, 0xA4, 0x5C, 0xCC, 0x5D, 0x65, 0xB6, 0x92,
|
||||
0x6C, 0x70, 0x48, 0x50, 0xFD, 0xED, 0xB9, 0xDA, 0x5E, 0x15, 0x46, 0x57, 0xA7, 0x8D, 0x9D, 0x84,
|
||||
0x90, 0xD8, 0xAB, 0x00, 0x8C, 0xBC, 0xD3, 0x0A, 0xF7, 0xE4, 0x58, 0x05, 0xB8, 0xB3, 0x45, 0x06,
|
||||
0xD0, 0x2C, 0x1E, 0x8F, 0xCA, 0x3F, 0x0F, 0x02, 0xC1, 0xAF, 0xBD, 0x03, 0x01, 0x13, 0x8A, 0x6B,
|
||||
0x3A, 0x91, 0x11, 0x41, 0x4F, 0x67, 0xDC, 0xEA, 0x97, 0xF2, 0xCF, 0xCE, 0xF0, 0xB4, 0xE6, 0x73,
|
||||
0x96, 0xAC, 0x74, 0x22, 0xE7, 0xAD, 0x35, 0x85, 0xE2, 0xF9, 0x37, 0xE8, 0x1C, 0x75, 0xDF, 0x6E,
|
||||
0x47, 0xF1, 0x1A, 0x71, 0x1D, 0x29, 0xC5, 0x89, 0x6F, 0xB7, 0x62, 0x0E, 0xAA, 0x18, 0xBE, 0x1B,
|
||||
0xFC, 0x56, 0x3E, 0x4B, 0xC6, 0xD2, 0x79, 0x20, 0x9A, 0xDB, 0xC0, 0xFE, 0x78, 0xCD, 0x5A, 0xF4,
|
||||
0x1F, 0xDD, 0xA8, 0x33, 0x88, 0x07, 0xC7, 0x31, 0xB1, 0x12, 0x10, 0x59, 0x27, 0x80, 0xEC, 0x5F,
|
||||
0x60, 0x51, 0x7F, 0xA9, 0x19, 0xB5, 0x4A, 0x0D, 0x2D, 0xE5, 0x7A, 0x9F, 0x93, 0xC9, 0x9C, 0xEF,
|
||||
0xA0, 0xE0, 0x3B, 0x4D, 0xAE, 0x2A, 0xF5, 0xB0, 0xC8, 0xEB, 0xBB, 0x3C, 0x83, 0x53, 0x99, 0x61,
|
||||
0x17, 0x2B, 0x04, 0x7E, 0xBA, 0x77, 0xD6, 0x26, 0xE1, 0x69, 0x14, 0x63, 0x55, 0x21, 0x0C, 0x7D
|
||||
};
|
||||
|
||||
const uint8_t accelc_aes_GF2p8_Mul_0x09[256] = {
|
||||
0x00, 0x09, 0x12, 0x1B, 0x24, 0x2D, 0x36, 0x3F, 0x48, 0x41, 0x5A, 0x53, 0x6C, 0x65, 0x7E, 0x77,
|
||||
0x90, 0x99, 0x82, 0x8B, 0xB4, 0xBD, 0xA6, 0xAF, 0xD8, 0xD1, 0xCA, 0xC3, 0xFC, 0xF5, 0xEE, 0xE7,
|
||||
0x3B, 0x32, 0x29, 0x20, 0x1F, 0x16, 0x0D, 0x04, 0x73, 0x7A, 0x61, 0x68, 0x57, 0x5E, 0x45, 0x4C,
|
||||
0xAB, 0xA2, 0xB9, 0xB0, 0x8F, 0x86, 0x9D, 0x94, 0xE3, 0xEA, 0xF1, 0xF8, 0xC7, 0xCE, 0xD5, 0xDC,
|
||||
0x76, 0x7F, 0x64, 0x6D, 0x52, 0x5B, 0x40, 0x49, 0x3E, 0x37, 0x2C, 0x25, 0x1A, 0x13, 0x08, 0x01,
|
||||
0xE6, 0xEF, 0xF4, 0xFD, 0xC2, 0xCB, 0xD0, 0xD9, 0xAE, 0xA7, 0xBC, 0xB5, 0x8A, 0x83, 0x98, 0x91,
|
||||
0x4D, 0x44, 0x5F, 0x56, 0x69, 0x60, 0x7B, 0x72, 0x05, 0x0C, 0x17, 0x1E, 0x21, 0x28, 0x33, 0x3A,
|
||||
0xDD, 0xD4, 0xCF, 0xC6, 0xF9, 0xF0, 0xEB, 0xE2, 0x95, 0x9C, 0x87, 0x8E, 0xB1, 0xB8, 0xA3, 0xAA,
|
||||
0xEC, 0xE5, 0xFE, 0xF7, 0xC8, 0xC1, 0xDA, 0xD3, 0xA4, 0xAD, 0xB6, 0xBF, 0x80, 0x89, 0x92, 0x9B,
|
||||
0x7C, 0x75, 0x6E, 0x67, 0x58, 0x51, 0x4A, 0x43, 0x34, 0x3D, 0x26, 0x2F, 0x10, 0x19, 0x02, 0x0B,
|
||||
0xD7, 0xDE, 0xC5, 0xCC, 0xF3, 0xFA, 0xE1, 0xE8, 0x9F, 0x96, 0x8D, 0x84, 0xBB, 0xB2, 0xA9, 0xA0,
|
||||
0x47, 0x4E, 0x55, 0x5C, 0x63, 0x6A, 0x71, 0x78, 0x0F, 0x06, 0x1D, 0x14, 0x2B, 0x22, 0x39, 0x30,
|
||||
0x9A, 0x93, 0x88, 0x81, 0xBE, 0xB7, 0xAC, 0xA5, 0xD2, 0xDB, 0xC0, 0xC9, 0xF6, 0xFF, 0xE4, 0xED,
|
||||
0x0A, 0x03, 0x18, 0x11, 0x2E, 0x27, 0x3C, 0x35, 0x42, 0x4B, 0x50, 0x59, 0x66, 0x6F, 0x74, 0x7D,
|
||||
0xA1, 0xA8, 0xB3, 0xBA, 0x85, 0x8C, 0x97, 0x9E, 0xE9, 0xE0, 0xFB, 0xF2, 0xCD, 0xC4, 0xDF, 0xD6,
|
||||
0x31, 0x38, 0x23, 0x2A, 0x15, 0x1C, 0x07, 0x0E, 0x79, 0x70, 0x6B, 0x62, 0x5D, 0x54, 0x4F, 0x46
|
||||
};
|
||||
|
||||
const uint8_t accelc_aes_GF2p8_Mul_0x0B[256] = {
|
||||
0x00, 0x0B, 0x16, 0x1D, 0x2C, 0x27, 0x3A, 0x31, 0x58, 0x53, 0x4E, 0x45, 0x74, 0x7F, 0x62, 0x69,
|
||||
0xB0, 0xBB, 0xA6, 0xAD, 0x9C, 0x97, 0x8A, 0x81, 0xE8, 0xE3, 0xFE, 0xF5, 0xC4, 0xCF, 0xD2, 0xD9,
|
||||
0x7B, 0x70, 0x6D, 0x66, 0x57, 0x5C, 0x41, 0x4A, 0x23, 0x28, 0x35, 0x3E, 0x0F, 0x04, 0x19, 0x12,
|
||||
0xCB, 0xC0, 0xDD, 0xD6, 0xE7, 0xEC, 0xF1, 0xFA, 0x93, 0x98, 0x85, 0x8E, 0xBF, 0xB4, 0xA9, 0xA2,
|
||||
0xF6, 0xFD, 0xE0, 0xEB, 0xDA, 0xD1, 0xCC, 0xC7, 0xAE, 0xA5, 0xB8, 0xB3, 0x82, 0x89, 0x94, 0x9F,
|
||||
0x46, 0x4D, 0x50, 0x5B, 0x6A, 0x61, 0x7C, 0x77, 0x1E, 0x15, 0x08, 0x03, 0x32, 0x39, 0x24, 0x2F,
|
||||
0x8D, 0x86, 0x9B, 0x90, 0xA1, 0xAA, 0xB7, 0xBC, 0xD5, 0xDE, 0xC3, 0xC8, 0xF9, 0xF2, 0xEF, 0xE4,
|
||||
0x3D, 0x36, 0x2B, 0x20, 0x11, 0x1A, 0x07, 0x0C, 0x65, 0x6E, 0x73, 0x78, 0x49, 0x42, 0x5F, 0x54,
|
||||
0xF7, 0xFC, 0xE1, 0xEA, 0xDB, 0xD0, 0xCD, 0xC6, 0xAF, 0xA4, 0xB9, 0xB2, 0x83, 0x88, 0x95, 0x9E,
|
||||
0x47, 0x4C, 0x51, 0x5A, 0x6B, 0x60, 0x7D, 0x76, 0x1F, 0x14, 0x09, 0x02, 0x33, 0x38, 0x25, 0x2E,
|
||||
0x8C, 0x87, 0x9A, 0x91, 0xA0, 0xAB, 0xB6, 0xBD, 0xD4, 0xDF, 0xC2, 0xC9, 0xF8, 0xF3, 0xEE, 0xE5,
|
||||
0x3C, 0x37, 0x2A, 0x21, 0x10, 0x1B, 0x06, 0x0D, 0x64, 0x6F, 0x72, 0x79, 0x48, 0x43, 0x5E, 0x55,
|
||||
0x01, 0x0A, 0x17, 0x1C, 0x2D, 0x26, 0x3B, 0x30, 0x59, 0x52, 0x4F, 0x44, 0x75, 0x7E, 0x63, 0x68,
|
||||
0xB1, 0xBA, 0xA7, 0xAC, 0x9D, 0x96, 0x8B, 0x80, 0xE9, 0xE2, 0xFF, 0xF4, 0xC5, 0xCE, 0xD3, 0xD8,
|
||||
0x7A, 0x71, 0x6C, 0x67, 0x56, 0x5D, 0x40, 0x4B, 0x22, 0x29, 0x34, 0x3F, 0x0E, 0x05, 0x18, 0x13,
|
||||
0xCA, 0xC1, 0xDC, 0xD7, 0xE6, 0xED, 0xF0, 0xFB, 0x92, 0x99, 0x84, 0x8F, 0xBE, 0xB5, 0xA8, 0xA3
|
||||
};
|
||||
|
||||
const uint8_t accelc_aes_GF2p8_Mul_0x0D[256] = {
|
||||
0x00, 0x0D, 0x1A, 0x17, 0x34, 0x39, 0x2E, 0x23, 0x68, 0x65, 0x72, 0x7F, 0x5C, 0x51, 0x46, 0x4B,
|
||||
0xD0, 0xDD, 0xCA, 0xC7, 0xE4, 0xE9, 0xFE, 0xF3, 0xB8, 0xB5, 0xA2, 0xAF, 0x8C, 0x81, 0x96, 0x9B,
|
||||
0xBB, 0xB6, 0xA1, 0xAC, 0x8F, 0x82, 0x95, 0x98, 0xD3, 0xDE, 0xC9, 0xC4, 0xE7, 0xEA, 0xFD, 0xF0,
|
||||
0x6B, 0x66, 0x71, 0x7C, 0x5F, 0x52, 0x45, 0x48, 0x03, 0x0E, 0x19, 0x14, 0x37, 0x3A, 0x2D, 0x20,
|
||||
0x6D, 0x60, 0x77, 0x7A, 0x59, 0x54, 0x43, 0x4E, 0x05, 0x08, 0x1F, 0x12, 0x31, 0x3C, 0x2B, 0x26,
|
||||
0xBD, 0xB0, 0xA7, 0xAA, 0x89, 0x84, 0x93, 0x9E, 0xD5, 0xD8, 0xCF, 0xC2, 0xE1, 0xEC, 0xFB, 0xF6,
|
||||
0xD6, 0xDB, 0xCC, 0xC1, 0xE2, 0xEF, 0xF8, 0xF5, 0xBE, 0xB3, 0xA4, 0xA9, 0x8A, 0x87, 0x90, 0x9D,
|
||||
0x06, 0x0B, 0x1C, 0x11, 0x32, 0x3F, 0x28, 0x25, 0x6E, 0x63, 0x74, 0x79, 0x5A, 0x57, 0x40, 0x4D,
|
||||
0xDA, 0xD7, 0xC0, 0xCD, 0xEE, 0xE3, 0xF4, 0xF9, 0xB2, 0xBF, 0xA8, 0xA5, 0x86, 0x8B, 0x9C, 0x91,
|
||||
0x0A, 0x07, 0x10, 0x1D, 0x3E, 0x33, 0x24, 0x29, 0x62, 0x6F, 0x78, 0x75, 0x56, 0x5B, 0x4C, 0x41,
|
||||
0x61, 0x6C, 0x7B, 0x76, 0x55, 0x58, 0x4F, 0x42, 0x09, 0x04, 0x13, 0x1E, 0x3D, 0x30, 0x27, 0x2A,
|
||||
0xB1, 0xBC, 0xAB, 0xA6, 0x85, 0x88, 0x9F, 0x92, 0xD9, 0xD4, 0xC3, 0xCE, 0xED, 0xE0, 0xF7, 0xFA,
|
||||
0xB7, 0xBA, 0xAD, 0xA0, 0x83, 0x8E, 0x99, 0x94, 0xDF, 0xD2, 0xC5, 0xC8, 0xEB, 0xE6, 0xF1, 0xFC,
|
||||
0x67, 0x6A, 0x7D, 0x70, 0x53, 0x5E, 0x49, 0x44, 0x0F, 0x02, 0x15, 0x18, 0x3B, 0x36, 0x21, 0x2C,
|
||||
0x0C, 0x01, 0x16, 0x1B, 0x38, 0x35, 0x22, 0x2F, 0x64, 0x69, 0x7E, 0x73, 0x50, 0x5D, 0x4A, 0x47,
|
||||
0xDC, 0xD1, 0xC6, 0xCB, 0xE8, 0xE5, 0xF2, 0xFF, 0xB4, 0xB9, 0xAE, 0xA3, 0x80, 0x8D, 0x9A, 0x97
|
||||
};
|
||||
|
||||
const uint8_t accelc_aes_GF2p8_Mul_0x0E[256] = {
|
||||
0x00, 0x0E, 0x1C, 0x12, 0x38, 0x36, 0x24, 0x2A, 0x70, 0x7E, 0x6C, 0x62, 0x48, 0x46, 0x54, 0x5A,
|
||||
0xE0, 0xEE, 0xFC, 0xF2, 0xD8, 0xD6, 0xC4, 0xCA, 0x90, 0x9E, 0x8C, 0x82, 0xA8, 0xA6, 0xB4, 0xBA,
|
||||
0xDB, 0xD5, 0xC7, 0xC9, 0xE3, 0xED, 0xFF, 0xF1, 0xAB, 0xA5, 0xB7, 0xB9, 0x93, 0x9D, 0x8F, 0x81,
|
||||
0x3B, 0x35, 0x27, 0x29, 0x03, 0x0D, 0x1F, 0x11, 0x4B, 0x45, 0x57, 0x59, 0x73, 0x7D, 0x6F, 0x61,
|
||||
0xAD, 0xA3, 0xB1, 0xBF, 0x95, 0x9B, 0x89, 0x87, 0xDD, 0xD3, 0xC1, 0xCF, 0xE5, 0xEB, 0xF9, 0xF7,
|
||||
0x4D, 0x43, 0x51, 0x5F, 0x75, 0x7B, 0x69, 0x67, 0x3D, 0x33, 0x21, 0x2F, 0x05, 0x0B, 0x19, 0x17,
|
||||
0x76, 0x78, 0x6A, 0x64, 0x4E, 0x40, 0x52, 0x5C, 0x06, 0x08, 0x1A, 0x14, 0x3E, 0x30, 0x22, 0x2C,
|
||||
0x96, 0x98, 0x8A, 0x84, 0xAE, 0xA0, 0xB2, 0xBC, 0xE6, 0xE8, 0xFA, 0xF4, 0xDE, 0xD0, 0xC2, 0xCC,
|
||||
0x41, 0x4F, 0x5D, 0x53, 0x79, 0x77, 0x65, 0x6B, 0x31, 0x3F, 0x2D, 0x23, 0x09, 0x07, 0x15, 0x1B,
|
||||
0xA1, 0xAF, 0xBD, 0xB3, 0x99, 0x97, 0x85, 0x8B, 0xD1, 0xDF, 0xCD, 0xC3, 0xE9, 0xE7, 0xF5, 0xFB,
|
||||
0x9A, 0x94, 0x86, 0x88, 0xA2, 0xAC, 0xBE, 0xB0, 0xEA, 0xE4, 0xF6, 0xF8, 0xD2, 0xDC, 0xCE, 0xC0,
|
||||
0x7A, 0x74, 0x66, 0x68, 0x42, 0x4C, 0x5E, 0x50, 0x0A, 0x04, 0x16, 0x18, 0x32, 0x3C, 0x2E, 0x20,
|
||||
0xEC, 0xE2, 0xF0, 0xFE, 0xD4, 0xDA, 0xC8, 0xC6, 0x9C, 0x92, 0x80, 0x8E, 0xA4, 0xAA, 0xB8, 0xB6,
|
||||
0x0C, 0x02, 0x10, 0x1E, 0x34, 0x3A, 0x28, 0x26, 0x7C, 0x72, 0x60, 0x6E, 0x44, 0x4A, 0x58, 0x56,
|
||||
0x37, 0x39, 0x2B, 0x25, 0x0F, 0x01, 0x13, 0x1D, 0x47, 0x49, 0x5B, 0x55, 0x7F, 0x71, 0x63, 0x6D,
|
||||
0xD7, 0xD9, 0xCB, 0xC5, 0xEF, 0xE1, 0xF3, 0xFD, 0xA7, 0xA9, 0xBB, 0xB5, 0x9F, 0x91, 0x83, 0x8D
|
||||
};
|
||||
@@ -0,0 +1,281 @@
|
||||
#include "blowfish.h"
|
||||
#include <memory.h>
|
||||
|
||||
#if defined(_MSC_VER)
|
||||
#include <intrin.h>
|
||||
#define _bswap _byteswap_ulong
|
||||
#elif defined(__GNUC__)
|
||||
#include <x86intrin.h>
|
||||
#endif
|
||||
|
||||
const uint32_t accelc_Blowfish_Original_PBox[18] = {
|
||||
0x243F6A88, 0x85A308D3, 0x13198A2E, 0x03707344, 0xA4093822, 0x299F31D0,
|
||||
0x082EFA98, 0xEC4E6C89, 0x452821E6, 0x38D01377, 0xBE5466CF, 0x34E90C6C,
|
||||
0xC0AC29B7, 0xC97C50DD, 0x3F84D5B5, 0xB5470917, 0x9216D5D9, 0x8979FB1B
|
||||
};
|
||||
|
||||
const uint32_t accelc_Blowfish_Original_SBox[4][256] = {
|
||||
{
|
||||
0xD1310BA6, 0x98DFB5AC, 0x2FFD72DB, 0xD01ADFB7, 0xB8E1AFED, 0x6A267E96, 0xBA7C9045, 0xF12C7F99, 0x24A19947, 0xB3916CF7, 0x0801F2E2, 0x858EFC16, 0x636920D8, 0x71574E69, 0xA458FEA3, 0xF4933D7E,
|
||||
0x0D95748F, 0x728EB658, 0x718BCD58, 0x82154AEE, 0x7B54A41D, 0xC25A59B5, 0x9C30D539, 0x2AF26013, 0xC5D1B023, 0x286085F0, 0xCA417918, 0xB8DB38EF, 0x8E79DCB0, 0x603A180E, 0x6C9E0E8B, 0xB01E8A3E,
|
||||
0xD71577C1, 0xBD314B27, 0x78AF2FDA, 0x55605C60, 0xE65525F3, 0xAA55AB94, 0x57489862, 0x63E81440, 0x55CA396A, 0x2AAB10B6, 0xB4CC5C34, 0x1141E8CE, 0xA15486AF, 0x7C72E993, 0xB3EE1411, 0x636FBC2A,
|
||||
0x2BA9C55D, 0x741831F6, 0xCE5C3E16, 0x9B87931E, 0xAFD6BA33, 0x6C24CF5C, 0x7A325381, 0x28958677, 0x3B8F4898, 0x6B4BB9AF, 0xC4BFE81B, 0x66282193, 0x61D809CC, 0xFB21A991, 0x487CAC60, 0x5DEC8032,
|
||||
0xEF845D5D, 0xE98575B1, 0xDC262302, 0xEB651B88, 0x23893E81, 0xD396ACC5, 0x0F6D6FF3, 0x83F44239, 0x2E0B4482, 0xA4842004, 0x69C8F04A, 0x9E1F9B5E, 0x21C66842, 0xF6E96C9A, 0x670C9C61, 0xABD388F0,
|
||||
0x6A51A0D2, 0xD8542F68, 0x960FA728, 0xAB5133A3, 0x6EEF0B6C, 0x137A3BE4, 0xBA3BF050, 0x7EFB2A98, 0xA1F1651D, 0x39AF0176, 0x66CA593E, 0x82430E88, 0x8CEE8619, 0x456F9FB4, 0x7D84A5C3, 0x3B8B5EBE,
|
||||
0xE06F75D8, 0x85C12073, 0x401A449F, 0x56C16AA6, 0x4ED3AA62, 0x363F7706, 0x1BFEDF72, 0x429B023D, 0x37D0D724, 0xD00A1248, 0xDB0FEAD3, 0x49F1C09B, 0x075372C9, 0x80991B7B, 0x25D479D8, 0xF6E8DEF7,
|
||||
0xE3FE501A, 0xB6794C3B, 0x976CE0BD, 0x04C006BA, 0xC1A94FB6, 0x409F60C4, 0x5E5C9EC2, 0x196A2463, 0x68FB6FAF, 0x3E6C53B5, 0x1339B2EB, 0x3B52EC6F, 0x6DFC511F, 0x9B30952C, 0xCC814544, 0xAF5EBD09,
|
||||
0xBEE3D004, 0xDE334AFD, 0x660F2807, 0x192E4BB3, 0xC0CBA857, 0x45C8740F, 0xD20B5F39, 0xB9D3FBDB, 0x5579C0BD, 0x1A60320A, 0xD6A100C6, 0x402C7279, 0x679F25FE, 0xFB1FA3CC, 0x8EA5E9F8, 0xDB3222F8,
|
||||
0x3C7516DF, 0xFD616B15, 0x2F501EC8, 0xAD0552AB, 0x323DB5FA, 0xFD238760, 0x53317B48, 0x3E00DF82, 0x9E5C57BB, 0xCA6F8CA0, 0x1A87562E, 0xDF1769DB, 0xD542A8F6, 0x287EFFC3, 0xAC6732C6, 0x8C4F5573,
|
||||
0x695B27B0, 0xBBCA58C8, 0xE1FFA35D, 0xB8F011A0, 0x10FA3D98, 0xFD2183B8, 0x4AFCB56C, 0x2DD1D35B, 0x9A53E479, 0xB6F84565, 0xD28E49BC, 0x4BFB9790, 0xE1DDF2DA, 0xA4CB7E33, 0x62FB1341, 0xCEE4C6E8,
|
||||
0xEF20CADA, 0x36774C01, 0xD07E9EFE, 0x2BF11FB4, 0x95DBDA4D, 0xAE909198, 0xEAAD8E71, 0x6B93D5A0, 0xD08ED1D0, 0xAFC725E0, 0x8E3C5B2F, 0x8E7594B7, 0x8FF6E2FB, 0xF2122B64, 0x8888B812, 0x900DF01C,
|
||||
0x4FAD5EA0, 0x688FC31C, 0xD1CFF191, 0xB3A8C1AD, 0x2F2F2218, 0xBE0E1777, 0xEA752DFE, 0x8B021FA1, 0xE5A0CC0F, 0xB56F74E8, 0x18ACF3D6, 0xCE89E299, 0xB4A84FE0, 0xFD13E0B7, 0x7CC43B81, 0xD2ADA8D9,
|
||||
0x165FA266, 0x80957705, 0x93CC7314, 0x211A1477, 0xE6AD2065, 0x77B5FA86, 0xC75442F5, 0xFB9D35CF, 0xEBCDAF0C, 0x7B3E89A0, 0xD6411BD3, 0xAE1E7E49, 0x00250E2D, 0x2071B35E, 0x226800BB, 0x57B8E0AF,
|
||||
0x2464369B, 0xF009B91E, 0x5563911D, 0x59DFA6AA, 0x78C14389, 0xD95A537F, 0x207D5BA2, 0x02E5B9C5, 0x83260376, 0x6295CFA9, 0x11C81968, 0x4E734A41, 0xB3472DCA, 0x7B14A94A, 0x1B510052, 0x9A532915,
|
||||
0xD60F573F, 0xBC9BC6E4, 0x2B60A476, 0x81E67400, 0x08BA6FB5, 0x571BE91F, 0xF296EC6B, 0x2A0DD915, 0xB6636521, 0xE7B9F9B6, 0xFF34052E, 0xC5855664, 0x53B02D5D, 0xA99F8FA1, 0x08BA4799, 0x6E85076A
|
||||
},
|
||||
|
||||
{
|
||||
0x4B7A70E9, 0xB5B32944, 0xDB75092E, 0xC4192623, 0xAD6EA6B0, 0x49A7DF7D, 0x9CEE60B8, 0x8FEDB266, 0xECAA8C71, 0x699A17FF, 0x5664526C, 0xC2B19EE1, 0x193602A5, 0x75094C29, 0xA0591340, 0xE4183A3E,
|
||||
0x3F54989A, 0x5B429D65, 0x6B8FE4D6, 0x99F73FD6, 0xA1D29C07, 0xEFE830F5, 0x4D2D38E6, 0xF0255DC1, 0x4CDD2086, 0x8470EB26, 0x6382E9C6, 0x021ECC5E, 0x09686B3F, 0x3EBAEFC9, 0x3C971814, 0x6B6A70A1,
|
||||
0x687F3584, 0x52A0E286, 0xB79C5305, 0xAA500737, 0x3E07841C, 0x7FDEAE5C, 0x8E7D44EC, 0x5716F2B8, 0xB03ADA37, 0xF0500C0D, 0xF01C1F04, 0x0200B3FF, 0xAE0CF51A, 0x3CB574B2, 0x25837A58, 0xDC0921BD,
|
||||
0xD19113F9, 0x7CA92FF6, 0x94324773, 0x22F54701, 0x3AE5E581, 0x37C2DADC, 0xC8B57634, 0x9AF3DDA7, 0xA9446146, 0x0FD0030E, 0xECC8C73E, 0xA4751E41, 0xE238CD99, 0x3BEA0E2F, 0x3280BBA1, 0x183EB331,
|
||||
0x4E548B38, 0x4F6DB908, 0x6F420D03, 0xF60A04BF, 0x2CB81290, 0x24977C79, 0x5679B072, 0xBCAF89AF, 0xDE9A771F, 0xD9930810, 0xB38BAE12, 0xDCCF3F2E, 0x5512721F, 0x2E6B7124, 0x501ADDE6, 0x9F84CD87,
|
||||
0x7A584718, 0x7408DA17, 0xBC9F9ABC, 0xE94B7D8C, 0xEC7AEC3A, 0xDB851DFA, 0x63094366, 0xC464C3D2, 0xEF1C1847, 0x3215D908, 0xDD433B37, 0x24C2BA16, 0x12A14D43, 0x2A65C451, 0x50940002, 0x133AE4DD,
|
||||
0x71DFF89E, 0x10314E55, 0x81AC77D6, 0x5F11199B, 0x043556F1, 0xD7A3C76B, 0x3C11183B, 0x5924A509, 0xF28FE6ED, 0x97F1FBFA, 0x9EBABF2C, 0x1E153C6E, 0x86E34570, 0xEAE96FB1, 0x860E5E0A, 0x5A3E2AB3,
|
||||
0x771FE71C, 0x4E3D06FA, 0x2965DCB9, 0x99E71D0F, 0x803E89D6, 0x5266C825, 0x2E4CC978, 0x9C10B36A, 0xC6150EBA, 0x94E2EA78, 0xA5FC3C53, 0x1E0A2DF4, 0xF2F74EA7, 0x361D2B3D, 0x1939260F, 0x19C27960,
|
||||
0x5223A708, 0xF71312B6, 0xEBADFE6E, 0xEAC31F66, 0xE3BC4595, 0xA67BC883, 0xB17F37D1, 0x018CFF28, 0xC332DDEF, 0xBE6C5AA5, 0x65582185, 0x68AB9802, 0xEECEA50F, 0xDB2F953B, 0x2AEF7DAD, 0x5B6E2F84,
|
||||
0x1521B628, 0x29076170, 0xECDD4775, 0x619F1510, 0x13CCA830, 0xEB61BD96, 0x0334FE1E, 0xAA0363CF, 0xB5735C90, 0x4C70A239, 0xD59E9E0B, 0xCBAADE14, 0xEECC86BC, 0x60622CA7, 0x9CAB5CAB, 0xB2F3846E,
|
||||
0x648B1EAF, 0x19BDF0CA, 0xA02369B9, 0x655ABB50, 0x40685A32, 0x3C2AB4B3, 0x319EE9D5, 0xC021B8F7, 0x9B540B19, 0x875FA099, 0x95F7997E, 0x623D7DA8, 0xF837889A, 0x97E32D77, 0x11ED935F, 0x16681281,
|
||||
0x0E358829, 0xC7E61FD6, 0x96DEDFA1, 0x7858BA99, 0x57F584A5, 0x1B227263, 0x9B83C3FF, 0x1AC24696, 0xCDB30AEB, 0x532E3054, 0x8FD948E4, 0x6DBC3128, 0x58EBF2EF, 0x34C6FFEA, 0xFE28ED61, 0xEE7C3C73,
|
||||
0x5D4A14D9, 0xE864B7E3, 0x42105D14, 0x203E13E0, 0x45EEE2B6, 0xA3AAABEA, 0xDB6C4F15, 0xFACB4FD0, 0xC742F442, 0xEF6ABBB5, 0x654F3B1D, 0x41CD2105, 0xD81E799E, 0x86854DC7, 0xE44B476A, 0x3D816250,
|
||||
0xCF62A1F2, 0x5B8D2646, 0xFC8883A0, 0xC1C7B6A3, 0x7F1524C3, 0x69CB7492, 0x47848A0B, 0x5692B285, 0x095BBF00, 0xAD19489D, 0x1462B174, 0x23820E00, 0x58428D2A, 0x0C55F5EA, 0x1DADF43E, 0x233F7061,
|
||||
0x3372F092, 0x8D937E41, 0xD65FECF1, 0x6C223BDB, 0x7CDE3759, 0xCBEE7460, 0x4085F2A7, 0xCE77326E, 0xA6078084, 0x19F8509E, 0xE8EFD855, 0x61D99735, 0xA969A7AA, 0xC50C06C2, 0x5A04ABFC, 0x800BCADC,
|
||||
0x9E447A2E, 0xC3453484, 0xFDD56705, 0x0E1E9EC9, 0xDB73DBD3, 0x105588CD, 0x675FDA79, 0xE3674340, 0xC5C43465, 0x713E38D8, 0x3D28F89E, 0xF16DFF20, 0x153E21E7, 0x8FB03D4A, 0xE6E39F2B, 0xDB83ADF7
|
||||
},
|
||||
|
||||
{
|
||||
0xE93D5A68, 0x948140F7, 0xF64C261C, 0x94692934, 0x411520F7, 0x7602D4F7, 0xBCF46B2E, 0xD4A20068, 0xD4082471, 0x3320F46A, 0x43B7D4B7, 0x500061AF, 0x1E39F62E, 0x97244546, 0x14214F74, 0xBF8B8840,
|
||||
0x4D95FC1D, 0x96B591AF, 0x70F4DDD3, 0x66A02F45, 0xBFBC09EC, 0x03BD9785, 0x7FAC6DD0, 0x31CB8504, 0x96EB27B3, 0x55FD3941, 0xDA2547E6, 0xABCA0A9A, 0x28507825, 0x530429F4, 0x0A2C86DA, 0xE9B66DFB,
|
||||
0x68DC1462, 0xD7486900, 0x680EC0A4, 0x27A18DEE, 0x4F3FFEA2, 0xE887AD8C, 0xB58CE006, 0x7AF4D6B6, 0xAACE1E7C, 0xD3375FEC, 0xCE78A399, 0x406B2A42, 0x20FE9E35, 0xD9F385B9, 0xEE39D7AB, 0x3B124E8B,
|
||||
0x1DC9FAF7, 0x4B6D1856, 0x26A36631, 0xEAE397B2, 0x3A6EFA74, 0xDD5B4332, 0x6841E7F7, 0xCA7820FB, 0xFB0AF54E, 0xD8FEB397, 0x454056AC, 0xBA489527, 0x55533A3A, 0x20838D87, 0xFE6BA9B7, 0xD096954B,
|
||||
0x55A867BC, 0xA1159A58, 0xCCA92963, 0x99E1DB33, 0xA62A4A56, 0x3F3125F9, 0x5EF47E1C, 0x9029317C, 0xFDF8E802, 0x04272F70, 0x80BB155C, 0x05282CE3, 0x95C11548, 0xE4C66D22, 0x48C1133F, 0xC70F86DC,
|
||||
0x07F9C9EE, 0x41041F0F, 0x404779A4, 0x5D886E17, 0x325F51EB, 0xD59BC0D1, 0xF2BCC18F, 0x41113564, 0x257B7834, 0x602A9C60, 0xDFF8E8A3, 0x1F636C1B, 0x0E12B4C2, 0x02E1329E, 0xAF664FD1, 0xCAD18115,
|
||||
0x6B2395E0, 0x333E92E1, 0x3B240B62, 0xEEBEB922, 0x85B2A20E, 0xE6BA0D99, 0xDE720C8C, 0x2DA2F728, 0xD0127845, 0x95B794FD, 0x647D0862, 0xE7CCF5F0, 0x5449A36F, 0x877D48FA, 0xC39DFD27, 0xF33E8D1E,
|
||||
0x0A476341, 0x992EFF74, 0x3A6F6EAB, 0xF4F8FD37, 0xA812DC60, 0xA1EBDDF8, 0x991BE14C, 0xDB6E6B0D, 0xC67B5510, 0x6D672C37, 0x2765D43B, 0xDCD0E804, 0xF1290DC7, 0xCC00FFA3, 0xB5390F92, 0x690FED0B,
|
||||
0x667B9FFB, 0xCEDB7D9C, 0xA091CF0B, 0xD9155EA3, 0xBB132F88, 0x515BAD24, 0x7B9479BF, 0x763BD6EB, 0x37392EB3, 0xCC115979, 0x8026E297, 0xF42E312D, 0x6842ADA7, 0xC66A2B3B, 0x12754CCC, 0x782EF11C,
|
||||
0x6A124237, 0xB79251E7, 0x06A1BBE6, 0x4BFB6350, 0x1A6B1018, 0x11CAEDFA, 0x3D25BDD8, 0xE2E1C3C9, 0x44421659, 0x0A121386, 0xD90CEC6E, 0xD5ABEA2A, 0x64AF674E, 0xDA86A85F, 0xBEBFE988, 0x64E4C3FE,
|
||||
0x9DBC8057, 0xF0F7C086, 0x60787BF8, 0x6003604D, 0xD1FD8346, 0xF6381FB0, 0x7745AE04, 0xD736FCCC, 0x83426B33, 0xF01EAB71, 0xB0804187, 0x3C005E5F, 0x77A057BE, 0xBDE8AE24, 0x55464299, 0xBF582E61,
|
||||
0x4E58F48F, 0xF2DDFDA2, 0xF474EF38, 0x8789BDC2, 0x5366F9C3, 0xC8B38E74, 0xB475F255, 0x46FCD9B9, 0x7AEB2661, 0x8B1DDF84, 0x846A0E79, 0x915F95E2, 0x466E598E, 0x20B45770, 0x8CD55591, 0xC902DE4C,
|
||||
0xB90BACE1, 0xBB8205D0, 0x11A86248, 0x7574A99E, 0xB77F19B6, 0xE0A9DC09, 0x662D09A1, 0xC4324633, 0xE85A1F02, 0x09F0BE8C, 0x4A99A025, 0x1D6EFE10, 0x1AB93D1D, 0x0BA5A4DF, 0xA186F20F, 0x2868F169,
|
||||
0xDCB7DA83, 0x573906FE, 0xA1E2CE9B, 0x4FCD7F52, 0x50115E01, 0xA70683FA, 0xA002B5C4, 0x0DE6D027, 0x9AF88C27, 0x773F8641, 0xC3604C06, 0x61A806B5, 0xF0177A28, 0xC0F586E0, 0x006058AA, 0x30DC7D62,
|
||||
0x11E69ED7, 0x2338EA63, 0x53C2DD94, 0xC2C21634, 0xBBCBEE56, 0x90BCB6DE, 0xEBFC7DA1, 0xCE591D76, 0x6F05E409, 0x4B7C0188, 0x39720A3D, 0x7C927C24, 0x86E3725F, 0x724D9DB9, 0x1AC15BB4, 0xD39EB8FC,
|
||||
0xED545578, 0x08FCA5B5, 0xD83D7CD3, 0x4DAD0FC4, 0x1E50EF5E, 0xB161E6F8, 0xA28514D9, 0x6C51133C, 0x6FD5C7E7, 0x56E14EC4, 0x362ABFCE, 0xDDC6C837, 0xD79A3234, 0x92638212, 0x670EFA8E, 0x406000E0
|
||||
},
|
||||
|
||||
{
|
||||
0x3A39CE37, 0xD3FAF5CF, 0xABC27737, 0x5AC52D1B, 0x5CB0679E, 0x4FA33742, 0xD3822740, 0x99BC9BBE, 0xD5118E9D, 0xBF0F7315, 0xD62D1C7E, 0xC700C47B, 0xB78C1B6B, 0x21A19045, 0xB26EB1BE, 0x6A366EB4,
|
||||
0x5748AB2F, 0xBC946E79, 0xC6A376D2, 0x6549C2C8, 0x530FF8EE, 0x468DDE7D, 0xD5730A1D, 0x4CD04DC6, 0x2939BBDB, 0xA9BA4650, 0xAC9526E8, 0xBE5EE304, 0xA1FAD5F0, 0x6A2D519A, 0x63EF8CE2, 0x9A86EE22,
|
||||
0xC089C2B8, 0x43242EF6, 0xA51E03AA, 0x9CF2D0A4, 0x83C061BA, 0x9BE96A4D, 0x8FE51550, 0xBA645BD6, 0x2826A2F9, 0xA73A3AE1, 0x4BA99586, 0xEF5562E9, 0xC72FEFD3, 0xF752F7DA, 0x3F046F69, 0x77FA0A59,
|
||||
0x80E4A915, 0x87B08601, 0x9B09E6AD, 0x3B3EE593, 0xE990FD5A, 0x9E34D797, 0x2CF0B7D9, 0x022B8B51, 0x96D5AC3A, 0x017DA67D, 0xD1CF3ED6, 0x7C7D2D28, 0x1F9F25CF, 0xADF2B89B, 0x5AD6B472, 0x5A88F54C,
|
||||
0xE029AC71, 0xE019A5E6, 0x47B0ACFD, 0xED93FA9B, 0xE8D3C48D, 0x283B57CC, 0xF8D56629, 0x79132E28, 0x785F0191, 0xED756055, 0xF7960E44, 0xE3D35E8C, 0x15056DD4, 0x88F46DBA, 0x03A16125, 0x0564F0BD,
|
||||
0xC3EB9E15, 0x3C9057A2, 0x97271AEC, 0xA93A072A, 0x1B3F6D9B, 0x1E6321F5, 0xF59C66FB, 0x26DCF319, 0x7533D928, 0xB155FDF5, 0x03563482, 0x8ABA3CBB, 0x28517711, 0xC20AD9F8, 0xABCC5167, 0xCCAD925F,
|
||||
0x4DE81751, 0x3830DC8E, 0x379D5862, 0x9320F991, 0xEA7A90C2, 0xFB3E7BCE, 0x5121CE64, 0x774FBE32, 0xA8B6E37E, 0xC3293D46, 0x48DE5369, 0x6413E680, 0xA2AE0810, 0xDD6DB224, 0x69852DFD, 0x09072166,
|
||||
0xB39A460A, 0x6445C0DD, 0x586CDECF, 0x1C20C8AE, 0x5BBEF7DD, 0x1B588D40, 0xCCD2017F, 0x6BB4E3BB, 0xDDA26A7E, 0x3A59FF45, 0x3E350A44, 0xBCB4CDD5, 0x72EACEA8, 0xFA6484BB, 0x8D6612AE, 0xBF3C6F47,
|
||||
0xD29BE463, 0x542F5D9E, 0xAEC2771B, 0xF64E6370, 0x740E0D8D, 0xE75B1357, 0xF8721671, 0xAF537D5D, 0x4040CB08, 0x4EB4E2CC, 0x34D2466A, 0x0115AF84, 0xE1B00428, 0x95983A1D, 0x06B89FB4, 0xCE6EA048,
|
||||
0x6F3F3B82, 0x3520AB82, 0x011A1D4B, 0x277227F8, 0x611560B1, 0xE7933FDC, 0xBB3A792B, 0x344525BD, 0xA08839E1, 0x51CE794B, 0x2F32C9B7, 0xA01FBAC9, 0xE01CC87E, 0xBCC7D1F6, 0xCF0111C3, 0xA1E8AAC7,
|
||||
0x1A908749, 0xD44FBD9A, 0xD0DADECB, 0xD50ADA38, 0x0339C32A, 0xC6913667, 0x8DF9317C, 0xE0B12B4F, 0xF79E59B7, 0x43F5BB3A, 0xF2D519FF, 0x27D9459C, 0xBF97222C, 0x15E6FC2A, 0x0F91FC71, 0x9B941525,
|
||||
0xFAE59361, 0xCEB69CEB, 0xC2A86459, 0x12BAA8D1, 0xB6C1075E, 0xE3056A0C, 0x10D25065, 0xCB03A442, 0xE0EC6E0E, 0x1698DB3B, 0x4C98A0BE, 0x3278E964, 0x9F1F9532, 0xE0D392DF, 0xD3A0342B, 0x8971F21E,
|
||||
0x1B0A7441, 0x4BA3348C, 0xC5BE7120, 0xC37632D8, 0xDF359F8D, 0x9B992F2E, 0xE60B6F47, 0x0FE3F11D, 0xE54CDA54, 0x1EDAD891, 0xCE6279CF, 0xCD3E7E6F, 0x1618B166, 0xFD2C1D05, 0x848FD2C5, 0xF6FB2299,
|
||||
0xF523F357, 0xA6327623, 0x93A83531, 0x56CCCD02, 0xACF08162, 0x5A75EBB5, 0x6E163697, 0x88D273CC, 0xDE966292, 0x81B949D0, 0x4C50901B, 0x71C65614, 0xE6C6C7BD, 0x327A140A, 0x45E1D006, 0xC3F27B9A,
|
||||
0xC9AA53FD, 0x62A80F00, 0xBB25BFE2, 0x35BDD2F6, 0x71126905, 0xB2040222, 0xB6CBCF7C, 0xCD769C2B, 0x53113EC0, 0x1640E3D3, 0x38ABBD60, 0x2547ADF0, 0xBA38209C, 0xF746CE76, 0x77AFA1C5, 0x20756060,
|
||||
0x85CBFE4E, 0x8AE88DD8, 0x7AAAF9B0, 0x4CF9AA7E, 0x1948C25C, 0x02FB8A8C, 0x01C36AE4, 0xD6EBE1F9, 0x90D4F869, 0xA65CDEA0, 0x3F09252D, 0xC208E69F, 0xB74E6132, 0xCE77E25B, 0x578FDFE3, 0x3AC372E6
|
||||
}
|
||||
};
|
||||
|
||||
#define f_transform(_x, _S) ((((_S)[0][(_x)[3]] + (_S)[1][(_x)[2]]) ^ (_S)[2][(_x)[1]]) + (_S)[3][(_x)[0]])
|
||||
|
||||
void accelc_Blowfish_encrypt(uint8_t srcBytes[8],
|
||||
const BLOWFISH_KEY* srcKey,
|
||||
int Endian) {
|
||||
uint32_t* const L = (uint32_t*)srcBytes;
|
||||
uint32_t* const R = (uint32_t*)(srcBytes + 4);
|
||||
|
||||
if (Endian == BLOWFISH_BIG_ENDIAN) {
|
||||
*L = _bswap(*L);
|
||||
*R = _bswap(*R);
|
||||
}
|
||||
|
||||
*L ^= srcKey->SubKey[0];
|
||||
*R ^= f_transform(srcBytes, srcKey->SBox);
|
||||
|
||||
*R ^= srcKey->SubKey[1];
|
||||
*L ^= f_transform(srcBytes + 4, srcKey->SBox);
|
||||
|
||||
*L ^= srcKey->SubKey[2];
|
||||
*R ^= f_transform(srcBytes, srcKey->SBox);
|
||||
|
||||
*R ^= srcKey->SubKey[3];
|
||||
*L ^= f_transform(srcBytes + 4, srcKey->SBox);
|
||||
|
||||
*L ^= srcKey->SubKey[4];
|
||||
*R ^= f_transform(srcBytes, srcKey->SBox);
|
||||
|
||||
*R ^= srcKey->SubKey[5];
|
||||
*L ^= f_transform(srcBytes + 4, srcKey->SBox);
|
||||
|
||||
*L ^= srcKey->SubKey[6];
|
||||
*R ^= f_transform(srcBytes, srcKey->SBox);
|
||||
|
||||
*R ^= srcKey->SubKey[7];
|
||||
*L ^= f_transform(srcBytes + 4, srcKey->SBox);
|
||||
|
||||
*L ^= srcKey->SubKey[8];
|
||||
*R ^= f_transform(srcBytes, srcKey->SBox);
|
||||
|
||||
*R ^= srcKey->SubKey[9];
|
||||
*L ^= f_transform(srcBytes + 4, srcKey->SBox);
|
||||
|
||||
*L ^= srcKey->SubKey[10];
|
||||
*R ^= f_transform(srcBytes, srcKey->SBox);
|
||||
|
||||
*R ^= srcKey->SubKey[11];
|
||||
*L ^= f_transform(srcBytes + 4, srcKey->SBox);
|
||||
|
||||
*L ^= srcKey->SubKey[12];
|
||||
*R ^= f_transform(srcBytes, srcKey->SBox);
|
||||
|
||||
*R ^= srcKey->SubKey[13];
|
||||
*L ^= f_transform(srcBytes + 4, srcKey->SBox);
|
||||
|
||||
*L ^= srcKey->SubKey[14];
|
||||
*R ^= f_transform(srcBytes, srcKey->SBox);
|
||||
|
||||
*R ^= srcKey->SubKey[15];
|
||||
*L ^= f_transform(srcBytes + 4, srcKey->SBox);
|
||||
|
||||
*L ^= srcKey->SubKey[16];
|
||||
*R ^= srcKey->SubKey[17];
|
||||
|
||||
uint32_t temp = *R;
|
||||
*R = *L;
|
||||
*L = temp;
|
||||
|
||||
if (Endian == BLOWFISH_BIG_ENDIAN) {
|
||||
*L = _bswap(*L);
|
||||
*R = _bswap(*R);
|
||||
}
|
||||
}
|
||||
|
||||
void accelc_Blowfish_decrypt(uint8_t srcBytes[8],
|
||||
const BLOWFISH_KEY* srcKey,
|
||||
int Endian) {
|
||||
uint32_t* const L = (uint32_t*)srcBytes;
|
||||
uint32_t* const R = (uint32_t*)(srcBytes + 4);
|
||||
|
||||
if (Endian == BLOWFISH_BIG_ENDIAN) {
|
||||
*L = _bswap(*L);
|
||||
*R = _bswap(*R);
|
||||
}
|
||||
|
||||
uint32_t temp = *R;
|
||||
*R = *L;
|
||||
*L = temp;
|
||||
|
||||
*L ^= srcKey->SubKey[16];
|
||||
*R ^= srcKey->SubKey[17];
|
||||
|
||||
*L ^= f_transform(srcBytes + 4, srcKey->SBox);
|
||||
*R ^= srcKey->SubKey[15];
|
||||
|
||||
*R ^= f_transform(srcBytes, srcKey->SBox);
|
||||
*L ^= srcKey->SubKey[14];
|
||||
|
||||
*L ^= f_transform(srcBytes + 4, srcKey->SBox);
|
||||
*R ^= srcKey->SubKey[13];
|
||||
|
||||
*R ^= f_transform(srcBytes, srcKey->SBox);
|
||||
*L ^= srcKey->SubKey[12];
|
||||
|
||||
*L ^= f_transform(srcBytes + 4, srcKey->SBox);
|
||||
*R ^= srcKey->SubKey[11];
|
||||
|
||||
*R ^= f_transform(srcBytes, srcKey->SBox);
|
||||
*L ^= srcKey->SubKey[10];
|
||||
|
||||
*L ^= f_transform(srcBytes + 4, srcKey->SBox);
|
||||
*R ^= srcKey->SubKey[9];
|
||||
|
||||
*R ^= f_transform(srcBytes, srcKey->SBox);
|
||||
*L ^= srcKey->SubKey[8];
|
||||
|
||||
*L ^= f_transform(srcBytes + 4, srcKey->SBox);
|
||||
*R ^= srcKey->SubKey[7];
|
||||
|
||||
*R ^= f_transform(srcBytes, srcKey->SBox);
|
||||
*L ^= srcKey->SubKey[6];
|
||||
|
||||
*L ^= f_transform(srcBytes + 4, srcKey->SBox);
|
||||
*R ^= srcKey->SubKey[5];
|
||||
|
||||
*R ^= f_transform(srcBytes, srcKey->SBox);
|
||||
*L ^= srcKey->SubKey[4];
|
||||
|
||||
*L ^= f_transform(srcBytes + 4, srcKey->SBox);
|
||||
*R ^= srcKey->SubKey[3];
|
||||
|
||||
*R ^= f_transform(srcBytes, srcKey->SBox);
|
||||
*L ^= srcKey->SubKey[2];
|
||||
|
||||
*L ^= f_transform(srcBytes + 4, srcKey->SBox);
|
||||
*R ^= srcKey->SubKey[1];
|
||||
|
||||
*R ^= f_transform(srcBytes, srcKey->SBox);
|
||||
*L ^= srcKey->SubKey[0];
|
||||
|
||||
if (Endian == BLOWFISH_BIG_ENDIAN) {
|
||||
*L = _bswap(*L);
|
||||
*R = _bswap(*R);
|
||||
}
|
||||
}
|
||||
|
||||
int accelc_Blowfish_set_key(const uint8_t srcUserKey[], uint8_t UserKeyLength,
|
||||
BLOWFISH_KEY* dstKey) {
|
||||
if (UserKeyLength == 0)
|
||||
return STATUS_BLOWFISH_INVALID_KEY_LENGTH;
|
||||
if (UserKeyLength > BLOWFISH_MAX_KEY_LENGTH)
|
||||
return STATUS_BLOWFISH_KEY_TOO_LONG;
|
||||
|
||||
memcpy(dstKey->SubKey, accelc_Blowfish_Original_PBox, sizeof(accelc_Blowfish_Original_PBox));
|
||||
memcpy(dstKey->SBox, accelc_Blowfish_Original_SBox, sizeof(accelc_Blowfish_Original_SBox));
|
||||
|
||||
for (int i = 0; i < 18; ++i) {
|
||||
uint32_t temp = 0;
|
||||
|
||||
temp <<= 8;
|
||||
temp |= srcUserKey[(i * 4) % UserKeyLength];
|
||||
|
||||
temp <<= 8;
|
||||
temp |= srcUserKey[(i * 4 + 1) % UserKeyLength];
|
||||
|
||||
temp <<= 8;
|
||||
temp |= srcUserKey[(i * 4 + 2) % UserKeyLength];
|
||||
|
||||
temp <<= 8;
|
||||
temp |= srcUserKey[(i * 4 + 3) % UserKeyLength];
|
||||
|
||||
dstKey->SubKey[i] ^= temp;
|
||||
}
|
||||
|
||||
uint8_t temp[8] = { 0 };
|
||||
for (int i = 0; i < 9; ++i) {
|
||||
accelc_Blowfish_encrypt(temp, dstKey, BLOWFISH_LITTLE_ENDIAN);
|
||||
((uint64_t*)dstKey->SubKey)[i] = *(uint64_t*)temp;
|
||||
}
|
||||
|
||||
for (int i = 0; i < 512; ++i) {
|
||||
accelc_Blowfish_encrypt(temp, dstKey, BLOWFISH_LITTLE_ENDIAN);
|
||||
((uint64_t*)dstKey->SBox)[i] = *(uint64_t*)temp;
|
||||
}
|
||||
|
||||
return STATUS_BLOWFISH_SUCCESS;
|
||||
}
|
||||
@@ -0,0 +1,39 @@
|
||||
#pragma once
|
||||
#include <stdint.h>
|
||||
#include <stddef.h>
|
||||
|
||||
#define STATUS_BLOWFISH_SUCCESS 0
|
||||
#define STATUS_BLOWFISH_INVALID_KEY_LENGTH (-1)
|
||||
#define STATUS_BLOWFISH_KEY_TOO_LONG (-2)
|
||||
|
||||
#define BLOWFISH_LITTLE_ENDIAN 0
|
||||
#define BLOWFISH_BIG_ENDIAN 1
|
||||
|
||||
#define BLOWFISH_MIN_KEY_LENGTH 1
|
||||
#define BLOWFISH_MAX_KEY_LENGTH 56
|
||||
|
||||
#define BLOWFISH_BLOCK_SIZE 8
|
||||
|
||||
#if defined(__cplusplus)
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
typedef struct _BLOWFISH_KEY {
|
||||
uint32_t SubKey[18];
|
||||
uint32_t SBox[4][256];
|
||||
} BLOWFISH_KEY;
|
||||
|
||||
void accelc_Blowfish_encrypt(uint8_t srcBytes[8],
|
||||
const BLOWFISH_KEY* srcKey,
|
||||
int Endian);
|
||||
|
||||
void accelc_Blowfish_decrypt(uint8_t srcBytes[8],
|
||||
const BLOWFISH_KEY* srcKey,
|
||||
int Endian);
|
||||
|
||||
int accelc_Blowfish_set_key(const uint8_t srcUserKey[], uint8_t UserKeyLength,
|
||||
BLOWFISH_KEY* dstKey);
|
||||
|
||||
#if defined(__cplusplus)
|
||||
}
|
||||
#endif
|
||||
@@ -0,0 +1,120 @@
|
||||
#include "sha1.h"
|
||||
#include <memory.h>
|
||||
|
||||
#if defined(_MSC_VER)
|
||||
#include <intrin.h>
|
||||
#define _bswap _byteswap_ulong
|
||||
#define _bswap64 _byteswap_uint64
|
||||
#elif defined(__GNUC__)
|
||||
#include <x86intrin.h>
|
||||
#endif
|
||||
|
||||
#define SHA1_BLOCKSIZE 64
|
||||
|
||||
void accelc_SHA1_init(SHA1_BUFFER* HashBuffer) {
|
||||
HashBuffer->dword[0] = 0x67452301;
|
||||
HashBuffer->dword[1] = 0xEFCDAB89;
|
||||
HashBuffer->dword[2] = 0x98BADCFE;
|
||||
HashBuffer->dword[3] = 0x10325476;
|
||||
HashBuffer->dword[4] = 0xC3D2E1F0;
|
||||
}
|
||||
|
||||
void accelc_SHA1_update(const void* __restrict srcBytes, size_t srcBytesLength,
|
||||
SHA1_BUFFER* __restrict HashBuffer) {
|
||||
uint32_t Buffer[80] = { 0 };
|
||||
uint32_t a, b, c, d, e;
|
||||
const uint32_t (*MessageBlock)[16] = srcBytes;
|
||||
|
||||
size_t RoundsOfMainCycle = srcBytesLength / SHA1_BLOCKSIZE;
|
||||
for (size_t i = 0; i < RoundsOfMainCycle; ++i) {
|
||||
|
||||
for (int j = 0; j < 16; ++j)
|
||||
Buffer[j] = _bswap(MessageBlock[i][j]);
|
||||
|
||||
for (int j = 16; j < 80; ++j) {
|
||||
uint32_t temp = Buffer[j - 3] ^ Buffer[j - 8] ^ Buffer[j - 14] ^ Buffer[j - 16];
|
||||
Buffer[j] = _rotl(temp, 1);
|
||||
}
|
||||
a = HashBuffer->dword[0];
|
||||
b = HashBuffer->dword[1];
|
||||
c = HashBuffer->dword[2];
|
||||
d = HashBuffer->dword[3];
|
||||
e = HashBuffer->dword[4];
|
||||
|
||||
for (int j = 0; j < 20; ++j) {
|
||||
uint32_t T = _rotl(a, 5);
|
||||
T += ((b & c) ^ (~b & d)) + e + 0x5A827999 + Buffer[j];
|
||||
e = d;
|
||||
d = c;
|
||||
c = _rotl(b, 30);
|
||||
b = a;
|
||||
a = T;
|
||||
}
|
||||
for (int j = 20; j < 40; ++j) {
|
||||
uint32_t T = _rotl(a, 5);
|
||||
T += (b ^ c ^ d) + e + 0x6ED9EBA1 + Buffer[j];
|
||||
e = d;
|
||||
d = c;
|
||||
c = _rotl(b, 30);
|
||||
b = a;
|
||||
a = T;
|
||||
}
|
||||
for (int j = 40; j < 60; ++j) {
|
||||
uint32_t T = _rotl(a, 5);
|
||||
T += ((b & c) ^ (b & d) ^ (c & d)) + e + 0x8F1BBCDC + Buffer[j];
|
||||
e = d;
|
||||
d = c;
|
||||
c = _rotl(b, 30);
|
||||
b = a;
|
||||
a = T;
|
||||
}
|
||||
for (int j = 60; j < 80; ++j) {
|
||||
uint32_t T = _rotl(a, 5);
|
||||
T += (b ^ c ^ d) + e + 0xCA62C1D6 + Buffer[j];
|
||||
e = d;
|
||||
d = c;
|
||||
c = _rotl(b, 30);
|
||||
b = a;
|
||||
a = T;
|
||||
}
|
||||
HashBuffer->dword[0] += a;
|
||||
HashBuffer->dword[1] += b;
|
||||
HashBuffer->dword[2] += c;
|
||||
HashBuffer->dword[3] += d;
|
||||
HashBuffer->dword[4] += e;
|
||||
}
|
||||
}
|
||||
|
||||
void accelc_SHA1_final(const void* __restrict LeftBytes, size_t LeftBytesLength, uint64_t TotalBytesLength,
|
||||
const SHA1_BUFFER* HashBuffer, SHA1_DIGEST* Hash) {
|
||||
if (HashBuffer != Hash)
|
||||
memcpy(Hash, HashBuffer, sizeof(SHA1_BUFFER));
|
||||
|
||||
if (LeftBytesLength >= SHA1_BLOCKSIZE) {
|
||||
accelc_SHA1_update(LeftBytes, LeftBytesLength, Hash);
|
||||
LeftBytes = (const uint8_t*)LeftBytes + (LeftBytesLength / SHA1_BLOCKSIZE) * SHA1_BLOCKSIZE;
|
||||
LeftBytesLength %= SHA1_BLOCKSIZE;
|
||||
}
|
||||
|
||||
uint8_t Extra[128] = { 0 };
|
||||
for (size_t i = 0; i < LeftBytesLength; ++i)
|
||||
Extra[i] = ((const uint8_t*)LeftBytes)[i];
|
||||
|
||||
Extra[LeftBytesLength] = 0x80;
|
||||
*(uint64_t*)(Extra + (LeftBytesLength >= 64 - 8 ? 128 - 8 : 64 - 8)) = _bswap64(TotalBytesLength * 8);
|
||||
|
||||
accelc_SHA1_update(Extra, LeftBytesLength >= 56 ? 128 : 64, Hash);
|
||||
|
||||
Hash->dword[0] = _bswap(Hash->dword[0]);
|
||||
Hash->dword[1] = _bswap(Hash->dword[1]);
|
||||
Hash->dword[2] = _bswap(Hash->dword[2]);
|
||||
Hash->dword[3] = _bswap(Hash->dword[3]);
|
||||
Hash->dword[4] = _bswap(Hash->dword[4]);
|
||||
}
|
||||
|
||||
void accelc_SHA1(const void* __restrict srcBytes, size_t srclen,
|
||||
SHA1_DIGEST* __restrict Hash) {
|
||||
accelc_SHA1_init(Hash);
|
||||
accelc_SHA1_update(srcBytes, srclen, Hash);
|
||||
accelc_SHA1_final((uint8_t*)srcBytes + (srclen / SHA1_BLOCKSIZE) * SHA1_BLOCKSIZE, srclen % SHA1_BLOCKSIZE, srclen, Hash, Hash);
|
||||
}
|
||||
@@ -0,0 +1,29 @@
|
||||
#pragma once
|
||||
#include <stdint.h>
|
||||
#include <stddef.h>
|
||||
|
||||
#if defined(__cplusplus)
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
typedef struct _SHA1_DIGEST {
|
||||
union {
|
||||
uint8_t byte[20];
|
||||
uint32_t dword[5];
|
||||
};
|
||||
} SHA1_DIGEST, SHA1_BUFFER;
|
||||
|
||||
void accelc_SHA1_init(SHA1_BUFFER* HashBuffer);
|
||||
|
||||
void accelc_SHA1_update(const void* __restrict srcBytes, size_t srcBytesLength,
|
||||
SHA1_BUFFER* __restrict HashBuffer);
|
||||
|
||||
void accelc_SHA1_final(const void* __restrict LeftBytes, size_t LeftBytesLength, uint64_t TotalBytesLength,
|
||||
const SHA1_BUFFER* HashBuffer, SHA1_DIGEST* Hash);
|
||||
|
||||
void accelc_SHA1(const void* __restrict srcBytes, size_t srclen,
|
||||
SHA1_DIGEST* __restrict Hash);
|
||||
|
||||
#if defined(__cplusplus)
|
||||
}
|
||||
#endif
|
||||
@@ -0,0 +1,59 @@
|
||||
#include "def.hpp"
|
||||
|
||||
// Solution0 is for navicat premium of which the version < 12.0.25
|
||||
namespace patcher::Solution0 {
|
||||
|
||||
BOOL Do(LPCTSTR navicat_exe_path, LPCTSTR prepared_key_file) {
|
||||
if (!BackupFile(navicat_exe_path))
|
||||
return FALSE;
|
||||
|
||||
RSA* PrivateKey = nullptr;
|
||||
if (prepared_key_file == nullptr) {
|
||||
PrivateKey = GenerateRSAKey();
|
||||
if (PrivateKey == nullptr)
|
||||
return FALSE;
|
||||
|
||||
if (!WriteRSAPrivateKeyToFile(TEXT("RegPrivateKey.pem"), PrivateKey)) {
|
||||
RSA_free(PrivateKey);
|
||||
return FALSE;
|
||||
}
|
||||
} else {
|
||||
PrivateKey = ReadRSAPrivateKeyFromFile(prepared_key_file);
|
||||
if (PrivateKey == nullptr)
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
char* pem_pubkey = GetPEMText(PrivateKey);
|
||||
if (pem_pubkey == nullptr)
|
||||
return FALSE;
|
||||
|
||||
RSA_free(PrivateKey); // we do not need it anymore
|
||||
|
||||
HANDLE hUpdater = BeginUpdateResource(navicat_exe_path, FALSE);
|
||||
if (hUpdater == NULL) {
|
||||
_tprintf_s(TEXT("Cannot modify navicat.exe. CODE: 0x%08x @[patcher::Solution0::Do -> BeginUpdateResource]\r\n"), GetLastError());
|
||||
|
||||
delete[] pem_pubkey;
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
if (!UpdateResource(hUpdater,
|
||||
RT_RCDATA,
|
||||
TEXT("ACTIVATIONPUBKEY"),
|
||||
MAKELANGID(LANG_ENGLISH, SUBLANG_DEFAULT),
|
||||
pem_pubkey, strlen(pem_pubkey))) {
|
||||
_tprintf_s(TEXT("Cannot replace public key. CODE: 0x%08x @[patcher::Solution0::Do -> UpdateResource]\r\n"), GetLastError());
|
||||
|
||||
EndUpdateResource(hUpdater, TRUE);
|
||||
delete[] pem_pubkey;
|
||||
return FALSE;
|
||||
} else {
|
||||
_tprintf_s(TEXT("@[patcher::Solution0::Do]: Public key has been replaced by:\r\n%hs"), pem_pubkey);
|
||||
|
||||
EndUpdateResource(hUpdater, FALSE);
|
||||
delete[] pem_pubkey;
|
||||
return TRUE;
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
@@ -0,0 +1,436 @@
|
||||
#include "def.hpp"
|
||||
|
||||
// Solution1 is for navicat premium of which the version = 12.0.25
|
||||
namespace patcher::Solution1 {
|
||||
|
||||
static BOOL CheckRSAKeyIsAppropriate(RSA* PrivateKey) {
|
||||
char* pem_pubkey = GetPEMText(PrivateKey);
|
||||
if (pem_pubkey == nullptr)
|
||||
return FALSE;
|
||||
|
||||
std::string encrypted_pem_text = EncryptPublicKey(pem_pubkey, strlen(pem_pubkey));
|
||||
delete[] pem_pubkey;
|
||||
|
||||
if (encrypted_pem_text[160] > '9' || encrypted_pem_text[160] < '1')
|
||||
return FALSE;
|
||||
for (int i = 1; i < 8; ++i)
|
||||
if (encrypted_pem_text[160 + i] > '9' || encrypted_pem_text[160 + i] < '0')
|
||||
return FALSE;
|
||||
|
||||
if (encrypted_pem_text[910] > '9' || encrypted_pem_text[910] < '1')
|
||||
return FALSE;
|
||||
for (int i = 1; i < 5; ++i)
|
||||
if (encrypted_pem_text[910 + i] > '9' || encrypted_pem_text[910 + i] < '0')
|
||||
return FALSE;
|
||||
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
static RSA* GenerateAppropriateRSAKey() {
|
||||
while (true) {
|
||||
RSA* Key = GenerateRSAKey();
|
||||
if (Key == nullptr)
|
||||
return nullptr;
|
||||
|
||||
if (CheckRSAKeyIsAppropriate(Key)) {
|
||||
return Key;
|
||||
} else {
|
||||
RSA_free(Key);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static BOOL FindPatchOffset(LPCTSTR libcc_dll_path, DWORD Offset[5]) {
|
||||
Offset[0] = 0;
|
||||
Offset[1] = 0;
|
||||
Offset[2] = 0;
|
||||
Offset[3] = 0;
|
||||
Offset[4] = 0;
|
||||
|
||||
HANDLE h_libcc = CreateFile(libcc_dll_path, GENERIC_READ, FILE_SHARE_READ, nullptr, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, nullptr);
|
||||
if (h_libcc == INVALID_HANDLE_VALUE) {
|
||||
_tprintf_s(TEXT("Failed to open libcc.dll. CODE: 0x%08x @[FindPatchOffset -> CreateFile]\r\n"), GetLastError());
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
// DWORD is enough, you know libcc.dll cannot be larger than 4GB
|
||||
DWORD libcc_size = GetFileSize(h_libcc, nullptr);
|
||||
HANDLE h_libcc_map = CreateFileMapping(h_libcc, nullptr, PAGE_READONLY, 0, 0, nullptr);
|
||||
if (h_libcc_map == NULL) {
|
||||
_tprintf_s(TEXT("Failed to create mapping for libcc.dll. CODE: 0x%08x @[FindPatchOffset -> CreateFileMapping]\r\n"), GetLastError());
|
||||
CloseHandle(h_libcc);
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
const uint8_t* libcc = reinterpret_cast<const uint8_t*>(MapViewOfFile(h_libcc_map, FILE_MAP_READ, 0, 0, 0));
|
||||
if (libcc == nullptr) {
|
||||
_tprintf_s(TEXT("Failed to map libcc.dll. CODE: 0x%08x @[FindPatchOffset -> MapViewOfFile]\r\n"), GetLastError());
|
||||
CloseHandle(h_libcc_map);
|
||||
CloseHandle(h_libcc);
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
const IMAGE_DOS_HEADER* libcc_dos_header = reinterpret_cast<const IMAGE_DOS_HEADER*>(libcc);
|
||||
|
||||
// check dos signature
|
||||
if (libcc_dos_header->e_magic != IMAGE_DOS_SIGNATURE) {
|
||||
_tprintf_s(TEXT("libcc.dll does not have a valid DOS header. @[FindPatchOffset]\r\n"));
|
||||
UnmapViewOfFile(libcc);
|
||||
CloseHandle(h_libcc_map);
|
||||
CloseHandle(h_libcc);
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
const IMAGE_NT_HEADERS* libcc_nt_header = reinterpret_cast<const IMAGE_NT_HEADERS*>(libcc + libcc_dos_header->e_lfanew);
|
||||
|
||||
// check nt signature
|
||||
if (libcc_nt_header->Signature != IMAGE_NT_SIGNATURE) {
|
||||
_tprintf_s(TEXT("libcc.dll does not have a valid NT header. @[FindPatchOffset]\r\n"));
|
||||
UnmapViewOfFile(libcc);
|
||||
CloseHandle(h_libcc_map);
|
||||
CloseHandle(h_libcc);
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
// check if a dll
|
||||
if ((libcc_nt_header->FileHeader.Characteristics & IMAGE_FILE_DLL) == 0) {
|
||||
_tprintf_s(TEXT("libcc.dll is not a DLL file. @[FindPatchOffset]\r\n"));
|
||||
UnmapViewOfFile(libcc);
|
||||
CloseHandle(h_libcc_map);
|
||||
CloseHandle(h_libcc);
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
// check if 32-bits or 64-bits
|
||||
#if defined(_M_X64)
|
||||
if (libcc_nt_header->FileHeader.Machine != IMAGE_FILE_MACHINE_AMD64 || libcc_nt_header->OptionalHeader.Magic != IMAGE_NT_OPTIONAL_HDR64_MAGIC) {
|
||||
_tprintf_s(TEXT("libcc.dll is not a 64-bits DLL file. @[FindPatchOffset]\r\n"));
|
||||
#elif defined(_M_IX86)
|
||||
if (libcc_nt_header->FileHeader.Machine != IMAGE_FILE_MACHINE_I386 || libcc_nt_header->OptionalHeader.Magic != IMAGE_NT_OPTIONAL_HDR32_MAGIC) {
|
||||
#else
|
||||
#error "unknown arch"
|
||||
#endif
|
||||
_tprintf_s(TEXT("libcc.dll is not a 32-bits DLL file. @[FindPatchOffset]\r\n"));
|
||||
UnmapViewOfFile(libcc);
|
||||
CloseHandle(h_libcc_map);
|
||||
CloseHandle(h_libcc);
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
WORD section_num = libcc_nt_header->FileHeader.NumberOfSections;
|
||||
const IMAGE_SECTION_HEADER* libcc_section_headers = reinterpret_cast<const IMAGE_SECTION_HEADER*>(
|
||||
libcc + libcc_dos_header->e_lfanew + sizeof(libcc_nt_header->Signature) + sizeof(libcc_nt_header->FileHeader) + libcc_nt_header->FileHeader.SizeOfOptionalHeader
|
||||
);
|
||||
|
||||
const IMAGE_SECTION_HEADER* rdata_section = nullptr;
|
||||
for (WORD i = 0; i < section_num; ++i) {
|
||||
if (*reinterpret_cast<const uint64_t*>(libcc_section_headers[i].Name) == 0x61746164722e) { // b'\x00\x00atadr.'
|
||||
rdata_section = libcc_section_headers + i;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (rdata_section == nullptr) {
|
||||
_tprintf_s(TEXT(".rdata section is not found. @[FindPatchOffset]\r\n"));
|
||||
UnmapViewOfFile(libcc);
|
||||
CloseHandle(h_libcc_map);
|
||||
CloseHandle(h_libcc);
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
const IMAGE_SECTION_HEADER* text_section = nullptr;
|
||||
for (WORD i = 0; i < section_num; ++i) {
|
||||
if (*reinterpret_cast<const uint64_t*>(libcc_section_headers[i].Name) == 0x747865742e) { // b'\x00\x00\x00txet.'
|
||||
text_section = libcc_section_headers + i;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (text_section == nullptr) {
|
||||
_tprintf_s(TEXT(".text section is not found. @[FindPatchOffset]\r\n"));
|
||||
UnmapViewOfFile(libcc);
|
||||
CloseHandle(h_libcc_map);
|
||||
CloseHandle(h_libcc);
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
// search offset[0]
|
||||
{
|
||||
const uint8_t keyword[] = "D75125B70767B94145B47C1CB3C0755E";
|
||||
const uint8_t* start = libcc + rdata_section->PointerToRawData;
|
||||
DWORD section_size = rdata_section->SizeOfRawData;
|
||||
for (DWORD i = 0; i < section_size; ++i) {
|
||||
if (start[i] == keyword[0]) {
|
||||
bool found = true;
|
||||
for (DWORD j = 1; j < sizeof(keyword) - 1; ++j)
|
||||
if (start[i + j] != keyword[j]) {
|
||||
found = false;
|
||||
break;
|
||||
}
|
||||
if (found) {
|
||||
Offset[0] = rdata_section->PointerToRawData + i;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// search offset[2]
|
||||
{
|
||||
const uint8_t keyword[] = "E1CED09B9C2186BF71A70C0FE2F1E0AE";
|
||||
const uint8_t* start = libcc + rdata_section->PointerToRawData;
|
||||
DWORD section_size = rdata_section->SizeOfRawData;
|
||||
for (DWORD i = 0; i < section_size; ++i) {
|
||||
if (start[i] == keyword[0]) {
|
||||
bool found = true;
|
||||
for (DWORD j = 1; j < sizeof(keyword) - 1; ++j)
|
||||
if (start[i + j] != keyword[j]) {
|
||||
found = false;
|
||||
break;
|
||||
}
|
||||
if (found) {
|
||||
Offset[2] = rdata_section->PointerToRawData + i;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// search offset[4]
|
||||
{
|
||||
const uint8_t keyword[] = "92933";
|
||||
const uint8_t* start = libcc + rdata_section->PointerToRawData;
|
||||
DWORD section_size = rdata_section->SizeOfRawData;
|
||||
for (DWORD i = 0; i < section_size; ++i) {
|
||||
if (start[i] == keyword[0]) {
|
||||
bool found = true;
|
||||
for (DWORD j = 1; j < sizeof(keyword) - 1; ++j)
|
||||
if (start[i + j] != keyword[j]) {
|
||||
found = false;
|
||||
break;
|
||||
}
|
||||
if (found) {
|
||||
Offset[4] = rdata_section->PointerToRawData + i;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// search offset[1]
|
||||
{
|
||||
const uint8_t keyword[] = { 0xfe, 0xea, 0xbc, 0x01 };
|
||||
const uint8_t* start = libcc + text_section->PointerToRawData;
|
||||
DWORD section_size = text_section->SizeOfRawData;
|
||||
for (DWORD i = 0; i < section_size; ++i) {
|
||||
if (start[i] == keyword[0]) {
|
||||
bool found = true;
|
||||
for (DWORD j = 1; j < sizeof(keyword); ++j)
|
||||
if (start[i + j] != keyword[j]) {
|
||||
found = false;
|
||||
break;
|
||||
}
|
||||
if (found) {
|
||||
Offset[1] = text_section->PointerToRawData + i;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// search offset[3]
|
||||
{
|
||||
const uint8_t keyword[] = { 0x59, 0x08, 0x01, 0x00 };
|
||||
const uint8_t* start = libcc + text_section->PointerToRawData;
|
||||
DWORD section_size = text_section->SizeOfRawData;
|
||||
for (DWORD i = 0; i < section_size; ++i) {
|
||||
if (start[i] == keyword[0]) {
|
||||
bool found = true;
|
||||
for (DWORD j = 1; j < sizeof(keyword); ++j)
|
||||
if (start[i + j] != keyword[j]) {
|
||||
found = false;
|
||||
break;
|
||||
}
|
||||
if (found) {
|
||||
Offset[3] = text_section->PointerToRawData + i;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
UnmapViewOfFile(libcc);
|
||||
CloseHandle(h_libcc_map);
|
||||
CloseHandle(h_libcc);
|
||||
|
||||
if (Offset[0] == 0 || Offset[1] == 0 || Offset[2] == 0 || Offset[3] == 0 || Offset[4] == 0) {
|
||||
_tprintf_s(TEXT("Failed to find all patch offset. Is libcc.dll from official? Or you've patched?\r\n"));
|
||||
return FALSE;
|
||||
} else {
|
||||
return TRUE;
|
||||
}
|
||||
}
|
||||
|
||||
BOOL Do(LPCTSTR libcc_dll_path, LPCTSTR prepared_key_file) {
|
||||
// uint8_t expected_hash[SHA256_DIGEST_LENGTH] = {
|
||||
// 0x60, 0x7e, 0x0a, 0x84, 0xc7, 0x59, 0x66, 0xb0,
|
||||
// 0x0f, 0x3d, 0x12, 0xfa, 0x83, 0x3e, 0x91, 0xd1,
|
||||
// 0x59, 0xe4, 0xf5, 0x1a, 0xc5, 0x1b, 0x6b, 0xa6,
|
||||
// 0x6f, 0x98, 0xd0, 0xc3, 0xcb, 0xef, 0xdc, 0xe0
|
||||
// };
|
||||
//
|
||||
// if (!Check_libcc_Hash(libcc_dll_path, expected_hash))
|
||||
// return FALSE;
|
||||
|
||||
DWORD Patch_Offset[5];
|
||||
if (!FindPatchOffset(libcc_dll_path, Patch_Offset))
|
||||
return FALSE;
|
||||
|
||||
|
||||
|
||||
if (!BackupFile(libcc_dll_path))
|
||||
return FALSE;
|
||||
|
||||
RSA* PrivateKey = nullptr;
|
||||
if (prepared_key_file != nullptr) {
|
||||
PrivateKey = ReadRSAPrivateKeyFromFile(prepared_key_file);
|
||||
if (PrivateKey == nullptr)
|
||||
return FALSE;
|
||||
|
||||
if (!CheckRSAKeyIsAppropriate(PrivateKey)) {
|
||||
_tprintf_s(TEXT("The key is not appropriate to use. @[patcher::Solution1::Do -> CheckRSAKeyIsAppropriate]\r\n"));
|
||||
RSA_free(PrivateKey);
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
} else {
|
||||
PrivateKey = GenerateAppropriateRSAKey();
|
||||
if (PrivateKey == nullptr)
|
||||
return FALSE;
|
||||
|
||||
if (!WriteRSAPrivateKeyToFile(TEXT("RegPrivateKey.pem"), PrivateKey)) {
|
||||
RSA_free(PrivateKey);
|
||||
return FALSE;
|
||||
}
|
||||
}
|
||||
|
||||
char* pem_pubkey = GetPEMText(PrivateKey);
|
||||
if (pem_pubkey == nullptr)
|
||||
return FALSE;
|
||||
|
||||
std::string encrypted_pem_pubkey = EncryptPublicKey(pem_pubkey, strlen(pem_pubkey));
|
||||
|
||||
delete[] pem_pubkey; // we do not need it anymore
|
||||
RSA_free(PrivateKey); // we do not need it anymore
|
||||
|
||||
// split encrypted_pem_pubkey to 5 part: |160 chars|8 chars|742 chars|5 chars|5 chars|
|
||||
// | |
|
||||
// \ / \ /
|
||||
// imm1 imm3
|
||||
std::string encrypted_pem_pubkey0(encrypted_pem_pubkey.begin(), encrypted_pem_pubkey.begin() + 160);
|
||||
std::string encrypted_pem_pubkey1(encrypted_pem_pubkey.begin() + 160, encrypted_pem_pubkey.begin() + 160 + 8);
|
||||
std::string encrypted_pem_pubkey2(encrypted_pem_pubkey.begin() + 160 + 8, encrypted_pem_pubkey.begin() + 160 + 8 + 742);
|
||||
std::string encrypted_pem_pubkey3(encrypted_pem_pubkey.begin() + 160 + 8 + 742, encrypted_pem_pubkey.begin() + 160 + 8 + 742 + 5);
|
||||
std::string encrypted_pem_pubkey4(encrypted_pem_pubkey.begin() + 160 + 8 + 742 + 5, encrypted_pem_pubkey.end());
|
||||
|
||||
uint32_t imm1 = std::stoul(encrypted_pem_pubkey1.c_str());
|
||||
uint32_t imm3 = std::stoul(encrypted_pem_pubkey3.c_str());
|
||||
|
||||
HANDLE hFile = CreateFile(libcc_dll_path, GENERIC_WRITE, NULL, nullptr, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, nullptr);
|
||||
if (hFile == INVALID_HANDLE_VALUE) {
|
||||
_tprintf_s(TEXT("Failed to open libcc.dll. CODE: 0x%08x @[patcher::Solution1::Do -> CreateFile]\r\n"), GetLastError());
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
// Start from win8, lpNumberOfBytesWritten parameter in WriteFile can be null if lpOverlapped is null.
|
||||
// But win7 is not. lpNumberOfBytesWritten cannot be null if lpOverlapped is null.
|
||||
// However MSDN does not mention that.
|
||||
DWORD WrittenBytes;
|
||||
|
||||
// start patch 0
|
||||
_tprintf_s(TEXT("\r\nStart to do patch 0......\r\n"));
|
||||
if (INVALID_SET_FILE_POINTER == SetFilePointer(hFile, Patch_Offset[0], nullptr, FILE_BEGIN)) {
|
||||
_tprintf_s(TEXT("Failed to set file pointer. CODE: 0x%08x @[patcher::Solution1::Do -> SetFilePointer]\r\n"), GetLastError());
|
||||
CloseHandle(hFile);
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
_tprintf_s(TEXT("At offset +0x%08x, write:\r\n\"%hs\"\r\n"), Patch_Offset[0], encrypted_pem_pubkey0.c_str());
|
||||
if (FALSE == WriteFile(hFile, encrypted_pem_pubkey0.c_str(), encrypted_pem_pubkey0.length(), &WrittenBytes, nullptr)) {
|
||||
_tprintf_s(TEXT("Failed to write patch 0. CODE: 0x%08x @[patcher::Solution1::Do -> WriteFile]\r\n"), GetLastError());
|
||||
CloseHandle(hFile);
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
_tprintf_s(TEXT("patch 0 done.....\r\n"));
|
||||
|
||||
// start patch 1
|
||||
_tprintf_s(TEXT("\r\nStart to do patch 1.....\r\n"));
|
||||
if (INVALID_SET_FILE_POINTER == SetFilePointer(hFile, Patch_Offset[1], nullptr, FILE_BEGIN)) {
|
||||
_tprintf_s(TEXT("Failed to set file pointer. CODE: 0x%08x @[patcher::Solution1::Do -> SetFilePointer]\r\n"), GetLastError());
|
||||
CloseHandle(hFile);
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
_tprintf_s(TEXT("At offset +0x%08x, write immediate value %d (type: uint32_t)\r\n"), Patch_Offset[1], imm1);
|
||||
if (FALSE == WriteFile(hFile, &imm1, sizeof(imm1), &WrittenBytes, nullptr)) {
|
||||
_tprintf_s(TEXT("Failed to write patch 1. CODE: 0x%08x @[patcher::Solution1::Do -> WriteFile]\r\n"), GetLastError());
|
||||
CloseHandle(hFile);
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
_tprintf_s(TEXT("patch 1 done.....\r\n"));
|
||||
|
||||
// start patch 2
|
||||
_tprintf_s(TEXT("\r\nStart to do patch 2.....\r\n"));
|
||||
if (INVALID_SET_FILE_POINTER == SetFilePointer(hFile, Patch_Offset[2], nullptr, FILE_BEGIN)) {
|
||||
_tprintf_s(TEXT("Failed to set file pointer. CODE: 0x%08x @[patcher::Solution1::Do -> SetFilePointer]\r\n"), GetLastError());
|
||||
CloseHandle(hFile);
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
_tprintf_s(TEXT("At offset +0x%08x, write:\r\n\"%hs\"\r\n"), Patch_Offset[2], encrypted_pem_pubkey2.c_str());
|
||||
if (FALSE == WriteFile(hFile, encrypted_pem_pubkey2.c_str(), encrypted_pem_pubkey2.length(), &WrittenBytes, nullptr)) {
|
||||
_tprintf_s(TEXT("Failed to write patch 2. CODE: 0x%08x @[patcher::Solution1::Do -> WriteFile]\r\n"), GetLastError());
|
||||
CloseHandle(hFile);
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
_tprintf_s(TEXT("patch 2 done.....\r\n"));
|
||||
|
||||
// start patch 3
|
||||
_tprintf_s(TEXT("\r\nStart to do patch 3.....\r\n"));
|
||||
if (INVALID_SET_FILE_POINTER == SetFilePointer(hFile, Patch_Offset[3], nullptr, FILE_BEGIN)) {
|
||||
_tprintf_s(TEXT("Failed to set file pointer. CODE: 0x%08x @[patcher::Solution1::Do -> SetFilePointer]\r\n"), GetLastError());
|
||||
CloseHandle(hFile);
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
_tprintf_s(TEXT("At offset +0x%08x, write immediate value %d (type: uint32_t)\r\n"), Patch_Offset[3], imm3);
|
||||
if (FALSE == WriteFile(hFile, &imm3, sizeof(imm3), &WrittenBytes, nullptr)) {
|
||||
_tprintf_s(TEXT("Failed to write patch 3. CODE: 0x%08x @[patcher::Solution1::Do -> WriteFile]\r\n"), GetLastError());
|
||||
CloseHandle(hFile);
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
_tprintf_s(TEXT("patch 3 done.....\r\n"));
|
||||
|
||||
// start patch 4
|
||||
_tprintf_s(TEXT("\r\nStart to do patch 4.....\r\n"));
|
||||
if (INVALID_SET_FILE_POINTER == SetFilePointer(hFile, Patch_Offset[4], nullptr, FILE_BEGIN)) {
|
||||
_tprintf_s(TEXT("Failed to set file pointer. CODE: 0x%08x @[patcher::Solution1::Do -> SetFilePointer]\r\n"), GetLastError());
|
||||
CloseHandle(hFile);
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
_tprintf_s(TEXT("At offset +0x%08x, write:\r\n\"%hs\"\r\n"), Patch_Offset[4], encrypted_pem_pubkey4.c_str());
|
||||
if (FALSE == WriteFile(hFile, encrypted_pem_pubkey4.c_str(), encrypted_pem_pubkey4.length(), &WrittenBytes, nullptr)) {
|
||||
_tprintf_s(TEXT("Failed to write patch 4. CODE: 0x%08x @[patcher::Solution1::Do -> WriteFile]\r\n"), GetLastError());
|
||||
CloseHandle(hFile);
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
_tprintf_s(TEXT("patch 4 done.....\r\n\r\n"));
|
||||
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
}
|
||||
+42
-88
@@ -1,105 +1,59 @@
|
||||
#include <tchar.h>
|
||||
#include <windows.h>
|
||||
#include "def.hpp"
|
||||
|
||||
#include <openssl/err.h>
|
||||
#include <openssl/bio.h>
|
||||
#include <openssl/rsa.h>
|
||||
#include <openssl/pem.h>
|
||||
|
||||
#pragma comment(lib, "libcrypto.lib")
|
||||
|
||||
BOOL BackupNavicat(PTSTR NavicatFileName) {
|
||||
TCHAR new_NavicatFileName[1024] = { };
|
||||
|
||||
if (NavicatFileName == nullptr)
|
||||
NavicatFileName = TEXT("navicat.exe");
|
||||
|
||||
_stprintf_s(new_NavicatFileName, TEXT("%s%s"), NavicatFileName, TEXT(".backup"));
|
||||
|
||||
if (!CopyFile(NavicatFileName, new_NavicatFileName, TRUE)) {
|
||||
switch (GetLastError()) {
|
||||
case ERROR_FILE_NOT_FOUND:
|
||||
_tprintf_s(TEXT("Cannot find %s.\r\n"), NavicatFileName);
|
||||
break;
|
||||
case ERROR_FILE_EXISTS:
|
||||
_tprintf_s(TEXT("Backup file already exists.\r\n"));
|
||||
break;
|
||||
default:
|
||||
_tprintf_s(TEXT("Unknown error. CODE: 0x%08x.\r\n"), GetLastError());
|
||||
}
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
_tprintf_s(TEXT("%s has been backed up.\r\n"), NavicatFileName);
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
BOOL ReplaceNavicatPublicKey(HANDLE resUpdater, void* pemPublicKey, size_t length) {
|
||||
return UpdateResource(resUpdater,
|
||||
RT_RCDATA,
|
||||
TEXT("ActivationPubKey"),
|
||||
MAKELANGID(LANG_ENGLISH, SUBLANG_DEFAULT),
|
||||
pemPublicKey, length);
|
||||
}
|
||||
|
||||
RSA* GeneratePrivateKey() {
|
||||
RSA* PrivateKey = RSA_generate_key(2048, RSA_F4, nullptr, nullptr);
|
||||
BIO* PrivateKeyFile = BIO_new(BIO_s_file());
|
||||
BIO_write_filename(PrivateKeyFile, "RegPrivateKey.pem");
|
||||
PEM_write_bio_RSAPrivateKey(PrivateKeyFile, PrivateKey, nullptr, nullptr, 0, nullptr, nullptr);
|
||||
BIO_free_all(PrivateKeyFile);
|
||||
|
||||
return PrivateKey;
|
||||
namespace std {
|
||||
#ifdef UNICODE
|
||||
typedef wstring Tstring;
|
||||
#else
|
||||
typedef string Tstring;
|
||||
#endif
|
||||
}
|
||||
|
||||
int _tmain(int argc, TCHAR* argv[]) {
|
||||
if (argc != 2 && argc != 3) {
|
||||
_tprintf_s(TEXT("Usage:\r\n"));
|
||||
_tprintf_s(TEXT(" navicat-patcher.exe <navicat.exe path>\r\n"));
|
||||
_tprintf_s(TEXT(" navicat-patcher.exe <Navicat installation path> [RSA-2048 PEM file]\r\n"));
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (BackupNavicat(argv[1]) == FALSE)
|
||||
return GetLastError();
|
||||
{ // check path validity
|
||||
DWORD attr = GetFileAttributes(argv[1]);
|
||||
if (attr == INVALID_FILE_ATTRIBUTES) {
|
||||
_tprintf_s(TEXT("Failed to get installation path attribute. CODE: 0x%08x @[GetFileAttributes]\r\n"), GetLastError());
|
||||
return 0;
|
||||
}
|
||||
|
||||
RSA* PrivateKey = GeneratePrivateKey();
|
||||
|
||||
HANDLE hUpdater = BeginUpdateResource(argv[1], FALSE);
|
||||
if (hUpdater == NULL) {
|
||||
_tprintf_s(TEXT("Cannot open file. CODE: 0x%08x\r\n"), GetLastError());
|
||||
RSA_free(PrivateKey);
|
||||
return GetLastError();
|
||||
}
|
||||
|
||||
char pemPublicKey[1024] = { };
|
||||
{
|
||||
char temp_buf[1024] = { };
|
||||
BIO* BIO_pemPublicKey = BIO_new(BIO_s_mem());
|
||||
|
||||
PEM_write_bio_RSA_PUBKEY(BIO_pemPublicKey, PrivateKey);
|
||||
BIO_read(BIO_pemPublicKey, temp_buf, 1024);
|
||||
BIO_free_all(BIO_pemPublicKey);
|
||||
|
||||
char* pemPublicKey_ptr = pemPublicKey;
|
||||
for (size_t i = 0; i < 1024; ++i) {
|
||||
if (temp_buf[i] == '\n')
|
||||
*(pemPublicKey_ptr++) = '\r';
|
||||
if (temp_buf[i] == 0)
|
||||
break;
|
||||
*(pemPublicKey_ptr++) = temp_buf[i];
|
||||
if ((attr & FILE_ATTRIBUTE_DIRECTORY) == 0) {
|
||||
_tprintf_s(TEXT("Error: Path is not a directory.\r\n"));
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
if (ReplaceNavicatPublicKey(hUpdater, pemPublicKey, strlen(pemPublicKey)) == FALSE) {
|
||||
_tprintf_s(TEXT("Cannot replace public key. CODE: 0x%08x\r\n"), GetLastError());
|
||||
EndUpdateResource(hUpdater, TRUE);
|
||||
return GetLastError();
|
||||
} else {
|
||||
_tprintf_s(TEXT("Public key has been replaced.\r\n"));
|
||||
EndUpdateResource(hUpdater, FALSE);
|
||||
std::Tstring navicat_exe_path(argv[1]);
|
||||
if (navicat_exe_path.back() != TEXT('/') && navicat_exe_path.back() != TEXT('\\'))
|
||||
navicat_exe_path.push_back(TEXT('\\'));
|
||||
navicat_exe_path += TEXT("navicat.exe");
|
||||
|
||||
std::Tstring libcc_dll_path(argv[1]);
|
||||
if (libcc_dll_path.back() != TEXT('/') && libcc_dll_path.back() != TEXT('\\'))
|
||||
libcc_dll_path.push_back(TEXT('\\'));
|
||||
libcc_dll_path += TEXT("libcc.dll");
|
||||
|
||||
DWORD NavicatMajorVersion;
|
||||
DWORD NavicatMinorVersion;
|
||||
if (!patcher::GetNavicatVerion(navicat_exe_path.c_str(), &NavicatMajorVersion, &NavicatMinorVersion))
|
||||
return 0;
|
||||
|
||||
BOOL status;
|
||||
if (NavicatMajorVersion <= 0x000C0000 && NavicatMinorVersion < 0x00190000) { // for navicat ver < 12.0.25
|
||||
status = patcher::Solution0::Do(navicat_exe_path.c_str());
|
||||
} else if (NavicatMajorVersion == 0x000C0000 && NavicatMinorVersion == 0x00190000) { // for navicat ver = 12.0.25
|
||||
status = patcher::Solution1::Do(libcc_dll_path.c_str(), argc == 3 ? argv[2] : nullptr);
|
||||
} else if (NavicatMajorVersion == 0x000C0000 && NavicatMinorVersion == 0x001A0000) { // for navicat ver = 12.0.26
|
||||
status = patcher::Solution1::Do(libcc_dll_path.c_str(), argc == 3 ? argv[2] : nullptr);
|
||||
} else if (NavicatMajorVersion == 0x000C0000 && NavicatMinorVersion == 0x001B0000) { // for navicat ver = 12.0.27
|
||||
status = patcher::Solution1::Do(libcc_dll_path.c_str(), argc == 3 ? argv[2] : nullptr);
|
||||
}
|
||||
|
||||
_tprintf_s(TEXT("Success!\r\n"));
|
||||
RSA_free(PrivateKey);
|
||||
_tprintf_s(TEXT("%s\r\n"), status == TRUE ? TEXT("Success!") : TEXT("Failed!"));
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,249 @@
|
||||
#include "def.hpp"
|
||||
|
||||
namespace patcher {
|
||||
|
||||
BOOL BackupFile(LPCTSTR file_path) {
|
||||
size_t file_path_len = _tcslen(file_path);
|
||||
|
||||
TCHAR* backup_file_path = new TCHAR[file_path_len + 16]();
|
||||
_stprintf_s(backup_file_path, file_path_len + 16, TEXT("%s%s"), file_path, TEXT(".backup"));
|
||||
|
||||
if (!CopyFile(file_path, backup_file_path, TRUE)) {
|
||||
switch (GetLastError()) {
|
||||
case ERROR_FILE_NOT_FOUND:
|
||||
_tprintf_s(TEXT("@[BackupFile]: Cannot find %s.\r\n"), file_path);
|
||||
break;
|
||||
case ERROR_FILE_EXISTS:
|
||||
_tprintf_s(TEXT("@[BackupFile]: Backup file already exists.\r\n"));
|
||||
break;
|
||||
case ERROR_ACCESS_DENIED:
|
||||
_tprintf_s(TEXT("@[BackupFile]: Access denied, please run as administrator.\r\n"));
|
||||
break;
|
||||
default:
|
||||
_tprintf_s(TEXT("Unknown error. CODE: 0x%08x @[BackupFile -> CopyFile]\r\n"), GetLastError());
|
||||
}
|
||||
delete[] backup_file_path;
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
_tprintf_s(TEXT("@[BackupFile]: %s has been backed up.\r\n"), file_path);
|
||||
delete[] backup_file_path;
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
RSA* GenerateRSAKey(int bits) {
|
||||
RSA* ret = RSA_generate_key(bits, RSA_F4, nullptr, nullptr);
|
||||
if (ret == nullptr) {
|
||||
_tprintf_s(TEXT("Failed to generate RSA key. CODE: 0x%08x @[GenerateRSAKey -> RSA_generate_key]\r\n"), ERR_get_error());
|
||||
return nullptr;
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
BOOL WriteRSAPrivateKeyToFile(LPCTSTR filename, RSA* PrivateKey) {
|
||||
#ifdef UNICODE
|
||||
int req_size = WideCharToMultiByte(CP_ACP, 0, filename, -1, nullptr, 0, nullptr, nullptr);
|
||||
if (req_size == 0) {
|
||||
_tprintf_s(TEXT("Failed to convert wchar* to char*. CODE: 0x%08x @[WriteRSAPrivateKeyToFile -> WideCharToMultiByte]\r\n"), GetLastError());
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
char* temp_filename = new char[req_size]();
|
||||
WideCharToMultiByte(CP_ACP, 0, filename, -1, temp_filename, req_size, nullptr, nullptr);
|
||||
|
||||
BIO* b = BIO_new(BIO_s_file());
|
||||
if (b == nullptr) {
|
||||
_tprintf_s(TEXT("Failed to create BIO object. CODE: 0x%08x @[WriteRSAPrivateKeyToFile -> BIO_new]\r\n"), ERR_get_error());
|
||||
delete[] temp_filename;
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
if (1 != BIO_write_filename(b, temp_filename)) {
|
||||
_tprintf_s(TEXT("Failed to set target file of BIO. CODE: 0x%08x @[WriteRSAPrivateKeyToFile -> BIO_write_filename]\r\n"), ERR_get_error());
|
||||
|
||||
BIO_free_all(b);
|
||||
delete[] temp_filename;
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
delete[] temp_filename;
|
||||
#else
|
||||
BIO* b = BIO_new(BIO_s_file());
|
||||
if (b == nullptr) {
|
||||
_tprintf_s(TEXT("Failed to create BIO object. CODE: 0x%08x @[WriteRSAPrivateKeyToFile -> BIO_new]\r\n"), ERR_get_error());
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
if (1 != BIO_write_filename(b, filename)) {
|
||||
_tprintf_s(TEXT("Failed to set target file of BIO. CODE: 0x%08x @[WriteRSAPrivateKeyToFile -> BIO_write_filename]\r\n"), ERR_get_error());
|
||||
|
||||
BIO_free_all(b);
|
||||
return FALSE;
|
||||
}
|
||||
#endif
|
||||
if (1 != PEM_write_bio_RSAPrivateKey(b, PrivateKey, nullptr, nullptr, 0, nullptr, nullptr)) {
|
||||
_tprintf_s(TEXT("Failed to write RSA private key. CODE: 0x%08x @[WriteRSAPrivateKeyToFile -> PEM_write_bio_RSAPrivateKey]\r\n"), ERR_get_error());
|
||||
|
||||
BIO_free_all(b);
|
||||
return FALSE;
|
||||
} else {
|
||||
BIO_free_all(b);
|
||||
return TRUE;
|
||||
}
|
||||
}
|
||||
|
||||
RSA* ReadRSAPrivateKeyFromFile(LPCTSTR filename) {
|
||||
#ifdef UNICODE
|
||||
int req_size = WideCharToMultiByte(CP_ACP, 0, filename, -1, nullptr, 0, nullptr, nullptr);
|
||||
if (req_size == 0) {
|
||||
_tprintf_s(TEXT("Failed to convert wchar* to char*. CODE: 0x%08x @[ReadRSAPrivateKeyFromFile -> WideCharToMultiByte]\r\n"), GetLastError());
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
char* temp_filename = new char[req_size]();
|
||||
WideCharToMultiByte(CP_ACP, 0, filename, -1, temp_filename, req_size, nullptr, nullptr);
|
||||
|
||||
BIO* b = BIO_new(BIO_s_file());
|
||||
if (b == nullptr) {
|
||||
_tprintf_s(TEXT("Failed to create BIO object. CODE: 0x%08x @[ReadRSAPrivateKeyFromFile -> BIO_new]\r\n"), ERR_get_error());
|
||||
delete[] temp_filename;
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
if (1 != BIO_read_filename(b, temp_filename)) {
|
||||
_tprintf_s(TEXT("Failed to set target file of BIO. CODE: 0x%08x @[ReadRSAPrivateKeyFromFile -> BIO_read_filename]\r\n"), ERR_get_error());
|
||||
|
||||
BIO_free_all(b);
|
||||
delete[] temp_filename;
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
delete[] temp_filename;
|
||||
#else
|
||||
BIO* b = BIO_new(BIO_s_file());
|
||||
if (b == nullptr) {
|
||||
_tprintf_s(TEXT("Failed to create BIO object. CODE: 0x%08x @[ReadRSAPrivateKeyFromFile -> BIO_new]\r\n"), ERR_get_error());
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
if (1 != BIO_read_filename(b, filename)) {
|
||||
_tprintf_s(TEXT("Failed to set target file of BIO. CODE: 0x%08x @[ReadRSAPrivateKeyFromFile -> BIO_read_filename]\r\n"), ERR_get_error());
|
||||
|
||||
BIO_free_all(b);
|
||||
return FALSE;
|
||||
}
|
||||
#endif
|
||||
RSA* ret = PEM_read_bio_RSAPrivateKey(b, nullptr, nullptr, nullptr);
|
||||
if (ret == nullptr) {
|
||||
_tprintf_s(TEXT("Failed to read RSA private key. CODE: 0x%08x @[ReadRSAPrivateKeyFromFile -> PEM_read_bio_RSAPrivateKey]\r\n"), ERR_get_error());
|
||||
|
||||
BIO_free_all(b);
|
||||
return nullptr;
|
||||
} else {
|
||||
BIO_free_all(b);
|
||||
return ret;
|
||||
}
|
||||
}
|
||||
|
||||
BOOL GetNavicatVerion(LPCTSTR exe_path, DWORD* major_ver, DWORD* minor_ver) {
|
||||
DWORD FileVersionInfoSize = GetFileVersionInfoSize(exe_path, nullptr);
|
||||
if (FileVersionInfoSize == 0) {
|
||||
_tprintf_s(TEXT("Failed to get navicat.exe verion info. CODE: 0x%08x @[GetNavicatVerion -> GetFileVersionInfoSize]\r\n"), GetLastError());
|
||||
return FALSE;
|
||||
}
|
||||
LPVOID buf = new unsigned char[FileVersionInfoSize]();
|
||||
if (FALSE == GetFileVersionInfo(exe_path, 0, FileVersionInfoSize, buf)) {
|
||||
_tprintf_s(TEXT("Failed to get navicat.exe verion info. CODE: 0x%08x @[GetNavicatVerion -> GetFileVersionInfo]\r\n"), GetLastError());
|
||||
delete[] buf;
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
LPVOID info_ptr;
|
||||
UINT info_len;
|
||||
if (FALSE == VerQueryValue(buf, TEXT("\\"), &info_ptr, &info_len)) {
|
||||
_tprintf_s(TEXT("Failed to get navicat.exe verion info. CODE: 0x%08x @[GetNavicatVerion -> VerQueryValue]\r\n"), GetLastError());
|
||||
delete[] buf;
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
*major_ver = static_cast<VS_FIXEDFILEINFO*>(info_ptr)->dwFileVersionMS;
|
||||
*minor_ver = static_cast<VS_FIXEDFILEINFO*>(info_ptr)->dwFileVersionLS;
|
||||
delete[] buf;
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
BOOL Check_libcc_Hash(LPCTSTR libcc_dll_path, const uint8_t expected_hash[SHA256_DIGEST_LENGTH]) {
|
||||
HANDLE hFile = CreateFile(libcc_dll_path, GENERIC_READ, FILE_SHARE_READ, nullptr, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
|
||||
if (hFile == INVALID_HANDLE_VALUE) {
|
||||
_tprintf_s(TEXT("Failed to open libcc.dll. CODE: 0x%08x @[Check_libcc_Hash -> CreateFile]\r\n"), GetLastError());
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
LARGE_INTEGER FileSize;
|
||||
if (FALSE == GetFileSizeEx(hFile, &FileSize)) {
|
||||
_tprintf_s(TEXT("Failed to get libcc.dll size. CODE: 0x%08x @[Check_libcc_Hash -> GetFileSizeEx]\r\n"), GetLastError());
|
||||
CloseHandle(hFile);
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
HANDLE hFileMap = CreateFileMapping(hFile, nullptr, PAGE_READONLY, 0, 0, nullptr);
|
||||
if (hFileMap == NULL) {
|
||||
_tprintf_s(TEXT("Failed to create mapping for libcc.dll. CODE: 0x%08x @[Check_libcc_Hash -> CreateFileMapping]\r\n"), GetLastError());
|
||||
CloseHandle(hFile);
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
const uint8_t* libcc_data = reinterpret_cast<const uint8_t*>(MapViewOfFile(hFileMap, FILE_MAP_READ, 0, 0, 0));
|
||||
if (libcc_data == nullptr) {
|
||||
_tprintf_s(TEXT("Failed to map libcc.dll. CODE: 0x%08x @[Check_libcc_Hash -> MapViewOfFile]\r\n"), GetLastError());
|
||||
CloseHandle(hFileMap);
|
||||
CloseHandle(hFile);
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
uint8_t real_hash[SHA256_DIGEST_LENGTH] = { };
|
||||
|
||||
SHA256(libcc_data, FileSize.LowPart, real_hash);
|
||||
UnmapViewOfFile(libcc_data);
|
||||
CloseHandle(hFileMap);
|
||||
CloseHandle(hFile);
|
||||
|
||||
if (memcmp(expected_hash, real_hash, SHA256_DIGEST_LENGTH) != 0) {
|
||||
_tprintf_s(TEXT("ERROR: SHA256 do not match.\r\n"));
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
char* GetPEMText(RSA* PrivateKey) {
|
||||
BIO* bio = BIO_new(BIO_s_mem());
|
||||
if (bio == nullptr) {
|
||||
_tprintf_s(TEXT("Cannot create BIO object. CODE: 0x%08x @[GetPEMText -> BIO_new]\r\n"), ERR_get_error());
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
if (1 != PEM_write_bio_RSA_PUBKEY(bio, PrivateKey)) {
|
||||
_tprintf_s(TEXT("Cannot write RSA-2048 public key. CODE: 0x%08x @[GetPEMText -> PEM_write_bio_RSA_PUBKEY]\r\n"), ERR_get_error());
|
||||
BIO_free_all(bio);
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
char* pem_data_ptr;
|
||||
int pem_data_len = BIO_get_mem_data(bio, &pem_data_ptr);
|
||||
|
||||
char* ret = new char[pem_data_len + 256]();
|
||||
for (int i = 0, j = 0; i < pem_data_len; ++i, ++j) {
|
||||
if (pem_data_ptr[i] == '\n') {
|
||||
ret[j++] = '\r';
|
||||
ret[j] = pem_data_ptr[i];
|
||||
} else {
|
||||
ret[j] = pem_data_ptr[i];
|
||||
}
|
||||
}
|
||||
|
||||
BIO_free_all(bio);
|
||||
return ret;
|
||||
}
|
||||
|
||||
}
|
||||
@@ -0,0 +1,51 @@
|
||||
#pragma once
|
||||
#include <tchar.h>
|
||||
#include <windows.h>
|
||||
#include <string>
|
||||
|
||||
#include <openssl/err.h>
|
||||
#include <openssl/bio.h>
|
||||
#include <openssl/rsa.h>
|
||||
#include <openssl/pem.h>
|
||||
|
||||
// OpenSSL precompiled lib, download from https://www.npcglib.org/~stathis/blog/precompiled-openssl/, MSVC2015 version
|
||||
// direct link https://www.npcglib.org/~stathis/downloads/openssl-1.1.0f-vs2015.7z
|
||||
// x86: "D:\openssl-1.1.0f-vs2015\include" has been add to include path. (modify it at project properties if necessary)
|
||||
// "D:\openssl-1.1.0f-vs2015\lib" has been add to library path. (modify it at project properties if necessary)
|
||||
// x64: "D:\openssl-1.1.0f-vs2015\include64" has been add to include path. (modify it at project properties if necessary)
|
||||
// "D:\openssl-1.1.0f-vs2015\lib64" has been add to library path. (modify it at project properties if necessary)
|
||||
#ifdef _DEBUG
|
||||
#pragma comment(lib, "libcryptoMTd.lib")
|
||||
#else
|
||||
#pragma comment(lib, "libcryptoMT.lib")
|
||||
#endif
|
||||
#pragma comment(lib, "WS2_32.lib") // some symbol are used in OpenSSL static lib
|
||||
#pragma comment(lib, "Crypt32.lib") // some symbol are used in OpenSSL static lib
|
||||
#pragma comment(lib, "version.lib") // GetFileVersionInfoSize, GetFileVersionInfo, VerQueryValue are in this lib
|
||||
|
||||
namespace patcher {
|
||||
|
||||
BOOL BackupFile(LPCTSTR file_path);
|
||||
|
||||
RSA* GenerateRSAKey(int bits = 2048);
|
||||
|
||||
BOOL WriteRSAPrivateKeyToFile(LPCTSTR filename, RSA* PrivateKey);
|
||||
RSA* ReadRSAPrivateKeyFromFile(LPCTSTR filename);
|
||||
|
||||
BOOL GetNavicatVerion(LPCTSTR exe_path, DWORD* major_ver, DWORD* minor_ver);
|
||||
|
||||
std::string EncryptPublicKey(const char* public_key, size_t len);
|
||||
|
||||
BOOL Check_libcc_Hash(LPCTSTR libcc_dll_path, const uint8_t expected_hash[SHA256_DIGEST_LENGTH]);
|
||||
|
||||
char* GetPEMText(RSA* PrivateKey);
|
||||
|
||||
namespace Solution0 {
|
||||
BOOL Do(LPCTSTR navicat_exe_path, LPCTSTR prepared_key_file = nullptr);
|
||||
}
|
||||
|
||||
namespace Solution1 {
|
||||
BOOL Do(LPCTSTR libcc_dll_path, LPCTSTR prepared_key_file = nullptr);
|
||||
}
|
||||
|
||||
}
|
||||
@@ -28,26 +28,26 @@
|
||||
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
|
||||
<ConfigurationType>Application</ConfigurationType>
|
||||
<UseDebugLibraries>true</UseDebugLibraries>
|
||||
<PlatformToolset>v140</PlatformToolset>
|
||||
<PlatformToolset>v140_xp</PlatformToolset>
|
||||
<CharacterSet>Unicode</CharacterSet>
|
||||
</PropertyGroup>
|
||||
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
|
||||
<ConfigurationType>Application</ConfigurationType>
|
||||
<UseDebugLibraries>false</UseDebugLibraries>
|
||||
<PlatformToolset>v140</PlatformToolset>
|
||||
<PlatformToolset>v140_xp</PlatformToolset>
|
||||
<WholeProgramOptimization>true</WholeProgramOptimization>
|
||||
<CharacterSet>Unicode</CharacterSet>
|
||||
</PropertyGroup>
|
||||
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
|
||||
<ConfigurationType>Application</ConfigurationType>
|
||||
<UseDebugLibraries>true</UseDebugLibraries>
|
||||
<PlatformToolset>v140</PlatformToolset>
|
||||
<PlatformToolset>v140_xp</PlatformToolset>
|
||||
<CharacterSet>Unicode</CharacterSet>
|
||||
</PropertyGroup>
|
||||
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
|
||||
<ConfigurationType>Application</ConfigurationType>
|
||||
<UseDebugLibraries>false</UseDebugLibraries>
|
||||
<PlatformToolset>v140</PlatformToolset>
|
||||
<PlatformToolset>v140_xp</PlatformToolset>
|
||||
<WholeProgramOptimization>true</WholeProgramOptimization>
|
||||
<CharacterSet>Unicode</CharacterSet>
|
||||
</PropertyGroup>
|
||||
@@ -71,23 +71,23 @@
|
||||
<PropertyGroup Label="UserMacros" />
|
||||
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
|
||||
<LinkIncremental>true</LinkIncremental>
|
||||
<IncludePath>D:\OpenSSL-Win32\include;$(IncludePath)</IncludePath>
|
||||
<LibraryPath>D:\OpenSSL-Win32\lib;$(LibraryPath)</LibraryPath>
|
||||
<IncludePath>D:\openssl-1.1.0f-vs2015\include;$(IncludePath)</IncludePath>
|
||||
<LibraryPath>D:\openssl-1.1.0f-vs2015\lib;$(LibraryPath)</LibraryPath>
|
||||
</PropertyGroup>
|
||||
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
|
||||
<LinkIncremental>true</LinkIncremental>
|
||||
<IncludePath>D:\OpenSSL-Win64\include;$(IncludePath)</IncludePath>
|
||||
<LibraryPath>D:\OpenSSL-Win64\lib;$(LibraryPath)</LibraryPath>
|
||||
<IncludePath>D:\openssl-1.1.0f-vs2015\include64;$(IncludePath)</IncludePath>
|
||||
<LibraryPath>D:\openssl-1.1.0f-vs2015\lib64;$(LibraryPath)</LibraryPath>
|
||||
</PropertyGroup>
|
||||
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
|
||||
<LinkIncremental>false</LinkIncremental>
|
||||
<IncludePath>D:\OpenSSL-Win32\include;$(IncludePath)</IncludePath>
|
||||
<LibraryPath>D:\OpenSSL-Win32\lib;$(LibraryPath)</LibraryPath>
|
||||
<IncludePath>D:\openssl-1.1.0f-vs2015\include;$(IncludePath)</IncludePath>
|
||||
<LibraryPath>D:\openssl-1.1.0f-vs2015\lib;$(LibraryPath)</LibraryPath>
|
||||
</PropertyGroup>
|
||||
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
|
||||
<LinkIncremental>false</LinkIncremental>
|
||||
<IncludePath>D:\OpenSSL-Win64\include;$(IncludePath)</IncludePath>
|
||||
<LibraryPath>D:\OpenSSL-Win64\lib;$(LibraryPath)</LibraryPath>
|
||||
<IncludePath>D:\openssl-1.1.0f-vs2015\include64;$(IncludePath)</IncludePath>
|
||||
<LibraryPath>D:\openssl-1.1.0f-vs2015\lib64;$(LibraryPath)</LibraryPath>
|
||||
</PropertyGroup>
|
||||
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
|
||||
<ClCompile>
|
||||
@@ -98,6 +98,7 @@
|
||||
<PreprocessorDefinitions>WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
|
||||
<SDLCheck>true</SDLCheck>
|
||||
<RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
|
||||
<AdditionalOptions>/std:c++latest</AdditionalOptions>
|
||||
</ClCompile>
|
||||
<Link>
|
||||
<SubSystem>Console</SubSystem>
|
||||
@@ -113,6 +114,7 @@
|
||||
<PreprocessorDefinitions>_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
|
||||
<SDLCheck>true</SDLCheck>
|
||||
<RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
|
||||
<AdditionalOptions>/std:c++latest</AdditionalOptions>
|
||||
</ClCompile>
|
||||
<Link>
|
||||
<SubSystem>Console</SubSystem>
|
||||
@@ -130,6 +132,7 @@
|
||||
<PreprocessorDefinitions>WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
|
||||
<SDLCheck>true</SDLCheck>
|
||||
<RuntimeLibrary>MultiThreaded</RuntimeLibrary>
|
||||
<AdditionalOptions>/std:c++latest</AdditionalOptions>
|
||||
</ClCompile>
|
||||
<Link>
|
||||
<SubSystem>Console</SubSystem>
|
||||
@@ -149,6 +152,7 @@
|
||||
<PreprocessorDefinitions>NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
|
||||
<SDLCheck>true</SDLCheck>
|
||||
<RuntimeLibrary>MultiThreaded</RuntimeLibrary>
|
||||
<AdditionalOptions>/std:c++latest</AdditionalOptions>
|
||||
</ClCompile>
|
||||
<Link>
|
||||
<SubSystem>Console</SubSystem>
|
||||
@@ -158,8 +162,23 @@
|
||||
</Link>
|
||||
</ItemDefinitionGroup>
|
||||
<ItemGroup>
|
||||
<ClCompile Include="common.cpp" />
|
||||
<ClCompile Include="EncryptPublicKey.cpp" />
|
||||
<ClCompile Include="NavicatCrypto\aes.c" />
|
||||
<ClCompile Include="NavicatCrypto\aes_constant.c" />
|
||||
<ClCompile Include="NavicatCrypto\blowfish.c" />
|
||||
<ClCompile Include="NavicatCrypto\sha1.c" />
|
||||
<ClCompile Include="Solution0.cpp" />
|
||||
<ClCompile Include="Solution1.cpp" />
|
||||
<ClCompile Include="_tmain.cpp" />
|
||||
</ItemGroup>
|
||||
<ItemGroup>
|
||||
<ClInclude Include="def.hpp" />
|
||||
<ClInclude Include="NavicatCrypto\aes.h" />
|
||||
<ClInclude Include="NavicatCrypto\blowfish.h" />
|
||||
<ClInclude Include="NavicatCrypto\NavicatCrypto.hpp" />
|
||||
<ClInclude Include="NavicatCrypto\sha1.h" />
|
||||
</ItemGroup>
|
||||
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
|
||||
<ImportGroup Label="ExtensionTargets">
|
||||
</ImportGroup>
|
||||
|
||||
@@ -18,5 +18,46 @@
|
||||
<ClCompile Include="_tmain.cpp">
|
||||
<Filter>源文件</Filter>
|
||||
</ClCompile>
|
||||
<ClCompile Include="NavicatCrypto\aes.c">
|
||||
<Filter>源文件</Filter>
|
||||
</ClCompile>
|
||||
<ClCompile Include="NavicatCrypto\aes_constant.c">
|
||||
<Filter>源文件</Filter>
|
||||
</ClCompile>
|
||||
<ClCompile Include="NavicatCrypto\blowfish.c">
|
||||
<Filter>源文件</Filter>
|
||||
</ClCompile>
|
||||
<ClCompile Include="NavicatCrypto\sha1.c">
|
||||
<Filter>源文件</Filter>
|
||||
</ClCompile>
|
||||
<ClCompile Include="EncryptPublicKey.cpp">
|
||||
<Filter>源文件</Filter>
|
||||
</ClCompile>
|
||||
<ClCompile Include="Solution0.cpp">
|
||||
<Filter>源文件</Filter>
|
||||
</ClCompile>
|
||||
<ClCompile Include="common.cpp">
|
||||
<Filter>源文件</Filter>
|
||||
</ClCompile>
|
||||
<ClCompile Include="Solution1.cpp">
|
||||
<Filter>源文件</Filter>
|
||||
</ClCompile>
|
||||
</ItemGroup>
|
||||
<ItemGroup>
|
||||
<ClInclude Include="NavicatCrypto\aes.h">
|
||||
<Filter>头文件</Filter>
|
||||
</ClInclude>
|
||||
<ClInclude Include="NavicatCrypto\blowfish.h">
|
||||
<Filter>头文件</Filter>
|
||||
</ClInclude>
|
||||
<ClInclude Include="NavicatCrypto\NavicatCrypto.hpp">
|
||||
<Filter>头文件</Filter>
|
||||
</ClInclude>
|
||||
<ClInclude Include="NavicatCrypto\sha1.h">
|
||||
<Filter>头文件</Filter>
|
||||
</ClInclude>
|
||||
<ClInclude Include="def.hpp">
|
||||
<Filter>头文件</Filter>
|
||||
</ClInclude>
|
||||
</ItemGroup>
|
||||
</Project>
|
||||
Reference in New Issue
Block a user