AMajor/SoftEtherVPN
1
0
Fork 0
mirror of https://github.com/SoftEtherVPN/SoftEtherVPN.git synced 2025-07-06 07:44:57 +03:00
Code Releases Activity

v4.13-9522-beta

Browse Source
This commit is contained in:
dnobori
2015-01-30 22:30:34 +09:00
parent 75f9836ce5
commit 06a72040a3
337 changed files with 1411 additions and 493 deletions
Download Patch File Download Diff File Expand all files Collapse all files

390
src/Mayaqua/Encrypt.c
View File

@ -156,6 +156,8 @@ UINT ssl_lock_num;
static bool openssl_inited = false;
static bool is_intel_aes_supported = false;
static unsigned char *Internal_SHA0(const unsigned char *d, size_t n, unsigned char *md);
// For the callback function
typedef struct CB_PARAM
{
@ -239,6 +241,74 @@ void Enc_tls1_PRF(unsigned char *label, int label_len, const unsigned char *sec,
Free(out2);
}
// Easy encryption
BUF *EasyEncrypt(BUF *src_buf)
{
UCHAR key[SHA1_SIZE];
BUF *tmp_data;
CRYPT *rc4;
BUF *ret;
// Validate arguments
if (src_buf == NULL)
{
return NULL;
}
Rand(key, SHA1_SIZE);
tmp_data = CloneBuf(src_buf);
rc4 = NewCrypt(key, SHA1_SIZE);
Encrypt(rc4, tmp_data->Buf, tmp_data->Buf, tmp_data->Size);
ret = NewBuf();
WriteBuf(ret, key, SHA1_SIZE);
WriteBufBuf(ret, tmp_data);
FreeCrypt(rc4);
FreeBuf(tmp_data);
SeekBufToBegin(ret);
return ret;
}
// Easy decryption
BUF *EasyDecrypt(BUF *src_buf)
{
UCHAR key[SHA1_SIZE];
BUF *tmp_buf;
CRYPT *rc4;
// Validate arguments
if (src_buf == NULL)
{
return NULL;
}
SeekBufToBegin(src_buf);
if (ReadBuf(src_buf, key, SHA1_SIZE) != SHA1_SIZE)
{
return NULL;
}
tmp_buf = ReadRemainBuf(src_buf);
if (tmp_buf == NULL)
{
return NULL;
}
rc4 = NewCrypt(key, SHA1_SIZE);
Encrypt(rc4, tmp_buf->Buf, tmp_buf->Buf, tmp_buf->Size);
FreeCrypt(rc4);
SeekBufToBegin(tmp_buf);
return tmp_buf;
}
// Calculation of HMAC (MD5)
void HMacMd5(void *dst, void *key, UINT key_size, void *data, UINT data_size)
{
@ -4158,7 +4228,7 @@ void Hash(void *dst, void *src, UINT size, bool sha)
else
{
// SHA hash
SHA(src, size, dst);
Internal_SHA0(src, size, dst);
}
}
@ -4907,6 +4977,324 @@ void DhFree(DH_CTX *dh)
Free(dh);
}
/////////////////////////
// SHA0 implementation //
/////////////////////////
//
// From: https://bitbucket.org/Polarina/ampheck/src/097585ce2a74/src/
/*
Copyright (C) 2009 Gabriel A. Petursson
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
struct ampheck_sha0
{
UINT h[5];
UCHAR buffer[64];
UINT64 length;
};
#define ROR(x, y) (((x) >> (y)) ^ ((x) << ((sizeof(x) * 8) - (y))))
#define ROL(x, y) (((x) << (y)) ^ ((x) >> ((sizeof(x) * 8) - (y))))
#define UNPACK_32_BE(x, str) { \
*((str)) = (UCHAR) ((x) >> 24); \
*((str) + 1) = (UCHAR) ((x) >> 16); \
*((str) + 2) = (UCHAR) ((x) >> 8); \
*((str) + 3) = (UCHAR) (x); \
}
#define UNPACK_64_BE(x, str) { \
*((str)) = (UCHAR) ((x) >> 56); \
*((str) + 1) = (UCHAR) ((x) >> 48); \
*((str) + 2) = (UCHAR) ((x) >> 40); \
*((str) + 3) = (UCHAR) ((x) >> 32); \
*((str) + 4) = (UCHAR) ((x) >> 24); \
*((str) + 5) = (UCHAR) ((x) >> 16); \
*((str) + 6) = (UCHAR) ((x) >> 8); \
*((str) + 7) = (UCHAR) (x); \
}
#define PACK_32_BE(str, x) { \
*(x) = ((UINT) *((str) ) << 24) \
^ ((UINT) *((str) + 1) << 16) \
^ ((UINT) *((str) + 2) << 8) \
^ ((UINT) *((str) + 3)); \
}
#define PACK_64_BE(str, x) { \
*(x) = ((UINT64) *((str) ) << 56) \
^ ((UINT64) *((str) + 1) << 48) \
^ ((UINT64) *((str) + 2) << 40) \
^ ((UINT64) *((str) + 3) << 32) \
^ ((UINT64) *((str) + 4) << 24) \
^ ((UINT64) *((str) + 5) << 16) \
^ ((UINT64) *((str) + 6) << 8) \
^ ((UINT64) *((str) + 7)); \
}
#define UNPACK_32_LE(x, str) { \
*((str)) = (UCHAR) (x); \
*((str) + 1) = (UCHAR) ((x) >> 8); \
*((str) + 2) = (UCHAR) ((x) >> 16); \
*((str) + 3) = (UCHAR) ((x) >> 24); \
}
#define UNPACK_64_LE(x, str) { \
*((str)) = (UCHAR) (x); \
*((str) + 1) = (UCHAR) ((x) >> 8); \
*((str) + 2) = (UCHAR) ((x) >> 16); \
*((str) + 3) = (UCHAR) ((x) >> 24); \
*((str) + 4) = (UCHAR) ((x) >> 32); \
*((str) + 5) = (UCHAR) ((x) >> 40); \
*((str) + 6) = (UCHAR) ((x) >> 48); \
*((str) + 7) = (UCHAR) ((x) >> 56); \
}
#define PACK_32_LE(str, x) { \
*(x) = ((UINT) *((str) )) \
^ ((UINT) *((str) + 1) << 8) \
^ ((UINT) *((str) + 2) << 16) \
^ ((UINT) *((str) + 3) << 24); \
}
#define PACK_64_LE(str, x) { \
*(x) = ((UINT64) *((str) )) \
^ ((UINT64) *((str) + 1) << 8) \
^ ((UINT64) *((str) + 2) << 16) \
^ ((UINT64) *((str) + 3) << 24) \
^ ((UINT64) *((str) + 4) << 32) \
^ ((UINT64) *((str) + 5) << 40) \
^ ((UINT64) *((str) + 6) << 48) \
^ ((UINT64) *((str) + 7) << 56); \
}
#define SHA0_R1(x, y, z) ((z ^ (x & (y ^ z))) + 0x5a827999)
#define SHA0_R2(x, y, z) ((x ^ y ^ z) + 0x6ed9eba1)
#define SHA0_R3(x, y, z) (((x & y) | (z & (x | y))) + 0x8f1bbcdc)
#define SHA0_R4(x, y, z) ((x ^ y ^ z) + 0xca62c1d6)
#define SHA0_PRC(a, b, c, d, e, idx, rnd) { \
wv[e] += ROR(wv[a], 27) + SHA0_R##rnd(wv[b], wv[c], wv[d]) + idx; \
wv[b] = ROR(wv[b], 2); \
}
#define SHA0_EXT(i) ( \
w[i] ^= w[(i - 3) & 0x0F] ^ w[(i - 8) & 0x0F] ^ w[(i - 14) & 0x0F] \
)
static void ampheck_sha0_init(struct ampheck_sha0 *ctx);
static void ampheck_sha0_update(struct ampheck_sha0 *ctx, const UCHAR *data, UINT length);
static void ampheck_sha0_finish(const struct ampheck_sha0 *ctx, UCHAR *digest);
static void ampheck_sha0_init(struct ampheck_sha0 *ctx)
{
ctx->h[0] = 0x67452301;
ctx->h[1] = 0xefcdab89;
ctx->h[2] = 0x98badcfe;
ctx->h[3] = 0x10325476;
ctx->h[4] = 0xc3d2e1f0;
ctx->length = 0;
}
static void ampheck_sha0_transform(struct ampheck_sha0 *ctx, const UCHAR *data, UINT blocks)
{
UINT i;
for (i = 0; i < blocks; ++i)
{
UINT wv[5];
UINT w[16];
PACK_32_BE(&data[(i << 6) ], &w[ 0]);
PACK_32_BE(&data[(i << 6) + 4], &w[ 1]);
PACK_32_BE(&data[(i << 6) + 8], &w[ 2]);
PACK_32_BE(&data[(i << 6) + 12], &w[ 3]);
PACK_32_BE(&data[(i << 6) + 16], &w[ 4]);
PACK_32_BE(&data[(i << 6) + 20], &w[ 5]);
PACK_32_BE(&data[(i << 6) + 24], &w[ 6]);
PACK_32_BE(&data[(i << 6) + 28], &w[ 7]);
PACK_32_BE(&data[(i << 6) + 32], &w[ 8]);
PACK_32_BE(&data[(i << 6) + 36], &w[ 9]);
PACK_32_BE(&data[(i << 6) + 40], &w[10]);
PACK_32_BE(&data[(i << 6) + 44], &w[11]);
PACK_32_BE(&data[(i << 6) + 48], &w[12]);
PACK_32_BE(&data[(i << 6) + 52], &w[13]);
PACK_32_BE(&data[(i << 6) + 56], &w[14]);
PACK_32_BE(&data[(i << 6) + 60], &w[15]);
wv[0] = ctx->h[0];
wv[1] = ctx->h[1];
wv[2] = ctx->h[2];
wv[3] = ctx->h[3];
wv[4] = ctx->h[4];
SHA0_PRC(0, 1, 2, 3, 4, w[ 0], 1);
SHA0_PRC(4, 0, 1, 2, 3, w[ 1], 1);
SHA0_PRC(3, 4, 0, 1, 2, w[ 2], 1);
SHA0_PRC(2, 3, 4, 0, 1, w[ 3], 1);
SHA0_PRC(1, 2, 3, 4, 0, w[ 4], 1);
SHA0_PRC(0, 1, 2, 3, 4, w[ 5], 1);
SHA0_PRC(4, 0, 1, 2, 3, w[ 6], 1);
SHA0_PRC(3, 4, 0, 1, 2, w[ 7], 1);
SHA0_PRC(2, 3, 4, 0, 1, w[ 8], 1);
SHA0_PRC(1, 2, 3, 4, 0, w[ 9], 1);
SHA0_PRC(0, 1, 2, 3, 4, w[10], 1);
SHA0_PRC(4, 0, 1, 2, 3, w[11], 1);
SHA0_PRC(3, 4, 0, 1, 2, w[12], 1);
SHA0_PRC(2, 3, 4, 0, 1, w[13], 1);
SHA0_PRC(1, 2, 3, 4, 0, w[14], 1);
SHA0_PRC(0, 1, 2, 3, 4, w[15], 1);
SHA0_PRC(4, 0, 1, 2, 3, SHA0_EXT( 0), 1);
SHA0_PRC(3, 4, 0, 1, 2, SHA0_EXT( 1), 1);
SHA0_PRC(2, 3, 4, 0, 1, SHA0_EXT( 2), 1);
SHA0_PRC(1, 2, 3, 4, 0, SHA0_EXT( 3), 1);
SHA0_PRC(0, 1, 2, 3, 4, SHA0_EXT( 4), 2);
SHA0_PRC(4, 0, 1, 2, 3, SHA0_EXT( 5), 2);
SHA0_PRC(3, 4, 0, 1, 2, SHA0_EXT( 6), 2);
SHA0_PRC(2, 3, 4, 0, 1, SHA0_EXT( 7), 2);
SHA0_PRC(1, 2, 3, 4, 0, SHA0_EXT( 8), 2);
SHA0_PRC(0, 1, 2, 3, 4, SHA0_EXT( 9), 2);
SHA0_PRC(4, 0, 1, 2, 3, SHA0_EXT(10), 2);
SHA0_PRC(3, 4, 0, 1, 2, SHA0_EXT(11), 2);
SHA0_PRC(2, 3, 4, 0, 1, SHA0_EXT(12), 2);
SHA0_PRC(1, 2, 3, 4, 0, SHA0_EXT(13), 2);
SHA0_PRC(0, 1, 2, 3, 4, SHA0_EXT(14), 2);
SHA0_PRC(4, 0, 1, 2, 3, SHA0_EXT(15), 2);
SHA0_PRC(3, 4, 0, 1, 2, SHA0_EXT( 0), 2);
SHA0_PRC(2, 3, 4, 0, 1, SHA0_EXT( 1), 2);
SHA0_PRC(1, 2, 3, 4, 0, SHA0_EXT( 2), 2);
SHA0_PRC(0, 1, 2, 3, 4, SHA0_EXT( 3), 2);
SHA0_PRC(4, 0, 1, 2, 3, SHA0_EXT( 4), 2);
SHA0_PRC(3, 4, 0, 1, 2, SHA0_EXT( 5), 2);
SHA0_PRC(2, 3, 4, 0, 1, SHA0_EXT( 6), 2);
SHA0_PRC(1, 2, 3, 4, 0, SHA0_EXT( 7), 2);
SHA0_PRC(0, 1, 2, 3, 4, SHA0_EXT( 8), 3);
SHA0_PRC(4, 0, 1, 2, 3, SHA0_EXT( 9), 3);
SHA0_PRC(3, 4, 0, 1, 2, SHA0_EXT(10), 3);
SHA0_PRC(2, 3, 4, 0, 1, SHA0_EXT(11), 3);
SHA0_PRC(1, 2, 3, 4, 0, SHA0_EXT(12), 3);
SHA0_PRC(0, 1, 2, 3, 4, SHA0_EXT(13), 3);
SHA0_PRC(4, 0, 1, 2, 3, SHA0_EXT(14), 3);
SHA0_PRC(3, 4, 0, 1, 2, SHA0_EXT(15), 3);
SHA0_PRC(2, 3, 4, 0, 1, SHA0_EXT( 0), 3);
SHA0_PRC(1, 2, 3, 4, 0, SHA0_EXT( 1), 3);
SHA0_PRC(0, 1, 2, 3, 4, SHA0_EXT( 2), 3);
SHA0_PRC(4, 0, 1, 2, 3, SHA0_EXT( 3), 3);
SHA0_PRC(3, 4, 0, 1, 2, SHA0_EXT( 4), 3);
SHA0_PRC(2, 3, 4, 0, 1, SHA0_EXT( 5), 3);
SHA0_PRC(1, 2, 3, 4, 0, SHA0_EXT( 6), 3);
SHA0_PRC(0, 1, 2, 3, 4, SHA0_EXT( 7), 3);
SHA0_PRC(4, 0, 1, 2, 3, SHA0_EXT( 8), 3);
SHA0_PRC(3, 4, 0, 1, 2, SHA0_EXT( 9), 3);
SHA0_PRC(2, 3, 4, 0, 1, SHA0_EXT(10), 3);
SHA0_PRC(1, 2, 3, 4, 0, SHA0_EXT(11), 3);
SHA0_PRC(0, 1, 2, 3, 4, SHA0_EXT(12), 4);
SHA0_PRC(4, 0, 1, 2, 3, SHA0_EXT(13), 4);
SHA0_PRC(3, 4, 0, 1, 2, SHA0_EXT(14), 4);
SHA0_PRC(2, 3, 4, 0, 1, SHA0_EXT(15), 4);
SHA0_PRC(1, 2, 3, 4, 0, SHA0_EXT( 0), 4);
SHA0_PRC(0, 1, 2, 3, 4, SHA0_EXT( 1), 4);
SHA0_PRC(4, 0, 1, 2, 3, SHA0_EXT( 2), 4);
SHA0_PRC(3, 4, 0, 1, 2, SHA0_EXT( 3), 4);
SHA0_PRC(2, 3, 4, 0, 1, SHA0_EXT( 4), 4);
SHA0_PRC(1, 2, 3, 4, 0, SHA0_EXT( 5), 4);
SHA0_PRC(0, 1, 2, 3, 4, SHA0_EXT( 6), 4);
SHA0_PRC(4, 0, 1, 2, 3, SHA0_EXT( 7), 4);
SHA0_PRC(3, 4, 0, 1, 2, SHA0_EXT( 8), 4);
SHA0_PRC(2, 3, 4, 0, 1, SHA0_EXT( 9), 4);
SHA0_PRC(1, 2, 3, 4, 0, SHA0_EXT(10), 4);
SHA0_PRC(0, 1, 2, 3, 4, SHA0_EXT(11), 4);
SHA0_PRC(4, 0, 1, 2, 3, SHA0_EXT(12), 4);
SHA0_PRC(3, 4, 0, 1, 2, SHA0_EXT(13), 4);
SHA0_PRC(2, 3, 4, 0, 1, SHA0_EXT(14), 4);
SHA0_PRC(1, 2, 3, 4, 0, SHA0_EXT(15), 4);
ctx->h[0] += wv[0];
ctx->h[1] += wv[1];
ctx->h[2] += wv[2];
ctx->h[3] += wv[3];
ctx->h[4] += wv[4];
}
}
static void ampheck_sha0_update(struct ampheck_sha0 *ctx, const UCHAR *data, UINT size)
{
UINT tmp = size;
if (size >= 64 - ctx->length % 64)
{
memcpy(&ctx->buffer[ctx->length % 64], data, 64 - ctx->length % 64);
data += 64 - ctx->length % 64;
size -= 64 - ctx->length % 64;
ampheck_sha0_transform(ctx, ctx->buffer, 1);
ampheck_sha0_transform(ctx, data, size / 64);
data += size & ~63;
size %= 64;
memcpy(ctx->buffer, data, size);
}
else
{
memcpy(&ctx->buffer[ctx->length % 64], data, size);
}
ctx->length += tmp;
}
static void ampheck_sha0_finish(const struct ampheck_sha0 *ctx, UCHAR *digest)
{
struct ampheck_sha0 tmp;
memcpy(tmp.h, ctx->h, 5 * sizeof(UINT));
memcpy(tmp.buffer, ctx->buffer, ctx->length % 64);
tmp.buffer[ctx->length % 64] = 0x80;
if (ctx->length % 64 < 56)
{
memset(&tmp.buffer[ctx->length % 64 + 1], 0x00, 55 - ctx->length % 64);
}
else
{
memset(&tmp.buffer[ctx->length % 64 + 1], 0x00, 63 - ctx->length % 64);
ampheck_sha0_transform(&tmp, tmp.buffer, 1);
memset(tmp.buffer, 0x00, 56);
}
UNPACK_64_BE(ctx->length * 8, &tmp.buffer[56]);
ampheck_sha0_transform(&tmp, tmp.buffer, 1);
UNPACK_32_BE(tmp.h[0], &digest[ 0]);
UNPACK_32_BE(tmp.h[1], &digest[ 4]);
UNPACK_32_BE(tmp.h[2], &digest[ 8]);
UNPACK_32_BE(tmp.h[3], &digest[12]);
UNPACK_32_BE(tmp.h[4], &digest[16]);
}
static unsigned char *Internal_SHA0(const unsigned char *d, size_t n, unsigned char *md)
{
struct ampheck_sha0 c;
static unsigned char m[SHA_DIGEST_LENGTH];
if (md == NULL) md=m;
ampheck_sha0_init(&c);
ampheck_sha0_update(&c, d, (UINT)n);
ampheck_sha0_finish(&c, md);
return md;
}
// Developed by SoftEther VPN Project at University of Tsukuba in Japan.
// Department of Computer Science has dozens of overly-enthusiastic geeks.
// Join us: http://www.tsukuba.ac.jp/english/admission/

3
src/Mayaqua/Encrypt.h
View File

@ -503,6 +503,9 @@ void Enc_tls1_PRF(unsigned char *label, int label_len, const unsigned char *sec,
void HMacSha1(void *dst, void *key, UINT key_size, void *data, UINT data_size);
void HMacMd5(void *dst, void *key, UINT key_size, void *data, UINT data_size);
BUF *EasyEncrypt(BUF *src_buf);
BUF *EasyDecrypt(BUF *src_buf);
void DisableIntelAesAccel();
#ifdef ENCRYPT_C

1
src/Mayaqua/MayaType.h
View File

@ -521,6 +521,7 @@ typedef struct SAFE_QUOTA2 SAFE_QUOTA2;
typedef struct SAFE_BLOCK SAFE_BLOCK;
typedef struct SAFE_REQUEST_LOG SAFE_REQUEST_LOG;
typedef struct DYN_VALUE DYN_VALUE;
typedef struct RELAY_PARAMETER RELAY_PARAMETER;
// Tick64.h
typedef struct ADJUST_TIME ADJUST_TIME;

4
src/Mayaqua/Microsoft.c
View File

@ -3670,10 +3670,6 @@ void MsRegistWindowsFirewallEx(char *title, char *exe)
{
return;
}
if (MsIsVista() == false && (GET_KETA(ostype, 100) != 3 && GET_KETA(ostype, 100) != 4 && GET_KETA(ostype, 100) != 5 && GET_KETA(ostype, 100) != 6 && GET_KETA(ostype, 100) != 7))
{
return;
}
if (MsIsAdmin() == false)
{
return;

162
src/Mayaqua/Network.c
View File

@ -1647,6 +1647,7 @@ void RUDPDo_NatT_Interrupt(RUDP_STACK *r)
{
if (IsZeroIp(&r->NatT_IP_Safe) == false)
{
if (g_no_rudp_register == false)
{
if (r->NatT_GetTokenNextTick == 0 || r->Now >= r->NatT_GetTokenNextTick)
@ -1674,25 +1675,28 @@ void RUDPDo_NatT_Interrupt(RUDP_STACK *r)
}
}
if (r->NatT_NextNatStatusCheckTick == 0 || r->Now >= r->NatT_NextNatStatusCheckTick)
{
UCHAR a = 'A';
UINT ddns_hash;
// Check of the NAT state
RUDPSendPacket(r, &r->NatT_IP_Safe, UDP_NAT_T_PORT, &a, 1, 0);
// Execution time of the next
r->NatT_NextNatStatusCheckTick = r->Now + (UINT64)GenRandInterval(UDP_NAT_T_NAT_STATUS_CHECK_INTERVAL_MIN, UDP_NAT_T_NAT_STATUS_CHECK_INTERVAL_MAX);
AddInterrupt(r->Interrupt, r->NatT_NextNatStatusCheckTick);
// Check whether the DDNS host name changing have not occurred
ddns_hash = GetCurrentDDnsFqdnHash();
if (r->LastDDnsFqdnHash != ddns_hash)
// Normal servers: Send request packets to the NAT-T server
if (r->NatT_NextNatStatusCheckTick == 0 || r->Now >= r->NatT_NextNatStatusCheckTick)
{
r->LastDDnsFqdnHash = ddns_hash;
// Do the Register immediately if there is a change in the DDNS host name
r->NatT_RegisterNextTick = 0;
UCHAR a = 'A';
UINT ddns_hash;
// Check of the NAT state
RUDPSendPacket(r, &r->NatT_IP_Safe, UDP_NAT_T_PORT, &a, 1, 0);
// Execution time of the next
r->NatT_NextNatStatusCheckTick = r->Now + (UINT64)GenRandInterval(UDP_NAT_T_NAT_STATUS_CHECK_INTERVAL_MIN, UDP_NAT_T_NAT_STATUS_CHECK_INTERVAL_MAX);
AddInterrupt(r->Interrupt, r->NatT_NextNatStatusCheckTick);
// Check whether the DDNS host name changing have not occurred
ddns_hash = GetCurrentDDnsFqdnHash();
if (r->LastDDnsFqdnHash != ddns_hash)
{
r->LastDDnsFqdnHash = ddns_hash;
// Do the Register immediately if there is a change in the DDNS host name
r->NatT_RegisterNextTick = 0;
}
}
}
@ -1775,8 +1779,17 @@ void RUDPRecvProc(RUDP_STACK *r, UDPPACKET *p)
return;
}
if (r->ServerMode)
{
if (g_no_rudp_server)
{
return;
}
}
if (r->ServerMode && r->NoNatTRegister == false)
{
if (p->SrcPort == UDP_NAT_T_PORT && CmpIpAddr(&p->SrcIP, &r->NatT_IP_Safe) == 0)
{
// There was a response from the NAT-T server
@ -4472,7 +4485,7 @@ void RUDPIpQueryThread(THREAD *thread, void *param)
{
IP ip;
if (GetMyPrivateIP(&ip))
if (GetMyPrivateIP(&ip, false))
{
Lock(r->Lock);
{
@ -4521,7 +4534,7 @@ UINT GenRandInterval(UINT min, UINT max)
}
// Identify the private IP of the interface which is used to connect to the Internet currently
bool GetMyPrivateIP(IP *ip)
bool GetMyPrivateIP(IP *ip, bool from_vg)
{
SOCK *s;
IP t;
@ -4532,11 +4545,6 @@ bool GetMyPrivateIP(IP *ip)
return false;
}
if (IsUseAlternativeHostname())
{
hostname = UDP_NAT_T_GET_PRIVATE_IP_TCP_SERVER_ALT;
}
s = ConnectEx(hostname, UDP_NAT_T_PORT_FOR_TCP_1, UDP_NAT_T_GET_PRIVATE_IP_CONNECT_TIMEOUT);
if (s == NULL)
@ -4545,7 +4553,7 @@ bool GetMyPrivateIP(IP *ip)
if (s == NULL)
{
s = ConnectEx(hostname, UDP_NAT_T_PORT_FOR_TCP_3, UDP_NAT_T_GET_PRIVATE_IP_CONNECT_TIMEOUT);
s = ConnectEx(GetRandHostNameForGetMyPrivateIP(), UDP_NAT_T_PORT_FOR_TCP_1, UDP_NAT_T_GET_PRIVATE_IP_CONNECT_TIMEOUT);
if (s == NULL)
{
@ -5462,7 +5470,11 @@ RUDP_STACK *NewRUDP(bool server_mode, char *svc_name, RUDP_STACK_INTERRUPTS_PROC
}
}
RUDPGetRegisterHostNameByIP(r->CurrentRegisterHostname, sizeof(r->CurrentRegisterHostname), NULL);
if (true
)
{
RUDPGetRegisterHostNameByIP(r->CurrentRegisterHostname, sizeof(r->CurrentRegisterHostname), NULL);
}
if (r->ServerMode)
{
@ -5470,7 +5482,8 @@ RUDP_STACK *NewRUDP(bool server_mode, char *svc_name, RUDP_STACK_INTERRUPTS_PROC
r->ProcRpcRecv = proc_rpc_recv;
}
if (r->ServerMode && r->NoNatTRegister == false)
if (r->ServerMode && r->NoNatTRegister == false
)
{
r->IpQueryThread = NewThread(RUDPIpQueryThread, r);
}
@ -5543,8 +5556,11 @@ void FreeRUDP(RUDP_STACK *r)
if (r->ServerMode && r->NoNatTRegister == false)
{
WaitThread(r->IpQueryThread, INFINITE);
ReleaseThread(r->IpQueryThread);
if (r->IpQueryThread != NULL)
{
WaitThread(r->IpQueryThread, INFINITE);
ReleaseThread(r->IpQueryThread);
}
}
WaitThread(r->Thread, INFINITE);
@ -12122,6 +12138,37 @@ void InitAsyncSocket(SOCK *sock)
#endif // OS_WIN32
}
// Get a new available UDP port number
UINT GetNewAvailableUdpPortRand()
{
UINT num_retry = 8;
UINT i;
UINT ret = 0;
UCHAR seed[SHA1_SIZE];
Rand(seed, sizeof(seed));
for (i = 0;i < num_retry;i++)
{
SOCK *s = NewUDPEx2Rand(false, NULL, seed, sizeof(seed), RAND_UDP_PORT_DEFAULT_NUM_RETRY);
if (s != NULL)
{
ret = s->LocalPort;
Disconnect(s);
ReleaseSock(s);
}
if (ret != 0)
{
break;
}
}
return ret;
}
// Open a UDP port (port number is random, but determine the randomness in the seed)
SOCK *NewUDPEx2Rand(bool ipv6, IP *ip, void *rand_seed, UINT rand_seed_size, UINT num_retry)
{
@ -17862,6 +17909,33 @@ bool IsIPPrivate(IP *ip)
return false;
}
// Is the IP address either local or private?
bool IsIPLocalOrPrivate(IP *ip)
{
// Validate arguments
if (ip == NULL)
{
return false;
}
if (IsIPPrivate(ip))
{
return true;
}
if (IsLocalHostIP(ip))
{
return true;
}
if (IsIPMyHost(ip))
{
return true;
}
return false;
}
// Read a private IP list file
void LoadPrivateIPFile()
{
@ -19841,8 +19915,10 @@ void UdpListenerThread(THREAD *thread, void *param)
UINT interval;
bool stage_changed = false;
IP nat_t_ip;
Zero(&nat_t_ip, sizeof(nat_t_ip));
if (u->LastCheckTick == 0 || (now >= (u->LastCheckTick + UDPLISTENER_CHECK_INTERVAL)))
{
LIST *iplist;
@ -20011,17 +20087,19 @@ LABEL_RESTART:
if (u->PollMyIpAndPort)
{
// Create a thread to get a NAT-T IP address if necessary
if (u->GetNatTIpThread == NULL)
{
char natt_hostname[MAX_SIZE];
// Create a thread to get a NAT-T IP address if necessary
if (u->GetNatTIpThread == NULL)
{
char natt_hostname[MAX_SIZE];
RUDPGetRegisterHostNameByIP(natt_hostname, sizeof(natt_hostname), NULL);
RUDPGetRegisterHostNameByIP(natt_hostname, sizeof(natt_hostname), NULL);
u->GetNatTIpThread = NewQueryIpThread(natt_hostname, QUERYIPTHREAD_INTERVAL_LAST_OK, QUERYIPTHREAD_INTERVAL_LAST_NG);
u->GetNatTIpThread = NewQueryIpThread(natt_hostname, QUERYIPTHREAD_INTERVAL_LAST_OK, QUERYIPTHREAD_INTERVAL_LAST_NG);
}
GetQueryIpThreadResult(u->GetNatTIpThread, &nat_t_ip);
}
GetQueryIpThreadResult(u->GetNatTIpThread, &nat_t_ip);
}
// Receive the data that is arriving at the socket
@ -20033,16 +20111,20 @@ LABEL_RESTART:
{
UINT num_ignore_errors = 0;
if (u->PollMyIpAndPort && IsZeroIP(&nat_t_ip) == false && IsIP4(&us->IpAddress))
if (u->PollMyIpAndPort && IsIP4(&us->IpAddress))
{
if (us->NextMyIpAndPortPollTick == 0 || us->NextMyIpAndPortPollTick <= now)
{
UCHAR c = 'A';
// Examine the self IP address and the self port number by using NAT-T server
us->NextMyIpAndPortPollTick = now + (UINT64)GenRandInterval(UDP_NAT_T_NAT_STATUS_CHECK_INTERVAL_MIN, UDP_NAT_T_NAT_STATUS_CHECK_INTERVAL_MAX);
SendTo(us->Sock, &nat_t_ip, UDP_NAT_T_PORT, &c, 1);
if (IsZeroIP(&nat_t_ip) == false
)
{
UCHAR c = 'A';
SendTo(us->Sock, &nat_t_ip, UDP_NAT_T_PORT, &c, 1);
}
}
}

13
src/Mayaqua/Network.h
View File

@ -759,12 +759,10 @@ struct RUDP_SESSION
#define UDP_NAT_T_GET_IP_INTERVAL_AFTER DYN32(UDP_NAT_T_GET_IP_INTERVAL_AFTER, (5 * 60 * 1000)) // IP address acquisition interval of NAT-T server (after success)
// Related to process to get the private IP address of itself with making a TCP connection to the NAT-T server
#define UDP_NAT_T_GET_PRIVATE_IP_TCP_SERVER "get-my-ip.nat-traversal.softether-network.net."
#define UDP_NAT_T_GET_PRIVATE_IP_TCP_SERVER_ALT "get-my-ip.nat-traversal.uxcom.jp."
#define UDP_NAT_T_GET_PRIVATE_IP_TCP_SERVER "www.msftncsi.com."
#define UDP_NAT_T_PORT_FOR_TCP_1 992
#define UDP_NAT_T_PORT_FOR_TCP_2 80
#define UDP_NAT_T_PORT_FOR_TCP_3 443
#define UDP_NAT_T_PORT_FOR_TCP_1 80
#define UDP_NAT_T_PORT_FOR_TCP_2 443
#define UDP_NAT_TRAVERSAL_VERSION 1
@ -1102,7 +1100,8 @@ void *InitWaitUntilHostIPAddressChanged();
void FreeWaitUntilHostIPAddressChanged(void *p);
void WaitUntilHostIPAddressChanged(void *p, EVENT *event, UINT timeout, UINT ip_check_interval);
UINT GetHostIPAddressHash32();
bool GetMyPrivateIP(IP *ip);
bool GetMyPrivateIP(IP *ip, bool from_vg);
char *GetRandHostNameForGetMyPrivateIP();
UINT GenRandInterval(UINT min, UINT max);
void RUDPProcess_NatT_Recv(RUDP_STACK *r, UDPPACKET *udp);
void RUDPDo_NatT_Interrupt(RUDP_STACK *r);
@ -1324,6 +1323,7 @@ SOCK *NewUDP4(UINT port, IP *ip);
SOCK *NewUDP6(UINT port, IP *ip);
SOCK *NewUDPEx2Rand(bool ipv6, IP *ip, void *rand_seed, UINT rand_seed_size, UINT num_retry);
SOCK *NewUDPEx2RandMachineAndExePath(bool ipv6, IP *ip, UINT num_retry, UCHAR rand_port_id);
UINT GetNewAvailableUdpPortRand();
UINT NewRandPortByMachineAndExePath(UINT start_port, UINT end_port, UINT additional_int);
void DisableUDPChecksum(SOCK *s);
UINT SendTo(SOCK *sock, IP *dest_addr, UINT dest_port, void *data, UINT size);
@ -1614,6 +1614,7 @@ void GetCurrentGlobalIPGuess(IP *ip, bool ipv6);
bool IsIPAddressInSameLocalNetwork(IP *a);
bool IsIPPrivate(IP *ip);
bool IsIPLocalOrPrivate(IP *ip);
bool IsIPMyHost(IP *ip);
void LoadPrivateIPFile();
bool IsOnPrivateIPFile(UINT ip);

44
src/Mayaqua/Win32.c
View File

@ -1075,7 +1075,7 @@ bool Win32GetVersionExInternal(void *info)
if (os.dwPlatformId == VER_PLATFORM_WIN32_NT)
{
if ((os.dwMajorVersion == 6 && os.dwMinorVersion >= 2) ||
(os.dwMajorVersion == 7))
(os.dwMajorVersion >= 7))
{
// Windows 8 later
return Win32GetVersionExInternalForWindows81orLater(info);
@ -1091,6 +1091,9 @@ bool Win32GetVersionExInternalForWindows81orLater(void *info)
{
OSVERSIONINFOEXA *ex = (OSVERSIONINFOEXA *)info;
char *str;
UINT major1 = 0, major2 = 0;
UINT minor1 = 0, minor2 = 0;
UINT major = 0, minor = 0;
// Validate arguments
if (info == NULL)
{
@ -1120,15 +1123,8 @@ bool Win32GetVersionExInternalForWindows81orLater(void *info)
if (t != NULL && t->NumTokens == 2)
{
UINT major = ToInt(t->Token[0]);
UINT minor = ToInt(t->Token[1]);
if (major >= 6)
{
// Version number acquisition success
ex->dwMajorVersion = major;
ex->dwMinorVersion = minor;
}
major1 = ToInt(t->Token[0]);
minor1 = ToInt(t->Token[1]);
}
FreeToken(t);
@ -1136,6 +1132,32 @@ bool Win32GetVersionExInternalForWindows81orLater(void *info)
Free(str);
major2 = MsRegReadIntEx2(REG_LOCAL_MACHINE,
"SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion",
"CurrentMajorVersionNumber", false, true);
minor2 = MsRegReadIntEx2(REG_LOCAL_MACHINE,
"SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion",
"CurrentMinorVersionNumber", false, true);
if ((major1 * 10000 + minor1) > (major2 * 10000 + minor2))
{
major = major1;
minor = minor1;
}
else
{
major = major2;
minor = minor2;
}
if (major >= 6)
{
// Version number acquisition success
ex->dwMajorVersion = major;
ex->dwMinorVersion = minor;
}
return true;
}
@ -1407,7 +1429,7 @@ UINT Win32GetOsType()
return OSTYPE_WINDOWS_SERVER_81;
}
}
else if (os.dwMajorVersion == 6 && os.dwMinorVersion == 4)
else if ((os.dwMajorVersion == 6 && os.dwMinorVersion == 4) || (os.dwMajorVersion == 10 && os.dwMinorVersion == 0))
{
if (os.wProductType == VER_NT_WORKSTATION)
{