// Get registry key of the network class data by GUID
bool GetClassRegKeyWin32(char *key, UINT key_size, char *short_key, UINT short_key_size, char *guid)
{
TOKEN_LIST *t;
bool ret = false;
UINT i;
// Validate arguments
if (key == NULL || short_key == NULL || guid == NULL)
{
return false;
}
t = MsRegEnumKey(REG_LOCAL_MACHINE,
"SYSTEM\\CurrentControlSet\\Control\\Class\\{4D36E972-E325-11CE-BFC1-08002BE10318}");
if (t == NULL)
{
return false;
}
for (i = 0;i < t->NumTokens;i++)
{
char keyname[MAX_SIZE];
char *value;
Format(keyname, sizeof(keyname),
"SYSTEM\\CurrentControlSet\\Control\\Class\\{4D36E972-E325-11CE-BFC1-08002BE10318}\\%s",
t->Token[i]);
value = MsRegReadStr(REG_LOCAL_MACHINE, keyname, "NetCfgInstanceId");
if (StrCmpi(value, guid) == 0)
{
ret = true;
StrCpy(key, key_size, keyname);
Format(short_key, short_key_size, "{4D36E972-E325-11CE-BFC1-08002BE10318}\\%s",
t->Token[i]);
}
Free(value);
}
FreeToken(t);
return ret;
}
// Get VLAN tag pass-through availability of all devices
bool EnumEthVLanWin32(RPC_ENUM_ETH_VLAN *t)
{
UINT i;
LIST *o;
// Validate arguments
if (t == NULL)
{
return false;
}
Zero(t, sizeof(RPC_ENUM_ETH_VLAN));
if (MsIsWin2000OrGreater() == false)
{
return false;
}
if (IsEthSupported() == false)
{
return false;
}
// Get device list
Lock(eth_list_lock);
InitEthAdaptersList();
o = NewListFast(CmpRpcEnumEthVLan);
for (i = 0;i < LIST_NUM(eth_list);i++)
{
WP_ADAPTER *a = LIST_DATA(eth_list, i);
if (IsEmptyStr(a->Guid) == false)
{
char class_key[MAX_SIZE];
char short_key[MAX_SIZE];
if (GetClassRegKeyWin32(class_key, sizeof(class_key),
short_key, sizeof(short_key), a->Guid))
{
char *device_instance_id = MsRegReadStr(REG_LOCAL_MACHINE, class_key, "DeviceInstanceID");
if (IsEmptyStr(device_instance_id))
{
Free(device_instance_id);
device_instance_id = SearchDeviceInstanceIdFromShortKey(short_key);
}
if (IsEmptyStr(device_instance_id) == false)
{
char device_key[MAX_SIZE];
char *service_name;
Format(device_key, sizeof(device_key), "SYSTEM\\CurrentControlSet\\Enum\\%s",
device_instance_id);
service_name = MsRegReadStr(REG_LOCAL_MACHINE, device_key, "Service");
if (IsEmptyStr(service_name) == false)
{
char service_key[MAX_SIZE];
char *sys;
Format(service_key, sizeof(service_key),
"SYSTEM\\CurrentControlSet\\services\\%s",
service_name);
sys = MsRegReadStr(REG_LOCAL_MACHINE, service_key, "ImagePath");
if (IsEmptyStr(sys) == false)
{
char sysname[MAX_PATH];
GetFileNameFromFilePath(sysname, sizeof(sysname), sys);
Trim(sysname);
if (EndWith(sysname, ".sys"))
{
// device found
RPC_ENUM_ETH_VLAN_ITEM *e = ZeroMalloc(sizeof(RPC_ENUM_ETH_VLAN_ITEM));
StrCpy(e->DeviceName, sizeof(e->DeviceName), a->Title);
StrCpy(e->Guid, sizeof(e->Guid), a->Guid);
StrCpy(e->DeviceInstanceId, sizeof(e->DeviceInstanceId), device_instance_id);
StrCpy(e->DriverName, sizeof(e->DriverName), sysname);
// Get VLAN tag pass-through availability of the device
GetVLanSupportStatus(e);
// Get current pass-through setting of the device
GetVLanEnableStatus(e);
Insert(o, e);
}
}
Free(sys);
}
Free(service_name);
}
Free(device_instance_id);
}
}
}
t->NumItem = LIST_NUM(o);
t->Items = ZeroMalloc(sizeof(RPC_ENUM_ETH_VLAN_ITEM) * i);
for (i = 0;i < LIST_NUM(o);i++)
{
RPC_ENUM_ETH_VLAN_ITEM *e = LIST_DATA(o, i);
Copy(&t->Items[i], e, sizeof(RPC_ENUM_ETH_VLAN_ITEM));
Free(e);
}
ReleaseList(o);
Unlock(eth_list_lock);
return true;
}
// Get the device instance id from short_key
char *SearchDeviceInstanceIdFromShortKey(char *short_key)
{
char *ret = NULL;
TOKEN_LIST *t1;
// Validate arguments
if (short_key == NULL)
{
return NULL;
}
t1 = MsRegEnumKey(REG_LOCAL_MACHINE, "SYSTEM\\CurrentControlSet\\Enum");
if (t1 != NULL)
{
TOKEN_LIST *t2;
char tmp[MAX_SIZE];
UINT i;
for (i = 0;i < t1->NumTokens;i++)
{
Format(tmp, sizeof(tmp), "SYSTEM\\CurrentControlSet\\Enum\\%s", t1->Token[i]);
t2 = MsRegEnumKey(REG_LOCAL_MACHINE, tmp);
if (t2 != NULL)
{
TOKEN_LIST *t3;
UINT i;
for (i = 0;i < t2->NumTokens;i++)
{
char tmp2[MAX_SIZE];
Format(tmp2, sizeof(tmp2), "%s\\%s", tmp, t2->Token[i]);
t3 = MsRegEnumKey(REG_LOCAL_MACHINE, tmp2);
if (t3 != NULL)
{
UINT i;
for (i = 0;i < t3->NumTokens;i++)
{
char tmp3[MAX_SIZE];
char *s;
Format(tmp3, sizeof(tmp3), "%s\\%s", tmp2, t3->Token[i]);
s = MsRegReadStr(REG_LOCAL_MACHINE, tmp3, "Driver");
if (s != NULL)
{
if (StrCmpi(s, short_key) == 0)
{
if (ret != NULL)
{
Free(ret);
}
ret = CopyStr(tmp3 + StrLen("SYSTEM\\CurrentControlSet\\Enum\\"));
}
Free(s);
}
}
FreeToken(t3);
}
}
FreeToken(t2);
}
}
FreeToken(t1);
}
return ret;
}
// Get the state of VLAN tag pass-through
void GetVLanEnableStatus(RPC_ENUM_ETH_VLAN_ITEM *e)
{
char key[MAX_SIZE];
char short_key[MAX_SIZE];
char tcpkey[MAX_SIZE];
// Validate arguments
if (e == NULL)
{
return;
}
e->Enabled = false;
if (e->Support == false)
{
return;
}
if (GetClassRegKeyWin32(key, sizeof(key), short_key, sizeof(short_key), e->Guid) == false)
{
return;
}
Format(tcpkey, sizeof(tcpkey),
"SYSTEM\\CurrentControlSet\\Services\\Tcpip\\Parameters\\Interfaces\\%s",
e->Guid);
if (StrCmpi(e->DriverType, "Intel") == 0)
{
char *VlanFiltering = MsRegReadStr(REG_LOCAL_MACHINE, key, "VlanFiltering");
UINT MonitorMode = MsRegReadInt(REG_LOCAL_MACHINE, key, "MonitorMode");
UINT MonitorModeEnabled = MsRegReadInt(REG_LOCAL_MACHINE, key, "MonitorModeEnabled");
char *TaggingMode = MsRegReadStr(REG_LOCAL_MACHINE, key, "TaggingMode");
if (StrCmpi(VlanFiltering, "0") == 0 &&
MonitorMode == 1 &&
MonitorModeEnabled == 1 &&
StrCmpi(TaggingMode, "0") == 0)
{
e->Enabled = true;
}
Free(VlanFiltering);
Free(TaggingMode);
}
else if (StrCmpi(e->DriverType, "Broadcom") == 0)
{
char *PreserveVlanInfoInRxPacket = MsRegReadStr(REG_LOCAL_MACHINE,
key, "PreserveVlanInfoInRxPacket");
if (StrCmpi(PreserveVlanInfoInRxPacket, "1") == 0)
{
e->Enabled = true;
}
Free(PreserveVlanInfoInRxPacket);
}
else if (StrCmpi(e->DriverType, "Marvell") == 0)
{
DWORD SkDisableVlanStrip = MsRegReadInt(REG_LOCAL_MACHINE,
key, "SkDisableVlanStrip");
if (SkDisableVlanStrip == 1)
{
e->Enabled = true;
}
}
if (MsRegIsValue(REG_LOCAL_MACHINE, tcpkey, "MTU") == false)
{
e->Enabled = false;
}
}
// Get the internet connection settings of the system
void GetSystemInternetSetting(INTERNET_SETTING *setting)
{
#ifdef OS_WIN32
bool use_proxy;
// Validate arguments
if (setting == NULL)
{
return;
}
Zero(setting, sizeof(INTERNET_SETTING));
use_proxy = MsRegReadInt(REG_CURRENT_USER,
"Software\\Microsoft\\Windows\\CurrentVersion\\Internet Settings",
"ProxyEnable");
if (use_proxy)
{
char *str = MsRegReadStr(REG_CURRENT_USER,
"Software\\Microsoft\\Windows\\CurrentVersion\\Internet Settings",
"ProxyServer");
if (str != NULL)
{
char name[MAX_HOST_NAME_LEN + 1];
UINT port;
if (GetProxyServerNameAndPortFromIeProxyRegStr(name, sizeof(name),
&port, str, "https"))
{
setting->ProxyType = PROXY_HTTP;
StrCpy(setting->ProxyHostName, sizeof(setting->ProxyHostName), name);
setting->ProxyPort = port;
}
else if (GetProxyServerNameAndPortFromIeProxyRegStr(name, sizeof(name),
&port, str, "http"))
{
setting->ProxyType = PROXY_HTTP;
StrCpy(setting->ProxyHostName, sizeof(setting->ProxyHostName), name);
setting->ProxyPort = port;
}
else if (GetProxyServerNameAndPortFromIeProxyRegStr(name, sizeof(name),
&port, str, "socks"))
{
setting->ProxyType = PROXY_SOCKS;
StrCpy(setting->ProxyHostName, sizeof(setting->ProxyHostName), name);
setting->ProxyPort = port;
}
else
{
if (SearchStrEx(str, "=", 0, false) == INFINITE)
{
char *host;
UINT port;
if (ParseHostPort(str, &host, &port, 0))
{
if (port != 0)
{
setting->ProxyType = PROXY_HTTP;
StrCpy(setting->ProxyHostName, sizeof(setting->ProxyHostName), host);
setting->ProxyPort = port;
}
Free(host);
}
}
}
Free(str);
}
}
#else // OS_WIN32
Zero(setting, sizeof(INTERNET_SETTING));
#endif // OS_WIN32
}
// Load the device module
bool Win32LoadSecModule(SECURE *sec)
{
SEC_DATA_WIN32 *w;
HINSTANCE hInst;
CK_FUNCTION_LIST_PTR api = NULL;
CK_RV (*get_function_list)(CK_FUNCTION_LIST_PTR_PTR);
// Validate arguments
if (sec == NULL)
{
return false;
}
if (sec->Dev->Id == 9)
{
char username[MAX_SIZE];
DWORD size;
// Because the device driver of Juki-Net needs the contents
// of the Software\JPKI registry key on HKLU of SYSTEM,
// if there is no key, copy the key from the value of other user
// if (MsRegIsValue(REG_CURRENT_USER, "Software\\JPKI", "Name") == false ||
// MsRegIsValue(REG_CURRENT_USER, "Software\\JPKI", "RWType") == false)
size = sizeof(username);
GetUserName(username, &size);
if (StrCmpi(username, "System") == 0)
{
TOKEN_LIST *t = MsRegEnumKey(REG_USERS, NULL);
if (t != NULL)
{
UINT i;
for (i = 0;i < t->NumTokens;i++)
{
char tmp[MAX_PATH];
if (StrCmpi(t->Token[i], ".DEFAULT") != 0 && StrCmpi(t->Token[i], "S-1-5-18") != 0)
{
Format(tmp, sizeof(tmp), "%s\\Software\\JPKI", t->Token[i]);
if (MsRegIsValue(REG_USERS, tmp, "Name") && MsRegIsValue(REG_USERS, tmp, "RWType"))
{
char *name = MsRegReadStr(REG_USERS, tmp, "Name");
char *port = MsRegReadStr(REG_USERS, tmp, "Port");
UINT type = MsRegReadInt(REG_USERS, tmp, "RWType");
MsRegWriteStr(REG_CURRENT_USER, "Software\\JPKI", "Name", name);
MsRegWriteStr(REG_CURRENT_USER, "Software\\JPKI", "Port", port);
MsRegWriteInt(REG_CURRENT_USER, "Software\\JPKI", "RWType", type);
Free(name);
Free(port);
break;
}
}
}
FreeToken(t);
}
}
}
// Load the Library
hInst = Win32SecureLoadLibraryEx(sec->Dev->ModuleName, 0);
if (hInst == NULL)
{
// Failure
return false;
}
// Get the API
get_function_list = (CK_RV (*)(CK_FUNCTION_LIST_PTR_PTR))
GetProcAddress(hInst, "C_GetFunctionList");
if (get_function_list == NULL)
{
// Failure
FreeLibrary(hInst);
return false;
}
get_function_list(&api);
if (api == NULL)
{
// Failure
FreeLibrary(hInst);
return false;
}
sec->Data = ZeroMalloc(sizeof(SEC_DATA_WIN32));
w = sec->Data;
w->hInst = hInst;
sec->Api = api;
return true;
}