5897 lines
201 KiB
Plaintext
5897 lines
201 KiB
Plaintext
{*******************************************************}
|
|
{ }
|
|
{ ManagerModel }
|
|
{ }
|
|
{ Copyright (C) 2022 kku }
|
|
{ }
|
|
{*******************************************************}
|
|
|
|
unit ManagerModel;
|
|
|
|
interface
|
|
|
|
uses
|
|
Tocsg.Obj, System.SysUtils, System.Classes, Winapi.Windows,
|
|
System.Generics.Collections, superobject, GlobalDefine, GlobalOutAddInDefine,
|
|
ManagerPolicy;
|
|
|
|
const
|
|
PASS_MODEL = 'P2022@0522aOkqvLdsoa*29409';
|
|
|
|
STATUS_DISCONN = 'Disconnected';
|
|
STATUS_CONN = 'Connected';
|
|
STATUS_UNKNOWN = 'Unknown';
|
|
STATUS_UPDATE = 'Update Required';
|
|
STATUS_LICENSE = 'License Over Limit';
|
|
STATUS_MAXUSER = 'Over Maximum Agent';
|
|
|
|
// TYPE_SOFT_CTRL_BLACK = 'BLACKLIST';
|
|
// TYPE_SOFT_CTRL_WHITE = 'WHITELIST';
|
|
// TYPE_SOFT_CTRL_WANDB = 'WBLIST';
|
|
|
|
MODEL_SEPARATOR = 'QTqW';
|
|
|
|
PREF_NETAPP_WHITELIST = 'APPWHITELIST';
|
|
PREF_NETAPP_BLACKLIST = 'APPBLACKLIST';
|
|
PREF_NETIP_WHITELIST = 'IPWHITELIST';
|
|
PREF_NETIP_BLACKLIST = 'IPBLACKLIST';
|
|
|
|
PREF_SLEEPAPP_WHITELIST = 'appwhite';
|
|
PREF_SLEEPAPP_BLACKLIST = 'appblack';
|
|
PREF_SLEEPIP_WHITELIST = 'ip';
|
|
|
|
PREF_PORTEX_FALSE = 0;
|
|
PREF_PORTEX_BLACK = 1;
|
|
PREF_PORTEX_WHITE = 2;
|
|
|
|
VER_AGENT_MODEL = 1;
|
|
|
|
type
|
|
PLogInfo = ^TLogInfo;
|
|
TLogInfo = record
|
|
sCode,
|
|
sBody,
|
|
sOcrBody,
|
|
sDevName,
|
|
sDevSerial,
|
|
sDevClassId,
|
|
sResInfo,
|
|
sSummary,
|
|
sAppName,
|
|
sAppPath,
|
|
sThumbIds,
|
|
sSender,
|
|
sRecipient,
|
|
sSubject,
|
|
sPath,
|
|
sFileCompId,
|
|
sDestIpUrl,
|
|
sDestPort,
|
|
sComment,
|
|
sLogId,
|
|
sActionId: String;
|
|
OVio: ISuperObject;
|
|
end;
|
|
|
|
TBlockKind = (bkNone, bkBlack, bkWhite, bkAll);
|
|
TWifiCtrlKind = (wckNone, wckPopup, wckBlock, wckBlockName, wckWhiteName, wckLog);
|
|
TNotifyType = (nftNormal, nftMin, nftACenter);
|
|
TNotifyKind = (nfkNone, nfkAll, nfkVul, nfkPol);
|
|
TUsbBlockKind = (ubkNone, ubkBlock, ubkReadOnly, _ubkPopup{사용안함}, ubkLog);
|
|
TDevBlockKind = (dbkNone, dbkBlock, _dbkPopup{사용안함}, dbkLog);
|
|
TAppInstKind = (aikNone, aikBlock, aikPopup, aikLog);
|
|
TBlockFRename = (bfrFalse, bfrAll, bfrExe, bfrPopup, bfrLog, bfrNoExe);
|
|
TBlockFdRename = (bdrFalse, bdrAll, bdrThis, bdrPopup, bdrLog);
|
|
TClipBlockKind = (cbkNone, cbkBlock, cbkPopup, cbkLog);
|
|
TShareFolderKind = (sfkNone, sfkAllBlock, sfkAddBlock, sfkPopup, sfkLog);
|
|
TFileCollectPlan = (fcpNone, fcpOnce, fcpWeek, fcpMonthDate, fcpMonthWeek);
|
|
TFileCollectKind = (fckNone, fckFile, fckFolder, fckFolderIncSub, fckFolderFKwd);
|
|
TScanBlockKind = (sbkNone, sbkDelete, sbkPopup, sbkLog, sbkDrmEnc);
|
|
TScreenLockKind = (slkNone, slkDef, slkCustom, slkBoth);
|
|
TOsPatchCheck = (opcNone, opcCheck, opcPopup, opcLog);
|
|
TWebbMonKind = (wmkNone, wmkBlock, wmkLog, wmkIncBlock, wmkIncAllow, wmkIncPop, wmkIncLog);
|
|
TCapAppMonKind = (camNone, camBlockAll, camIncAllow, camPopup, camLog);
|
|
TPwChkTerm = (pctNone, pctBlock, pctPopup, pctLog);
|
|
TIfSecureKind = (askNone, askAlways, askRunTargetOn, askUseTargetOn, askRunTargetOff, askUseTargetOff);
|
|
TOffLogKind = (olkNone, olkCollect, olkColOR, olkColAND);
|
|
TUninstKind = (uikNormal, uikPassword, uikOTP, uikCode);
|
|
TPoViewKind = (pvkAll, pvkEnabled, pvkDisabled);
|
|
|
|
TOsPatch = class(TTgObject)
|
|
|
|
end;
|
|
TOsPatchList = class(TList<TOsPatch>)
|
|
protected
|
|
procedure Notify(const Item: TOsPatch; Action: TCollectionNotification); override;
|
|
end;
|
|
|
|
TCompanyModel = class(TTgObject)
|
|
public
|
|
CustomerType,
|
|
CustomerSubType: ULONGLONG;
|
|
SvrDestList: TStringList;
|
|
|
|
Constructor Create;
|
|
Destructor Destroy; override;
|
|
|
|
procedure Save(sPath: String);
|
|
procedure Load;
|
|
end;
|
|
|
|
TAgentModel = class(TTgObject)
|
|
public
|
|
IP,
|
|
MAC,
|
|
HostName,
|
|
Version,
|
|
AgentId,
|
|
Location,
|
|
// VpnInfo,
|
|
EmpNo,
|
|
|
|
UName, // 인사연동된 사용자 이름
|
|
Email,
|
|
DeptName,
|
|
EulaTxt,
|
|
Account,
|
|
UserName,
|
|
DomainName,
|
|
DeleteCode: String;
|
|
LastConn,
|
|
EulaDT,
|
|
AfterRptDT,
|
|
RecentCltFldDT,
|
|
LastOsPatchDT: TDateTime;
|
|
|
|
AModelVer: Integer;
|
|
|
|
FirstConn,
|
|
ForceVulMode: Boolean;
|
|
|
|
Constructor Create;
|
|
|
|
procedure Save(sPath: String = '');
|
|
procedure Load(sPath: String = '');
|
|
end;
|
|
|
|
TFileMonPolicy = record
|
|
Kind: TFileMonKind;
|
|
ContentFilter: TContentFilter;
|
|
IsNoti,
|
|
IsCollectTxt,
|
|
IsCollectFile,
|
|
DoEnc,
|
|
OnlyUSB,
|
|
CreateEvt,
|
|
ModifyEvt,
|
|
DeleteEvt,
|
|
RenameEvt: Boolean;
|
|
sExts,
|
|
sExceptPath: String;
|
|
end;
|
|
TFileColPo = record
|
|
bTxt,
|
|
bFile: Boolean;
|
|
end;
|
|
|
|
TPrintKind = (pkNone, pkBlock, _pkPopup{사용안함}, pkLog);
|
|
TPrintWater = (pwNone, pwActive, pwApprove);
|
|
TPrintPolicy = record
|
|
PrintKind: TPrintKind;
|
|
PrintWater: TPrintWater;
|
|
// PrinterExcept,
|
|
// PrintAppExcept,
|
|
// PrintUrlExcept: TBlockKind;
|
|
ContentFilter: TContentFilter;
|
|
sWaterExcepts, // 사용하지 않음
|
|
sPrinterExcepts,
|
|
sPrintAppExcepts,
|
|
sPrintUrlExcepts,
|
|
sPrintDocExcepts: String;
|
|
bPopup,
|
|
// bPrtMasking,
|
|
bDateBlock,
|
|
bCollectFile,
|
|
bCollectOutput: Boolean;
|
|
dtBlockB,
|
|
dtBlockE: TDateTime;
|
|
end;
|
|
|
|
// TOutlookMonKind = (omkNone, omkBlock, omkSubject, omkBody, omkMask, omkPopup, omkLog);
|
|
TOutlookPolicy = record
|
|
bActive,
|
|
bBlock,
|
|
bPopup,
|
|
bSchSubject,
|
|
bSchBody,
|
|
bUseMasking,
|
|
bCollect,
|
|
bAttachLog: Boolean;
|
|
// Kind: TOutlookMonKind;
|
|
ContentFilter: TContentFilter;
|
|
end;
|
|
|
|
|
|
TPrefModel = class(TTgObject)
|
|
private
|
|
// VpnIpList,
|
|
// VpnRcAppList: TStringList;
|
|
|
|
ORecent_: ISuperObject;
|
|
bLoaded_: Boolean;
|
|
sPoId_,
|
|
sConfDir_,
|
|
sCheckHash_: String;
|
|
bSaveAble_: Boolean;
|
|
nDefPrtDPI_: Integer;
|
|
|
|
DcPo_: TDictionary<String,String>;
|
|
|
|
// 정책 정보
|
|
sPoFName_: String;
|
|
|
|
// 정의된 정책 정보, 정책 코드 확인
|
|
MgPo_: TManagerPolicy;
|
|
|
|
function LoadFromJsonObj(aO: ISuperObject; CP: Boolean): Boolean;
|
|
procedure SetOldDefault;
|
|
function LoadFromJsonObj_Old(aO: ISuperObject): Boolean;
|
|
procedure Load;
|
|
procedure SetPolicyFromJsonObj(aO: ISuperObject);
|
|
procedure SetDefault(bGrpName: Boolean = true);
|
|
|
|
// function SetPoKeyVal(aO: ISuperObject): Integer;
|
|
// procedure SetPolicyVal(sKey: String; var bPo: Boolean); overload;
|
|
// procedure SetPolicyVal(sKey: String; var sPo: String); overload;
|
|
// procedure SetPolicyInt(sKey: String; var nPo: Integer; nDef: Integer = 0);
|
|
// function GetPolicyValStr(sKey: String): String;
|
|
// function GetPolicyValInt(sKey: String; nDef: Integer = 0): Integer;
|
|
// function GetPolicyValBool(sKey: String): Boolean;
|
|
public
|
|
PolicyId,
|
|
PolicyGroup,
|
|
PolicyName,
|
|
DeptName,
|
|
IdlPolicy,
|
|
VulPolicy,
|
|
OffPolicy,
|
|
ExpPolicy,
|
|
Language,
|
|
VpnAppName,
|
|
ForceScreenLock,
|
|
NetworkExceptType,
|
|
NetworkBlockType,
|
|
AgentPatchVersion,
|
|
AgentPatchExeName,
|
|
xPrintUpVer,
|
|
VpnMethod,
|
|
NoticeContent,
|
|
RestricMac,
|
|
RestricDate,
|
|
UnsafeActions,
|
|
EulaTitle,
|
|
EulaBody,
|
|
CBCollectApp: String;
|
|
HideMainUI,
|
|
UseRemoteScrLogoBold,
|
|
BlockChangeTime,
|
|
UseIdleScrLogoBold,
|
|
UseIpScrLogoBold,
|
|
WinCapScrLogoOff,
|
|
CheckAllowMAC,
|
|
IsIgrScrCapKeyCB,
|
|
IsRestricDate,
|
|
IsEulaSubmit,
|
|
IsEnableCheck,
|
|
IsWaterMark,
|
|
IsMasking,
|
|
IsSmbPortBlock,
|
|
IsDefPortBlock,
|
|
IsAgentUpdateExist,
|
|
IsFixedVerUpdate,
|
|
IsAllowAccess,
|
|
IsTemporaryConn,
|
|
IsAgentDelete,
|
|
IsNoticeEnable,
|
|
IsPreventSettingChange,
|
|
IsClipboardExcept,
|
|
IsCBCollect,
|
|
IsUseAfterReport,
|
|
IsPreventDownloads,
|
|
IsWifiPublicBlock,
|
|
IsMobileHotspotExp,
|
|
IsAppBlackDate,
|
|
IsAppBlackTime,
|
|
IsLongtimeDisconn,
|
|
IsShowPolicy,
|
|
IsShowAInfo,
|
|
IsMustSecuApp,
|
|
IsMonApp,
|
|
IsMonAppNoti,
|
|
IsBlockApp,
|
|
IsBlockAppLog,
|
|
IsBlockAppNotice,
|
|
DetectFixedDisk,
|
|
IsUninstallAble,
|
|
UseFileTag: Boolean;
|
|
ScreenLogo,
|
|
ScreenBlockAppExp: TIfSecureKind;
|
|
CaptureBlockUrlKind: TBlockKind;
|
|
CbCF: TContentFilter;
|
|
|
|
AppRcdNoti,
|
|
AppRcdActive: Boolean;
|
|
AppRcdMaxMin: Integer;
|
|
AppRcdApps: String;
|
|
|
|
xPrintUpEnable,
|
|
xPrintUpFixedVer,
|
|
ScreenLogoVisible,
|
|
ScreenLogoInvisible: Boolean;
|
|
|
|
UninstKind: TUninstKind;
|
|
NetBlockDayB,
|
|
NetBlockDayE,
|
|
AppBlackDateB,
|
|
AppBlackDateE: TDateTime;
|
|
|
|
SecuExitWaitSec,
|
|
CfZipDepth,
|
|
CfTimeoutSec,
|
|
CfLimitMB,
|
|
ScreenLogoAlpha,
|
|
VulDueTimeSec,
|
|
AppBlackTimeB,
|
|
AppBlackTimeE: Integer;
|
|
|
|
ScreenLogoUpdateMin,
|
|
HealthCheckMilSec,
|
|
MinIdleScrLogoBold,
|
|
PersonalInfoFileMax,
|
|
HeartbeatTime,
|
|
TemporaryConnMin: Integer;
|
|
|
|
ScrLogoBoldIps,
|
|
UninstallPW,
|
|
ScreenLogoApps,
|
|
ScreenBlockAppsExp,
|
|
IgrCaptureApps: String;
|
|
MonAppList,
|
|
SoftwareListB,
|
|
SoftwareListW,
|
|
NetworkBlockList,
|
|
NetworkExceptList,
|
|
SMBPortExceptList,
|
|
|
|
CaptureBlockApps,
|
|
CaptureBlockUrls,
|
|
|
|
ScreenLockPwd,
|
|
WifiBlockNames,
|
|
ClipboardExceptApp: String;
|
|
|
|
ExtraPortEnableType,
|
|
UnsafeActionsMin,
|
|
ForceScreenLockMin,
|
|
ForceShutdownMin: Integer;
|
|
WifiCtrlKind: TWifiCtrlKind;
|
|
WifiGpsOn: Boolean;
|
|
UsbBlockKind: TUsbBlockKind;
|
|
AbleUsbExceptReq,
|
|
AbleMtpExceptReq,
|
|
AbleBtExceptReq,
|
|
AbleCdExceptReq: Boolean;
|
|
AppInstKind: TAppInstKind;
|
|
FileMon,
|
|
FileBlock: TFileMonPolicy;
|
|
FmCreateCol,
|
|
FmModifyCol,
|
|
fmRenameCol: TFileColPo;
|
|
DrmCF: TContentFilter;
|
|
IsNetBlockDay,
|
|
IsForceShutdown,
|
|
IsSecuEndActions,
|
|
IsUnsafeActions,
|
|
bCaptureBlockApps_,
|
|
FileMonOnlyLog: Boolean;
|
|
EtcAB,
|
|
WebbAB,
|
|
OutlookAB: TAttachBlockPolicy;
|
|
ShareFolder: TShareFolderKind;
|
|
FileCollectPlan: TFileCollectPlan;
|
|
FileCollectKind: TFileCollectKind;
|
|
ScanBlockKind: TScanBlockKind;
|
|
ScreenLockKind: TScreenLockKind;
|
|
CapAppMonKind: TCapAppMonKind;
|
|
PwChkTerm: TPwChkTerm;
|
|
FileCollectDate: TDate;
|
|
EtcABApps,
|
|
FileMonExt,
|
|
TgFileCollect,
|
|
TgFileCollectKwd,
|
|
WebABUrlList,
|
|
EtcNicBlockExcept,
|
|
LogoUrlList,
|
|
WebAbSigs,
|
|
WebAbFNames,
|
|
EtcAbSigs,
|
|
EtcAbFNames,
|
|
WebABLogUrlList,
|
|
EtcAbLogList: String;
|
|
|
|
IsPcStatePower,
|
|
IsPcStateIpCh,
|
|
IsUrlCatchLogo,
|
|
IsPrtCollectThum,
|
|
IsIgrCollectCutWebAB,
|
|
IsIgrCollectCutAppAB,
|
|
IsAllowLogWebAB, // X
|
|
IsAllowLogAppAB: Boolean;
|
|
|
|
FileMonNoLog,
|
|
IsNotiBCA: Boolean;
|
|
FileMonEncDelaySec,
|
|
PrtCollThumLimit,
|
|
NotiCloseSec,
|
|
PwChkTermDay: Integer;
|
|
|
|
BlockFRename: TBlockFRename;
|
|
BlockFdRename: TBlockFdRename;
|
|
ClipBlockKind: TClipBlockKind;
|
|
CbPopup,
|
|
CbImgBlock,
|
|
DoClipOcr: Boolean;
|
|
OutPo: TOutlookPolicy;
|
|
|
|
MtpBlockKind: TUsbBlockKind;
|
|
BlueBlockKind : TDevBlockKind;
|
|
CdromBlockKind: TUsbBlockKind;
|
|
WebbMonKind: TWebbMonKind;
|
|
USBPopup,
|
|
BTPopup,
|
|
CDPopup,
|
|
MTPPopup,
|
|
IsDrmAttAble,
|
|
IsDrmAttAbleFB, // 파일 생성 차단에 있는 옵션
|
|
IsDrmDecrypt,
|
|
EtcNicBlock,
|
|
EtcNicBlockNoti,
|
|
IsDomainBlock,
|
|
IsStartupScreenLock,
|
|
AutoRunBlock,
|
|
HostEnable,
|
|
RouteEnable,
|
|
IsDailyEulaCheck,
|
|
IsEmpVerify,
|
|
IsVpnAndCondition: Boolean;
|
|
NotifyType: TNotifyType;
|
|
NotifyKind: TNotifyKind;
|
|
IsNotiSystem: Boolean;
|
|
OsPatchCheck: TOsPatchCheck;
|
|
DrmAccessKind,
|
|
DrmModifyKind: TDrmAccessKind;
|
|
PoViewKind: TPoViewKind;
|
|
|
|
BlockFRenames,
|
|
BlockDirFileRenames,
|
|
UrlBlkRuleList,
|
|
UrlBlockList,
|
|
UrlBlockExcpList,
|
|
DomainBlockList,
|
|
MtpExcept,
|
|
MtpExceptVender,
|
|
BlueExcept,
|
|
BlueExceptVender,
|
|
CdromExcept,
|
|
UsbExceptVender,
|
|
AllowConn,
|
|
BlockPortList,
|
|
VpnHour,
|
|
VpnIpList,
|
|
VpnRcAppList,
|
|
NacCheckUrl,
|
|
ScreenLogoData: String;
|
|
|
|
// 차단/허용 알림 정책
|
|
WifiBlockPopup,
|
|
WifiAllowPopup,
|
|
OutBodyAllowPopup,
|
|
OutFileAllowPopup,
|
|
ShareFldBlockPopup,
|
|
ShareFldAllowPopup,
|
|
UsbAllowPopup,
|
|
MtpAllowPopup,
|
|
BtAllowPopup,
|
|
CdAllowPopup,
|
|
PrtAllowPopup,
|
|
HdMonPopup: Boolean;
|
|
|
|
FileExpMin,
|
|
// 원본 파일수집 크기제한
|
|
WebABLimitMB,
|
|
AppABLimitMB,
|
|
OutABLimitMB,
|
|
FileMonLimitMB,
|
|
FileBlkLimitMB,
|
|
|
|
OutFileBlockMB,
|
|
WebFileBlockMB,
|
|
AppFileBlockMB,
|
|
|
|
FileExpMinMB,
|
|
FileExpMaxMB,
|
|
WebABMinMB,
|
|
AppABMinMB,
|
|
OutABMinMB,
|
|
FileMonMinMB,
|
|
FileBlkMinMB,
|
|
PrtMinMB,
|
|
PrtMaxMB: Integer;
|
|
|
|
FileOpenMon,
|
|
// 취약점 점검 정책
|
|
VulOsVersion,
|
|
VulAntiVirus,
|
|
VulPassword,
|
|
VulScreenSaver,
|
|
VulFirewall: Boolean;
|
|
|
|
// 오프라인 정책
|
|
UseExpPo: Boolean;
|
|
ExpPoLimit,
|
|
ExpPoMin: Integer;
|
|
ExpPoAgree: String;
|
|
|
|
// 오프라인 로그
|
|
OffLogKind: TOffLogKind;
|
|
OffLogDays,
|
|
OffLogMaxMB: Integer;
|
|
UseOffLogDay,
|
|
UseOffLogMaxMB: Boolean;
|
|
|
|
IgrUsbSerialList: TStringList;
|
|
IgrUsbSerials,
|
|
IgrUsbSerialsKn: String;
|
|
|
|
Print: TPrintPolicy;
|
|
PrinterIpExcept: String;
|
|
PrtWtExpUrl,
|
|
PrtWtExpDocName,
|
|
PrtWtExpPrtName,
|
|
PrtWtExpProcName,
|
|
PrtApvExpUrl,
|
|
PrtApvExpDocName,
|
|
PrtApvExpPrtName,
|
|
PrtApvExpProcName: String;
|
|
PrtWaterCfg: TPrtWaterCfg;
|
|
|
|
PrintApproval,
|
|
PrintApprovalPost,
|
|
UsbApproval,
|
|
WebUrlApproval,
|
|
BtApproval,
|
|
CdApproval,
|
|
MtpApproval,
|
|
DrmApproval,
|
|
ExFApproval,
|
|
CapApproval: Boolean;
|
|
|
|
BlockNoUrl,
|
|
BlockNoUrlAB,
|
|
BlockWidgetAB,
|
|
|
|
UrlBlockNoti,
|
|
UrlAllowNoti,
|
|
WebAAllowNoti,
|
|
AppAAllowNoti: Boolean;
|
|
|
|
IsOldPolicy, // 저장된 정책이 서버 2.6 이하면 true
|
|
IsTempGroup: Boolean;
|
|
|
|
ShFileCrMon: TShFileCrMon;
|
|
|
|
// 확장 정책
|
|
LogLv,
|
|
TextLimit,
|
|
PrtDPI,
|
|
ChkConSec,
|
|
LogKeepDays,
|
|
AipEncMSec,
|
|
BtConNotiDSec: Integer;
|
|
AipOff,
|
|
LogEnc,
|
|
DrmPopupNo,
|
|
PrtPopupNo,
|
|
PrtWaterPop,
|
|
OpenDetect,
|
|
IgrNetPathAB,
|
|
CodePo,
|
|
NoOutlRcvr: Boolean;
|
|
PrtNameH,
|
|
PrtWaterAppH,
|
|
PrtWaterAppHig,
|
|
SmbPortEx,
|
|
CfFblkExts,
|
|
WebAbExts,
|
|
EtcAbExts: String;
|
|
PrtOcrTxtExtList: TStringList;
|
|
|
|
IntBtBlockNewFile,
|
|
IntUsbBlockNewFile,
|
|
IntUsbToUsbBlockNewFile,
|
|
IntCdromBlockNewFile,
|
|
IntMtpBlockNewFile: TIntBlockNewFile;
|
|
|
|
IgnoreDriverLoad: Boolean;
|
|
|
|
Constructor Create(sPoName: String; bLoad: Boolean = true; bSaveAble: Boolean = true);
|
|
Destructor Destroy; override;
|
|
|
|
procedure Clear(bGrpName: Boolean = true; bDelFile: Boolean = false);
|
|
procedure Save;
|
|
function SetPrefModel(aO: ISuperObject): Boolean; // 2.6.x 이하에서 사용
|
|
function SetPolicy(sPoId: String; aO: ISuperObject; CP: Boolean): Boolean; // 2.7.x 이상에서 사용
|
|
function SetMngPolicy(aO: ISuperObject; CP: Boolean): Boolean;
|
|
function SetSetPolicy(aO: ISuperObject; CP: Boolean): Boolean;
|
|
function IsScanBlock: Boolean;
|
|
function IsNeedHook: Boolean;
|
|
function IsAbleCodePo: Boolean;
|
|
function GetPrefModeToJsonObj: ISuperObject; // 2.6.x 이하에서 사용
|
|
function GetPolicyToJsonObj: ISuperObject; // 2.7.x 이상에서 사용
|
|
procedure ProcessAfterSetPolicy;
|
|
|
|
property PoFileName: String read sPoFName_;
|
|
property InternalPoId: String read sPoId_;
|
|
property Loaded: Boolean read bLoaded_;
|
|
end;
|
|
|
|
PCttSchTaskEnt = ^TCttSchTaskEnt;
|
|
TCttSchTaskEnt = record
|
|
sScanId: String;
|
|
dtRecent,
|
|
dtRecentLC: TDateTime;
|
|
end;
|
|
TCttSchTaskEntList = TList<PCttSchTaskEnt>;
|
|
|
|
TManagerCttSch = class(TTgObject)
|
|
private
|
|
TaskEntList_: TCttSchTaskEntList;
|
|
procedure OnTaskEntNotify(Sender: TObject; const Item: PCttSchTaskEnt; Action: TCollectionNotification);
|
|
function GetTaskEntByScanId(sScanId: String): PCttSchTaskEnt;
|
|
procedure Load;
|
|
public
|
|
Constructor Create;
|
|
Destructor Destroy; override;
|
|
|
|
procedure Save;
|
|
procedure Clear;
|
|
|
|
procedure CompleteTask(sScanId: String; dtComp: TDateTime = 0);
|
|
function GetTastRecentDT(sScanId: String): TDateTime;
|
|
function GetTastRecentLcDT(sScanId: String): TDateTime;
|
|
end;
|
|
|
|
TManagerCttSchExcept = class(TTgObject)
|
|
private
|
|
HashList_: TStringList;
|
|
procedure Load;
|
|
public
|
|
Constructor Create;
|
|
Destructor Destroy; override;
|
|
|
|
function AddFileHash(sPath: String): Boolean;
|
|
function HasFileHash(sPath: String): Boolean;
|
|
procedure Save;
|
|
end;
|
|
|
|
TManagerCampExcept = class(TTgObject)
|
|
private
|
|
PathList_: TStringList;
|
|
procedure Load;
|
|
public
|
|
Constructor Create;
|
|
Destructor Destroy; override;
|
|
|
|
procedure AddFile(sPath: String);
|
|
function IsExceptFile(sPath: String): Boolean;
|
|
procedure Save;
|
|
end;
|
|
|
|
PPweEnt = ^TPweEnt;
|
|
TPweEnt = record
|
|
dtReg: TDateTime;
|
|
sHash: String;
|
|
end;
|
|
TManagerPrtWaterExcept = class(TTgObject)
|
|
private
|
|
HashEntList_: TList<PPweEnt>;
|
|
HashList_: TStringList;
|
|
procedure OnEntNotify(Sender: TObject; const Item: PPweEnt; Action: TCollectionNotification);
|
|
procedure Load;
|
|
public
|
|
Constructor Create;
|
|
Destructor Destroy; override;
|
|
|
|
function AddFileHash(sPath: String): Boolean;
|
|
function HasFileHash(sPath: String): Boolean;
|
|
function CountHash: Integer;
|
|
procedure Save;
|
|
end;
|
|
|
|
PCltFldTaskEnt = ^TCltFldTaskEnt;
|
|
TCltFldTaskEnt = record
|
|
sCollectId: String;
|
|
dtRecent: TDateTime;
|
|
end;
|
|
TCltFldTaskEntList = TList<PCltFldTaskEnt>;
|
|
|
|
TManagerCltFld = class(TTgObject)
|
|
private
|
|
TaskEntList_: TCltFldTaskEntList;
|
|
procedure OnTaskEntNotify(Sender: TObject; const Item: PCltFldTaskEnt; Action: TCollectionNotification);
|
|
function GetTaskEntByScanId(sCollectId: String): PCltFldTaskEnt;
|
|
procedure Load;
|
|
public
|
|
Constructor Create;
|
|
Destructor Destroy; override;
|
|
|
|
procedure Save;
|
|
|
|
procedure CompleteTask(sCollectId: String);
|
|
function GetTastRecentDT(sScanId: String): TDateTime;
|
|
end;
|
|
|
|
function StrListToCommaStr(aStrList: String; sDm: String = ','; bCheckInt: Boolean = false; bIgrSpace: Boolean = true): String;
|
|
procedure MakeAgentId_Test(sPath, sId: String);
|
|
function GetAgentId(sEmpNo: String): String;
|
|
|
|
implementation
|
|
|
|
uses
|
|
Tocsg.Safe, Tocsg.Strings, Tocsg.WTS, Tocsg.Trace,
|
|
Tocsg.Exception, Condition, Tocsg.Convert, System.IniFiles,
|
|
Tocsg.Path, Tocsg.Hash, Tocsg.Encrypt, Tocsg.DateTime, Tocsg.WinInfo,
|
|
Tocsg.Network, Tocsg.Json, Tocsg.Registry, System.DateUtils,
|
|
EM.Tocsg.hash;
|
|
|
|
function StrListToCommaStr(aStrList: String; sDm: String = ','; bCheckInt: Boolean = false; bIgrSpace: Boolean = true): String;
|
|
var
|
|
StrList: TStringList;
|
|
sVal: String;
|
|
i: Integer;
|
|
begin
|
|
Result := '';
|
|
if aStrList = '' then
|
|
exit;
|
|
|
|
Guard(StrList, TStringList.Create);
|
|
sVal := StringReplace(aStrList, #13#10, sDm, [rfReplaceAll]);
|
|
sVal := StringReplace(sVal, MODEL_SEPARATOR, sDm, [rfReplaceAll]);
|
|
sVal := StringReplace(sVal, ';', sDm, [rfReplaceAll]);
|
|
sVal := StringReplace(sVal, ',', sDm, [rfReplaceAll]);
|
|
sVal := StringReplace(sVal, '|', sDm, [rfReplaceAll]);
|
|
if not bIgrSpace then
|
|
sVal := StringReplace(sVal, ' ', sDm, [rfReplaceAll]);
|
|
if SplitString(sVal, sDm, StrList) > 0 then
|
|
begin
|
|
for i := 0 to StrList.Count - 1 do
|
|
begin
|
|
sVal := StrList[i];
|
|
if sVal = '' then
|
|
continue;
|
|
|
|
if not bCheckInt or
|
|
(StrToIntDef(StringReplace(sVal, '-', '', [rfReplaceAll]), -1) <> -1) then // 포트 범위를 위해 - 제외하고 체크
|
|
SumString(Result, sVal, sDm);
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
procedure MakeAgentId_Test(sPath, sId: String);
|
|
var
|
|
ss: TStringStream;
|
|
O: ISuperObject;
|
|
begin
|
|
O := SO;
|
|
O.S['MAC'] := 'TEST1230492';
|
|
O.S['COM'] := 'TESTCOMNAME';
|
|
O.S['ID'] := sId;
|
|
|
|
Guard(ss, TStringStream.Create(
|
|
EncStrToBinStr(ekAes256cbc, PASS_MODEL, O.AsString), TEncoding.UTF8));
|
|
ss.SaveToFile(sPath);
|
|
end;
|
|
|
|
function IsSameEmpNoAgentId: Boolean;
|
|
begin
|
|
case CUSTOMER_TYPE of
|
|
CUSTOMER_JB_DEV,
|
|
CUSTOMER_JB_MAINTAIN,
|
|
CUSTOMER_HANYANG,
|
|
CUSTOMER_METLIFE,
|
|
CUSTOMER_LX,
|
|
CUSTOMER_KR,
|
|
CUSTOMER_CGBEST,
|
|
CUSTOMER_UBASE,
|
|
CUSTOMER_KISTEP,
|
|
CUSTOMER_ABL,
|
|
CUSTOMER_SHCD,
|
|
CUSTOMER_KFB,
|
|
CUSTOMER_HDENG,
|
|
CUSTOMER_AUTOLEASE,
|
|
CUSTOMER_TMAP,
|
|
CUSTOMER_HDQUMING,
|
|
CUSTOMER_NIPA,
|
|
CUSTOMER_DICIA,
|
|
CUSTOMER_LGCNSVTN,
|
|
CUSTOMER_SOLMIX,
|
|
CUSTOMER_HCA,
|
|
CUSTOMER_GEC,
|
|
CUSTOMER_CNSCERT : Result := true;
|
|
else Result := false;
|
|
end;
|
|
end;
|
|
|
|
function GetAgentId(sEmpNo: String): String;
|
|
const
|
|
DAT_AGENTID = 'heaid.dat';
|
|
begin
|
|
if CUSTOMER_TYPE = CUSTOMER_VOLVO then
|
|
begin
|
|
Result := GetComName;
|
|
exit;
|
|
end else
|
|
if IsSameEmpNoAgentId then
|
|
begin
|
|
Result := sEmpNo;
|
|
exit;
|
|
end;
|
|
|
|
Result := '';
|
|
try
|
|
var sPath: String := GetSystemDir + DAT_AGENTID;
|
|
var O: ISuperObject;
|
|
var ss: TStringStream;
|
|
|
|
if FileExists(sPath) then
|
|
begin
|
|
Guard(ss, TStringStream.Create('', TEncoding.UTF8));
|
|
ss.LoadFromFile(sPath);
|
|
|
|
O := SO(DecBinStrToStr(ekAes256cbc, PASS_MODEL, ss.DataString));
|
|
if (O <> nil) and (O.S['MAC'] <> '') and
|
|
(O.S['COM'] <> '') and (O.S['ID'] <> '') then
|
|
begin
|
|
Result := O.S['ID'];
|
|
|
|
case CUSTOMER_TYPE of
|
|
CUSTOMER_LOTTEMART :
|
|
begin
|
|
// 롯데마트 AgentId 중복사건... 나중에 지워야함 25_0925 09:57:49 kku
|
|
var sChk: String := UpperCase(Result);
|
|
if (sChk = '2507300832249C7BEFC387F4') or (sChk = '250610134856345A604D55B2') then
|
|
Result := ''
|
|
else exit;
|
|
end;
|
|
CUSTOMER_UNITUS :
|
|
begin
|
|
// 추가 25_0109 10:16:15 kku
|
|
var sChk: String := UpperCase(Result);
|
|
if (sChk = '25070216251948EA622BE3BD') or (sChk = '2508211136537C57583C8907') then
|
|
Result := ''
|
|
else exit;
|
|
end;
|
|
else exit;
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
var sMac: String := GetMACAddrUsing;
|
|
if sMac = '' then
|
|
begin
|
|
sMac := GetMACAddr;
|
|
if sMac = '' then
|
|
begin
|
|
var MacList: TStringList;
|
|
Guard(MacList, TStringList.Create);
|
|
GetMACAddrToList(MacList);
|
|
if MacList.Count > 0 then
|
|
sMac := MacList[0]
|
|
else
|
|
sMac := MAC_NULL;
|
|
end;
|
|
end;
|
|
var sComName: String := GetComName;
|
|
|
|
// 초기화 후 전달한 PC에서 재설치 시 동일 PC로 보인다고 사용하지 않도록함;;; 22_0915 13:02:26 kku
|
|
// try
|
|
// var i, c: Integer;
|
|
// c := 0;
|
|
// Result := '';
|
|
// for i := 1 to Length(sComName) do
|
|
// begin
|
|
// Result := Result + sComName[i] + sMac[i];
|
|
// Inc(c, 2);
|
|
// if c = 24 then
|
|
// break;
|
|
// end;
|
|
//
|
|
// if c <> 24 then
|
|
// Result := Result + Copy(sMac, i, Length(sMac) - i);
|
|
// except
|
|
// Result := sComName + sMac;
|
|
// end;
|
|
|
|
// 임의값으로 변경 22_0915 13:02:42 kku
|
|
Result := FormatDateTime('yymmddhhnnss', Now) + sMac;
|
|
|
|
// DB에 에이전트 아이디 크기가 최대 24
|
|
if Length(Result) > 24 then
|
|
SetLength(Result, 24);
|
|
|
|
O := SO;
|
|
O.S['MAC'] := sMac;
|
|
O.S['COM'] := sComName;
|
|
O.S['ID'] := Result;
|
|
|
|
Guard(ss, TStringStream.Create(
|
|
EncStrToBinStr(ekAes256cbc, PASS_MODEL, O.AsString), TEncoding.UTF8));
|
|
ss.SaveToFile(sPath);
|
|
except
|
|
on E: Exception do
|
|
begin
|
|
ETgException.TraceException(E, 'Fail .. GetAgentId()');
|
|
if Result = '' then
|
|
begin
|
|
Result := GetComName + GetMACAddrUsing;
|
|
if Length(Result) > 24 then
|
|
SetLength(Result, 24);
|
|
end;
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
{ TOsPatch }
|
|
|
|
{ TOsPatchList }
|
|
|
|
procedure TOsPatchList.Notify(const Item: TOsPatch; Action: TCollectionNotification);
|
|
begin
|
|
if Action = cnRemoved then
|
|
Item.Free;
|
|
end;
|
|
|
|
{ TCompanyModel }
|
|
|
|
Constructor TCompanyModel.Create;
|
|
begin
|
|
Inherited Create;
|
|
CustomerType := CUSTOMER_TYPE;
|
|
CustomerType := CUSTOMER_SUB_TYPE;
|
|
SvrDestList := TStringList.Create;
|
|
GetDestServerList(SvrDestList);
|
|
end;
|
|
|
|
Destructor TCompanyModel.Destroy;
|
|
begin
|
|
FreeAndNil(SvrDestList);
|
|
Inherited;
|
|
end;
|
|
|
|
procedure TCompanyModel.Save(sPath: String);
|
|
var
|
|
O: ISuperObject;
|
|
ss: TStringStream;
|
|
begin
|
|
try
|
|
O := SO;
|
|
O.I['CT'] := CustomerType;
|
|
O.I['CST'] := CustomerSubType;
|
|
O.S['SD'] := SvrDestList.CommaText;
|
|
|
|
if CustomerType <> 0 then
|
|
SetRegValueInteger(HKEY_LOCAL_MACHINE, REG_HE, 'CT', CustomerType, true);
|
|
|
|
if CustomerSubType <> 0 then
|
|
SetRegValueInteger(HKEY_LOCAL_MACHINE, REG_HE, 'CST', CustomerSubType, true);
|
|
|
|
Guard(ss, TStringStream.Create(
|
|
EncStrToBinStr(ekAes256cbc, PASS_MODEL, O.AsString), TEncoding.UTF8));
|
|
|
|
if sPath = '' then
|
|
sPath := GetRunExePathDir + DIR_CONF + DAT_COMPANY;
|
|
|
|
if ForceDirectories(ExtractFilePath(sPath)) then
|
|
ss.SaveToFile(sPath);
|
|
except
|
|
on E: Exception do
|
|
ETgException.TraceException(Self, E, 'Fail .. Save()');
|
|
end;
|
|
end;
|
|
|
|
procedure TCompanyModel.Load;
|
|
var
|
|
sPath: String;
|
|
ss: TStringStream;
|
|
O: ISuperObject;
|
|
begin
|
|
sPath := GetRunExePathDir + DIR_CONF + DAT_COMPANY;
|
|
if not FileExists(sPath) then
|
|
begin
|
|
CustomerType := GetRegValueAsInteger(HKEY_LOCAL_MACHINE, REG_HE, 'CT');
|
|
if CustomerType <> 0 then
|
|
begin
|
|
GetDestServerList(SvrDestList, true);
|
|
Save(sPath);
|
|
end;
|
|
CustomerSubType := GetRegValueAsInteger(HKEY_LOCAL_MACHINE, REG_HE, 'CST');
|
|
exit;
|
|
end;
|
|
|
|
try
|
|
Guard(ss, TStringStream.Create('', TEncoding.UTF8));
|
|
ss.LoadFromFile(sPath);
|
|
|
|
O := SO(DecBinStrToStr(ekAes256cbc, PASS_MODEL, ss.DataString));
|
|
if O <> nil then
|
|
begin
|
|
CustomerType := O.I['CT'];
|
|
if CustomerType = 0 then
|
|
CustomerType := CUSTOMER_TYPE;
|
|
CustomerSubType := O.I['CST'];
|
|
SvrDestList.Clear;
|
|
SvrDestList.CommaText := O.S['SD'];
|
|
if SvrDestList.Count = 0 then
|
|
GetDestServerList(SvrDestList);
|
|
end;
|
|
except
|
|
on E: Exception do
|
|
ETgException.TraceException(Self, E, 'Load()');
|
|
end;
|
|
end;
|
|
|
|
{ TAgentModel }
|
|
|
|
Constructor TAgentModel.Create;
|
|
begin
|
|
Inherited Create;
|
|
|
|
IP := '';
|
|
MAC := '';
|
|
HostName := '';
|
|
Version := '';
|
|
AgentId := '';
|
|
Location := '';
|
|
// VpnInfo := '';
|
|
EmpNo := '';
|
|
EulaTxt := '';
|
|
Account := '';
|
|
UserName := '';
|
|
UName := '';
|
|
Email := '';
|
|
DeptName := '';
|
|
DomainName := '';
|
|
EulaDT := 0;
|
|
LastConn := 0;
|
|
FirstConn := true;
|
|
ForceVulMode := false;
|
|
RecentCltFldDT := 0;
|
|
LastOsPatchDT := 0;
|
|
AfterRptDT := 0;
|
|
end;
|
|
|
|
procedure TAgentModel.Save(sPath: String = '');
|
|
var
|
|
O: ISuperObject;
|
|
ss: TStringStream;
|
|
begin
|
|
try
|
|
AModelVer := VER_AGENT_MODEL;
|
|
|
|
O := SO;
|
|
O.S['IP'] := IP;
|
|
O.S['MAC'] := MAC;
|
|
O.S['HostName'] := HostName;
|
|
O.S['Version'] := Version;
|
|
O.S['AgentId'] := AgentId;
|
|
O.S['Location'] := Location;
|
|
// O.S['VpnInfo'] := VpnInfo;
|
|
O.S['EmpNo'] := EmpNo;
|
|
O.S['EulaTxt'] := EulaTxt;
|
|
O.S['Account'] := Account;
|
|
O.S['UserName'] := UserName;
|
|
O.S['UName'] := UName;
|
|
O.S['Email'] := Email;
|
|
O.S['DeptName'] := DeptName;
|
|
O.S['DomainName'] := DomainName;
|
|
O.D['LastConn'] := LastConn;
|
|
O.B['FirstConn'] := FirstConn;
|
|
O.B['ForceVulMode'] := ForceVulMode;
|
|
O.D['EulaDT'] := EulaDT;
|
|
O.D['AfterRptDT'] := AfterRptDT;
|
|
O.D['RecentCltFldDT'] := RecentCltFldDT;
|
|
O.D['LastOsPatchDT'] := LastOsPatchDT;
|
|
O.I['AModelVer'] := AModelVer;
|
|
O.S['DeleteCode'] := DeleteCode;
|
|
|
|
SetRegValueString(HKEY_LOCAL_MACHINE, REG_HE, 'EmpNo', EmpNo, true);
|
|
SetRegValueString(HKEY_LOCAL_MACHINE, REG_HE, 'UserName', UserName, true);
|
|
SetRegValueString(HKEY_LOCAL_MACHINE, REG_HE, 'HostName', HostName, true);
|
|
SetRegValueString(HKEY_LOCAL_MACHINE, REG_HE, 'DomainName', DomainName, true);
|
|
|
|
Guard(ss, TStringStream.Create(
|
|
EncStrToBinStr(ekAes256cbc, PASS_MODEL, O.AsString), TEncoding.UTF8));
|
|
|
|
if sPath = '' then
|
|
sPath := GetRunExePathDir + DIR_CONF + DAT_AGENT;
|
|
|
|
if ForceDirectories(ExtractFilePath(sPath)) then
|
|
ss.SaveToFile(sPath);
|
|
except
|
|
on E: Exception do
|
|
ETgException.TraceException(Self, E, 'Fail .. Save()');
|
|
end;
|
|
end;
|
|
|
|
procedure TAgentModel.Load(sPath: String = '');
|
|
var
|
|
ss: TStringStream;
|
|
O: ISuperObject;
|
|
begin
|
|
try
|
|
if sPath = '' then
|
|
sPath := GetRunExePathDir + DIR_CONF + DAT_AGENT;
|
|
|
|
if not FileExists(sPath) then
|
|
begin
|
|
FirstConn := true;
|
|
exit;
|
|
end;
|
|
|
|
try
|
|
Guard(ss, TStringStream.Create('', TEncoding.UTF8));
|
|
ss.LoadFromFile(sPath);
|
|
|
|
O := SO(DecBinStrToStr(ekAes256cbc, PASS_MODEL, ss.DataString));
|
|
if O <> nil then
|
|
begin
|
|
IP := O.S['IP'];
|
|
MAC := O.S['MAC'];
|
|
// VpnInfo := O.S['VpnInfo'];
|
|
EmpNo := O.S['EmpNo'];
|
|
HostName := O.S['HostName'];
|
|
Version := O.S['Version'];
|
|
AgentId := GetAgentId(EmpNo);
|
|
Location := O.S['Location'];
|
|
LastConn := O.D['LastConn'];
|
|
FirstConn := O.B['FirstConn'];
|
|
ForceVulMode := O.B['ForceVulMode'];
|
|
EulaDT := O.D['EulaDT'];
|
|
AfterRptDT := O.D['AfterRptDT'];
|
|
RecentCltFldDT := O.D['RecentCltFldDT'];
|
|
LastOsPatchDT := O.D['LastOsPatchDT'];
|
|
AModelVer := O.I['AModelVer'];
|
|
UName := O.S['UName'];
|
|
Email := O.S['Email'];
|
|
DeptName := O.S['DeptName'];
|
|
DeleteCode := O.S['DeleteCode'];
|
|
end;
|
|
except
|
|
on E: Exception do
|
|
ETgException.TraceException(Self, E, 'Load()');
|
|
end;
|
|
finally
|
|
if EmpNo = '' then
|
|
begin
|
|
_Trace('Not found EmpNo ...');
|
|
EmpNo := GetRegValueAsString(HKEY_LOCAL_MACHINE, REG_HE, 'EmpNo');
|
|
// VpnInfo := EmpNo;
|
|
if EmpNo <> '' then
|
|
_Trace('Found EmpNo ... from REG .. EmpNo="%s"', [EmpNo])
|
|
else
|
|
_Trace('Not found EmpNo ... from REG');
|
|
end;
|
|
if UserName = '' then
|
|
UserName := GetRegValueAsString(HKEY_LOCAL_MACHINE, REG_HE, 'UserName');
|
|
if HostName = '' then
|
|
HostName := GetRegValueAsString(HKEY_LOCAL_MACHINE, REG_HE, 'HostName');
|
|
if DomainName = '' then
|
|
DomainName := GetRegValueAsString(HKEY_LOCAL_MACHINE, REG_HE, 'DomainName');
|
|
end;
|
|
{$IFDEF DEBUG}
|
|
if IsNewServerOnly then
|
|
begin
|
|
if IsSameEmpNoAgentId then
|
|
EmpNo := 'kku777'
|
|
else
|
|
EmpNo := 'kku';//'kku' //':Anyone'
|
|
end else
|
|
EmpNo := 'kjkim2';
|
|
{$ENDIF}
|
|
end;
|
|
|
|
{ TPrefModel }
|
|
|
|
Constructor TPrefModel.Create(sPoName: String; bLoad: Boolean = true; bSaveAble: Boolean = true);
|
|
begin
|
|
Inherited Create;
|
|
|
|
IsOldPolicy := false;
|
|
|
|
DcPo_ := TDictionary<String,String>.Create;
|
|
MgPo_ := TManagerPolicy.Create(GetRunExePathDir + DIR_CONF + DAT_PO);
|
|
|
|
sPoId_ := '';
|
|
sPoFName_ := sPoName;
|
|
IgrUsbSerialList := TStringList.Create;
|
|
bSaveAble_ := bSaveAble;
|
|
sConfDir_ := GetRunExePathDir + DIR_CONF;
|
|
nDefPrtDPI_ := 300;
|
|
ChkConSec := 10;
|
|
PrtOcrTxtExtList := TStringList.Create;
|
|
Clear;
|
|
if bLoad then Load;
|
|
end;
|
|
|
|
Destructor TPrefModel.Destroy;
|
|
begin
|
|
FreeAndNil(PrtOcrTxtExtList);
|
|
FreeAndNil(IgrUsbSerialList);
|
|
FreeAndNil(MgPo_);
|
|
FreeAndNil(DcPo_);
|
|
Inherited;
|
|
end;
|
|
|
|
procedure TPrefModel.Clear(bGrpName: Boolean = true; bDelFile: Boolean = false);
|
|
begin
|
|
bLoaded_ := false;
|
|
sCheckHash_ := '';
|
|
IdlPolicy := '';
|
|
VulPolicy := '';
|
|
OffPolicy := '';
|
|
ExpPolicy := '';
|
|
IgrUsbSerialList.Clear;
|
|
SetDefault(bGrpName);
|
|
|
|
if bDelFile and (sPoFName_ <> '') then
|
|
begin
|
|
var sPath: String := GetRunExePathDir + DIR_CONF + Format('%s-%s%s', [NAME_PREF, sPoFName_, EXT_PROP]);
|
|
DeleteFile(PChar(sPath));
|
|
end;
|
|
end;
|
|
|
|
procedure TPrefModel.SetDefault(bGrpName: Boolean = true);
|
|
var
|
|
sVpnMethod: String;
|
|
begin
|
|
if bGrpName then
|
|
begin
|
|
PolicyGroup := 'DefaultGroup';
|
|
PolicyId := 'false';
|
|
DeptName := '';
|
|
end;
|
|
|
|
PolicyName := 'Default';
|
|
Language := 'ko';
|
|
VpnAppName := '';
|
|
VpnHour := '';
|
|
ForceScreenLock := '0';
|
|
ForceScreenLockMin := 10;
|
|
ForceShutdownMin := 0;
|
|
UnsafeActionsMin := 10;
|
|
IsSecuEndActions := true;
|
|
IsUnsafeActions := true;
|
|
WifiCtrlKind := wckNone;
|
|
WifiGpsOn := false;
|
|
WifiBlockNames := '';
|
|
// sSoftwareControlType_ := TYPE_SOFT_CTRL_BLACK; // BLACKLIST, WHITELIST
|
|
IsMustSecuApp := false;
|
|
IsBlockApp := false;
|
|
IsBlockAppLog := false;
|
|
IsBlockAppNotice := false;
|
|
IsMonApp := false;
|
|
IsMonAppNoti := false;
|
|
NetworkExceptType := 'NULL';
|
|
NetworkBlockType := 'false';
|
|
AppRcdNoti := false;
|
|
AppRcdActive := false;
|
|
AppRcdMaxMin := 3;
|
|
AppRcdApps := '';
|
|
xPrintUpVer := '';
|
|
xPrintUpEnable := false;
|
|
xPrintUpFixedVer := false;
|
|
AgentPatchVersion := '';
|
|
AgentPatchExeName := '';
|
|
// sSleepList_ := '';
|
|
Finalize(Print);
|
|
ZeroMemory(@Print, SizeOf(Print));
|
|
PrinterIpExcept := '';
|
|
PrtWtExpUrl := '';
|
|
PrtWtExpDocName := '';
|
|
PrtWtExpPrtName := '';
|
|
PrtWtExpProcName := '';
|
|
PrtApvExpUrl := '';
|
|
PrtApvExpDocName := '';
|
|
PrtApvExpPrtName := '';
|
|
PrtApvExpProcName := '';
|
|
PrintApproval := false;
|
|
PrintApprovalPost := false;
|
|
ZeroMemory(@PrtWaterCfg, SizeOf(PrtWaterCfg));
|
|
UsbApproval := false;
|
|
WebUrlApproval := false;
|
|
BtApproval := false;
|
|
CdApproval := false;
|
|
MtpApproval := false;
|
|
DrmApproval := false;
|
|
ExFApproval := false;
|
|
CapApproval := false;
|
|
BlockNoUrl := false;
|
|
BlockNoUrlAB := false;
|
|
BlockWidgetAB := false;
|
|
UrlBlockNoti := false;
|
|
UrlAllowNoti := false;
|
|
WebAAllowNoti := false;
|
|
AppAAllowNoti := false;
|
|
LogLv := 0;
|
|
LogEnc := false;
|
|
AipOff := false;
|
|
TextLimit := 8000;
|
|
PrtDPI := nDefPrtDPI_;
|
|
ChkConSec := 10;
|
|
DrmPopupNo := false;
|
|
PrtPopupNo := false;
|
|
PrtWaterPop := false;
|
|
OpenDetect := false;
|
|
IgrNetPathAB := false;
|
|
CodePo := false;
|
|
NoOutlRcvr := false;
|
|
// VpnMethod := '';//'app;'; // app, ip, rc, nic, time
|
|
NoticeContent := ''; //'안녕하세요.ㅄ환영합니다.';
|
|
RestricMac := 'NULL';
|
|
CheckAllowMAC := false;
|
|
RestricDate := 'NULL';
|
|
UnsafeActions := '';
|
|
// sUnsafePrevents_ := '';
|
|
IsRestricDate := false;
|
|
IsEulaSubmit := false; // true;
|
|
EulaTitle := '';
|
|
EulaBody := '';
|
|
IsEnableCheck := false;
|
|
IsWaterMark := false;
|
|
Finalize(FileMon);
|
|
ZeroMemory(@FileMon, SizeOf(FileMon));
|
|
FileOpenMon := false;
|
|
Finalize(FmCreateCol);
|
|
ZeroMemory(@FmCreateCol, SizeOf(FmCreateCol));
|
|
Finalize(FmModifyCol);
|
|
ZeroMemory(@FmModifyCol, SizeOf(FmModifyCol));
|
|
Finalize(fmRenameCol);
|
|
ZeroMemory(@fmRenameCol, SizeOf(fmRenameCol));
|
|
FileMonOnlyLog := false;
|
|
Finalize(FileBlock);
|
|
ZeroMemory(@FileBlock, SizeOf(FileBlock));
|
|
FileMonExt := '';
|
|
Finalize(DrmCF);
|
|
ZeroMemory(@DrmCF, SizeOf(DrmCF));
|
|
ShareFolder := sfkNone;
|
|
FileCollectPlan := fcpNone;
|
|
FileCollectKind := fckNone;
|
|
TgFileCollect := '';
|
|
TgFileCollectKwd := '';
|
|
WebABUrlList := '';
|
|
FileCollectDate := 0;
|
|
// bIsBlockPending_ := false;
|
|
IsMasking := false;
|
|
IsDefPortBlock := false;
|
|
IsSmbPortBlock := false;
|
|
IsAgentUpdateExist := false;
|
|
IsFixedVerUpdate := false;
|
|
ScreenLogo := askNone;
|
|
ScreenLogoVisible := true;
|
|
ScreenLogoInvisible := false;
|
|
ScreenLogoApps := '';
|
|
ScreenBlockAppExp := askNone;
|
|
ScreenBlockAppsExp := '';
|
|
IsAllowAccess := true; // 기본 허용
|
|
IsTemporaryConn := false;
|
|
TemporaryConnMin := 10;
|
|
IsAgentDelete := false;
|
|
IsNoticeEnable := false; // true;
|
|
ExtraPortEnableType := 0;
|
|
WinCapScrLogoOff := false;
|
|
UseIpScrLogoBold := false;
|
|
UseIdleScrLogoBold := false;
|
|
MinIdleScrLogoBold := 0;
|
|
UseRemoteScrLogoBold := false;
|
|
BlockChangeTime := false;
|
|
ScreenLogoUpdateMin := 0;
|
|
ScreenLogoAlpha := 0;
|
|
CfZipDepth := 7;
|
|
SecuExitWaitSec := 0;
|
|
CfTimeoutSec := 20;
|
|
CfLimitMB := 20;
|
|
IsIgrScrCapKeyCB := false;
|
|
HideMainUI := false;
|
|
HealthCheckMilSec := 0;
|
|
IsPreventSettingChange := false;
|
|
IsClipboardExcept := false;
|
|
ClipboardExceptApp := '';
|
|
IsUseAfterReport := false;
|
|
IsPreventDownloads := false;
|
|
IsUninstallAble := true; // CUSTOMER_TYPE = CUSTOMER_GEC; // 모든 고객사, 최초 정책 수신전 기본으로 삭제가능하도록 수정 24_0902 15:22:09 kku
|
|
UninstKind := uikNormal;
|
|
UninstallPW := '';
|
|
IsWifiPublicBlock := false;
|
|
IsMobileHotspotExp := false;
|
|
IsStartupScreenLock := false;
|
|
ScreenLockPwd := '';
|
|
IsAppBlackDate := false;
|
|
IsAppBlackTime := false;
|
|
IsLongtimeDisconn := false;
|
|
IsShowPolicy := false;
|
|
PoViewKind := pvkAll;
|
|
IsShowAInfo := true;
|
|
AppBlackDateB := 0;
|
|
AppBlackDateE := 0;
|
|
AppBlackTimeB := -1;
|
|
AppBlackTimeE := -1;
|
|
CaptureBlockApps := '';
|
|
bCaptureBlockApps_ := false;
|
|
CaptureBlockUrls := ''; // 'daum|naver';
|
|
CaptureBlockUrlKind := bkNone; // true;
|
|
IgrCaptureApps := '';
|
|
VulDueTimeSec := 0;
|
|
UseFileTag := false;
|
|
DetectFixedDisk := false;
|
|
IgrUsbSerials := '';
|
|
IgrUsbSerialsKn := '';
|
|
IsTempGroup := false;
|
|
|
|
BlockFRename := bfrFalse;
|
|
BlockFdRename := bdrFalse;
|
|
ClipBlockKind := cbkNone;
|
|
CbPopup := false;
|
|
CbImgBlock := false;
|
|
DoClipOcr := false;
|
|
Finalize(OutPo);
|
|
ZeroMemory(@OutPo, SizeOf(OutPo));
|
|
|
|
IsCBCollect := false;
|
|
CBCollectApp := '';
|
|
Finalize(CbCF);
|
|
ZeroMemory(@CbCF, SizeOf(CbCF));
|
|
|
|
BlockFRenames := '';
|
|
BlockDirFileRenames := '';
|
|
|
|
WebbMonKind := wmkNone;
|
|
EtcNicBlock := false;
|
|
EtcNicBlockNoti := false;
|
|
EtcNicBlockExcept := '';
|
|
IsDomainBlock := false;
|
|
UrlBlockList := '';
|
|
UrlBlkRuleList := '';
|
|
UrlBlockExcpList := '';
|
|
DomainBlockList := '';
|
|
IsNotiBCA := false;
|
|
FileMonNoLog := false;
|
|
CapAppMonKind := camNone;
|
|
PwChkTerm := pctNone;
|
|
PwChkTermDay := 0;
|
|
|
|
VpnIpList := '';
|
|
VpnRcAppList := '';
|
|
NacCheckUrl := '';
|
|
ScreenLogoData := '';
|
|
|
|
HeartbeatTime := 90;
|
|
// SoftwareList_.Add('cutproc.exe');
|
|
MonAppList := '';
|
|
SoftwareListB := '';
|
|
SoftwareListW := '';
|
|
NetworkBlockList := '';
|
|
NetworkExceptList := '';
|
|
SMBPortExceptList := '';
|
|
IsNetBlockDay := false;
|
|
NetBlockDayB := 0;
|
|
NetBlockDayE := 0;
|
|
|
|
IsPcStatePower := false;
|
|
IsPcStateIpCh := false;
|
|
|
|
IsUrlCatchLogo := false;
|
|
LogoUrlList := '';
|
|
WebAbSigs := '';
|
|
WebAbFNames := '';
|
|
EtcAbSigs := '';
|
|
EtcAbFNames := '';
|
|
CfFblkExts := '';
|
|
WebAbExts := '';
|
|
EtcAbExts := '';
|
|
PrtOcrTxtExtList.Clear;
|
|
ZeroMemory(@ShFileCrMon, SizeOf(ShFileCrMon));
|
|
WebABLogUrlList := '';
|
|
EtcAbLogList := '';
|
|
FileExpMin := 60;
|
|
LogKeepDays := 10;
|
|
BtConNotiDSec := 0;
|
|
PrtNameH := 'CANON';
|
|
PrtWaterAppH := '';
|
|
PrtWaterAppHig := '';
|
|
SmbPortEx := '';
|
|
AipEncMSec := 0;
|
|
IsPrtCollectThum := false;
|
|
FileMonEncDelaySec := 0;
|
|
PrtCollThumLimit := 3;
|
|
IsIgrCollectCutWebAB := false;
|
|
IsIgrCollectCutAppAB := false;
|
|
IsAllowLogWebAB := false; // X
|
|
IsAllowLogAppAB := false;
|
|
|
|
WebABLimitMB := 20;
|
|
AppABLimitMB := 20;
|
|
OutABLimitMB := 20;
|
|
FileMonLimitMB := 20;
|
|
FileBlkLimitMB := 20;
|
|
FileExpMinMB := 0;
|
|
FileExpMaxMB := 20;
|
|
WebABMinMB := 0;
|
|
AppABMinMB := 0;
|
|
OutABMinMB := 0;
|
|
OutFileBlockMB := 0;
|
|
WebFileBlockMB := 0;
|
|
AppFileBlockMB := 0;
|
|
FileMonMinMB := 0;
|
|
FileBlkMinMB := 0;
|
|
PrtMinMB := 0;
|
|
PrtMaxMB := 20;
|
|
|
|
WifiBlockPopup := true;
|
|
WifiAllowPopup := false;
|
|
OutBodyAllowPopup := false;
|
|
OutFileAllowPopup := false;
|
|
ShareFldBlockPopup := true;
|
|
ShareFldAllowPopup := false;
|
|
UsbAllowPopup := false;
|
|
MtpAllowPopup := false;
|
|
BtAllowPopup := false;
|
|
CdAllowPopup := false;
|
|
PrtAllowPopup := false;
|
|
HdMonPopup := false;
|
|
|
|
ScanBlockKind := sbkNone;
|
|
ScreenLockKind := slkNone;
|
|
// nPersonalInfoMax_ := 1000;
|
|
PersonalInfoFileMax := 0;
|
|
Finalize(OutLookAB);
|
|
ZeroMemory(@OutLookAB, SizeOf(OutLookAB));
|
|
Finalize(WebbAB);
|
|
ZeroMemory(@WebbAB, SizeOf(WebbAB));
|
|
Finalize(EtcAB);
|
|
ZeroMemory(@EtcAB, SizeOf(EtcAB));
|
|
EtcABApps := '';
|
|
|
|
if IsVpnAppCheck then
|
|
sVpnMethod := 'app;'
|
|
else
|
|
sVpnMethod := 'false;';
|
|
|
|
sVpnMethod := sVpnMethod + BooleanToStr(IsVpnIpCheck, 'ip;', 'false;');
|
|
sVpnMethod := sVpnMethod + BooleanToStr(IsVpnNetworkcardCheck, 'nic;', 'false;');
|
|
sVpnMethod := sVpnMethod + BooleanToStr(IsRemoteCall, 'rc;', 'false;');
|
|
sVpnMethod := sVpnMethod + BooleanToStr(IsVpnTimeCheck, 'time;', 'false;');
|
|
VpnMethod := sVpnMethod;
|
|
|
|
// TOptionModel
|
|
UsbBlockKind := ubkNone;
|
|
MtpBlockKind := ubkNone;
|
|
BlueBlockKind := dbkNone;
|
|
CdromBlockKind := ubkNone;
|
|
AppInstKind := aikNone;
|
|
USBPopup := false;
|
|
BTPopup := false;
|
|
CDPopup := false;
|
|
MTPPopup := false;
|
|
HostEnable := false;
|
|
AutoRunBlock := false;
|
|
AbleUsbExceptReq := false;
|
|
AbleMtpExceptReq := false;
|
|
AbleBtExceptReq := false;
|
|
AbleCdExceptReq := false;
|
|
RouteEnable := false; //false;
|
|
MtpExcept := '';
|
|
BlueExcept := '';
|
|
BlueExceptVender := '';
|
|
MtpExceptVender := '';
|
|
UsbExceptVender := '';
|
|
AllowConn := 'true';
|
|
// bPopupEnabled_ := false; //true;
|
|
NotifyType := nftNormal;
|
|
NotifyKind := nfkAll;
|
|
IsNotiSystem := true;
|
|
if Condition.IsOsPatchPopupOnly then
|
|
OsPatchCheck := opcPopup
|
|
else
|
|
OsPatchCheck := opcCheck;
|
|
//{$IFDEF DEBUG}
|
|
// DrmAccessKind := dakEmpNo;
|
|
// DrmModifyKind := dakEmpNo;
|
|
//{$ELSE}
|
|
DrmAccessKind := dakNone; // dakEmpNo;
|
|
DrmModifyKind := dakNone; // dakEmpNo;
|
|
//{$ENDIF}
|
|
IsDrmAttAble := false;
|
|
IsDrmAttAbleFB := false;
|
|
IsDrmDecrypt := false;
|
|
IsDailyEulaCheck := IsEulaCheckDaily;
|
|
IsEmpVerify := false;
|
|
BlockPortList := '';
|
|
IsVpnAndCondition := false;
|
|
|
|
VulOsVersion := false;
|
|
VulAntiVirus := false;
|
|
VulPassword := false;
|
|
VulScreenSaver := false;
|
|
VulFirewall := false;
|
|
|
|
UseExpPo := false;
|
|
ExpPoMin := 0;
|
|
ExpPoLimit := 0;
|
|
ExpPoAgree := 'false';
|
|
|
|
OffLogKind := olkNone;
|
|
OffLogDays := 0;
|
|
OffLogMaxMB := 0;
|
|
UseOffLogDay := false;
|
|
UseOffLogMaxMB := false;
|
|
end;
|
|
|
|
function TPrefModel.IsScanBlock: Boolean;
|
|
begin
|
|
case ScanBlockKind of
|
|
sbkNone,
|
|
sbkDelete,
|
|
sbkDrmEnc : Result := true;
|
|
else Result := false;
|
|
end;
|
|
end;
|
|
|
|
function TPrefModel.IsNeedHook: Boolean;
|
|
begin
|
|
Result := ((EtcAB.Kind <> abkNone) and (EtcABApps <> '')) or
|
|
(DrmAccessKind <> dakNone) or
|
|
(WebbAB.Kind <> abkNone) or
|
|
(OutlookAB.Kind <> abkNone) or
|
|
(Print.PrintKind <> pkNone) or
|
|
( (IsPrintWaterHook or not FileExists(sConfDir_ + EXE_SPL)) and
|
|
(Print.PrintWater <> pwNone) ) or
|
|
(CaptureBlockUrlKind <> bkNone) or
|
|
(bCaptureBlockApps_ and (CaptureBlockApps <> '')) or
|
|
(MtpBlockKind = ubkReadOnly) or
|
|
(ShFileCrMon.nKind <> 0);
|
|
end;
|
|
|
|
function TPrefModel.IsAbleCodePo: Boolean;
|
|
begin
|
|
Result := MgPo_.GetPoKeyCount > 0;
|
|
end;
|
|
|
|
procedure TPrefModel.Save;
|
|
var
|
|
ss: TStringStream;
|
|
sDir: String;
|
|
begin
|
|
try
|
|
sDir := GetRunExePathDir + DIR_CONF;
|
|
|
|
if sPoFName_ <> '' then
|
|
begin
|
|
Guard(ss, TStringStream.Create(
|
|
EncStrToBinStr(ekAes256cbc, PASS_MODEL, GetPolicyToJsonObj.AsString), TEncoding.UTF8));
|
|
|
|
if ForceDirectories(sDir) then
|
|
ss.SaveToFile(sDir + Format('%s-%s%s', [NAME_PREF, sPoFName_, EXT_PROP]));
|
|
|
|
var plainText: TStringStream;
|
|
//mgkim plainText
|
|
Guard(plainText, TStringStream.Create(GetPolicyToJsonObj.AsString, TEncoding.UTF8));
|
|
|
|
if ForceDirectories(sDir) then
|
|
plainText.SaveToFile(sDir + Format('%s-%s_painText%s', [NAME_PREF, sPoFName_, EXT_PROP]));
|
|
|
|
_Trace('정책 저장 : %s' ,[sDir + Format('%s-%s%s', [NAME_PREF, sPoFName_, EXT_PROP])], 1);
|
|
|
|
end else
|
|
if ORecent_ <> nil then
|
|
begin
|
|
// 정책 파일 삭제 될때 복구를 위해 추가 23_0216 14:02:32 kku
|
|
if bSaveAble_ then
|
|
begin
|
|
if ORecent_.S['mwPKey_LOCNAME'] <> '' then
|
|
begin
|
|
Guard(ss, TStringStream.Create(
|
|
EncStrToBinStr(ekAes256cbc, PASS_MODEL, ORecent_.AsString), TEncoding.UTF8));
|
|
|
|
if ForceDirectories(sDir) then
|
|
ss.SaveToFile(sDir + DAT_PREF);
|
|
end;
|
|
end;
|
|
end;
|
|
except
|
|
{$IFDEF DEBUG}
|
|
on E: Exception do
|
|
ETgException.TraceException(Self, E, 'Fail .. Save()');
|
|
{$ENDIF}
|
|
// ..
|
|
end;
|
|
end;
|
|
|
|
function BooleanStr(S: String): Boolean; inline;
|
|
begin
|
|
Result := S.ToLower = 'true';
|
|
end;
|
|
|
|
// 2.6.x 이하에서 사용
|
|
function TPrefModel.SetPrefModel(aO: ISuperObject): Boolean;
|
|
var
|
|
sHash: String;
|
|
begin
|
|
Result := false;
|
|
try
|
|
if aO = nil then
|
|
exit;
|
|
|
|
sHash := ConvStrToSha1W(aO.AsString);
|
|
if (sHash = '') or (sHash = sCheckHash_) then
|
|
exit;
|
|
|
|
if LoadFromJsonObj_Old(aO) then
|
|
begin
|
|
sCheckHash_ := sHash;
|
|
ORecent_ := aO;
|
|
Save;
|
|
Result := true;
|
|
end;
|
|
except
|
|
on E: Exception do
|
|
ETgException.TraceException(Self, E, 'Fail .. SetPrefModel()');
|
|
end;
|
|
end;
|
|
|
|
// 2.7.x 이상에서 사용
|
|
function TPrefModel.SetPolicy(sPoId: String; aO: ISuperObject; CP: Boolean): Boolean;
|
|
begin
|
|
Result := true;
|
|
try
|
|
sPoId_ := sPoId;
|
|
if aO.S['PolicyGroup'] = '' then
|
|
begin
|
|
LoadFromJsonObj(aO, CP);
|
|
end else
|
|
SetPolicyFromJsonObj(aO);
|
|
|
|
Save;
|
|
except
|
|
on E: Exception do
|
|
begin
|
|
Result := false;
|
|
ETgException.TraceException(Self, E, 'Fail .. SetPolicy()');
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
function TPrefModel.SetMngPolicy(aO: ISuperObject; CP: Boolean): Boolean;
|
|
var
|
|
sTemp: String;
|
|
i: Integer;
|
|
O: ISuperObject;
|
|
begin
|
|
try
|
|
IsVpnAndCondition := BooleanStr(aO.S[MgPo_.GetPoKey('MNG_SECUMODEANDOR', CP)]);
|
|
|
|
sTemp := '';
|
|
if aO.S[MgPo_.GetPoKey('MNG_SECUMODEAPP', CP)].ToLower = 'true' then
|
|
SumString(sTemp, 'app', ';');
|
|
if BooleanStr(aO.S[MgPo_.GetPoKey('MNG_SECUMODEVPN', CP)]) then
|
|
SumString(sTemp, 'nic', ';');
|
|
if BooleanStr(aO.S[MgPo_.GetPoKey('MNG_SECUMODERC', CP)]) then
|
|
SumString(sTemp, 'rc', ';');
|
|
if BooleanStr(aO.S[MgPo_.GetPoKey('MNG_SECUMODEET', CP)]) then
|
|
SumString(sTemp, 'et', ';');
|
|
if BooleanStr(aO.S[MgPo_.GetPoKey('MNG_SECUMODETIME', CP)]) then
|
|
SumString(sTemp, 'hour', ';');
|
|
if BooleanStr(aO.S[MgPo_.GetPoKey('MNG_SECUMODEALLTIME', CP)]) then
|
|
SumString(sTemp, 'time', ';');
|
|
if BooleanStr(aO.S[MgPo_.GetPoKey('MNG_SECUMODEIP', CP)]) then
|
|
SumString(sTemp, 'ip', ';');
|
|
VpnIpList := StrListToCommaStr(aO.S[MgPo_.GetPoKey('MNG_SECUMODEIPRANGE', CP)], ','); // 저장된거 호환을 위해 | 대신 , 계속 사용 25_0915 16:09:11 kku
|
|
if VpnMethod <> sTemp then
|
|
VpnMethod := sTemp;
|
|
|
|
sTemp := '';
|
|
if BooleanStr(aO.S[MgPo_.GetPoKey('MNG_SECUMODERCZOOM', CP)]) then
|
|
SumString(sTemp, 'zo', ';');
|
|
if BooleanStr(aO.S[MgPo_.GetPoKey('MNG_SECUMODERCCISCO', CP)]) then
|
|
SumString(sTemp, 'we', ';');
|
|
if BooleanStr(aO.S[MgPo_.GetPoKey('MNG_SECUMODERCWHALE', CP)]) then
|
|
SumString(sTemp, 'wh', ';');
|
|
if BooleanStr(aO.S[MgPo_.GetPoKey('MNG_SECUMODERCCURIX', CP)]) then
|
|
SumString(sTemp, 'cu', ';');
|
|
if VpnRcAppList <> sTemp then
|
|
VpnRcAppList := sTemp;
|
|
|
|
sTemp := aO.S[MgPo_.GetPoKey('MNG_SECUMODETIMESTART', CP)];
|
|
if sTemp <> '' then
|
|
sTemp := sTemp + ';' + aO.S[MgPo_.GetPoKey('MNG_SECUMODETIMEEND', CP)];
|
|
if VpnHour <> sTemp then
|
|
VpnHour := sTemp;
|
|
IsAllowAccess := BooleanStr(aO.S[MgPo_.GetPoKey('MNG_SECUALLOWSECUMODE', CP)]);
|
|
// todo : 2.7서버에서 IsRestricDate 처리 필요 24_0110 08:41:57 kku
|
|
// IsAllowAccess := IsAllowAccess or not IsRestricDate;
|
|
IsTemporaryConn := BooleanStr(aO.S[MgPo_.GetPoKey('MNG_SECUALLOWTEMP', CP)]);
|
|
TemporaryConnMin := StrToIntDef(aO.S[MgPo_.GetPoKey('MNG_SECUALLOWTEMPTIME', CP)], 10);
|
|
IsMustSecuApp := BooleanStr(aO.S[MgPo_.GetPoKey('MNG_SECUWHITELISTAPP', CP)]);
|
|
SoftwareListW := StrListToCommaStr(aO.S[MgPo_.GetPoKey('MNG_SECUAPPLIST', CP)], ';');
|
|
IsSecuEndActions := BooleanStr(aO.S[MgPo_.GetPoKey('MNG_SECUENDACTION', CP)]); // 보안 모드 종료 동작
|
|
sTemp := '';
|
|
if BooleanStr(aO.S[MgPo_.GetPoKey('MNG_SECUENDCLOSEAPP', CP)]) then
|
|
SumString(sTemp, 'app', ';');
|
|
|
|
if BooleanStr(aO.S[MgPo_.GetPoKey('MNG_SECUENDCLOSEVPN', CP)]) then
|
|
SumString(sTemp, 'vnic', ';');
|
|
|
|
if BooleanStr(aO.S[MgPo_.GetPoKey('MNG_SECUENDCLOSENET', CP)]) then
|
|
SumString(sTemp, 'net', ';');
|
|
|
|
if UnsafeActions <> sTemp then
|
|
UnsafeActions := sTemp;
|
|
IsUnsafeActions := BooleanStr(aO.S[MgPo_.GetPoKey('MNG_SECUENDDELAYENABLE', CP)]); // 보안 모드 종료 동작 > 대기시간 사용
|
|
UnsafeActionsMin := StrToIntDef(aO.S[MgPo_.GetPoKey('MNG_SECUENDDELAYTIME', CP)], 10);
|
|
IsShowAInfo := BooleanStr(aO.S[MgPo_.GetPoKey('MNG_DISPLAYAGENTINFO', CP)]);
|
|
sTemp := aO.S[MgPo_.GetPoKey('MNG_SHOWPOLICY', CP)].ToLower;
|
|
IsShowPolicy := (sTemp <> '') and (sTemp <> 'false');
|
|
if sTemp = 'enabled' then
|
|
PoViewKind := pvkEnabled
|
|
else if sTemp = 'disabled' then
|
|
PoViewKind := pvkDisabled
|
|
else
|
|
PoViewKind := pvkAll;
|
|
|
|
IsEmpVerify := BooleanStr(aO.S[MgPo_.GetPoKey('MNG_EMPVERIFY', CP)]);
|
|
// MNG_EMPCHANGEEULA // 사번 검증 시 동의
|
|
// MNG_EMPCHANGEOTP // 사번 검증 OTP
|
|
IsLongtimeDisconn := BooleanStr(aO.S[MgPo_.GetPoKey('MNG_INACTIVELOCK', CP)]);
|
|
// MNG_INACTIVEDATE // 미접속 PC 관리
|
|
// MNG_INACTIVEBLOCKSECURITY // [대응] 보안 모드 차단
|
|
// MNG_INACTIVEBLOCKCONNECT // [대응] 서버 접속 차단
|
|
// MNG_INACTIVEUNINSTALL // [대응] 에이전트 삭제
|
|
if BooleanStr(aO.S[MgPo_.GetPoKey('MNG_ENABLESCRNLOCK', CP)]) then // 화면 잠금 사용
|
|
begin
|
|
IsStartupScreenLock := BooleanStr(aO.S[MgPo_.GetPoKey('MNG_STARTSCRNLOCK', CP)]);
|
|
ScreenLockPwd := aO.S[MgPo_.GetPoKey('MNG_SCRNPASSWORD', CP)];
|
|
if (ScreenLockPwd <> '') and
|
|
( (ScreenLockPwd.ToLower = 'false') or (ScreenLockPwd.ToLower = 'null') ) then
|
|
ScreenLockPwd := '';
|
|
|
|
if BooleanStr(aO.S[MgPo_.GetPoKey('MNG_IDLESCRNLOCK', CP)]) and BooleanStr(aO.S[MgPo_.GetPoKey('MNG_IDLEWINLOCK', CP)]) then
|
|
ScreenLockKind := slkBoth
|
|
else if BooleanStr(aO.S[MgPo_.GetPoKey('MNG_IDLEWINLOCK', CP)]) then
|
|
ScreenLockKind := slkDef
|
|
else if BooleanStr(aO.S[MgPo_.GetPoKey('MNG_IDLESCRNLOCK', CP)]) then
|
|
ScreenLockKind := slkCustom
|
|
else
|
|
ScreenLockKind := slkNone;
|
|
ForceScreenLock := aO.S[MgPo_.GetPoKey('MNG_IDLESCRNTIME', CP)];
|
|
ForceScreenLockMin := StrToIntDef(ForceScreenLock, 0);
|
|
end else begin
|
|
IsStartupScreenLock := false;
|
|
ScreenLockPwd := '';
|
|
ScreenLockKind := slkNone;
|
|
ForceScreenLock := '';
|
|
ForceScreenLockMin := 0;
|
|
end;
|
|
|
|
IsForceShutdown := BooleanStr(aO.S[MgPo_.GetPoKey('MNG_SYSTEMOFF', CP)]);
|
|
ForceShutdownMin := StrToIntDef(aO.S[MgPo_.GetPoKey('MNG_SYSTEMOFFTIME', CP)], 0);
|
|
IsEnableCheck := BooleanStr(aO.S[MgPo_.GetPoKey('MNG_VULENABLE', CP)]);
|
|
sTemp := aO.S[MgPo_.GetPoKey('MNG_VULDUETIME', CP)].ToLower;
|
|
if sTemp = 'twomin' then
|
|
VulDueTimeSec := 120
|
|
else if sTemp = 'fivemin' then
|
|
VulDueTimeSec := 300
|
|
else
|
|
VulDueTimeSec := StrToIntDef(sTemp, 0);
|
|
sTemp := aO.S[MgPo_.GetPoKey('MNG_VULOSPATCH', CP)].ToLower;
|
|
if sTemp = 'true' then
|
|
OsPatchCheck := opcCheck
|
|
else if sTemp = 'popup' then
|
|
OsPatchCheck := opcPopup
|
|
else if sTemp = 'logonly' then
|
|
OsPatchCheck := opcLog
|
|
else
|
|
OsPatchCheck := opcNone;
|
|
// MNG_VULPIRESULT // 개인정보보유 점검, old : KEY_BLOCKBYSCAN
|
|
// MNG_VULPIRESULTCNT // 개인정보보유량, old : KEY_BLOCKBYSCANCNT
|
|
// MNG_VULPIRESPDRM // 검출 파일 암호화, old : KEY_BLOCKBYSCANRESP
|
|
// MNG_VULPIRESPDEL // 검출 파일 완전삭제, old : KEY_BLOCKBYSCANRESP
|
|
sTemp := aO.S[MgPo_.GetPoKey('MNG_VULPWDCHECK', CP)].ToLower;
|
|
if sTemp = 'popup' then
|
|
PwChkTerm := pctPopup
|
|
else if sTemp = 'logonly' then
|
|
PwChkTerm := pctLog
|
|
else if sTemp = 'true' then
|
|
PwChkTerm := pctBlock
|
|
else
|
|
PwChkTerm := pctNone;
|
|
PwChkTermDay := StrToIntDef(aO.S[MgPo_.GetPoKey('MNG_VULPWDCHECKPERIOD', CP)], 0);
|
|
BlockChangeTime := BooleanStr(aO.S[MgPo_.GetPoKey('MNG_SYSTEMTIMEPROTECT', CP)]);
|
|
HealthCheckMilSec := StrToIntDef(aO.S[MgPo_.GetPoKey('MNG_HEALTHCHECKTIME', CP)], 3) * 1000;
|
|
HideMainUI := BooleanStr(aO.S[MgPo_.GetPoKey('MNG_DISABLEUI', CP)]);
|
|
|
|
SecuExitWaitSec := StrToIntDef(aO.S[MgPo_.GetPoKey('MNG_SECUMODEDELAY', CP)], 0);
|
|
|
|
// 취약점 점검 정책
|
|
VulOsVersion := BooleanStr(aO.S[MgPo_.GetPoKey('MNG_VULOSVERSION', CP)]);
|
|
VulAntiVirus := BooleanStr(aO.S[MgPo_.GetPoKey('MNG_VULANTIVIRUS', CP)]);
|
|
VulPassword := BooleanStr(aO.S[MgPo_.GetPoKey('MNG_VULPASSWORD', CP)]);
|
|
VulScreenSaver := BooleanStr(aO.S[MgPo_.GetPoKey('MNG_VULSCREENSAVER', CP)]);
|
|
VulFirewall := BooleanStr(aO.S[MgPo_.GetPoKey('MNG_VULFIREWALL', CP)]);
|
|
|
|
PersonalInfoFileMax := StrToIntDef(aO.S[MgPo_.GetPoKey('MNG_VULPIRESULTCNT', CP)], 0);
|
|
|
|
// 허용 MAC, 이 MAC이 없는 경우 차단 23_1120 14:03:45 kku
|
|
CheckAllowMAC := BooleanStr(aO.S[MgPo_.GetPoKey('MNG_SECUMODEMAC', CP)]) or BooleanStr(aO.S[MgPo_.GetPoKey('MNG_VULMACCHECK', CP)]);
|
|
if CheckAllowMAC then
|
|
RestricMac := aO.S[MgPo_.GetPoKey('MNG_LIMITMAC', CP)].ToUpper
|
|
else
|
|
RestricMac := '';
|
|
|
|
// 에이전트 삭제 정책
|
|
if aO.S[MgPo_.GetPoKey('MNG_AGENTDELETEENABLE', CP)] <> '' then
|
|
begin
|
|
// System 설정에서 Management 설정으로 변경됨.
|
|
// 아래는 이전 서버 버전과 호환을 위해 남겨둠 23_1207 13:36:51 kku
|
|
IsUninstallAble := BooleanStr(aO.S[MgPo_.GetPoKey('MNG_AGENTDELETEENABLE', CP)]);
|
|
if IsUninstallAble then
|
|
begin
|
|
sTemp := aO.S[MgPo_.GetPoKey('MNG_AGENTDELETEOPTION', CP)].ToLower;
|
|
if sTemp = 'password' then
|
|
begin
|
|
UninstKind := uikPassword;
|
|
sTemp := aO.S[MgPo_.GetPoKey('mng_agentDeletePw', CP)];
|
|
if sTemp <> '' then
|
|
UninstallPW := ':' + sTemp
|
|
else
|
|
UninstallPW := aO.S[MgPo_.GetPoKey('MNG_AGENTDELETEPASSWORD', CP)];
|
|
end else if sTemp = 'otp' then
|
|
UninstKind := uikOTP
|
|
else if sTemp = 'deletecode' then
|
|
UninstKind := uikCode
|
|
else
|
|
UninstKind := uikNormal;
|
|
end;
|
|
end;
|
|
|
|
// Agent 관리
|
|
O := nil;
|
|
try
|
|
O := SO(aO.S[MgPo_.GetPoKey('mng_agentCustCfg', CP)]);
|
|
except
|
|
|
|
end;
|
|
|
|
if O <> nil then
|
|
begin
|
|
LogLv := O.I['LogLv'];
|
|
LogEnc := O.B['LogEnc'];
|
|
AipOff := O.B['AipOff'];
|
|
TextLimit := O.I['TextLimit'];
|
|
if TextLimit <= 0 then
|
|
TextLimit := 8000;
|
|
PrtDPI := O.I['PrtDPI'];
|
|
case PrtDPI of
|
|
100, 200, 300,
|
|
400, 500, 600 : ;
|
|
else PrtDPI := nDefPrtDPI_;
|
|
end;
|
|
ChkConSec := O.I['ChkConSec'];
|
|
if ChkConSec = 0 then
|
|
ChkConSec := 10
|
|
else if ChkConSec > 999 then
|
|
ChkConSec := 999;
|
|
DrmPopupNo := O.B['DrmPopupNo'];
|
|
PrtPopupNo := O.B['PrtPopupNo'];
|
|
PrtWaterPop := O.B['PrtWaterPop'];
|
|
OpenDetect := O.B['OpenDetect'];
|
|
IgrNetPathAB := O.B['IgrNetPathAB'];
|
|
CodePo := O.B['CodePo'];
|
|
NoOutlRcvr := O.B['NoOutlRcvr'];
|
|
PrtNameH := O.S['PrtNameH'];
|
|
if PrtNameH = '' then
|
|
PrtNameH := 'CANON';
|
|
PrtWaterAppH := O.S['PrtWaterAppH'];
|
|
PrtWaterAppHig := O.S['PrtWaterAppHig'];
|
|
SmbPortEx := O.S['SmbPortEx'];
|
|
AipEncMSec := O.I['AipEncMSec'];
|
|
CfFblkExts := O.S['CfFblkExts'];
|
|
WebAbExts := O.S['WebAbExts'];
|
|
EtcAbExts := O.S['EtcAbExts'];
|
|
LogKeepDays := O.I['LogKeepDays'];
|
|
if LogKeepDays = 0 then
|
|
LogKeepDays := 10;
|
|
BtConNotiDSec := O.I['BtConNotiDSec'];
|
|
SplitString(UpperCase(O.S['GetPrtOcrTxt']), '|', PrtOcrTxtExtList);
|
|
|
|
IgnoreDriverLoad := O.B['IgnoreDriverLoad'];
|
|
end;
|
|
|
|
Save;
|
|
except
|
|
on E: Exception do
|
|
ETgException.TraceException(Self, E, 'Fail .. SetMngPolicy()');
|
|
end;
|
|
end;
|
|
|
|
function TPrefModel.SetSetPolicy(aO: ISuperObject; CP: Boolean): Boolean;
|
|
var
|
|
sTemp: String;
|
|
begin
|
|
try
|
|
sTemp := aO.S[MgPo_.GetPoKey('KEY_AGENTDELETEENABLE', CP)];
|
|
if sTemp <> '' then
|
|
begin
|
|
// System 설정에서 Management 설정으로 변경됨.
|
|
// 아래는 이전 서버 버전과 호환을 위해 남겨둠 23_1207 13:36:51 kku
|
|
IsUninstallAble := BooleanStr(sTemp);
|
|
if IsUninstallAble then
|
|
begin
|
|
sTemp := aO.S[MgPo_.GetPoKey('KEY_AGENTDELETEOPTION', CP)].ToLower;
|
|
if sTemp = 'password' then
|
|
begin
|
|
UninstKind := uikPassword;
|
|
UninstallPW := aO.S[MgPo_.GetPoKey('KEY_AGENTDELETEPASSWORD', CP)]
|
|
end else if sTemp = 'otp' then
|
|
UninstKind := uikOTP
|
|
else
|
|
UninstKind := uikNormal;
|
|
end;
|
|
end;
|
|
VpnAppName := StrListToCommaStr(aO.S[MgPo_.GetPoKey('KEY_VPNAPPNAME', CP)], ';');
|
|
UseExpPo := BooleanStr(aO.S[MgPo_.GetPoKey('KEY_OFFLINEKEYENABLE', CP)]);
|
|
sTemp := aO.S[MgPo_.GetPoKey('KEY_OFFLINEKEYENABLE', CP)].ToLower;
|
|
if sTemp = 'oneday' then
|
|
ExpPoMin := 9999 // 하루, 24시간이 아니고 날짜가 바뀌면 끝
|
|
else
|
|
ExpPoMin := StrToIntDef(sTemp, 0);
|
|
UseExpPo := ExpPoMin <> 0;
|
|
IsEulaSubmit := BooleanStr(aO.S[MgPo_.GetPoKey('KEY_EULAENABLE', CP)]);
|
|
EulaTitle := aO.S[MgPo_.GetPoKey('KEY_EULATITLE', CP)];
|
|
EulaBody := aO.S[MgPo_.GetPoKey('KEY_EULABODY', CP)];
|
|
IsUseAfterReport := BooleanStr(aO.S[MgPo_.GetPoKey('KEY_WORKREPORTENABLE', CP)]);
|
|
IsDailyEulaCheck := BooleanStr(aO.S[MgPo_.GetPoKey('KEY_EULADAILYCHECK', CP)]);
|
|
IsNoticeEnable := BooleanStr(aO.S[MgPo_.GetPoKey('KEY_NOTICEENABLE', CP)]);
|
|
NoticeContent := aO.S[MgPo_.GetPoKey('KEY_NOTICEBODY', CP)];
|
|
IsTempGroup := BooleanStr(aO.S[MgPo_.GetPoKey('KEY_TEMPUSERGROUPENABLE', CP)]);
|
|
|
|
IsAgentUpdateExist := BooleanStr(aO.S[MgPo_.GetPoKey('KEY_ENABLEPATCH', CP)]);
|
|
IsFixedVerUpdate := BooleanStr(aO.S[MgPo_.GetPoKey('KEY_FIXEDVERUP', CP)]);
|
|
AgentPatchVersion := aO.S[MgPo_.GetPoKey('KEY_AGENTPATCHVERSION', CP)];
|
|
AgentPatchExeName := aO.S[MgPo_.GetPoKey('KEY_AGENTPATCHFILENAME', CP)];
|
|
xPrintUpVer := aO.S[MgPo_.GetPoKey('key_xPrintPatchVer', CP)];
|
|
xPrintUpEnable := BooleanStr(aO.S[MgPo_.GetPoKey('key_xPrintPatchEnable', CP)]);
|
|
xPrintUpFixedVer := BooleanStr(aO.S[MgPo_.GetPoKey('key_xPrintSetFixedVersion', CP)]);
|
|
|
|
if BooleanStr(aO.S[MgPo_.GetPoKey('KEY_OFFLINELOGTYPE', CP)]) then
|
|
OffLogKind := olkCollect
|
|
else
|
|
OffLogKind := olkNone;
|
|
OffLogDays := StrToIntDef(aO.S[MgPo_.GetPoKey('KEY_OFFLINEMAXDATE', CP)], 0);
|
|
UseOffLogDay := BooleanStr(aO.S[MgPo_.GetPoKey('KEY_OFFLINEPERIODENABLE', CP)]);
|
|
UseOffLogMaxMB := BooleanStr(aO.S[MgPo_.GetPoKey('KEY_OFFLINESIZEENABLE', CP)]);
|
|
OffLogMaxMB := StrToIntDef(aO.S[MgPo_.GetPoKey('KEY_EULABODY', CP)], 0);
|
|
|
|
Save;
|
|
except
|
|
on E: Exception do
|
|
ETgException.TraceException(Self, E, 'Fail .. SetSetPolicy()');
|
|
end;
|
|
end;
|
|
|
|
function TPrefModel.LoadFromJsonObj(aO: ISuperObject; CP: Boolean): Boolean;
|
|
|
|
function GetJsonObj(const sKeyName: String): ISuperObject;
|
|
begin
|
|
try
|
|
Result := SO(aO.S[MgPo_.GetPoKey(sKeyName, CP)]);
|
|
except
|
|
Result := SO;
|
|
end;
|
|
end;
|
|
|
|
function GetIniBlockFileNew(const sKeyName: string): TIntBlockNewFile;
|
|
var
|
|
i: Integer;
|
|
O: ISuperObject;
|
|
sTemp: String;
|
|
begin
|
|
O := GetJsonObj(sKeyName);
|
|
var mode := O.S['mode'];
|
|
if mode = 'true' then
|
|
Result.mode := abkBlock
|
|
else if mode ='log' then
|
|
Result.mode := abkLog
|
|
else
|
|
Result.mode := abkNone;
|
|
|
|
Result.userAlert := O.B['userAlert'];
|
|
Result.origTextCol := O.B['origTextCol'];
|
|
Result.fileNameChk := O.B['fileNameChk'];
|
|
|
|
if O.O['origFileCol'] <> nil then
|
|
begin
|
|
Result.origFileCol_use := O.O['origFileCol'].B['use'];
|
|
Result.origFileCol_maxMb := O.O['origFileCol'].I['maxMb'];
|
|
Result.origFileCol_minMb := O.O['origFileCol'].I['minMb'];
|
|
end else begin
|
|
Result.origFileCol_use := False;
|
|
end;
|
|
|
|
if (O.O['extList'] <> nil) and (O.O['extList'].DataType = stArray) then
|
|
begin
|
|
sTemp := '';
|
|
for i := 0 to O.A['extList'].Length - 1 do
|
|
SumString(sTemp, O.A['extList'].S[i], '|');
|
|
Result.extList := sTemp;
|
|
end;
|
|
|
|
if (O.O['excList'] <> nil) and (O.O['excList'].DataType = stArray) then
|
|
begin
|
|
sTemp := '';
|
|
for i := 0 to O.A['excList'].Length - 1 do
|
|
SumString(sTemp, O.A['excList'].S[i], '|');
|
|
Result.excList := sTemp;
|
|
end;
|
|
|
|
if O.O['contentsFilter'] <> nil then
|
|
begin
|
|
Result.contentsFilter_use := O.O['contentsFilter'].B['use'];
|
|
if Result.contentsFilter_use then
|
|
begin
|
|
if (O.O['contentsFilter'].O['list'] <> nil) and (O.O['contentsFilter'].O['list'].DataType = stArray) then
|
|
begin
|
|
sTemp := '';
|
|
for i := 0 to O.O['contentsFilter'].A['list'].Length - 1 do
|
|
SumString(sTemp, O.O['contentsFilter'].A['list'].S[i], '|');
|
|
Result.contentsFilter_list := sTemp;
|
|
end;
|
|
end;
|
|
|
|
|
|
end else begin
|
|
Result.origFileCol_use := False;
|
|
end;
|
|
|
|
if O.O['blockByFilename'] <> nil then
|
|
begin
|
|
Result.blockByFilename_use := O.O['blockByFilename'].B['use'];
|
|
if Result.blockByFilename_use then
|
|
begin
|
|
if (O.O['blockByFilename'].O['list'] <> nil) and (O.O['blockByFilename'].O['list'].DataType = stArray) then
|
|
begin
|
|
sTemp := '';
|
|
for i := 0 to O.O['blockByFilename'].A['list'].Length - 1 do
|
|
SumString(sTemp, O.O['blockByFilename'].A['list'].S[i], '|');
|
|
Result.blockByFilename_list := sTemp;
|
|
end;
|
|
end;
|
|
|
|
end else begin
|
|
Result.blockByFilename_use := False;
|
|
end;
|
|
|
|
if O.O['blockBySig'] <> nil then
|
|
begin
|
|
Result.blockBySig_use := O.O['blockBySig'].B['use'];
|
|
if Result.blockBySig_use then
|
|
begin
|
|
if (O.O['blockBySig'].O['list'] <> nil) and (O.O['blockBySig'].O['list'].DataType = stArray) then
|
|
begin
|
|
sTemp := '';
|
|
for i := 0 to O.O['blockBySig'].A['list'].Length - 1 do
|
|
SumString(sTemp, O.O['blockBySig'].A['list'].S[i], '|');
|
|
Result.blockBySig_list := sTemp;
|
|
end;
|
|
end;
|
|
|
|
end else begin
|
|
Result.blockBySig_use := False;
|
|
end;
|
|
|
|
if O.O['blockBySizeLimit'] <> nil then
|
|
begin
|
|
Result.blockBySizeLimit_use := O.O['blockBySizeLimit'].B['use'];
|
|
Result.blockBySizeLimit_minMb := O.O['blockBySizeLimit'].I['minMb'];
|
|
end else begin
|
|
Result.blockBySizeLimit_use := False;
|
|
end;
|
|
|
|
end;
|
|
var
|
|
sTemp: String;
|
|
i: Integer;
|
|
O: ISuperObject;
|
|
begin
|
|
try
|
|
if BooleanStr(aO.S[MgPo_.GetPoKey('INT_MONITORINSTALL', CP)]) then
|
|
AppInstKind := aikLog // aikPopup // 기본 팝업 뜨기 않게 수정 24_0726 12:21:28 kku
|
|
else
|
|
AppInstKind := aikNone;
|
|
|
|
// 일단 항상 켜둠 24_0223 10:36:55 kku
|
|
UseFileTag := true;
|
|
|
|
sTemp := aO.S[MgPo_.GetPoKey('INT_BLOCKAPPUSE', CP)].ToLower;
|
|
if sTemp = 'true' then
|
|
begin
|
|
IsBlockApp := true;
|
|
IsBlockAppLog := false;
|
|
end else if sTemp = 'log' then
|
|
begin
|
|
IsBlockApp := true;
|
|
IsBlockAppLog := true;
|
|
end else begin
|
|
IsBlockApp := false;
|
|
IsBlockAppLog := false;
|
|
end;
|
|
IsBlockAppNotice := BooleanStr(aO.S[MgPo_.GetPoKey('INT_BLOCKAPPNOTICE', CP)]);
|
|
SoftwareListB := StrListToCommaStr(aO.S[MgPo_.GetPoKey('INT_BLOCKSWLIST', CP)], '|');
|
|
|
|
// APP 사용 감시 기능 추가 25_0120 17:06:42 kku
|
|
O := GetJsonObj('int_monitorAppUsage');
|
|
if O <> nil then
|
|
begin
|
|
IsMonApp := O.S['mode'].ToLower = 'true';
|
|
IsMonAppNoti := O.B['noti'];
|
|
sTemp := '';
|
|
if (O.O['appList'] <> nil) and (O.O['appList'].DataType = stArray) then
|
|
begin
|
|
for i := 0 to O.A['appList'].Length - 1 do
|
|
SumString(sTemp, O.A['appList'].S[i], '|');
|
|
end;
|
|
if sTemp <> MonAppList then
|
|
MonAppList := sTemp;
|
|
end else
|
|
IsMonApp := false;
|
|
|
|
AppBlackDateB := StrToDateDef(aO.S[MgPo_.GetPoKey('INT_APPDAYSTART', CP)], 0);
|
|
IsAppBlackDate := BooleanStr(aO.S[MgPo_.GetPoKey('INT_APPDAYBLOCK', CP)]);
|
|
if AppBlackDateB <> 0 then
|
|
AppBlackDateB := AppendTime(AppBlackDateB, 0, 0, 0, 0);
|
|
AppBlackDateE := StrToDateDef(aO.S[MgPo_.GetPoKey('INT_APPDAYEND', CP)], 0);
|
|
if AppBlackDateE <> 0 then
|
|
AppBlackDateE := AppendTime(AppBlackDateE, 23, 59, 59, 0);
|
|
IsAppBlackTime := BooleanStr(aO.S[MgPo_.GetPoKey('INT_APPHOURBLOCK', CP)]);
|
|
AppBlackTimeB := StrToIntDef(aO.S[MgPo_.GetPoKey('INT_APPHOURSTART', CP)], -1);
|
|
AppBlackTimeE := StrToIntDef(aO.S[MgPo_.GetPoKey('INT_APPHOUREND', CP)], -1);
|
|
sTemp := aO.S[MgPo_.GetPoKey('INT_WIFIPREVENT', CP)].ToLower;
|
|
if sTemp = 'popup' then
|
|
WifiCtrlKind := wckPopup
|
|
else if sTemp = 'true' then
|
|
WifiCtrlKind := wckBlock
|
|
else if (sTemp = 'blockname') or (sTemp = 'partial') then
|
|
WifiCtrlKind := wckBlockName
|
|
else if (sTemp = 'whitelist') or (sTemp = 'except') then
|
|
WifiCtrlKind := wckWhiteName
|
|
else if (sTemp = 'logonly') or (sTemp = 'log') then
|
|
WifiCtrlKind := wckLog
|
|
else
|
|
WifiCtrlKind := wckNone;
|
|
WifiBlockPopup := BooleanStr(aO.S[MgPo_.GetPoKey('int_wifiPreventNotice', CP)]);
|
|
WifiAllowPopup := BooleanStr(aO.S[MgPo_.GetPoKey('int_wifiPreventAllowNotice', CP)]);
|
|
IsWifiPublicBlock := BooleanStr(aO.S[MgPo_.GetPoKey('INT_WIFIPREVENTPWD', CP)]);
|
|
IsMobileHotspotExp := BooleanStr(aO.S[MgPo_.GetPoKey('int_wifiHotspotException', CP)]);
|
|
WifiBlockNames := StrListToCommaStr(aO.S[MgPo_.GetPoKey('INT_WIFINAMELIST', CP)], ';');
|
|
WifiGpsOn := BooleanStr(aO.S[MgPo_.GetPoKey('int_wifiBlockGpsEnable', CP)]);
|
|
HostEnable := BooleanStr(aO.S[MgPo_.GetPoKey('INT_HOSTFILEBLOCK', CP)]);
|
|
RouteEnable := BooleanStr(aO.S[MgPo_.GetPoKey('INT_ROUTINGBLOCK', CP)]);
|
|
IsDefPortBlock := BooleanStr(aO.S[MgPo_.GetPoKey('INT_DEFPORTDISABLE', CP)]);
|
|
if BooleanStr(aO.S[MgPo_.GetPoKey('INT_EXTRAPORTWHITELIST', CP)]) then
|
|
ExtraPortEnableType := PREF_PORTEX_WHITE
|
|
else if BooleanStr(aO.S[MgPo_.GetPoKey('INT_EXTRAPORTDISABLE', CP)]) then
|
|
ExtraPortEnableType := PREF_PORTEX_BLACK
|
|
else
|
|
ExtraPortEnableType := PREF_PORTEX_FALSE;
|
|
// 포트제어, IP 예외
|
|
IsSmbPortBlock := BooleanStr(aO.S[MgPo_.GetPoKey('int_portBlockSmb', CP)]);
|
|
O := GetJsonObj('int_portExceptIpList');
|
|
if (O <> nil) and (O.DataType = stArray) then
|
|
begin
|
|
sTemp := '';
|
|
for i := 0 to O.AsArray.Length do
|
|
begin
|
|
if O.AsArray.S[i] <> '' then
|
|
SumString(sTemp, O.AsArray.S[i], ',');
|
|
end;
|
|
if SMBPortExceptList <> sTemp then
|
|
SMBPortExceptList := sTemp;
|
|
end else if SMBPortExceptList <> '' then
|
|
SMBPortExceptList := '';
|
|
BlockPortList := aO.S[MgPo_.GetPoKey('INT_BLOCKPORTLIST', CP)];
|
|
// 모든 접속 제어 (APP 접속 차단과 같은 변수 사용)
|
|
sTemp := aO.S[MgPo_.GetPoKey('INT_BLOCKCONNECT', CP)].ToLower;
|
|
if sTemp = 'true' then
|
|
begin
|
|
NetworkBlockType := PREF_NETAPP_WHITELIST;
|
|
NetworkBlockList := '<none>'; // 여기 빈값 넣으면 정책이 동작하지 않음
|
|
NetworkExceptList := '';
|
|
end else begin
|
|
if sTemp = 'partial' then
|
|
NetworkBlockType := PREF_NETIP_BLACKLIST
|
|
else if sTemp = 'except' then
|
|
NetworkBlockType := PREF_NETIP_WHITELIST
|
|
else
|
|
NetworkBlockType := '';
|
|
|
|
if NetworkBlockType <> '' then
|
|
begin
|
|
NetworkBlockList := aO.S[MgPo_.GetPoKey('INT_BLOCKCONNECTLIST', CP)];
|
|
NetworkExceptList := aO.S[MgPo_.GetPoKey('INT_BLOCKCONNECTEXCEPT', CP)];
|
|
end;
|
|
end;
|
|
// 모든 접속 제어, 특정 기간 적용
|
|
IsNetBlockDay := BooleanStr(aO.S[MgPo_.GetPoKey('INT_CONNECTDAYBLOCK', CP)]);
|
|
if IsNetBlockDay then
|
|
begin
|
|
NetBlockDayB := AppendTime(StrToDate(aO.S[MgPo_.GetPoKey('INT_CONNECTDAYSTART', CP)]), 0, 0, 0, 0);
|
|
NetBlockDayE := AppendTime(StrToDate(aO.S[MgPo_.GetPoKey('INT_CONNECTDAYEND', CP)]), 23, 59, 59, 0);
|
|
end;
|
|
|
|
// APP 접속 차단 (모든 접속 제어와 같은 변수 사용)
|
|
sTemp := aO.S[MgPo_.GetPoKey('INT_APPCONNBLOCK', CP)].ToLower;
|
|
if sTemp = 'true' then
|
|
begin
|
|
NetworkBlockType := PREF_NETAPP_WHITELIST;
|
|
NetworkBlockList := '<none>'; // 여기 빈값 넣으면 정책이 동작하지 않음
|
|
NetworkExceptList := '';
|
|
end else
|
|
if NetworkBlockType = '' then // 모든 접속 제어가 설정 안되어 있을경우만 체크
|
|
begin
|
|
if sTemp = 'partial' then
|
|
NetworkBlockType := PREF_NETAPP_BLACKLIST
|
|
else if sTemp = 'except' then
|
|
NetworkBlockType := PREF_NETAPP_WHITELIST
|
|
else
|
|
NetworkBlockType := '';
|
|
|
|
if NetworkBlockType <> '' then
|
|
begin
|
|
NetworkBlockList := aO.S[MgPo_.GetPoKey('INT_APPCONNBLOCKLIST', CP)]; // APP 접속 차단
|
|
NetworkExceptList := aO.S[MgPo_.GetPoKey('INT_APPCONNEXCEPTLIST', CP)]; // APP 접속 차단 목록
|
|
end;
|
|
end;
|
|
|
|
// INT_BLOCKCONNECTNOTICE // 접속 제어, 사용자 알림 수행
|
|
// KEY_CONNECTDAYBLOCK // 접속 제어, 특정 기간 적용
|
|
// INT_CONNECTDAYSTART // 접속 제어, 기간 시작
|
|
// INT_CONNECTDAYEND // 접속 제어, 기간 종료
|
|
|
|
sTemp := aO.S[MgPo_.GetPoKey('INT_BROWSERBLOCK', CP)].ToLower;
|
|
if sTemp = 'true' then
|
|
WebbMonKind := wmkBlock
|
|
else if (sTemp = 'logonly') or (sTemp = 'log') then
|
|
begin
|
|
WebbMonKind := wmkIncPop; // 이걸로 해야 지정된 목록만 수집 기능이 적용됨 24_0723 17:15:48 kku
|
|
end
|
|
else if (sTemp = 'blockname') or (sTemp = 'partial') then
|
|
WebbMonKind := wmkIncBlock
|
|
else if (sTemp = 'whitelist') or (sTemp = 'except') then
|
|
WebbMonKind := wmkIncAllow
|
|
else if sTemp = 'popup' then
|
|
WebbMonKind := wmkIncPop
|
|
else if sTemp = 'logpart' then
|
|
WebbMonKind := wmkIncLog
|
|
else
|
|
WebbMonKind := wmkNone;
|
|
UrlBlockList := StrListToCommaStr(aO.S[MgPo_.GetPoKey('INT_BROWSERBLOCKLIST', CP)], '|');
|
|
UrlBlockExcpList := StrListToCommaStr(aO.S[MgPo_.GetPoKey('int_browserBlockExceptionList', CP)], '|');
|
|
sTemp := aO.S[MgPo_.GetPoKey('INT_BROWSERATTACHBLOCK', CP)].ToLower;
|
|
if sTemp = 'true' then
|
|
WebbAB.Kind := abkBlock
|
|
else
|
|
if sTemp = 'except' then
|
|
WebbAB.Kind := abkUrlAllow
|
|
else
|
|
if sTemp = 'partial' then
|
|
WebbAB.Kind := abkUrlBlock
|
|
else
|
|
if sTemp = 'log' then
|
|
WebbAB.Kind := abkLog
|
|
else
|
|
WebbAB.Kind := abkNone;
|
|
WebbAB.bPopup := BooleanStr(aO.S[MgPo_.GetPoKey('INT_BROWSERATTACHNOTICE', CP)]); // 브라우저 파일 차단, 사용자 알림 수행
|
|
// todo : 읽기, 쓰기 옵션 세분화
|
|
WebbAB.bReadBlock := BooleanStr(aO.S[MgPo_.GetPoKey('INT_BROWSERATTACHREADBLOCK', CP)]);
|
|
WebbAB.bWriteBlock := BooleanStr(aO.S[MgPo_.GetPoKey('INT_BROWSERATTACHWRITEBLOCK', CP)]);
|
|
WebABUrlList := StrListToCommaStr(aO.S[MgPo_.GetPoKey('INT_BROWSERATTACHLIST', CP)], '|');
|
|
WebbAB.bCollectTxt := BooleanStr(aO.S[MgPo_.GetPoKey('INT_BROWSERATTACHGETCONTENTS', CP)]); // 브라우저 파일 차단, 원문 수집
|
|
WebbAB.bCollectFile := BooleanStr(aO.S[MgPo_.GetPoKey('INT_BROWSERATTACHGETFILE', CP)]); // 브라우저 파일 차단, 파일 수집
|
|
sTemp := UpperCase(aO.S[MgPo_.GetPoKey('int_brFileUpAllow', CP)]);
|
|
WebbAB.bUpAllowLog := sTemp.Contains('UL:1');
|
|
WebbAB.bUpColAllowTxt := sTemp.Contains('UC:1');
|
|
WebbAB.bUpColAllowFile := sTemp.Contains('UF:1');
|
|
sTemp := UpperCase(aO.S[MgPo_.GetPoKey('int_brFileUpBlock', CP)]);
|
|
WebbAB.bUpBlockLog := sTemp.Contains('UBL:1');
|
|
WebbAB.bUpColBlockTxt := sTemp.Contains('UBC:1');
|
|
WebbAB.bUpColBlockFile := sTemp.Contains('UBF:1');
|
|
sTemp := UpperCase(aO.S[MgPo_.GetPoKey('int_brFileDownAllow', CP)]);
|
|
WebbAB.bDlAllowLog := sTemp.Contains('DL:1');
|
|
WebbAB.bDlColAllowTxt := sTemp.Contains('DC:1');
|
|
WebbAB.bDlColAllowFile := sTemp.Contains('DF:1');
|
|
WebbAB.bDlBlockLog := UpperCase(aO.S[MgPo_.GetPoKey('int_brFileDownBlock', CP)]) = 'DBL:1';
|
|
WebABLimitMB := StrToIntDef(aO.S[MgPo_.GetPoKey('int_browserAttachGetFileSize', CP)], 20);
|
|
WebABMinMB := StrToIntDef(aO.S[MgPo_.GetPoKey('int_browserFileSize', CP)], 0);
|
|
IsIgrCollectCutWebAB := BooleanStr(aO.S[MgPo_.GetPoKey('int_collectOriginalOnBlockException', CP)]); // XXXXXXXXXXXXX << 차단 시 원본 수집 예외
|
|
IsAllowLogWebAB := BooleanStr(aO.S[MgPo_.GetPoKey('int_collectLogOnAllow', CP)]); // XXXXXXXXXXXXX << 허용 시 로그 수집
|
|
WebbAB.ContentFilter.bActive := BooleanStr(aO.S[MgPo_.GetPoKey('INT_BROWSERATTACHFILTERENABLE', CP)]);
|
|
WebbAB.ContentFilter.nHitLimit := BooleanToInt(WebbAB.ContentFilter.bActive, 1, 0);
|
|
// INT_BROWSERATTACHAND // 브라우저 파일 차단, 필터 AND 조건
|
|
// INT_BROWSERATTACHHIGHNOTICE // 브라우저 파일 차단, HIGH 알림
|
|
WebbAB.ContentFilter.sPatterns := aO.S[MgPo_.GetPoKey('INT_BROWSERATTACHCRLIST', CP)];
|
|
WebAbSigs := aO.S[MgPo_.GetPoKey('int_brSignatureList', CP)];
|
|
WebAbFNames := aO.S[MgPo_.GetPoKey('int_brFileNmList', CP)];
|
|
WebABLogUrlList := StrListToCommaStr(aO.S[MgPo_.GetPoKey('int_browserAttachExcList', CP)], '|');
|
|
|
|
sTemp := aO.S[MgPo_.GetPoKey('INT_APPATTACHBLOCK', CP)].ToLower;
|
|
if (sTemp = 'true') or (sTemp = 'partial') then
|
|
EtcAB.Kind := abkBlock
|
|
else if sTemp = 'log' then
|
|
EtcAB.Kind := abkLog
|
|
else
|
|
EtcAB.Kind := abkNone;
|
|
EtcAB.bPopup := BooleanStr(aO.S[MgPo_.GetPoKey('INT_APPATTACHNOTICE', CP)]);
|
|
EtcAB.bReadBlock := BooleanStr(aO.S[MgPo_.GetPoKey('INT_APPATTACHREADBLOCK', CP)]);
|
|
EtcAB.bWriteBlock := BooleanStr(aO.S[MgPo_.GetPoKey('INT_APPATTACHWRITEBLOCK', CP)]);
|
|
EtcABApps := StrListToCommaStr(aO.S[MgPo_.GetPoKey('INT_APPATTACHBLOCKLIST', CP)], '|');
|
|
EtcAB.bCollectTxt := BooleanStr(aO.S[MgPo_.GetPoKey('INT_APPATTACHGETCONTENTS', CP)]); // APP 파일 차단, 원문 수집
|
|
EtcAB.bCollectFile := BooleanStr(aO.S[MgPo_.GetPoKey('INT_APPATTACHGETFILE', CP)]); // APP 파일 차단, 파일 수집
|
|
sTemp := UpperCase(aO.S[MgPo_.GetPoKey('int_appFileUpAllow', CP)]);
|
|
EtcAB.bUpAllowLog := sTemp.Contains('UL:1');
|
|
EtcAB.bUpColAllowTxt := sTemp.Contains('UC:1');
|
|
EtcAB.bUpColAllowFile := sTemp.Contains('UF:1');
|
|
sTemp := UpperCase(aO.S[MgPo_.GetPoKey('int_appFileUpBlock', CP)]);
|
|
EtcAB.bUpBlockLog := sTemp.Contains('UBL:1');
|
|
EtcAB.bUpColBlockTxt := sTemp.Contains('UBC:1');
|
|
EtcAB.bUpColBlockFile := sTemp.Contains('UBF:1');
|
|
sTemp := UpperCase(aO.S[MgPo_.GetPoKey('int_appFileDownAllow', CP)]);
|
|
EtcAB.bDlAllowLog := sTemp.Contains('DL:1');
|
|
EtcAB.bDlColAllowTxt := sTemp.Contains('DC:1');
|
|
EtcAB.bDlColAllowFile := sTemp.Contains('DF:1');
|
|
EtcAB.bDlBlockLog := UpperCase(aO.S[MgPo_.GetPoKey('int_appFileDownBlock', CP)]) = 'DBL:1';
|
|
EtcAB.ContentFilter.bActive := BooleanStr(aO.S[MgPo_.GetPoKey('INT_APPATTACHFILTERENABLE', CP)]);
|
|
EtcAB.ContentFilter.nHitLimit := BooleanToInt(EtcAB.ContentFilter.bActive, 1, 0);
|
|
// INT_APPATTACHAND // APP 파일 차단, 필터 AND 조건
|
|
// INT_APPATTACHHIGHNOTICE // APP 파일 차단, HIGH 알림 조건
|
|
EtcAB.ContentFilter.sPatterns := aO.S[MgPo_.GetPoKey('INT_APPATTACHCRLIST', CP)];
|
|
EtcAbSigs := aO.S[MgPo_.GetPoKey('int_appSignatureList', CP)];
|
|
EtcAbFNames := aO.S[MgPo_.GetPoKey('int_appFileNmList', CP)];
|
|
EtcAbLogList := StrListToCommaStr(aO.S[MgPo_.GetPoKey('int_appAttachExcList', CP)], '|');
|
|
|
|
AppABLimitMB := StrToIntDef(aO.S[MgPo_.GetPoKey('int_appAttachGetFileSize', CP)], 20);
|
|
AppABMinMB := StrToIntDef(aO.S[MgPo_.GetPoKey('int_appFileSize', CP)], 0);
|
|
IsIgrCollectCutAppAB := BooleanStr(aO.S[MgPo_.GetPoKey('int_appAttachCollectOriginalOnBlockException', CP)]); // XXXXXXXXXXXXX << 차단 시 원본 수집 예외
|
|
IsAllowLogAppAB := BooleanStr(aO.S[MgPo_.GetPoKey('int_appAttachCollectLogOnAllow', CP)]); // XXXXXXXXXXXXX << 허용 시 로그 수집
|
|
|
|
OutFileBlockMB := StrToIntDef(aO.S[MgPo_.GetPoKey('int_outlookAttachBlockMaxSize', CP)], 0);
|
|
WebFileBlockMB := StrToIntDef(aO.S[MgPo_.GetPoKey('int_browserAttachBlockMaxSize', CP)], 0);
|
|
AppFileBlockMB := StrToIntDef(aO.S[MgPo_.GetPoKey('int_appFileBlockMaxSize', CP)], 0);
|
|
|
|
sTemp := aO.S[MgPo_.GetPoKey('INT_OUTLOOKBODYBLOCK', CP)].ToLower;
|
|
if sTemp = 'true' then
|
|
begin
|
|
OutPo.bActive := true;
|
|
OutPo.bBlock := true;
|
|
end else
|
|
if sTemp = 'log' then
|
|
begin
|
|
OutPo.bActive := true;
|
|
OutPo.bBlock := false;
|
|
end else begin
|
|
OutPo.bActive := false;
|
|
OutPo.bBlock := false;
|
|
end;
|
|
OutPo.bPopup := BooleanStr(aO.S[MgPo_.GetPoKey('INT_OUTLOOKBODYNOTICE', CP)]); // 아웃룩 본문 탐지, HIGH 사용자 알림
|
|
OutBodyAllowPopup := BooleanStr(aO.S[MgPo_.GetPoKey('int_outlookBodyAllowNotice', CP)]);// 아웃룩 본문 탐지, 허용 알림
|
|
OutPo.bSchSubject := BooleanStr(aO.S[MgPo_.GetPoKey('INT_OUTLOOKBODYSUBJECT', CP)]); // 아웃룩 본문 탐지, 제목검사
|
|
OutPo.bSchBody := BooleanStr(aO.S[MgPo_.GetPoKey('INT_OUTLOOKBODYCONTENTS', CP)]); // 아웃룩 본문 탐지, 본문검사
|
|
OutPo.bUseMasking := BooleanStr(aO.S[MgPo_.GetPoKey('INT_OUTLOOKBODYMASKING', CP)]); // 아웃룩 본문 탐지, 마스킹 적용 발송
|
|
OutPo.bCollect := BooleanStr(aO.S[MgPo_.GetPoKey('INT_OUTLOOKBODYGETCONTENTS', CP)]); // 아웃룩 본문 탐지, 원문 수집
|
|
OutPo.ContentFilter.bActive := BooleanStr(aO.S[MgPo_.GetPoKey('INT_OUTLOOKBODYFILTERENABLE', CP)]);
|
|
OutPo.ContentFilter.nHitLimit := BooleanToInt(OutPo.ContentFilter.bActive, 1, 0); // old : KEY_OUTLOOKBODYBYSCANCNT
|
|
OutPo.ContentFilter.sPatterns := aO.S[MgPo_.GetPoKey('INT_OUTLOOKBODYCRLIST', CP)];
|
|
// INT_OUTLOOKBODYAND // 아웃룩 본문 탐지, 필터 AND 탐지
|
|
// INT_OUTLOOKBODYHIGHNOTICE // 아웃룩 본문 탐지, HIGH 사용자 알림
|
|
sTemp := aO.S[MgPo_.GetPoKey('INT_OUTLOOKATTACHBLOCK', CP)].ToLower;
|
|
if sTemp = 'true' then
|
|
OutlookAB.Kind := abkBlock
|
|
else if sTemp = 'log' then
|
|
OutlookAB.Kind := abkLog
|
|
else
|
|
OutlookAB.Kind := abkNone;
|
|
OutlookAB.bPopup := BooleanStr(aO.S[MgPo_.GetPoKey('INT_OUTLOOKATTACHNOTICE', CP)]); // 아웃룩 파일 차단, 사용자 알림
|
|
OutFileAllowPopup := BooleanStr(aO.S[MgPo_.GetPoKey('int_outlookAttachAllowNotice', CP)]); // 아웃룩 파일 첨부 감지, 허용 알림
|
|
OutlookAB.bReadBlock := true;
|
|
OutlookAB.bWriteBlock := false;
|
|
OutlookAB.bCollectTxt := BooleanStr(aO.S[MgPo_.GetPoKey('INT_OUTLOOKGETCONTENTS', CP)]); // 아웃룩 파일 차단, 원문 수집
|
|
OutlookAB.bCollectFile := BooleanStr(aO.S[MgPo_.GetPoKey('INT_OUTLOOKGETFILE', CP)]); // 아웃룩 파일 차단, 파일 수집
|
|
OutlookAB.ContentFilter.bActive := BooleanStr(aO.S[MgPo_.GetPoKey('INT_OUTLOOKATTACHFILTERENABLE', CP)]);
|
|
OutlookAB.ContentFilter.nHitLimit := BooleanToInt(OutlookAB.ContentFilter.bActive, 1, 0); // old : KEY_OUTLOOKBYSCANCNT
|
|
// INT_OUTLOOKATTACHAND // 아웃룩 파일 차단, 필터 AND 조건
|
|
// INT_OUTLOOKATTACHHIGHNOTICE // 아웃룩 파일 차단, HIGH 사용자 알림
|
|
OutlookAB.ContentFilter.sPatterns := aO.S[MgPo_.GetPoKey('INT_OUTLOOKATTACHCRLIST', CP)];
|
|
OutABLimitMB := StrToIntDef(aO.S[MgPo_.GetPoKey('int_outlookGetFileSize', CP)], 20);
|
|
OutABMinMB := StrToIntDef(aO.S[MgPo_.GetPoKey('int_outlookFileSize', CP)], 0);
|
|
|
|
sTemp := aO.S[MgPo_.GetPoKey('INT_NETSHAREFOLDER', CP)].ToLower;
|
|
if sTemp = 'true' then
|
|
ShareFolder := sfkAllBlock
|
|
else if sTemp = 'partial' then
|
|
ShareFolder := sfkAddBlock
|
|
else if sTemp = 'popup' then
|
|
ShareFolder := sfkPopup
|
|
else if sTemp = 'log' then
|
|
ShareFolder := sfkLog
|
|
else
|
|
ShareFolder := sfkNone;
|
|
ShareFldBlockPopup := BooleanStr(aO.S[MgPo_.GetPoKey('int_netShareFolderNotice', CP)]);
|
|
ShareFldAllowPopup := BooleanStr(aO.S[MgPo_.GetPoKey('int_netShareFolderAllowNotice', CP)]);
|
|
|
|
sTemp := aO.S[MgPo_.GetPoKey('INT_CLIPBOARDENABLE', CP)].ToLower;
|
|
if sTemp = 'true' then
|
|
ClipBlockKind := cbkBlock
|
|
else if sTemp = 'popup' then
|
|
ClipBlockKind := cbkPopup
|
|
else if (sTemp = 'logonly') or (sTemp = 'log') then
|
|
ClipBlockKind := cbkLog
|
|
else
|
|
ClipBlockKind := cbkNone;
|
|
CbPopup := BooleanStr(aO.S[MgPo_.GetPoKey('INT_CLIPBOARDNOTICE', CP)]);
|
|
CbImgBlock := BooleanStr(aO.S[MgPo_.GetPoKey('int_clipboardBlockImg', CP)]);
|
|
DoClipOcr := BooleanStr(aO.S[MgPo_.GetPoKey('INT_CLIPBOARDOCRENABLE', CP)]);
|
|
ClipboardExceptApp := StrListToCommaStr(aO.S[MgPo_.GetPoKey('INT_CLIPBOARDEXCEPTLIST', CP)], ';');
|
|
IsClipboardExcept := ClipboardExceptApp <> '';
|
|
IsCBCollect := BooleanStr(aO.S[MgPo_.GetPoKey('INT_CLIPBOARDCOLLECT', CP)]); // // 클립보드 차단, 원문 수집
|
|
CBCollectApp := StrListToCommaStr(aO.S[MgPo_.GetPoKey('INT_CLIPBOARDCOLLECTAPP', CP)], ';'); // 클립보드 차단, 원문 수집 APP
|
|
CbCF.bActive := BooleanStr(aO.S[MgPo_.GetPoKey('INT_CLIPBOARDFILTERENABLE', CP)]); // 클립보드 차단, 필터 사용
|
|
CbCF.nHitLimit := BooleanToInt(CbCF.bActive, 1, 0);
|
|
CbCF.sPatterns := aO.S[MgPo_.GetPoKey('INT_CLIPBOARDCRLIST', CP)]; // 클립보드 차단, 필터 목록
|
|
// INT_CLIPBOARDAND // 클립보드 차단, 필터 AND 사용
|
|
// INT_CLIPBOARDHIGHNOTICE // 클립보드 차단, HIGH 사용자 알림//
|
|
|
|
IsNotiBCA := BooleanStr(aO.S[MgPo_.GetPoKey('INT_CAPTURE_APP_NOTICE', CP)]);// 캡쳐 APP 차단, 사용자 알림 수행
|
|
ScreenBlockAppsExp := StrListToCommaStr(aO.S[MgPo_.GetPoKey('INT_CAPTUREAPPLIST', CP)], '|');
|
|
IgrCaptureApps := StrListToCommaStr(aO.S[MgPo_.GetPoKey('INT_CAPTUREAPPEXCEPTLIST', CP)], '|');
|
|
sTemp := aO.S[MgPo_.GetPoKey('INT_CAPTUREAPPBLOCK', CP)].ToLower;
|
|
if (sTemp <> '') and (sTemp <> 'false') then
|
|
begin
|
|
if sTemp = 'blacklistprocess' then
|
|
ScreenBlockAppExp := askRunTargetOn
|
|
else if sTemp = 'blacklistusage' then
|
|
ScreenBlockAppExp := askUseTargetOn
|
|
else if sTemp = 'whitelistprocess' then
|
|
ScreenBlockAppExp := askRunTargetOff
|
|
else if sTemp = 'whitelistusage' then
|
|
ScreenBlockAppExp := askUseTargetOff
|
|
else
|
|
ScreenBlockAppExp := askNone;
|
|
|
|
if ScreenBlockAppExp = askNone then
|
|
begin
|
|
if sTemp = 'log' then
|
|
CapAppMonKind := camLog
|
|
else if IgrCaptureApps <> '' then
|
|
CapAppMonKind := camIncAllow
|
|
else
|
|
CapAppMonKind := camBlockAll;
|
|
end else
|
|
CapAppMonKind := camNone;
|
|
end else begin
|
|
CapAppMonKind := camNone;
|
|
ScreenBlockAppExp := askNone;
|
|
end;
|
|
bCaptureBlockApps_ := BooleanStr(aO.S[MgPo_.GetPoKey('INT_CAPTUREPROTECTENABLE', CP)]);
|
|
CaptureBlockApps := StrListToCommaStr(aO.S[MgPo_.GetPoKey('INT_CAPTUREPROTECTLIST', CP)], '|');
|
|
sTemp := aO.S[MgPo_.GetPoKey('INT_CAPTUREURL', CP)].ToLower;
|
|
if (sTemp = 'blacklist') or (sTemp = 'partial') then
|
|
CaptureBlockUrlKind := bkBlack
|
|
else if (sTemp = 'whitelist') or (sTemp = 'except') then
|
|
CaptureBlockUrlKind := bkWhite
|
|
else if sTemp = 'true' then
|
|
CaptureBlockUrlKind := bkAll
|
|
else
|
|
CaptureBlockUrlKind := bkNone;
|
|
CaptureBlockUrls := StrListToCommaStr(aO.S[MgPo_.GetPoKey('INT_CAPTUREURLLIST', CP)], '|');
|
|
IsWaterMark := BooleanStr(aO.S[MgPo_.GetPoKey('INT_IMAGEWATERMARK', CP)]);
|
|
sTemp := aO.S[MgPo_.GetPoKey('INT_SCRNWATERMARK', CP)].ToLower;
|
|
if sTemp = 'true' then
|
|
ScreenLogo := askAlways
|
|
else if sTemp = 'blacklistprocess' then
|
|
ScreenLogo := askRunTargetOn
|
|
else if sTemp = 'blacklistusage' then
|
|
ScreenLogo := askUseTargetOn
|
|
else if sTemp = 'whitelistprocess' then
|
|
ScreenLogo := askRunTargetOff
|
|
else if sTemp = 'whitelistusage' then
|
|
ScreenLogo := askUseTargetOff
|
|
else
|
|
ScreenLogo := askNone;
|
|
ScreenLogoApps := StrListToCommaStr(aO.S[MgPo_.GetPoKey('INT_SCRNWATERMARKAPPLIST', CP)], '|');
|
|
sTemp := aO.S[MgPo_.GetPoKey('int_scrnLogoType', CP)].ToLower;
|
|
ScreenLogoVisible := (sTemp = 'watermark') or (sTemp = 'both') or ScreenLogoApps.Contains('*V*');
|
|
ScreenLogoInvisible := (sTemp = 'snaptag') or (sTemp = 'both') or ScreenLogoApps.Contains('*I*');
|
|
if not ScreenLogoVisible and not ScreenLogoInvisible then
|
|
ScreenLogoVisible := true;
|
|
WinCapScrLogoOff := BooleanStr(aO.S[MgPo_.GetPoKey('INT_SCRNWATERMARKWINEXCEPT', CP)]);
|
|
UseIpScrLogoBold := BooleanStr(aO.S[MgPo_.GetPoKey('INT_SCRNWATERMARKIPBOLD', CP)]);
|
|
ScrLogoBoldIps := StrListToCommaStr(aO.S[MgPo_.GetPoKey('INT_SCRNWATERMARKIPBOLDLIST', CP)], ';');
|
|
if (ScrLogoBoldIps <> '') and (ScrLogoBoldIps[1] = ':') then
|
|
begin
|
|
ScreenLogoData := ScrLogoBoldIps;
|
|
Delete(ScreenLogoData, 1, 1);
|
|
ScrLogoBoldIps := '';
|
|
end else
|
|
ScreenLogoData := '';
|
|
IsUrlCatchLogo := BooleanStr(aO.S[MgPo_.GetPoKey('INT_SCRNWATERMARKURLDETECTION', CP)]);
|
|
LogoUrlList := StrListToCommaStr(aO.S[MgPo_.GetPoKey('INT_SCRNWATERMARKURLLIST', CP)], '|'); // varchar(8000)
|
|
|
|
MinIdleScrLogoBold := StrToIntDef(aO.S[MgPo_.GetPoKey('INT_SCRNWATERMARKIDLEBOLDTIME', CP)], 0);
|
|
UseIdleScrLogoBold := MinIdleScrLogoBold > 0;
|
|
UseRemoteScrLogoBold := BooleanStr(aO.S[MgPo_.GetPoKey('INT_SCRNWATERMARKCONNBOLD', CP)]);
|
|
sTemp := aO.S[MgPo_.GetPoKey('INT_USBBLOCKENABLE', CP)].ToLower;
|
|
if sTemp = 'true' then
|
|
UsbBlockKind := ubkBlock
|
|
else if sTemp = 'readonly' then
|
|
UsbBlockKind := ubkReadOnly
|
|
else if (sTemp = 'logonly') or (sTemp = 'log') then
|
|
UsbBlockKind := ubkLog
|
|
else
|
|
UsbBlockKind := ubkNone;
|
|
USBPopup := BooleanStr(aO.S[MgPo_.GetPoKey('INT_USBBLOCKNOTICE', CP)]); // USB 차단, 사용자 알림
|
|
UsbAllowPopup := BooleanStr(aO.S[MgPo_.GetPoKey('int_usbBlockAllowNotice', CP)]); // USB 허용 시 사용자 알림
|
|
AbleUsbExceptReq := BooleanStr(aO.S[MgPo_.GetPoKey('INT_USBBLOCKAPPROVE', CP)]); // USB 차단, 차단 시 예외 신청 허용
|
|
AutoRunBlock := BooleanStr(aO.S[MgPo_.GetPoKey('INT_USBBLOCKAUTORUN', CP)]);
|
|
sTemp := StrListToCommaStr(aO.S[MgPo_.GetPoKey('INT_USBBLOCKSERIAL', CP)], '|');
|
|
if sTemp <> '' then
|
|
begin
|
|
SplitString(sTemp, '|', IgrUsbSerialList);
|
|
if UseFltCtrl then
|
|
begin
|
|
// vid, pid 없는건 제외해준다
|
|
var bMod: Boolean := false;
|
|
var nPos: Integer;
|
|
var sEnt, sIgrKn: String;
|
|
sIgrKn := '';
|
|
for i := IgrUsbSerialList.Count - 1 downto 0 do
|
|
begin
|
|
sEnt := IgrUsbSerialList[i];
|
|
nPos := Pos('***', sEnt);
|
|
if nPos > 0 then
|
|
begin
|
|
IgrUsbSerialList[i] := Copy(sEnt, 1, nPos - 1);
|
|
Delete(sEnt, 1, nPos + 2);
|
|
SumString(sIgrKn, StrsReplace(sEnt, ['<!>'], '|'), '|');
|
|
end else
|
|
IgrUsbSerialList.Delete(i);
|
|
end;
|
|
IgrUsbSerialsKn := sIgrKn;
|
|
end;
|
|
IgrUsbSerials := sTemp;
|
|
end else begin
|
|
IgrUsbSerials := '';
|
|
IgrUsbSerialsKn := '';
|
|
IgrUsbSerialList.Clear;
|
|
end;
|
|
UsbExceptVender := StrListToCommaStr(aO.S[MgPo_.GetPoKey('INT_USBBLOCKPROD', CP)], ';');
|
|
sTemp := aO.S[MgPo_.GetPoKey('INT_MTPBLOCKENABLE', CP)].ToLower;
|
|
if sTemp = 'true' then
|
|
MtpBlockKind := ubkBlock
|
|
else if sTemp = 'readonly' then
|
|
MtpBlockKind := ubkReadOnly
|
|
else if (sTemp = 'logonly') or (sTemp = 'log') then
|
|
MtpBlockKind := ubkLog
|
|
else
|
|
MtpBlockKind := ubkNone;
|
|
MTPPopup := BooleanStr(aO.S[MgPo_.GetPoKey('INT_MTPBLOCKNOTICE', CP)]); // MTP 차단, 사용자 알림
|
|
MtpAllowPopup := BooleanStr(aO.S[MgPo_.GetPoKey('int_mtpBlockAllowNotice', CP)]); // MTP 허용, 사용자 알림
|
|
MtpExcept := StrListToCommaStr(aO.S[MgPo_.GetPoKey('INT_MTPBLOCKSERIAL', CP)], ';');
|
|
MtpExceptVender := StrListToCommaStr(aO.S[MgPo_.GetPoKey('INT_MTPBLOCKPROD', CP)], ';');
|
|
AbleMtpExceptReq := BooleanStr(aO.S[MgPo_.GetPoKey('INT_MTPBLOCKAPPROVE', CP)]); // MTP 차단, 차단 시 예외 신청 허용
|
|
sTemp := aO.S[MgPo_.GetPoKey('INT_BTBLOCKENABLE', CP)].ToLower;
|
|
if sTemp = 'true' then
|
|
BlueBlockKind := dbkBlock
|
|
else if (sTemp = 'logonly') or (sTemp = 'log') then
|
|
BlueBlockKind := dbkLog
|
|
else
|
|
BlueBlockKind := dbkNone;
|
|
BTPopup := BooleanStr(aO.S[MgPo_.GetPoKey('INT_BTBLOCKNOTICE', CP)]);
|
|
BtAllowPopup := BooleanStr(aO.S[MgPo_.GetPoKey('int_btBlockAllowNotice', CP)]);
|
|
sTemp := '';
|
|
if BooleanStr(aO.S[MgPo_.GetPoKey('INT_BTEXCEPTMISC', CP)]) then // 블루투스 차단, 기타 기기 예외
|
|
SumString(sTemp, 'Misc', ';');
|
|
if BooleanStr(aO.S[MgPo_.GetPoKey('INT_BTEXCEPTCOMPUTER', CP)]) then // 블루투스 차단, 컴퓨터 예외
|
|
SumString(sTemp, 'Computer', ';');
|
|
if BooleanStr(aO.S[MgPo_.GetPoKey('INT_BTEXCEPTMOBILE', CP)]) then // 블루투스 차단, 핸드폰 예외
|
|
SumString(sTemp, 'Phone', ';');
|
|
if BooleanStr(aO.S[MgPo_.GetPoKey('INT_BTEXCEPTACCESSORY', CP)]) then // 블루투스 차단, 주변 기기 예외
|
|
SumString(sTemp, 'Peripheral', ';');
|
|
if BooleanStr(aO.S[MgPo_.GetPoKey('INT_BTEXCEPTLAN', CP)]) then // 블루투스 차단, LanAccessPoint 예외
|
|
SumString(sTemp, 'LanAccessPoint', ';');
|
|
if BooleanStr(aO.S[MgPo_.GetPoKey('INT_BTEXCEPTAUDIO', CP)]) then // 블루투스 차단, Audio-Video 예외
|
|
SumString(sTemp, 'Audio/Video', ';');
|
|
if BooleanStr(aO.S[MgPo_.GetPoKey('INT_BTEXCEPTIMAGE', CP)]) then // 블루투스 차단, Imaging 장치 예외
|
|
SumString(sTemp, 'Imaging', ';');
|
|
if BooleanStr(aO.S[MgPo_.GetPoKey('INT_BTEXCEPTUNKNOWN', CP)]) then // 블루투스 차단, 알수없음 기기 예외
|
|
SumString(sTemp, 'Unclassified', ';');
|
|
if BlueExcept <> sTemp then
|
|
BlueExcept := sTemp;
|
|
SumString(BlueExcept, StrListToCommaStr(aO.S[MgPo_.GetPoKey('INT_BTEXCEPT', CP)], ';'), ';'); // 추가 25_0218 16:12:41 kku
|
|
BlueExceptVender := StrListToCommaStr(aO.S[MgPo_.GetPoKey('INT_BTEXCEPTPROD', CP)], ';');
|
|
AbleBtExceptReq := BooleanStr(aO.S[MgPo_.GetPoKey('INT_BTAPPROVE', CP)]); // 블루투스 차단, 차단 시 예외 신청 허용
|
|
|
|
CDPopup := BooleanStr(aO.S[MgPo_.GetPoKey('INT_CDNOTICE', CP)]);
|
|
CdAllowPopup := BooleanStr(aO.S[MgPo_.GetPoKey('int_cdAllowNotice', CP)]);
|
|
sTemp := aO.S[MgPo_.GetPoKey('INT_CDBLOCKENABLE', CP)].ToLower;
|
|
if sTemp = 'true' then
|
|
CdromBlockKind := ubkBlock
|
|
else if sTemp = 'readonly' then
|
|
CdromBlockKind := ubkReadOnly
|
|
else if (sTemp = 'logonly') or (sTemp = 'log') then
|
|
CdromBlockKind := ubkLog
|
|
else
|
|
CdromBlockKind := ubkNone;
|
|
|
|
CdromExcept := StrListToCommaStr(aO.S[MgPo_.GetPoKey('INT_CDBLOCKEXCEPT', CP)], ';');
|
|
AbleCdExceptReq := BooleanStr(aO.S[MgPo_.GetPoKey('INT_CDAPPROVE', CP)]); // CD/DVD 차단, 차단 시 예외 신청 허용
|
|
|
|
Print.sPrintAppExcepts := StrListToCommaStr(UpperCase(aO.S[MgPo_.GetPoKey('INT_PRINTAPPLIST', CP)]), '|', false, true);
|
|
Print.sPrintUrlExcepts := StrListToCommaStr(UpperCase(aO.S[MgPo_.GetPoKey('INT_PRINTURLLIST', CP)]), '|', false, true);
|
|
Print.sPrinterExcepts := StrListToCommaStr(UpperCase(aO.S[MgPo_.GetPoKey('INT_PRINTSERIALLIST', CP)]), '|', false, true);
|
|
Print.sPrintDocExcepts := StrListToCommaStr(UpperCase(aO.S[MgPo_.GetPoKey('int_printDocList', CP)]), '|', false, true);
|
|
sTemp := aO.S[MgPo_.GetPoKey('INT_PRINTBLOCK', CP)].ToLower;
|
|
if sTemp = 'true' then
|
|
begin
|
|
Print.PrintKind := pkBlock;
|
|
// Print.PrinterExcept := bkNone;
|
|
// Print.PrintAppExcept := bkNone;
|
|
// Print.PrintUrlExcept := bkNone;
|
|
end else
|
|
if sTemp = 'watermark' then
|
|
begin
|
|
// 구버전 출력 보안을 위해 유지함 23_0131 15:19:47 kku
|
|
Print.PrintWater := pwActive;
|
|
// Print.PrintKind := pkPopup;
|
|
end
|
|
else if sTemp = 'log' then
|
|
begin
|
|
Print.PrintKind := pkLog;
|
|
// Print.PrinterExcept := bkNone;
|
|
// Print.PrintAppExcept := bkNone;
|
|
// Print.PrintUrlExcept := bkNone;
|
|
end else
|
|
Print.PrintKind := pkNone;
|
|
Print.bPopup := BooleanStr(aO.S[MgPo_.GetPoKey('INT_PRINTNOTICE', CP)]); // 프린터 차단, 사용자 알림
|
|
PrtAllowPopup := BooleanStr(aO.S[MgPo_.GetPoKey('int_printAllowNotice', CP)]);
|
|
// INT_PRINTUNKNOWNBLOCK // 프린터 차단, 미인식 프린터 차단
|
|
sTemp := aO.S[MgPo_.GetPoKey('INT_PRINTWATERMARK', CP)].ToLower;
|
|
if sTemp = 'true' then
|
|
Print.PrintWater := pwActive
|
|
else if sTemp = 'approve' then
|
|
Print.PrintWater := pwApprove
|
|
else
|
|
Print.PrintWater := pwNone;
|
|
// Print.bPrtMasking := false; // (CUSTOMER_TYPE = CUSTOMER_DEV) and (Print.PrintWater <> pwNone); // todo : 마스킹 옵션 추가
|
|
Print.bDateBlock := aO.S[MgPo_.GetPoKey('INT_PRINTDAYBLOCK', CP)].ToLower = 'true';
|
|
Print.dtBlockB:= StrToDateDef(aO.S[MgPo_.GetPoKey('INT_PRINTDAYSTART', CP)], 0);
|
|
if Print.dtBlockB <> 0 then
|
|
Print.dtBlockB := AppendTime(Print.dtBlockB, 0, 0, 0, 0);
|
|
Print.dtBlockE := StrToDateDef(aO.S[MgPo_.GetPoKey('INT_PRINTDAYEND', CP)], 0);
|
|
if Print.dtBlockE <> 0 then
|
|
Print.dtBlockE := AppendTime(Print.dtBlockE, 23, 59, 59, 0);
|
|
|
|
// if Print.sPrinterExcepts <> '' then
|
|
// Print.PrinterExcept := bkWhite;
|
|
// INT_PRINTMAXPAGE // 프린터 차단, 최대 장수 지정
|
|
// INT_PRINTCOLORBLOCK // 프린터 차단, 컬러 출력 차단
|
|
Print.bCollectOutput := aO.S[MgPo_.GetPoKey('INT_PRINTGETCONTENT', CP)].ToLower = 'true'; // 프린터 차단, 원문 수집
|
|
Print.bCollectFile := aO.S[MgPo_.GetPoKey('INT_PRINTGETFILE', CP)].ToLower = 'true'; // 프린터 차단, 원본 수집
|
|
Print.ContentFilter.bActive := aO.S[MgPo_.GetPoKey('INT_PRINTFILTERENABLE', CP)].ToLower = 'true';
|
|
Print.ContentFilter.nHitLimit := BooleanToInt(Print.ContentFilter.bActive, 1, 0);
|
|
// INT_PRINTAND // 프린터 차단, 필터 AND 조건
|
|
// INT_PRINTHIGHNOTICE // 프린터 차단, HIGH 알림
|
|
Print.ContentFilter.sPatterns := aO.S[MgPo_.GetPoKey('INT_PRINTCRLIST', CP)];
|
|
PrinterIpExcept := StrListToCommaStr(UpperCase(aO.S[MgPo_.GetPoKey('int_printIpException', CP)]), '|', false, true);
|
|
O := GetJsonObj('int_printWatermarkExcept');
|
|
PrtWtExpUrl := O.S['url'];
|
|
PrtWtExpDocName := O.S['doc'];
|
|
PrtWtExpPrtName := O.S['printer'];
|
|
PrtWtExpProcName := O.S['process'];
|
|
PrtMinMB := aO.I[MgPo_.GetPoKey('int_printFileSizeMin', CP)];
|
|
PrtMaxMB := aO.I[MgPo_.GetPoKey('int_printFileSizeMax', CP)];
|
|
if PrtMaxMB = 0 then
|
|
PrtMaxMB := 20;
|
|
|
|
O := GetJsonObj('int_printWatermarkCfg');
|
|
if O <> nil then
|
|
begin
|
|
PrtWaterCfg.bActive := O.B['use'];
|
|
if O.O['topItem'] <> nil then
|
|
begin
|
|
PrtWaterCfg.sTopText := O.O['topItem'].S['text'];
|
|
sTemp := LowerCase(O.O['topItem'].S['position']);
|
|
if sTemp = 'left' then
|
|
PrtWaterCfg.nTopPos := 1
|
|
else if sTemp = 'center' then
|
|
PrtWaterCfg.nTopPos := 2
|
|
else if sTemp = 'right' then
|
|
PrtWaterCfg.nTopPos := 3;
|
|
PrtWaterCfg.nTopSize := O.O['topItem'].I['fontSize'];
|
|
end;
|
|
|
|
if O.O['bottomItem'] <> nil then
|
|
begin
|
|
PrtWaterCfg.sBotText := O.O['bottomItem'].S['text'];
|
|
sTemp := LowerCase(O.O['bottomItem'].S['position']);
|
|
if sTemp = 'left' then
|
|
PrtWaterCfg.nBotPos := 1
|
|
else if sTemp = 'center' then
|
|
PrtWaterCfg.nBotPos := 2
|
|
else if sTemp = 'right' then
|
|
PrtWaterCfg.nBotPos := 3;
|
|
PrtWaterCfg.nBotSize := O.O['bottomItem'].I['fontSize'];
|
|
end;
|
|
end else
|
|
ZeroMemory(@PrtWaterCfg, SizeOf(PrtWaterCfg));
|
|
|
|
O := GetJsonObj('int_printApprovalExcept');
|
|
PrtApvExpUrl := O.S['url'];
|
|
PrtApvExpDocName := O.S['doc'];
|
|
PrtApvExpPrtName := O.S['printer'];
|
|
PrtApvExpProcName := O.S['process'];
|
|
|
|
PrintApproval := IsApproveSupport and BooleanStr(aO.S[MgPo_.GetPoKey('int_printBlockRequestApproval', CP)]);
|
|
PrintApprovalPost := PrintApproval and BooleanStr(aO.S[MgPo_.GetPoKey('int_printPostApproval', CP)]);
|
|
IsPrtCollectThum := BooleanStr(aO.S[MgPo_.GetPoKey('int_printGetThumbnail', CP)]);
|
|
PrtCollThumLimit := StrToIntDef(aO.S[MgPo_.GetPoKey('int_printThumbnailMaxNum', CP)], 3);
|
|
if PrtCollThumLimit = 0 then
|
|
PrtCollThumLimit := 3;
|
|
|
|
UsbApproval := aO.S[MgPo_.GetPoKey('int_usbBlockApproval', CP)].ToLower = 'true';
|
|
WebUrlApproval := aO.S[MgPo_.GetPoKey('int_browserBlockApproval', CP)].ToLower = 'true';
|
|
BtApproval := aO.S[MgPo_.GetPoKey('int_btBlockApproval', CP)].ToLower = 'true';
|
|
CdApproval := aO.S[MgPo_.GetPoKey('int_cdBlockApproval', CP)].ToLower = 'true';
|
|
MtpApproval := aO.S[MgPo_.GetPoKey('int_mtpBlockApproval', CP)].ToLower = 'true';
|
|
DrmApproval := aO.S[MgPo_.GetPoKey('INT_DRMDEC', CP)].ToLower = 'approval';
|
|
ExFApproval := aO.S[MgPo_.GetPoKey('int_fileExportApproval', CP)].ToLower = 'true';
|
|
CapApproval := aO.S[MgPo_.GetPoKey('int_captureAppApproval', CP)].ToLower = 'true';
|
|
|
|
// 파일 반출 결재 승인 시 유효 시간(분)
|
|
O := GetJsonObj('int_fileExportApprovalCfg');
|
|
FileExpMin := O.I['expMins'];
|
|
if FileExpMin = 0 then
|
|
FileExpMin := 60;
|
|
if O.O['limit'] <> nil then
|
|
begin
|
|
FileExpMinMB := O.O['limit'].I['minMb'];
|
|
FileExpMaxMB := O.O['limit'].I['maxMb'];
|
|
end else begin
|
|
FileExpMinMB := 0;
|
|
FileExpMaxMB := 0;
|
|
end;
|
|
|
|
// int_browserBlockConnWidget : 위젯 사용 시 접속 차단
|
|
BlockNoUrl := aO.S[MgPo_.GetPoKey('int_browserBlockConnUrl', CP)].ToLower = 'true';
|
|
BlockNoUrlAB := aO.S[MgPo_.GetPoKey('int_browserBlockFileUrl', CP)].ToLower = 'true';
|
|
BlockWidgetAB := aO.S[MgPo_.GetPoKey('int_browserBlockFileWidget', CP)].ToLower = 'true';
|
|
|
|
UrlBlockNoti := aO.S[MgPo_.GetPoKey('int_browserBlockNotice', CP)].ToLower <> 'false';
|
|
UrlAllowNoti := aO.S[MgPo_.GetPoKey('int_browserBlockAllowNotice', CP)].ToLower = 'true';
|
|
// WebABlockNoti := aO.S[MgPo_.GetPoKey('INT_BROWSERATTACHNOTICE', CP)].ToLower <> 'false'; // WebbAB.bPopup
|
|
WebAAllowNoti := aO.S[MgPo_.GetPoKey('int_browserAttachAllowNotice', CP)].ToLower = 'true';
|
|
// AppABlockNoti := aO.S[MgPo_.GetPoKey('INT_APPATTACHNOTICE', CP)].ToLower <> 'false'; // EtcAB.bPopup
|
|
AppAAllowNoti := aO.S[MgPo_.GetPoKey('int_appAttachAllowNotice', CP)].ToLower = 'true';
|
|
|
|
DetectFixedDisk := BooleanStr(aO.S[MgPo_.GetPoKey('INT_MONITORHARDDISK', CP)]); // 고정 디스크 변경 감시
|
|
HdMonPopup := BooleanStr(aO.S[MgPo_.GetPoKey('int_monitorHardDiskNotice', CP)]);
|
|
IsDrmDecrypt := aO.S[MgPo_.GetPoKey('INT_DRMDEC', CP)].ToLower = 'true';
|
|
sTemp := aO.S[MgPo_.GetPoKey('INT_DRMREAD', CP)].ToLower;
|
|
if sTemp = 'true' then
|
|
DrmAccessKind := dakAll
|
|
else if sTemp = 'individual' then
|
|
DrmAccessKind := dakEmpNo
|
|
else if sTemp = 'dept' then
|
|
DrmAccessKind := dakDept
|
|
else if sTemp = 'approve' then
|
|
DrmAccessKind := dakNone
|
|
else
|
|
DrmAccessKind := dakNone;
|
|
sTemp := aO.S[MgPo_.GetPoKey('INT_DRMMODIFY', CP)].ToLower;
|
|
if (sTemp = '') or (sTemp = 'off') then
|
|
DrmModifyKind := dakNone
|
|
else if sTemp = 'individual' then
|
|
DrmModifyKind := dakEmpNo
|
|
else if sTemp = 'dept' then
|
|
DrmModifyKind := dakDept
|
|
else if sTemp = 'approve' then
|
|
DrmModifyKind := dakNone
|
|
else
|
|
DrmModifyKind := dakAll; // false
|
|
IsDrmAttAble := aO.S[MgPo_.GetPoKey('INT_DRMONLYSEND', CP)].ToLower = 'true';
|
|
// INT_DRMEXCEPTPROCESS // DRM, 예외 프로세스 목록
|
|
DrmCF.bActive := aO.S[MgPo_.GetPoKey('INT_DRMFILTERENABLE', CP)].ToLower = 'true';
|
|
DrmCF.nHitLimit := BooleanToInt(DrmCF.bActive, 1, 0);
|
|
// INT_DRMFILTERAND // DRM, 필터 AND 조건
|
|
DrmCF.sPatterns := aO.S[MgPo_.GetPoKey('INT_DRMCRLIST', CP)];
|
|
sTemp := aO.S[MgPo_.GetPoKey('INT_MONITORFILECHANGE', CP)].ToLower;
|
|
if sTemp = 'true' then
|
|
FileMon.Kind := fmkAll
|
|
else if sTemp ='partial' then
|
|
FileMon.Kind := fmkIncExt
|
|
else if sTemp ='except' then
|
|
FileMon.Kind := fmkIgrExt
|
|
else if sTemp = 'logonly' then
|
|
begin
|
|
FileMon.Kind := fmkIgrExt;
|
|
end else
|
|
if sTemp = 'logonly2' then
|
|
begin
|
|
FileMon.Kind := fmkIncExt;
|
|
end else
|
|
if sTemp = 'logonly3' then
|
|
begin
|
|
FileMon.Kind := fmkAll;
|
|
end else
|
|
FileMon.Kind := fmkNone;
|
|
FileMon.IsNoti := BooleanStr(aO.S[MgPo_.GetPoKey('INT_MONITORFILENOTICE', CP)]); // 파일 변경 감시, 사용자 알림
|
|
FileMon.OnlyUSB := BooleanStr(aO.S[MgPo_.GetPoKey('INT_MONITORFILEUSBONLY', CP)]); // 파일 변경 감시, USB 연결 시에만
|
|
FileMon.CreateEvt := BooleanStr(aO.S[MgPo_.GetPoKey('INT_MONITORFILECREATE', CP)]); // 파일 변경 감시, 파일 생성 이벤트 감시
|
|
FileMon.DeleteEvt := BooleanStr(aO.S[MgPo_.GetPoKey('INT_MONITORFILEDELETE', CP)]); // 파일 변경 감시, 파일 삭제 이벤트 감시
|
|
FileMon.ModifyEvt := BooleanStr(aO.S[MgPo_.GetPoKey('INT_MONITORFILEMODIFY', CP)]); // 파일 변경 감시, 파일 수정 이벤트 감시
|
|
FileMon.RenameEvt := BooleanStr(aO.S[MgPo_.GetPoKey('INT_MONITORFILENAMECHANGE', CP)]); // 파일 변경 감시, 파일 이름변경 이벤트 감시
|
|
FileMon.sExts := StrListToCommaStr(UpperCase(aO.S[MgPo_.GetPoKey('INT_MONITORFILEEXTENSION', CP)]), '|');
|
|
FileMon.DoEnc := BooleanStr(aO.S[MgPo_.GetPoKey('INT_MONITORFILEENCRYPT', CP)]); // [대응] 암호화
|
|
sTemp := UpperCase(aO.S[MgPo_.GetPoKey('INT_MONITORFILEEXCEPTFOLDER', CP)]);
|
|
if sTemp.StartsWith('$NOLOG') then
|
|
begin
|
|
FileMonNoLog := FileMon.DoEnc;
|
|
if FileMonNoLog then
|
|
FileMon.IsNoti := false;
|
|
sTemp := StringReplace(sTemp, '$NOLOG', '', [rfReplaceAll]);
|
|
end else
|
|
FileMonNoLog := false;
|
|
FileMon.sExceptPath := StrListToCommaStr(sTemp, '|'); // 파일 변경 감시, 예외 폴더
|
|
FileMon.IsCollectTxt := BooleanStr(aO.S[MgPo_.GetPoKey('INT_MONITORFILEGETCONTENTS', CP)]); // 파일 변경 감시, 원문 수집
|
|
FileMon.IsCollectFile := BooleanStr(aO.S[MgPo_.GetPoKey('INT_MONITORFILEGETFILE', CP)]); // 파일 변경 감시, 원본 파일 수집
|
|
FileMon.ContentFilter.bActive := BooleanStr(aO.S[MgPo_.GetPoKey('INT_MONITORFILTERENABLE', CP)]);
|
|
FileMon.ContentFilter.nHitLimit := BooleanToInt(FileMon.ContentFilter.bActive, 1, 0) ; // old : KEY_MONITORBYSCANCNT
|
|
// INT_MONITORFILEAND // 파일 변경 감시, 필터 AND 조건
|
|
// INT_MONITORHIGHNOTICE // 파일 변경 감시, HIGH 알림
|
|
FileMon.ContentFilter.sPatterns := aO.S[MgPo_.GetPoKey('INT_MONITORCRLIST', CP)];
|
|
FileMonLimitMB := StrToIntDef(aO.S[MgPo_.GetPoKey('int_monitorFileGetFileSize', CP)], 20);
|
|
FileMonMinMB := StrToIntDef(aO.S[MgPo_.GetPoKey('int_monitorFileSize', CP)], 0);
|
|
FileMonEncDelaySec := StrToIntDef(aO.S[MgPo_.GetPoKey('int_monitorFileEncryptTime', CP)], 0);
|
|
if (CUSTOMER_TYPE = CUSTOMER_KDNVN) and (FileMonEncDelaySec = 0) then
|
|
FileMonEncDelaySec := 600;
|
|
FileOpenMon := BooleanStr(aO.S[MgPo_.GetPoKey('int_monitorFileAccess', CP)]);
|
|
|
|
sTemp := aO.S[MgPo_.GetPoKey('int_collectSrcOnFileCreate', CP)];
|
|
O := SO(sTemp);
|
|
FmCreateCol.bTxt := O.B['text'];
|
|
FmCreateCol.bFile := O.B['file'];
|
|
O := GetJsonObj('int_collectSrcOnFileModify');
|
|
FmModifyCol.bTxt := O.B['text'];
|
|
FmModifyCol.bFile := O.B['file'];
|
|
O := GetJsonObj('int_collectSrcOnFileRename');
|
|
fmRenameCol.bTxt := O.B['text'];
|
|
fmRenameCol.bFile := O.B['file'];
|
|
|
|
sTemp := aO.S[MgPo_.GetPoKey('INT_PREVENTFILECHANGE', CP)].ToLower;
|
|
if sTemp = 'true' then
|
|
FileBlock.Kind := fmkAll
|
|
else if sTemp ='partial' then
|
|
FileBlock.Kind := fmkIncExt
|
|
else if sTemp ='except' then
|
|
FileBlock.Kind := fmkIgrExt
|
|
else
|
|
FileBlock.Kind := fmkNone;
|
|
IsDrmAttAbleFB := BooleanStr(aO.S[MgPo_.GetPoKey('INT_FILEDRMONLYSEND', CP)]);
|
|
FileBlock.IsNoti := BooleanStr(aO.S[MgPo_.GetPoKey('INT_PREVENTFILENOTICE', CP)]); // 파일 저장 차단, 사용자 알림
|
|
FileBlock.OnlyUSB := BooleanStr(aO.S[MgPo_.GetPoKey('INT_PREVENTFILEUSBONLY', CP)]); // 파일 저장 차단, USB 연결 시에만
|
|
FileBlock.IsCollectTxt := BooleanStr(aO.S[MgPo_.GetPoKey('INT_PREVENTFILEGETCONTENTS', CP)]); // 파일 저장 차단, 원문 수집
|
|
FileBlock.IsCollectFile := BooleanStr(aO.S[MgPo_.GetPoKey('INT_PREVENTFILEGETFILE', CP)]); // 파일 저장 차단, 원본 파일 수집
|
|
FileBlock.sExts := StrListToCommaStr(UpperCase(aO.S[MgPo_.GetPoKey('INT_PREVENTFILEEXTENSION', CP)]), '|');
|
|
FileBlock.sExceptPath := StrListToCommaStr(UpperCase(aO.S[MgPo_.GetPoKey('INT_PREVENTFILEEXCEPTFOLDER', CP)]), '|');
|
|
FileBlock.DoEnc := false;
|
|
// INT_PREVENTFILEEXCEPTFOLDER // 파일 저장 차단, 예외 폴더
|
|
FileBlock.ContentFilter.bActive := aO.S[MgPo_.GetPoKey('INT_PREVENTFILTERENABLE', CP)].ToLower = 'true';
|
|
FileBlock.ContentFilter.nHitLimit := BooleanToInt(FileBlock.ContentFilter.bActive, 1, 0); // old : KEY_WRITEBYSCANCNT
|
|
// INT_PREVENTFILEAND // 파일 저장 차단, 필터 AND 조건
|
|
// INT_PREVENTHIGHNOTICE // 파일 저장 차단, HIGH 알림
|
|
FileBlock.ContentFilter.sPatterns := aO.S[MgPo_.GetPoKey('INT_PREVENTCRLIST', CP)];
|
|
FileBlkLimitMB := StrToIntDef(aO.S[MgPo_.GetPoKey('int_preventFileGetFileSize', CP)], 20);
|
|
FileBlkMinMB := StrToIntDef(aO.S[MgPo_.GetPoKey('int_preventFileSize', CP)], 0);
|
|
|
|
IsPreventDownloads := aO.S[MgPo_.GetPoKey('INT_BLOCKDOWNLOADFOLDER', CP)].ToLower = 'true';
|
|
sTemp := aO.S[MgPo_.GetPoKey('INT_BLOCKFILENAME', CP)].ToLower;
|
|
if sTemp = 'recursive' then
|
|
BlockFdRename := bdrAll
|
|
else if sTemp ='folderonly' then
|
|
BlockFdRename := bdrThis
|
|
// else if sTemp = 'popup' then
|
|
// BlockFdRename := bdrPopup
|
|
// else if sTemp = 'logonly' then
|
|
// BlockFdRename := bdrLog
|
|
else
|
|
BlockFdRename := bdrFalse;
|
|
|
|
if sTemp = 'nonexecutor' then // 비 실행파일
|
|
BlockFRename := bfrNoExe
|
|
else if sTemp = 'executor' then
|
|
BlockFRename := bfrExe
|
|
else if sTemp ='true' then
|
|
BlockFRename := bfrAll
|
|
// else if sTemp = 'popup' then
|
|
// BlockFRename := bfrPopup
|
|
// else if sTemp = 'logonly' then
|
|
// BlockFRename := bfrLog
|
|
else
|
|
BlockFRename := bfrFalse;
|
|
// INT_BLOCKFILENAMENOTICE // 파일 이름 변경 차단, 사용자 알림
|
|
BlockDirFileRenames := UpperCase(StrListToCommaStr(aO.S[MgPo_.GetPoKey('INT_BLOCKFILEDIRLIST', CP)], '|'));
|
|
BlockFRenames := UpperCase(StrListToCommaStr(aO.S[MgPo_.GetPoKey('INT_BLOCKFILEKEYWORD', CP)], '|'));
|
|
sTemp := aO.S[MgPo_.GetPoKey('INT_POPUPTYPE', CP)].ToLower;
|
|
if sTemp = 'simple' then
|
|
NotifyType := nftMin
|
|
else if sTemp = 'wincenter' then
|
|
NotifyType := nftACenter
|
|
else
|
|
NotifyType := nftNormal; // 'default'
|
|
NotiCloseSec := StrToIntDef(aO.S[MgPo_.GetPoKey('int_popUpTimeOut', CP)], 0);
|
|
if BooleanStr(aO.S[MgPo_.GetPoKey('INT_POPUPPOL', CP)]) and BooleanStr(aO.S[MgPo_.GetPoKey('INT_POPUPVUL', CP)]) then
|
|
NotifyKind := nfkAll
|
|
else if BooleanStr(aO.S[MgPo_.GetPoKey('INT_POPUPPOL', CP)]) then
|
|
NotifyKind := nfkPol
|
|
else if BooleanStr(aO.S[MgPo_.GetPoKey('INT_POPUPVUL', CP)]) then
|
|
NotifyKind := nfkVul
|
|
else NotifyKind := nfkNone;
|
|
IsNotiSystem := BooleanStr(aO.S[MgPo_.GetPoKey('INT_POPUPMOD', CP)]);
|
|
// INT_ZIPNESTMAXCNT // 컨텐츠 필터, 압축 파일 중첩 제한, 숫자
|
|
// INT_EXTRACTMAXTIME // 컨텐츠 필터, 타임아웃
|
|
// INT_EXTRACTMAXSIZE // 컨텐츠 필터, 최대 크기
|
|
|
|
CfZipDepth := StrToIntDef(aO.S[MgPo_.GetPoKey('INT_ZIPNESTMAXCNT', CP)], 7);
|
|
CfTimeoutSec := StrToIntDef(aO.S[MgPo_.GetPoKey('INT_EXTRACTMAXTIME', CP)], 20);
|
|
CfLimitMB := StrToIntDef(aO.S[MgPo_.GetPoKey('INT_EXTRACTMAXSIZE', CP)], 20);
|
|
|
|
ScreenLogoUpdateMin := StrToIntDef(aO.S[MgPo_.GetPoKey('INT_SCRNWATERMARKREFRESH', CP)], 0);
|
|
ScreenLogoAlpha := StrToIntDef(aO.S[MgPo_.GetPoKey('INT_WMTRANSPARENT', CP)], 0);
|
|
if ScreenLogoAlpha < 0 then
|
|
ScreenLogoAlpha := 0
|
|
else if ScreenLogoAlpha > 255 then
|
|
ScreenLogoAlpha := 255;
|
|
IsIgrScrCapKeyCB := BooleanStr(aO.S[MgPo_.GetPoKey('INT_CLIPBOARDPRTSCR', CP)]);
|
|
|
|
EtcNicBlock := BooleanStr(aO.S[MgPo_.GetPoKey('INT_BLOCKHOTSPOT', CP)]);
|
|
EtcNicBlockNoti := BooleanStr(aO.S[MgPo_.GetPoKey('INT_USBTETHERINGNOTICE', CP)]);
|
|
EtcNicBlockExcept := UpperCase(StrListToCommaStr(aO.S[MgPo_.GetPoKey('int_exceptionNetworkList', CP)], '|'));
|
|
|
|
O := GetJsonObj('int_netShareFolderFileCfg');
|
|
ShFileCrMon.sMode := ''; // 사용하지 않음
|
|
if O.S['mode'] = 'true' then
|
|
ShFileCrMon.nKind := 2
|
|
else if O.S['mode'] = 'log' then
|
|
ShFileCrMon.nKind := 1
|
|
else
|
|
ShFileCrMon.nKind := 0;
|
|
ShFileCrMon.bBlkNoti := O.B['blkNoti'];
|
|
ShFileCrMon.bMonNoti := O.B['monNoti'];
|
|
if (O.O['pathList'] <> nil) and (O.O['pathList'].DataType = stArray) then
|
|
begin
|
|
sTemp := '';
|
|
for i := 0 to O.A['pathList'].Length - 1 do
|
|
SumString(sTemp, O.A['pathList'].S[i], '|');
|
|
|
|
ShFileCrMon.sExpLst := sTemp;
|
|
end;
|
|
|
|
sTemp := aO.S[MgPo_.GetPoKey('int_winStatusLog', CP)].ToLower;
|
|
IsPcStatePower := sTemp.Contains('pcpower');
|
|
IsPcStateIpCh := sTemp.Contains('ipchange');
|
|
|
|
O := GetJsonObj('int_appScreenRec');
|
|
AppRcdNoti := O.B['noti'];
|
|
AppRcdActive := (O.S['use'] <> '') and (O.S['use'] <> 'false');
|
|
AppRcdMaxMin := O.I['maxMins'];
|
|
if AppRcdMaxMin = 0 then
|
|
AppRcdMaxMin := 3;
|
|
if (O.O['appList'] <> nil) and (O.O['appList'].DataType = stArray) then
|
|
begin
|
|
var sTmp: String := '';
|
|
for i := 0 to O.A['appList'].Length - 1 do
|
|
SumString(sTmp, O.A['appList'].S[i], '|');
|
|
|
|
if sTmp <> AppRcdApps then
|
|
AppRcdApps := sTmp;
|
|
end;
|
|
|
|
// mgkim 정책 추가확인 26-03-16 블루투스 파일 반출 차단 정책 추가
|
|
//{
|
|
// "mode": "partial", # 모드
|
|
// "userAlert": true, #사용자 알림 수행
|
|
// "extList": [ # 확장 목록
|
|
// "jpg",
|
|
// "exe",
|
|
// "png"
|
|
// ],
|
|
// "excList": [ # 예외 목록
|
|
// "gif",
|
|
// "hi"
|
|
// ],
|
|
// "origTextCol": true, # 원문 수집
|
|
// "origFileCol": {
|
|
// "use": true, # 원본 수집
|
|
// "maxMb": 30, # 다음 크기까지
|
|
// "minMb": 20 # 다음 크기이상
|
|
// },
|
|
// "fileNameChk": true, # 파일 이름 검사
|
|
// "contentsFilter": {
|
|
// "use": true, # 컨텐츠 필터 사용 여부
|
|
// "list": [ # 선택된 컨텐츠 필터
|
|
// "D017",
|
|
// "D018"
|
|
// ]
|
|
// },
|
|
// "blockByFilename": { # 파일명 차단
|
|
// "use": false, # 파일명 차단 사용 여부
|
|
// "list": [] # 파일명 리스트
|
|
// },
|
|
// "blockBySig": { # 시그니처 차단
|
|
// "use": false, # 시그니처 차단 사용 여부
|
|
// "list": [] # 시그니처 리스트
|
|
// },
|
|
// "blockBySizeLimit": { # 크기 차단
|
|
// "use": false, # 크기 차단 사용 여부
|
|
// "minMb": 0 # 다음 크기 이상
|
|
// }
|
|
//}
|
|
|
|
IntBtBlockNewFile:= GetIniBlockFileNew('int_btBlockNewFile');
|
|
_Trace('블루 투스 파일 차단 정책 시작 : mode : %d, content : %s',[Integer(IntBtBlockNewFile.mode), IntBtBlockNewFile.contentsFilter_list], 1);
|
|
IntUsbBlockNewFile:= GetIniBlockFileNew('int_usbBlockNewFile');
|
|
_Trace('Usb 파일 차단 정책 시작 : mode : %d, content : %s',[Integer(IntUsbBlockNewFile.mode), IntUsbBlockNewFile.contentsFilter_list], 1);
|
|
IntUsbToUsbBlockNewFile:= GetIniBlockFileNew('int_usbToUsbBlockNewFile');
|
|
_Trace('Usb To Usb 파일 차단 정책 시작 : mode : %d, content : %s',[Integer(IntUsbToUsbBlockNewFile.mode), IntUsbToUsbBlockNewFile.contentsFilter_list], 1);
|
|
IntCdromBlockNewFile:= GetIniBlockFileNew('int_cdBlockNewFile');
|
|
_Trace('Cdrom 파일 차단 정책 시작 : mode : %d, content : %s',[Integer(IntCdromBlockNewFile.mode), IntCdromBlockNewFile.contentsFilter_list], 1);
|
|
IntMtpBlockNewFile:= GetIniBlockFileNew('int_mtpBlockNewFile');
|
|
_Trace('Mtp 파일 차단 정책 시작 : mode : %d, content : %s',[Integer(IntMtpBlockNewFile.mode), IntMtpBlockNewFile.contentsFilter_list], 1);
|
|
|
|
bLoaded_ := true;
|
|
IsOldPolicy := false;
|
|
ProcessAfterSetPolicy;
|
|
except
|
|
on E: Exception do
|
|
ETgException.TraceException(Self, E, 'Fail .. LoadFromJsonObj()');
|
|
end;
|
|
end;
|
|
|
|
procedure TPrefModel.SetOldDefault;
|
|
begin
|
|
if IsOldPolicy then
|
|
begin
|
|
// 올드 정책에 강제 처리해야할 정책
|
|
FileMon.CreateEvt := true;
|
|
FileMon.ModifyEvt := true;
|
|
FileMon.DeleteEvt := true;
|
|
FileMon.RenameEvt := true;
|
|
FileMon.DoEnc := false;
|
|
FileOpenMon := false;
|
|
IsNotiSystem := true;
|
|
IsSecuEndActions := true;
|
|
CheckAllowMAC := true;
|
|
IsBlockAppNotice := true;
|
|
IsBlockAppLog := false;
|
|
IsMonApp := false;
|
|
IsMonAppNoti := false;
|
|
IsFixedVerUpdate := false;
|
|
IsNetBlockDay := false;
|
|
IsNotiBCA := true;
|
|
FileMonNoLog := false;
|
|
EtcNicBlockNoti := true;
|
|
EtcNicBlockExcept := '';
|
|
ScreenLogoVisible := true;
|
|
ScreenLogoInvisible := false;
|
|
PrinterIpExcept := '';
|
|
PrtWtExpUrl := '';
|
|
PrtWtExpDocName := '';
|
|
PrtWtExpPrtName := '';
|
|
PrtWtExpProcName := '';
|
|
PrtApvExpUrl := '';
|
|
PrtApvExpDocName := '';
|
|
PrtApvExpPrtName := '';
|
|
PrtApvExpProcName := '';
|
|
ZeroMemory(@PrtWaterCfg, SizeOf(PrtWaterCfg));
|
|
PrintApproval := false;
|
|
PrintApprovalPost := false;
|
|
UsbApproval := false;
|
|
WebUrlApproval := false;
|
|
|
|
EtcAB.bReadBlock := true;
|
|
EtcAB.bWriteBlock := false;
|
|
WebbAB.bReadBlock := true;
|
|
WebbAB.bWriteBlock := false;
|
|
OutlookAB.bReadBlock := true;
|
|
OutlookAB.bWriteBlock := false;
|
|
CbPopup := true;
|
|
CbImgBlock := false;
|
|
|
|
NotiCloseSec := 0;
|
|
WebABLimitMB := 50;
|
|
AppABLimitMB := 50;
|
|
OutABLimitMB := 50;
|
|
FileMonLimitMB := 50;
|
|
FileBlkLimitMB := 50;
|
|
FileExpMinMB := 0;
|
|
FileExpMaxMB := 50;
|
|
WebABMinMB := 0;
|
|
AppABMinMB := 0;
|
|
OutABMinMB := 0;
|
|
OutFileBlockMB := 0;
|
|
WebFileBlockMB := 0;
|
|
AppFileBlockMB := 0;
|
|
FileMonMinMB := 0;
|
|
FileBlkMinMB := 0;
|
|
PrtMinMB := 0;
|
|
PrtMaxMB := 20;
|
|
IsIgrCollectCutWebAB := false;
|
|
IsAllowLogWebAB := false; // X
|
|
IsIgrCollectCutAppAB := false;
|
|
IsAllowLogAppAB := false;
|
|
IsPrtCollectThum := false;
|
|
PrtCollThumLimit := 3;
|
|
FileMonEncDelaySec := 0;
|
|
IsUrlCatchLogo := false;
|
|
IsPcStatePower := false;
|
|
IsPcStateIpCh := false;
|
|
IsSmbPortBlock := false;
|
|
SMBPortExceptList := '';
|
|
LogoUrlList := '';
|
|
WebAbSigs := '';
|
|
WebAbFNames := '';
|
|
WebABLogUrlList := '';
|
|
EtcAbLogList := '';
|
|
EtcAbSigs := '';
|
|
EtcAbFNames := '';
|
|
PrtNameH := 'CANON';
|
|
PrtWaterAppH := '';
|
|
PrtWaterAppHig := '';
|
|
CfFblkExts := '';
|
|
WebAbExts := '';
|
|
EtcAbExts := '';
|
|
SmbPortEx := '';
|
|
AipEncMSec := 0;
|
|
FileExpMin := 60;
|
|
LogKeepDays := 10;
|
|
BtConNotiDSec := 0;
|
|
PrtOcrTxtExtList.Clear;
|
|
|
|
WifiBlockPopup := true;
|
|
WifiAllowPopup := false;
|
|
WifiGpsOn := false;
|
|
OutBodyAllowPopup := false;
|
|
OutFileAllowPopup := false;
|
|
ShareFldBlockPopup := true;
|
|
ShareFldAllowPopup := false;
|
|
UsbAllowPopup := false;
|
|
MtpAllowPopup := false;
|
|
BtAllowPopup := false;
|
|
CdAllowPopup := false;
|
|
PrtAllowPopup := false;
|
|
HdMonPopup := false;
|
|
end;
|
|
end;
|
|
|
|
function TPrefModel.LoadFromJsonObj_Old(aO: ISuperObject): Boolean;
|
|
var
|
|
sTemp: String;
|
|
q: Integer;
|
|
dt: TDateTime;
|
|
begin
|
|
Result := false;
|
|
with aO do
|
|
begin
|
|
// sTemp := Trim(S['mwPKey_LOCNAME']);
|
|
// if (sTemp = '') and (PolicyName <> '') then
|
|
// begin
|
|
// _Trace('Faill .. LoadFromJsonObj() .. EmptyPolicy?=[%s]', [aO.AsString]);
|
|
// exit;
|
|
// end;
|
|
PolicyId := '2.6_USE';
|
|
PolicyGroup := Trim(S['mwPKey_LOCNAME']); // Trim(S['mwPKey_GROUPNAME']);
|
|
PolicyName := Trim(S['mwPKey_POLICYNAME']);
|
|
DeptName := Trim(S['mwPKey_DEPTNAME']);
|
|
Language := Trim(S['mwPKey_LANGUAGE']);
|
|
sTemp := Trim(S['mwPKey_EULASUBMIT']).ToLower;
|
|
IsEulaSubmit := (sTemp = 'true') or (sTemp = 'contents');
|
|
VpnAppName := Trim(S['mwPKey_VPNAPPNAME']);
|
|
sTemp := Trim(S['mwPKey_AGENTAUTO']).ToLower;
|
|
IsEnableCheck := (sTemp <> '') and (sTemp <> 'false');
|
|
sTemp := Trim(S['mwPKey_PCTURNOFF']).ToLower;
|
|
if sTemp = 'true' then
|
|
ScreenLockKind := slkDef
|
|
else if sTemp ='custom' then
|
|
ScreenLockKind := slkCustom
|
|
else
|
|
ScreenLockKind := slkNone;
|
|
if ScreenLockKind <> slkNone then
|
|
begin
|
|
sTemp := Trim(S['mwPKey_SCRNLOCKTIME']);
|
|
ForceScreenLock := BooleanToStr(sTemp = '', '0', sTemp);
|
|
ForceScreenLockMin := StrToIntDef(ForceScreenLock, 0);
|
|
end else begin
|
|
ForceScreenLock := '0';
|
|
ForceScreenLockMin := 0;
|
|
end;
|
|
if Trim(S['KEY_SYSTEMOFF']).ToLower = 'true' then
|
|
ForceShutdownMin := StrToIntDef(Trim(S['KEY_SYSTEMOFFTIME']), 0)
|
|
else
|
|
ForceShutdownMin := 0;
|
|
IsUnsafeActions := Trim(S['KEY_MODEOFF']).ToLower = 'true';
|
|
if IsUnsafeActions then
|
|
begin
|
|
UnsafeActionsMin := StrToIntDef(Trim(S['KEY_MODEOFFTIME']), 10);
|
|
if UnsafeActionsMin = 0 then
|
|
UnsafeActionsMin := 10;
|
|
end else
|
|
UnsafeActionsMin := 0;
|
|
IsWaterMark := Trim(S['mwPKey_WATERMARK']).ToLower = 'true';
|
|
|
|
// sDrmCttSchPtrn_ := S['KEY_LISTCRFILEDRM'];
|
|
|
|
// FileMonOnlyLog
|
|
sTemp := Trim(S['mwPKey_FILEMONITOR']).ToLower;
|
|
if sTemp = 'true' then
|
|
FileMon.Kind := fmkAll
|
|
else if sTemp ='partial' then
|
|
FileMon.Kind := fmkIncExt
|
|
else if sTemp ='except' then
|
|
FileMon.Kind := fmkIgrExt
|
|
else if sTemp = 'logonly' then
|
|
begin
|
|
FileMon.Kind := fmkIgrExt;
|
|
end else
|
|
if sTemp = 'logonly2' then
|
|
begin
|
|
FileMon.Kind := fmkIncExt;
|
|
end else
|
|
if sTemp = 'logonly3' then
|
|
begin
|
|
FileMon.Kind := fmkAll;
|
|
end else
|
|
FileMon.Kind := fmkNone;
|
|
FileMon.IsNoti := true;
|
|
FileMonOnlyLog := Pos('logonly', sTemp) > 0;
|
|
FileMon.OnlyUSB := Trim(S['KEY_MONITORFILEUSBONLY']).ToLower = 'true'; // 추가 23_1103 11:02:59 kku
|
|
FileMon.CreateEvt := true;
|
|
FileMon.ModifyEvt := true;
|
|
FileMon.DeleteEvt := true;
|
|
FileMon.RenameEvt := true;
|
|
FileMon.ContentFilter.bActive := Trim(S['KEY_CRFILEMONITOR']).ToLower = 'true';
|
|
FileMon.ContentFilter.sPatterns := S['KEY_LISTCRFILEMONITOR'];
|
|
FileMon.ContentFilter.nHitLimit := StrToIntDef(Trim(S['KEY_MONITORBYSCANCNT']), 0);
|
|
if FileMon.ContentFilter.nHitLimit = 0 then
|
|
FileMon.ContentFilter.nHitLimit := 1;
|
|
|
|
sTemp := Trim(S['mwPKey_SAVFILE']).ToLower;
|
|
if sTemp = 'true' then
|
|
FileBlock.Kind := fmkAll
|
|
else if sTemp ='partial' then
|
|
FileBlock.Kind := fmkIncExt
|
|
else if sTemp ='except' then
|
|
FileBlock.Kind := fmkIgrExt
|
|
else
|
|
FileBlock.Kind := fmkNone;
|
|
FileBlock.ContentFilter.bActive := Trim(S['KEY_CRFILEWRITE']).ToLower = 'true';
|
|
FileBlock.ContentFilter.sPatterns := S['KEY_LISTCRFILEWRITE'];
|
|
FileBlock.ContentFilter.nHitLimit := StrToIntDef(Trim(S['KEY_WRITEBYSCANCNT']), 0);
|
|
if FileBlock.ContentFilter.nHitLimit = 0 then
|
|
FileBlock.ContentFilter.nHitLimit := 1;
|
|
|
|
FileMonExt := StrListToCommaStr(UpperCase(Trim(S['KEY_FILEEXTLIST'])), '|');
|
|
// bIsBlockPending_ := false; //Trim(S['mwPKey_BLOCKPENDING']).ToLower = 'true';
|
|
// IsMasking := Trim(S['mwPKey_MASKING']) = 'true'; // 마스킹 기능 정책 삭제됨 23_0421 09:09:33 kku
|
|
|
|
DrmCF.bActive := Trim(S['KEY_CRFILEDRM']).ToLower = 'true';
|
|
DrmCF.sPatterns := S['KEY_LISTCRFILEDRM'];
|
|
DrmCF.nHitLimit := StrToIntDef(Trim(S['KEY_DRMBYSCANCNT']), 0);
|
|
if DrmCF.nHitLimit = 0 then
|
|
DrmCF.nHitLimit := 1;
|
|
|
|
VpnHour := Trim(S['KEY_VPNHOURRANGE']);
|
|
|
|
sTemp := Trim(S['mwPKey_PRINTERABLE']).ToLower;
|
|
if sTemp = 'true' then
|
|
begin
|
|
Print.PrintKind := pkBlock;
|
|
Print.bPopup := true;
|
|
end else
|
|
if sTemp = 'popup' then
|
|
begin
|
|
Print.PrintKind := pkLog;
|
|
Print.bPopup := true;
|
|
end else
|
|
if sTemp = 'watermark' then
|
|
begin
|
|
// 구버전 출력 보안을 위해 유지함 23_0131 15:19:47 kku
|
|
Print.PrintWater := pwActive;
|
|
Print.PrintKind := pkLog;
|
|
Print.bPopup := true;
|
|
end
|
|
else if sTemp = 'logonly' then
|
|
begin
|
|
Print.PrintKind := pkLog;
|
|
Print.bPopup := false;
|
|
end else
|
|
Print.PrintKind := pkNone;
|
|
// sTemp := Trim(S['KEY_PRINTEXCEPT']).ToLower;
|
|
// if sTemp = 'true' then
|
|
// Print.PrinterExcept := bkBlack
|
|
// else if sTemp = 'whitelist' then
|
|
// Print.PrinterExcept := bkWhite
|
|
// else
|
|
// Print.PrinterExcept := bkNone;
|
|
Print.sWaterExcepts := StrListToCommaStr(UpperCase(aO.S['KEY_PRINTWATERMARKEXCEPT']), '|', false, true);
|
|
Print.sPrinterExcepts := StrListToCommaStr(UpperCase(Trim(S['KEY_PRINTLIST'])), '|', false, true);
|
|
Print.ContentFilter.bActive := Trim(S['KEY_CRFILEPRINTER']).ToLower = 'true';
|
|
Print.ContentFilter.sPatterns := S['KEY_LISTCRFILEPRINTER'];
|
|
Print.bDateBlock := Trim(S['KEY_PRINTDAYBLOCK']).ToLower = 'true';
|
|
if Print.bDateBlock then
|
|
begin
|
|
Print.dtBlockB:= StrToDateDef(Trim(S['KEY_PRINTDAYSTART']), 0);
|
|
if Print.dtBlockB <> 0 then
|
|
Print.dtBlockB := AppendTime(Print.dtBlockB, 0, 0, 0, 0);
|
|
Print.dtBlockE := StrToDateDef(Trim(S['KEY_PRINTDAYEND']), 0);
|
|
if Print.dtBlockE <> 0 then
|
|
Print.dtBlockE := AppendTime(Print.dtBlockE, 23, 59, 59, 0);
|
|
end;
|
|
// sTemp := Trim(S['KEY_PRINTAPPEXCEPT']).ToLower;
|
|
// if sTemp = 'true' then
|
|
// Print.PrintAppExcept := bkBlack
|
|
// else if sTemp = 'whitelist' then
|
|
// Print.PrintAppExcept := bkWhite
|
|
// else
|
|
// Print.PrintAppExcept := bkNone;
|
|
Print.sPrintAppExcepts := StrListToCommaStr(UpperCase(Trim(S['KEY_PRINTAPPLIST'])), '|', false, true);
|
|
// sTemp := Trim(S['KEY_PRINTURLEXCEPT']).ToLower;
|
|
// if sTemp = 'true' then
|
|
// Print.PrintUrlExcept := bkBlack
|
|
// else if sTemp = 'whitelist' then
|
|
// Print.PrintUrlExcept := bkWhite
|
|
// else
|
|
// Print.PrintUrlExcept := bkNone;
|
|
Print.sPrintUrlExcepts := StrListToCommaStr(UpperCase(Trim(S['KEY_PRINTURLLIST'])), '|', false, true);
|
|
Print.sPrintDocExcepts := '';
|
|
sTemp := Trim(S['KEY_PRINTWATERMARK']).ToLower;
|
|
if sTemp = 'true' then
|
|
Print.PrintWater := pwActive
|
|
else if sTemp = 'approve' then
|
|
Print.PrintWater := pwApprove
|
|
else
|
|
Print.PrintWater := pwNone;
|
|
Print.ContentFilter.nHitLimit := StrToIntDef(Trim(S['KEY_PRINTBYSCANCNT']), 0);
|
|
if Print.ContentFilter.nHitLimit = 0 then
|
|
Print.ContentFilter.nHitLimit := 1;
|
|
|
|
IsDefPortBlock := Trim(S['mwPKey_DEFPORTBLOCK']).ToLower = 'true';
|
|
SoftwareListB := Trim(S['mwPKey_BLOCKSWLIST']);
|
|
if SoftwareListB.ToLower = 'false' then
|
|
SoftwareListB := ''
|
|
else
|
|
SoftwareListB := StrListToCommaStr(SoftwareListB, ';');
|
|
SoftwareListW := Trim(S['mwPKey_WHITESWLIST']);
|
|
if SoftwareListW.ToLower = 'false' then
|
|
SoftwareListW := ''
|
|
else
|
|
SoftwareListW := StrListToCommaStr(SoftwareListW, ';');
|
|
// sSoftwareControlType_ := Trim(S['mwPKey_SWCONTROLTYPE']);
|
|
IsMustSecuApp := Trim(S['mwPKey_SWCONTROLUSE']).ToLower = 'true';
|
|
IsBlockApp := Trim(S['mwPKey_SWCONTROLTYPE']).ToLower = 'true';
|
|
|
|
IsAppBlackDate := Trim(S['KEY_APPDAYBLOCK']) = 'true';
|
|
IsAppBlackTime := Trim(S['KEY_APPHOURBLOCK']) = 'true';
|
|
IsLongtimeDisconn := Trim(S['mwPKey_LOCKUSER']) = 'true';
|
|
IsShowPolicy := Trim(S['mwPKey_SHOWPOLICY']) = 'true';
|
|
IsShowAInfo := Trim(S['KEY_DISPLAYAGENTINFO']) = 'true';
|
|
|
|
AppBlackDateB := StrToDateDef(Trim(S['KEY_APPDAYSTART']), 0);
|
|
if AppBlackDateB <> 0 then
|
|
AppBlackDateB := AppendTime(AppBlackDateB, 0, 0, 0, 0);
|
|
AppBlackDateE := StrToDateDef(Trim(S['KEY_APPDAYEND']), 0);
|
|
if AppBlackDateE <> 0 then
|
|
AppBlackDateE := AppendTime(AppBlackDateE, 23, 59, 59, 0);
|
|
AppBlackTimeB := -1;
|
|
AppBlackTimeE := -1;
|
|
sTemp := Trim(S['KEY_APPHOURRANGE']);
|
|
if sTemp <> '' then
|
|
begin
|
|
q := Pos(';', sTemp);
|
|
if q > 0 then
|
|
begin
|
|
AppBlackTimeB := StrToIntDef(Copy(sTemp, 1, q - 1), -1);
|
|
System.Delete(sTemp, 1, q);
|
|
AppBlackTimeE := StrToIntDef(sTemp, -1);
|
|
end;
|
|
end;
|
|
|
|
HeartbeatTime := StrToIntDef(Trim(S['mwPKey_HEARTBEAT']), 90);
|
|
IsAgentUpdateExist := Trim(S['mwPKey_ISAGENTPATCHEXIST']) = 'true';
|
|
|
|
sTemp := Trim(S['mwPKey_LOGODISPLAY']).ToLower;
|
|
if sTemp = 'true' then
|
|
ScreenLogo := askAlways
|
|
else if sTemp = 'blacklistprocess' then
|
|
ScreenLogo := askRunTargetOn
|
|
else if sTemp = 'blacklistusage' then
|
|
ScreenLogo := askUseTargetOn
|
|
else if sTemp = 'whitelistprocess' then
|
|
ScreenLogo := askRunTargetOff
|
|
else if sTemp = 'whitelistusage' then
|
|
ScreenLogo := askUseTargetOff
|
|
else
|
|
ScreenLogo := askNone;
|
|
ScreenLogoApps := StrListToCommaStr(Trim(UpperCase(S['KEY_SCRNWATERMARKLIST'])), ';');
|
|
|
|
sTemp := Trim(S['KEY_CAPTUREAPPEXCEPT']).ToLower;
|
|
if sTemp = 'true' then
|
|
ScreenBlockAppExp := askAlways
|
|
else if sTemp = 'blacklistprocess' then
|
|
ScreenBlockAppExp := askRunTargetOn
|
|
else if sTemp = 'blacklistusage' then
|
|
ScreenBlockAppExp := askUseTargetOn
|
|
else if sTemp = 'whitelistprocess' then
|
|
ScreenBlockAppExp := askRunTargetOff
|
|
else if sTemp = 'whitelistusage' then
|
|
ScreenBlockAppExp := askUseTargetOff
|
|
else
|
|
ScreenBlockAppExp := askNone;
|
|
ScreenBlockAppsExp := StrListToCommaStr(Trim(UpperCase(S['KEY_CAPTUREAPPEXCEPTLIST'])), ';');
|
|
|
|
sTemp := Trim(S['mwPKey_SCRNAPPLIST']);
|
|
NetworkExceptType := BooleanToStr(sTemp = '', 'false', sTemp);
|
|
NetworkExceptList := Trim(S['mwPKey_AVLINK']);
|
|
sTemp := Trim(S['mwPKey_SERVERLIST']);
|
|
NetworkBlockType := BooleanToStr(sTemp = '', 'false', sTemp);
|
|
NetworkBlockList := Trim(S['mwPKey_OSPATCHLIST']);
|
|
IsTemporaryConn := Trim(S['mwPKey_ISOSPATCHSELECT']).ToLower = 'true';
|
|
TemporaryConnMin := StrToIntDef(Trim(S['KEY_BLOCKPENDINGTIME']), 10);
|
|
if IsTemporaryConn and (TemporaryConnMin <= 0) then
|
|
TemporaryConnMin := 10;
|
|
IsAgentDelete := Trim(S['mwPKey_ISAGENTDELETE']).ToLower = 'true';
|
|
// bIsOsPatchCheck := Trim(S['mwPKey_ISCOLLECTREASON']).ToLower = 'true';
|
|
IsNoticeEnable := Trim(S['mwPKey_WEBMAILENABLE']).ToLower = 'true';
|
|
sTemp := Trim(S['mwPKey_OUTLOOKENABLE']).ToLower;
|
|
if sTemp = 'blacklist' then
|
|
ExtraPortEnableType := PREF_PORTEX_BLACK
|
|
else if sTemp = 'whitelist' then
|
|
ExtraPortEnableType := PREF_PORTEX_WHITE
|
|
else
|
|
ExtraPortEnableType := PREF_PORTEX_FALSE;
|
|
IsPreventSettingChange := Trim(S['mwPKey_BLOCKSETTING']).ToLower = 'true';
|
|
AgentPatchVersion := Trim(S['mwPKey_AGENTPATVER']);
|
|
VpnMethod := Trim(S['mwPKey_LOGOLINK']).ToLower;
|
|
NoticeContent := Trim(S['mwPKey_WATERMARKLINK']);
|
|
RestricMac := StrListToCommaStr(Trim(UpperCase(S['mwPKey_EULAONELINK'])), ';');
|
|
|
|
// 기본 만료일 차단으로 하고 "접속 허용" 정책과 OR로 사용함 22_1111 08:50:34 kku
|
|
// RestricDate := Trim(S['mwPKey_EULATWOLINK']);
|
|
RestricDate := StringReplace(Trim(S['mwPKey_EULATWOLINK']), '2099-01-01', '1900-01-01', [rfReplaceAll]);
|
|
dt := AppendTime(TDate(ConvStrToDateTime(RestricDate)), 23, 59, 59, 0);
|
|
IsRestricDate := (dt <> 0) and (CompareDateTime(dt, Now) = -1);
|
|
IsAllowAccess := (Trim(S['mwPKey_TRACEONLY']).ToLower = 'true') or not IsRestricDate;
|
|
|
|
// sSleepList_ := Trim(S['mwPKey_SLEEPLIST']);
|
|
// if sSleepList_.ToLower = 'false' then
|
|
// sSleepList_ := ''
|
|
// else
|
|
// sSleepList_ := StringReplace(sSleepList_, MODEL_SEPARATOR, ';', [rfReplaceAll]);
|
|
// sSleepBlockType_ := Trim(S['mwPKey_SLEEPRESTRIC']).ToLower;
|
|
IsUseAfterReport := Trim(S['mwPKey_COLLECTSUBMIT']).ToLower = 'true';
|
|
IsPreventDownloads := Trim(S['mwPKey_BLOCKDOWNLOAD']).ToLower = 'true';
|
|
sTemp := Trim(S['mwPKey_BLOCKINSTALL']).ToLower;
|
|
if sTemp = 'true' then
|
|
AppInstKind := aikBlock
|
|
else if sTemp = 'popup' then
|
|
AppInstKind := aikPopup
|
|
else if sTemp = 'logonly' then
|
|
AppInstKind := aikLog
|
|
else
|
|
AppInstKind := aikNone;
|
|
IsUninstallAble := Trim(S['mwPKey_UNINSTALLABLE']).ToLower = 'true';
|
|
UninstallPW := '';
|
|
if IsUninstallAble and (Trim(S['KEY_UNINSTALLPASSWORDUSE']).ToLower = 'password') then
|
|
UninstallPW := Trim(S['KEY_UNINSTALLPASSWORD']);
|
|
sTemp := StrListToCommaStr(Trim(S['mwPKey_USBEXCEPT']), ';');
|
|
if sTemp <> '' then
|
|
begin
|
|
SplitString(sTemp, ';', IgrUsbSerialList);
|
|
IgrUsbSerials := sTemp;
|
|
end else begin
|
|
IgrUsbSerials := '';
|
|
IgrUsbSerialsKn := '';
|
|
IgrUsbSerialList.Clear;
|
|
end;
|
|
sTemp := Trim(S['mwPKey_WIFIPREVENT']).ToLower;
|
|
if sTemp = 'popup' then
|
|
WifiCtrlKind := wckPopup
|
|
else if sTemp = 'true' then
|
|
WifiCtrlKind := wckBlock
|
|
else if sTemp = 'blockname' then
|
|
WifiCtrlKind := wckBlockName
|
|
else if sTemp = 'whitelist' then
|
|
WifiCtrlKind := wckWhiteName
|
|
else if sTemp = 'logonly' then
|
|
WifiCtrlKind := wckLog
|
|
else
|
|
WifiCtrlKind := wckNone;
|
|
WifiBlockNames := UpperCase(StrListToCommaStr(Trim(S['KEY_WIFINAMELIST']), ';'));
|
|
IsWifiPublicBlock := Trim(S['mwPKey_PREVENTWIFIPWD']).ToLower = 'true';
|
|
|
|
ScreenLockPwd := Trim(S['KEY_OPTG']);
|
|
if (ScreenLockPwd <> '') and (ScreenLockPwd.ToLower = 'false') then
|
|
ScreenLockPwd := '';
|
|
IsStartupScreenLock := Trim(S['KEY_OPTV']).ToLower = 'true';
|
|
|
|
UnsafeActions := Trim(S['mwPKey_VPNCLOSE']).ToLower;
|
|
// sUnsafePrevents_ := Trim(S['mwPKey_VULLIST']).ToLower;
|
|
|
|
// Option
|
|
sTemp := Trim(S['mwOKey_OPTIONA']).ToLower;
|
|
if sTemp = 'true' then
|
|
NotifyKind := nfkAll
|
|
else if sTemp ='tvul' then
|
|
NotifyKind := nfkVul
|
|
else if sTemp = 'tpol' then
|
|
NotifyKind := nfkPol
|
|
else
|
|
NotifyKind := nfkNone;
|
|
IsNotiSystem := true;
|
|
sTemp := Trim(S['mwPKey_POPUPTYPE']).ToLower;
|
|
if sTemp = 'simple' then
|
|
NotifyType := nftMin
|
|
else if sTemp = 'wincenter' then
|
|
NotifyType := nftACenter
|
|
else
|
|
NotifyType := nftNormal; // 'default'
|
|
sTemp := Trim(S['mwOKey_OPTIONB']).ToLower;
|
|
if sTemp = 'true' then
|
|
begin
|
|
UsbBlockKind := ubkBlock;
|
|
USBPopup := true;
|
|
end else
|
|
if sTemp = 'readonly' then
|
|
begin
|
|
UsbBlockKind := ubkReadOnly;
|
|
USBPopup := true;
|
|
end else
|
|
if sTemp = 'popup' then
|
|
begin
|
|
UsbBlockKind := ubkLog;
|
|
USBPopup := true;
|
|
end else
|
|
if sTemp = 'logonly' then
|
|
begin
|
|
UsbBlockKind := ubkLog;
|
|
USBPopup := false;
|
|
end else
|
|
UsbBlockKind := ubkNone;
|
|
sTemp := Trim(S['KEY_MTPBLOCK']).ToLower;
|
|
if sTemp = 'true' then
|
|
begin
|
|
MtpBlockKind := ubkBlock;
|
|
MTPPopup := true;
|
|
end else
|
|
if sTemp = 'popup' then
|
|
begin
|
|
MtpBlockKind := ubkLog;
|
|
MTPPopup := true;
|
|
end else
|
|
if sTemp = 'logonly' then
|
|
MtpBlockKind := ubkLog
|
|
else
|
|
MtpBlockKind := ubkNone;
|
|
sTemp := Trim(S['KEY_BLUETOOTHBLOCK']).ToLower;
|
|
if sTemp = 'true' then
|
|
begin
|
|
BlueBlockKind := dbkBlock;
|
|
BTPopup := true;
|
|
end else
|
|
if sTemp = 'popup' then
|
|
begin
|
|
BlueBlockKind := dbkLog;
|
|
BTPopup := true;
|
|
end else
|
|
if sTemp = 'logonly' then
|
|
begin
|
|
BlueBlockKind := dbkLog;
|
|
BTPopup := false;
|
|
end else
|
|
BlueBlockKind := dbkNone;
|
|
sTemp := Trim(S['KEY_CDROMBLOCK']).ToLower;
|
|
if sTemp = 'true' then
|
|
CdromBlockKind := ubkBlock
|
|
else if sTemp = 'popup' then
|
|
CdromBlockKind := _ubkPopup
|
|
else if sTemp = 'logonly' then
|
|
CdromBlockKind := ubkLog
|
|
else
|
|
CdromBlockKind := ubkNone;
|
|
|
|
AutoRunBlock := Trim(S['KEY_AUTORUNBLOCK']).ToLower = 'true';
|
|
HostEnable := Trim(S['mwOKey_OPTIONC']).ToLower = 'true';
|
|
RouteEnable := Trim(S['mwOKey_OPTIOND']).ToLower = 'true';
|
|
MtpExcept := StrListToCommaStr(Trim(S['KEY_MTPEXCEPT']), ';');
|
|
MtpExceptVender := StrListToCommaStr(Trim(S['KEY_MTPEXCEPTPROD']), ';');
|
|
BlueExcept := StringReplace(StrListToCommaStr(Trim(S['KEY_BLUETOOTHEXCEPT']), ';'), 'device:', '', [rfReplaceAll]);
|
|
UsbExceptVender := StrListToCommaStr(Trim(S['KEY_USBEXCEPTPROD']), ';');
|
|
BlueExceptVender := StrListToCommaStr(Trim(S['KEY_BLUETOOTHEXPROD']), ';');
|
|
CdromExcept := StrListToCommaStr(Trim(S['KEY_CDROMEXCEPT']), ';');
|
|
|
|
sTemp := Trim(S['mwOKey_OPTIONE']).ToLower;
|
|
if (sTemp = '') or (sTemp = 'null') then
|
|
begin
|
|
sTemp := 'true';
|
|
end else
|
|
if sTemp = 'disconn' then
|
|
begin
|
|
sTemp := 'false';
|
|
end else
|
|
if (sTemp.Length = 8) and sTemp.StartsWith('20') then
|
|
begin
|
|
dt := AppendTime(TDate(ConvStrToDateTime(sTemp)), 23, 59, 59, 0);
|
|
if dt < Now then
|
|
sTemp := 'false'
|
|
else
|
|
sTemp := FormatDateTime('yyyy-mm-dd hh:nn:ss', dt);
|
|
end;
|
|
AllowConn := sTemp;
|
|
BlockPortList := Trim(S['mwPKey_BLOCKPORT']);
|
|
if BlockPortList = '' then
|
|
BlockPortList := Trim(S['mwPKey_OPTIONH']); // 음... wOKey_ 로 와야하는데.. 서버에서 잘못 보내는거 같다 22_0516 08:08:58 kku
|
|
if BlockPortList = '' then
|
|
BlockPortList := Trim(S['mwOKey_OPTIONH']); // 음... wOKey_ 로 와야하는데.. 서버에서 잘못 보내는거 같다 22_0516 08:08:58 kku
|
|
if BlockPortList.ToLower = 'false' then
|
|
BlockPortList := ''
|
|
else
|
|
BlockPortList := StringReplace(BlockPortList, MODEL_SEPARATOR, ';', [rfReplaceAll]);
|
|
VpnIpList := Trim(S['mwOKey_OPTIONK']);
|
|
VpnRcAppList := Trim(S['mwOKey_OPTIONL']);
|
|
sTemp := Trim(S['mwOKey_OPTIONF']).ToLower;
|
|
if sTemp = 'true' then
|
|
OsPatchCheck := opcCheck
|
|
else if sTemp = 'popup' then
|
|
OsPatchCheck := opcPopup
|
|
else if sTemp = 'logonly' then
|
|
OsPatchCheck := opcLog
|
|
else
|
|
OsPatchCheck := opcNone;
|
|
IsDailyEulaCheck := Trim(S['mwOKey_OPTIONG']).ToLower = 'true';
|
|
IsEmpVerify := Trim(S['mwOKey_OPTIONI']).ToLower = 'true';
|
|
IsVpnAndCondition := Trim(S['mwOKey_OPTIONJ']).ToLower = 'true';
|
|
|
|
IdlPolicy := Trim(S['Policy_Idle']);
|
|
VulPolicy := Trim(S['Policy_Vulnerable']);
|
|
OffPolicy := Trim(S['Policy_Offline']);
|
|
ExpPolicy := Trim(S['Policy_OfflineExcept']);
|
|
|
|
sTemp := Trim(S['KEY_BLOCKFILENAMEDIR']).ToLower;
|
|
if sTemp = 'recursive' then
|
|
BlockFdRename := bdrAll
|
|
else if sTemp ='folderonly' then
|
|
BlockFdRename := bdrThis
|
|
else if sTemp = 'popup' then
|
|
BlockFdRename := bdrPopup
|
|
else if sTemp = 'logonly' then
|
|
BlockFdRename := bdrLog
|
|
else
|
|
BlockFdRename := bdrFalse;
|
|
BlockDirFileRenames := UpperCase(StrListToCommaStr(Trim(S['KEY_BLOCKFILENAMEDIRLIST']), '|'));
|
|
|
|
sTemp := Trim(S['KEY_BLOCKFILENAMEFILE']).ToLower;
|
|
if sTemp = 'executor' then
|
|
BlockFRename := bfrExe
|
|
else if sTemp ='true' then
|
|
BlockFRename := bfrAll
|
|
else if sTemp = 'popup' then
|
|
BlockFRename := bfrPopup
|
|
else if sTemp = 'logonly' then
|
|
BlockFRename := bfrLog
|
|
else
|
|
BlockFRename := bfrFalse;
|
|
BlockFRenames := UpperCase(StrListToCommaStr(Trim(S['KEY_BLOCKFILENAMELIST']), '|'));
|
|
|
|
IsClipboardExcept := Trim(S['KEY_CLIPEXCEPT']).ToLower = 'true';
|
|
sTemp := Trim(S['mwPKey_CLIPBOARDENABLE']).ToLower;
|
|
if sTemp = 'true' then
|
|
ClipBlockKind := cbkBlock
|
|
else if sTemp = 'popup' then
|
|
ClipBlockKind := cbkPopup
|
|
else if sTemp = 'logonly' then
|
|
ClipBlockKind := cbkLog
|
|
else
|
|
ClipBlockKind := cbkNone;
|
|
ClipboardExceptApp := StrListToCommaStr(Trim(S['KEY_CLIPLIST']), ';');
|
|
|
|
sTemp := Trim(S['KEY_OUTLOOKBODYBLOCK']).ToLower;
|
|
OutPo.bActive := (sTemp <> '') and (sTemp <> 'false');
|
|
OutPo.bPopup := OutPo.bActive;
|
|
OutPo.bCollect := false;
|
|
if sTemp = 'true' then
|
|
begin
|
|
OutPo.bBlock := true;
|
|
end else if sTemp = 'masking' then
|
|
begin
|
|
OutPo.bBlock := false;
|
|
OutPo.bUseMasking := true;
|
|
OutPo.bSchSubject := false;
|
|
OutPo.bSchBody := true;
|
|
end else if sTemp = 'subjectonly' then
|
|
begin
|
|
OutPo.bBlock := true;
|
|
OutPo.bUseMasking := false;
|
|
OutPo.bSchSubject := true;
|
|
OutPo.bSchBody := false;
|
|
end else if sTemp = 'bodyonly' then
|
|
begin
|
|
OutPo.bBlock := true;
|
|
OutPo.bUseMasking := false;
|
|
OutPo.bSchSubject := false;
|
|
OutPo.bSchBody := true;
|
|
end else if sTemp = 'popup' then
|
|
begin
|
|
OutPo.bBlock := false;
|
|
OutPo.bUseMasking := false;
|
|
OutPo.bSchSubject := false;
|
|
OutPo.bSchBody := false;
|
|
end else if sTemp = 'logonly' then
|
|
begin
|
|
OutPo.bBlock := false;
|
|
OutPo.bUseMasking := false;
|
|
OutPo.bSchSubject := false;
|
|
OutPo.bSchBody := false;
|
|
OutPo.bPopup := false;
|
|
end;
|
|
OutPo.ContentFilter.bActive := Trim(S['KEY_CRBODYOUTLOOK']).ToLower = 'true';
|
|
OutPo.ContentFilter.sPatterns := S['KEY_LISTCRBODYOUTLOOK'];
|
|
OutPo.ContentFilter.nHitLimit := StrToIntDef(Trim(S['KEY_OUTLOOKBODYBYSCANCNT']), 0);
|
|
if OutPo.ContentFilter.nHitLimit = 0 then
|
|
OutPo.ContentFilter.nHitLimit := 1;
|
|
|
|
sTemp := Trim(S['KEY_OUTLOOKATTACHBLOCK']).ToLower;
|
|
if sTemp = 'true' then
|
|
begin
|
|
OutlookAB.Kind := abkBlock;
|
|
OutlookAB.bPopup := true;
|
|
end else
|
|
if sTemp = 'logonly' then
|
|
begin
|
|
OutlookAB.Kind := abkLog;
|
|
OutlookAB.bPopup := false;
|
|
end
|
|
else if sTemp = 'popup' then
|
|
begin
|
|
// OutlookAB.Kind := abkPopup
|
|
OutlookAB.bPopup := true;
|
|
OutlookAB.Kind := abkLog
|
|
end else begin
|
|
OutlookAB.Kind := abkNone;
|
|
OutlookAB.bPopup := false;
|
|
end;
|
|
OutlookAB.ContentFilter.bActive := Trim(S['KEY_CRFILEOUTLOOK']).ToLower = 'true';
|
|
OutlookAB.ContentFilter.sPatterns := S['KEY_LISTCRFILEOUTLOOK'];
|
|
OutlookAB.ContentFilter.nHitLimit := StrToIntDef(Trim(S['KEY_OUTLOOKBYSCANCNT']), 0);
|
|
if OutlookAB.ContentFilter.nHitLimit = 0 then
|
|
OutlookAB.ContentFilter.nHitLimit := 1;
|
|
|
|
sTemp := Trim(S['KEY_WEBATTACHBLOCK']).ToLower;
|
|
if sTemp = 'true' then
|
|
begin
|
|
WebbAB.Kind := abkBlock;
|
|
WebbAB.bPopup := true;
|
|
end else
|
|
if sTemp = 'logonly' then
|
|
begin
|
|
WebbAB.Kind := abkUrlAllow;
|
|
WebbAB.bPopup := false;
|
|
end else
|
|
if sTemp = 'logonly2' then
|
|
begin
|
|
WebbAB.Kind := abkUrlBlock;
|
|
WebbAB.bPopup := false;
|
|
end else
|
|
if sTemp = 'logonly3' then
|
|
begin
|
|
WebbAB.Kind := abkLog;
|
|
WebbAB.bPopup := false;
|
|
end else
|
|
if sTemp = 'popup' then
|
|
begin
|
|
// WebbAB.Kind := abkPopup;
|
|
WebbAB.Kind := abkLog;
|
|
WebbAB.bPopup := true;
|
|
end
|
|
else if sTemp = 'blacklist' then
|
|
begin
|
|
WebbAB.Kind := abkUrlBlock;
|
|
WebbAB.bPopup := true;
|
|
end
|
|
else if sTemp = 'whitelist' then
|
|
begin
|
|
WebbAB.Kind := abkUrlAllow;
|
|
WebbAB.bPopup := true;
|
|
end else
|
|
WebbAB.Kind := abkNone;
|
|
WebbAB.ContentFilter.bActive := Trim(S['KEY_CRFILEBROWSER']).ToLower = 'true';
|
|
WebbAB.ContentFilter.sPatterns := S['KEY_LISTCRFILEBROWSER'];
|
|
WebbAB.ContentFilter.nHitLimit := StrToIntDef(Trim(S['KEY_BROWSERBYSCANCNT']), 0);
|
|
if WebbAB.ContentFilter.nHitLimit = 0 then
|
|
WebbAB.ContentFilter.nHitLimit := 1;
|
|
|
|
WebABUrlList := StrListToCommaStr(Trim(S['KEY_WEBATTACHBLOCKLIST']), '|');
|
|
if WebABUrlList = '' then
|
|
WebABUrlList := StrListToCommaStr(Trim(S['KEY_WEBATTACHURLLIST']), '|');
|
|
|
|
sTemp := Trim(S['KEY_PROCATTACHBLOCK']).ToLower;
|
|
if sTemp = 'true' then
|
|
begin
|
|
EtcAB.Kind := abkBlock;
|
|
EtcAB.bPopup := true;
|
|
end else
|
|
if sTemp = 'logonly' then
|
|
begin
|
|
EtcAB.Kind := abkLog;
|
|
EtcAB.bPopup := false;
|
|
end else
|
|
if sTemp = 'popup' then
|
|
begin
|
|
// EtcAB.Kind := abkPopup
|
|
EtcAB.Kind := abkLog;
|
|
EtcAB.bPopup := true;
|
|
end else
|
|
EtcAB.Kind := abkNone;
|
|
EtcABApps := StrListToCommaStr(Trim(S['KEY_PROCATTACHLIST']), '|');
|
|
if (EtcAB.Kind <> abkNone) and (EtcABApps = '') then
|
|
EtcAB.Kind := abkNone;
|
|
EtcAB.ContentFilter.bActive := Trim(S['KEY_CRFILEAPP']).ToLower = 'true';
|
|
EtcAB.ContentFilter.sPatterns := S['KEY_LISTCRFILEAPP'];
|
|
EtcAB.ContentFilter.nHitLimit := StrToIntDef(Trim(S['KEY_APPBYSCANCNT']), 0);
|
|
if EtcAB.ContentFilter.nHitLimit = 0 then
|
|
EtcAB.ContentFilter.nHitLimit := 1;
|
|
|
|
sTemp := Trim(S['KEY_NETSHAREFOLDER']).ToLower;
|
|
if sTemp = 'true' then
|
|
ShareFolder := sfkAllBlock
|
|
else if sTemp = 'addonly' then
|
|
ShareFolder := sfkAddBlock
|
|
else if sTemp = 'popup' then
|
|
ShareFolder := sfkPopup
|
|
else if sTemp = 'logonly' then
|
|
ShareFolder := sfkLog
|
|
else
|
|
ShareFolder := sfkNone;
|
|
|
|
sTemp := Trim(S['KEY_FILESCHEDULEPLAN']).ToLower;
|
|
if sTemp = 'once' then
|
|
FileCollectPlan := fcpOnce
|
|
else if sTemp = 'week' then
|
|
FileCollectPlan := fcpWeek
|
|
else if sTemp = 'monthdate' then
|
|
FileCollectPlan := fcpMonthDate
|
|
else if sTemp = 'monthday' then
|
|
FileCollectPlan := fcpMonthWeek
|
|
else
|
|
FileCollectPlan := fcpNone;
|
|
sTemp := Trim(S['KEY_FILECOLLECT']).ToLower;
|
|
if sTemp = 'file' then
|
|
FileCollectKind := fckFile
|
|
else if sTemp = 'folder' then
|
|
FileCollectKind := fckFolder
|
|
else if sTemp = 'recursive' then
|
|
FileCollectKind := fckFolderIncSub
|
|
else if sTemp = 'folderkeyword' then
|
|
FileCollectKind := fckFolderFKwd
|
|
else
|
|
FileCollectKind := fckNone;
|
|
FileCollectDate := StrToDateDef(Trim(S['KEY_FILESCHEDULEDATE']), 0);
|
|
sTemp := GetUserNameFromReg;
|
|
TgFileCollect := Trim(S['KEY_FILECOLLECTKEYWORD']);
|
|
TgFileCollect := StringReplace(TgFileCollect, '{{SystemDrive}}', 'C:\', [rfReplaceAll, rfIgnoreCase]);
|
|
TgFileCollect := StringReplace(TgFileCollect, '{{SystemRoot}}', GetWindowsDir, [rfReplaceAll, rfIgnoreCase]);
|
|
TgFileCollect := StringReplace(TgFileCollect, '{{ProgramData}}', 'C:\ProgramData\', [rfReplaceAll, rfIgnoreCase]);
|
|
TgFileCollect := StringReplace(TgFileCollect, '{{ProgramFiles}}', GetProgramFilesDir, [rfReplaceAll, rfIgnoreCase]);
|
|
TgFileCollect := StringReplace(TgFileCollect, '{{HOMEPATH}}', System.SysUtils.Format('C:\Users\%s\', [sTemp]), [rfReplaceAll, rfIgnoreCase]);
|
|
TgFileCollect := StringReplace(TgFileCollect, '{{APPDATA}}', System.SysUtils.Format('C:\Users\%s\AppData\Roaming\', [sTemp]), [rfReplaceAll, rfIgnoreCase]);
|
|
TgFileCollect := StringReplace(TgFileCollect, '{{LOCALAPPDATA}}', System.SysUtils.Format('C:\Users\%s\AppData\Local\', [sTemp]), [rfReplaceAll, rfIgnoreCase]);
|
|
TgFileCollect := StringReplace(TgFileCollect, '{{TEMP}}', System.SysUtils.Format('C:\Users\%s\AppData\Local\Temp\', [sTemp]), [rfReplaceAll, rfIgnoreCase]);
|
|
TgFileCollect := StringReplace(TgFileCollect, '\\', '\', [rfReplaceAll, rfIgnoreCase]);
|
|
TgFileCollectKwd := StrListToCommaStr(Trim(S['KEY_FILECOLLECTSEARCH']), '|');
|
|
|
|
sTemp := Trim(S['KEY_BLOCKBYSCANRESP']).ToLower;
|
|
if sTemp = 'true' then
|
|
ScanBlockKind := sbkDelete
|
|
else if sTemp = 'popup' then
|
|
ScanBlockKind := sbkPopup
|
|
else if sTemp = 'logonly' then
|
|
ScanBlockKind := sbkLog
|
|
else if sTemp = 'drmencrypt' then
|
|
ScanBlockKind := sbkDrmEnc
|
|
else
|
|
ScanBlockKind := sbkNone;
|
|
if Trim(S['KEY_BLOCKBYSCAN']).ToLower = 'true' then
|
|
PersonalInfoFileMax := StrToIntDef(Trim(S['KEY_BLOCKBYSCANCNT']), 0)
|
|
else
|
|
PersonalInfoFileMax := 0;
|
|
|
|
EtcNicBlock := Trim(S['KEY_NICPREVENT']).ToLower = 'true';
|
|
|
|
sTemp := Trim(S['mwPKey_NETMONITOR']).ToLower;
|
|
if sTemp = 'true' then
|
|
WebbMonKind := wmkBlock
|
|
else if sTemp = 'logonly' then
|
|
WebbMonKind := wmkLog
|
|
else if sTemp = 'blockname' then
|
|
WebbMonKind := wmkIncBlock
|
|
else if sTemp = 'whitelist' then
|
|
WebbMonKind := wmkIncAllow
|
|
else if sTemp = 'popup' then
|
|
WebbMonKind := wmkIncPop
|
|
else if sTemp = 'logpart' then
|
|
WebbMonKind := wmkIncLog
|
|
else
|
|
WebbMonKind := wmkNone;
|
|
UrlBlockList := StrListToCommaStr(Trim(S['KEY_NETMONITORLIST']), '|');
|
|
|
|
sTemp := Trim(S['KEY_DRMREAD']).ToLower;
|
|
if sTemp = 'true' then
|
|
DrmAccessKind := dakAll
|
|
else if sTemp = 'individual' then
|
|
DrmAccessKind := dakEmpNo
|
|
else if sTemp = 'dept' then
|
|
DrmAccessKind := dakDept
|
|
else if sTemp = 'approve' then
|
|
DrmAccessKind := dakNone
|
|
else
|
|
DrmAccessKind := dakNone;
|
|
sTemp := Trim(S['KEY_DRMMODIFY']).ToLower;
|
|
if sTemp = '' then
|
|
DrmModifyKind := dakNone
|
|
else if sTemp = 'individual' then
|
|
DrmModifyKind := dakEmpNo
|
|
else if sTemp = 'dept' then
|
|
DrmModifyKind := dakDept
|
|
else if sTemp = 'approve' then
|
|
DrmModifyKind := dakNone
|
|
else
|
|
DrmModifyKind := dakAll;
|
|
IsDrmAttAble := Trim(S['KEY_DRMONLYSEND']).ToLower = 'true';
|
|
IsDrmDecrypt := Trim(S['KEY_DRMDEC']).ToLower = 'true'; // false, true, approve
|
|
|
|
sTemp := Trim(S['KEY_VULDUETIME']).ToLower;
|
|
if sTemp = 'twomin' then
|
|
VulDueTimeSec := 120
|
|
else if sTemp = 'fivemin' then
|
|
VulDueTimeSec := 300
|
|
else if sTemp = 'fivemin' then
|
|
VulDueTimeSec := 3600
|
|
else
|
|
VulDueTimeSec := StrToIntDef(sTemp, 0);
|
|
|
|
UseFileTag := Trim(S['KEY_FILETAGENABLE']).ToLower = 'true';
|
|
|
|
sTemp := Trim(S['KEY_ENABLECAPTURE']).ToLower;
|
|
if sTemp = '' then
|
|
sTemp := 'false';
|
|
if sTemp = 'popup' then
|
|
CapAppMonKind := camPopup
|
|
else if sTemp = 'logonly' then
|
|
CapAppMonKind := camLog
|
|
else if sTemp = 'whitelist' then
|
|
CapAppMonKind := camIncAllow
|
|
else if sTemp = 'false' then
|
|
CapAppMonKind := camNone
|
|
else
|
|
CapAppMonKind := camBlockAll;
|
|
IgrCaptureApps := StrListToCommaStr(Trim(S['KEY_ENABLECAPTURELIST']), '|');
|
|
|
|
sTemp := Trim(S['KEY_OLDPWDCHECK']).ToLower;
|
|
if sTemp = 'popup' then
|
|
PwChkTerm := pctPopup
|
|
else if sTemp = 'logonly' then
|
|
PwChkTerm := pctLog
|
|
else if sTemp = 'true' then
|
|
PwChkTerm := pctBlock
|
|
else
|
|
PwChkTerm := pctNone;
|
|
PwChkTermDay := StrToIntDef(Trim(S['KEY_OLDPWDPERIOD']).ToLower, 0);
|
|
|
|
bCaptureBlockApps_ := Trim(S['KEY_CAPTUREPROTECTENABLE']).ToLower = 'true';
|
|
if bCaptureBlockApps_ then
|
|
CaptureBlockApps := StrListToCommaStr(Trim(S['KEY_CAPTUREPROTECTLIST']), '|')
|
|
else
|
|
CaptureBlockApps := '';
|
|
|
|
sTemp := Trim(S['KEY_CAPTUREURLENABLE']).ToLower;
|
|
if sTemp = 'blacklist' then
|
|
CaptureBlockUrlKind := bkBlack
|
|
else if sTemp = 'whitelist' then
|
|
CaptureBlockUrlKind := bkWhite
|
|
else if sTemp = 'true' then
|
|
CaptureBlockUrlKind := bkAll
|
|
else
|
|
CaptureBlockUrlKind := bkNone;
|
|
CaptureBlockUrls := StrListToCommaStr(Trim(S['KEY_CAPTUREURLLIST']), '|');
|
|
|
|
ExpPoMin := StrToIntDef(Trim(S['KEY_OFFLINEKEYENABLE']).ToLower, 0);
|
|
UseExpPo := ExpPoMin > 0;
|
|
ExpPoAgree := Trim(S['KEY_OFFLINEKEYAPPROVE']).ToLower;
|
|
sTemp := Trim(S['KEY_OFFLINEKEYLIMIT']).ToLower;
|
|
if sTemp = 'onceday' then
|
|
ExpPoLimit := 1
|
|
else if sTemp = 'triday' then
|
|
ExpPoLimit := 3
|
|
else
|
|
ExpPoLimit := StrToIntDef(sTemp, 0);
|
|
|
|
sTemp := Trim(S['KEY_OFFLINELOGTYPE']).ToLower;
|
|
if sTemp = 'orcondition' then
|
|
OffLogKind := olkColOR
|
|
else if sTemp = 'andcondition' then
|
|
OffLogKind := olkColAND
|
|
else if sTemp = 'true' then
|
|
OffLogKind := olkCollect
|
|
else
|
|
OffLogKind := olkNone;
|
|
UseOffLogDay := Trim(S['KEY_OFFLINELOGTYPE']).ToLower = 'true';
|
|
if UseOffLogDay then
|
|
OffLogDays := StrToIntDef(Trim(S['KEY_OFFLINELOGMAXDATE']), 0)
|
|
else
|
|
OffLogDays := 0;
|
|
UseOffLogMaxMB := Trim(S['KEY_OFFLINELOGSIZE']).ToLower = 'true';
|
|
if UseOffLogMaxMB then
|
|
OffLogMaxMB := StrToIntDef(Trim(S['KEY_OFFLINELOGMAXMB']), 0)
|
|
else
|
|
OffLogMaxMB := 0;
|
|
|
|
NacCheckUrl := Trim(S['KEY_NACCHECKURL']).ToLower;
|
|
if NacCheckUrl = '' then
|
|
NacCheckUrl := 'https://www.hiworks.com';
|
|
|
|
sTemp := Trim(S['KEY_SCRLOGOSET']).ToLower;
|
|
if (sTemp.Length > 0) then // and (sTemp[1] = '{') then
|
|
ScreenLogoData := sTemp
|
|
else
|
|
ScreenLogoData := '';
|
|
|
|
// 취약점 점검 세부 옵션 추가 23_1121 10:12:05 kku
|
|
VulOsVersion := BooleanStr(aO.S['KEY_VULOSVERSION']);
|
|
VulAntiVirus := BooleanStr(aO.S['KEY_VULANTIVIRUS']);
|
|
VulPassword := BooleanStr(aO.S['KEY_VULPASSWORD']);
|
|
VulScreenSaver := BooleanStr(aO.S['KEY_VULSCREENSAVER']);
|
|
VulFirewall := BooleanStr(aO.S['KEY_VULFIREWALL']);
|
|
|
|
bLoaded_ := true;
|
|
IsOldPolicy := true;
|
|
SetOldDefault;
|
|
end;
|
|
Result := true;
|
|
end;
|
|
|
|
procedure TPrefModel.Load;
|
|
var
|
|
sPath: String;
|
|
ss: TStringStream;
|
|
O: ISuperObject;
|
|
begin
|
|
try
|
|
if sPoFName_ <> '' then
|
|
begin
|
|
sPath := GetRunExePathDir + DIR_CONF + Format('%s-%s%s', [NAME_PREF, sPoFName_, EXT_PROP]);
|
|
if FileExists(sPath) then
|
|
begin
|
|
Guard(ss, TStringStream.Create('', TEncoding.UTF8));
|
|
ss.LoadFromFile(sPath);
|
|
|
|
O := SO(DecBinStrToStr(ekAes256cbc, PASS_MODEL, ss.DataString));
|
|
if O <> nil then
|
|
begin
|
|
SetPolicyFromJsonObj(O);
|
|
exit;
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
sPath := GetRunExePathDir + DIR_CONF + DAT_PREF;
|
|
if FileExists(sPath) then
|
|
begin
|
|
Guard(ss, TStringStream.Create('', TEncoding.UTF8));
|
|
ss.LoadFromFile(sPath);
|
|
|
|
O := SO(DecBinStrToStr(ekAes256cbc, PASS_MODEL, ss.DataString));
|
|
if O <> nil then
|
|
begin
|
|
if LoadFromJsonObj_Old(O) then
|
|
begin
|
|
ORecent_ := O;
|
|
sCheckHash_ := ConvStrToSha1W(O.AsString);
|
|
end;
|
|
end;
|
|
end;
|
|
except
|
|
on E: Exception do
|
|
ETgException.TraceException(Self, E, 'Fail .. Load()');
|
|
end;
|
|
end;
|
|
|
|
// 2.6.x 이하에서 사용
|
|
function TPrefModel.GetPrefModeToJsonObj: ISuperObject;
|
|
var
|
|
sPath: String;
|
|
ss: TStringStream;
|
|
O: ISuperObject;
|
|
begin
|
|
Result := ORecent_;
|
|
if Result = nil then
|
|
begin
|
|
sPath := GetRunExePathDir + DIR_CONF + DAT_PREF;
|
|
if not FileExists(sPath) then
|
|
exit;
|
|
|
|
try
|
|
Guard(ss, TStringStream.Create('', TEncoding.UTF8));
|
|
ss.LoadFromFile(sPath);
|
|
|
|
O := SO(DecBinStrToStr(ekAes256cbc, PASS_MODEL, ss.DataString));
|
|
if O <> nil then
|
|
Result := O;
|
|
except
|
|
on E: Exception do
|
|
ETgException.TraceException(Self, E, 'Fail .. GetPrefModeToJsonObj()');
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
// 2.7.x 이상에서 사용
|
|
function TPrefModel.GetPolicyToJsonObj: ISuperObject;
|
|
var
|
|
i: Integer;
|
|
sTemp: String;
|
|
begin
|
|
try
|
|
Result := SO;
|
|
|
|
Result.S['PolicyId'] := PolicyId;
|
|
Result.S['PolicyGroup'] := PolicyGroup;
|
|
Result.S['PolicyName'] := PolicyName;
|
|
Result.S['DeptName'] := DeptName;
|
|
Result.S['Language'] := Language;
|
|
Result.S['VpnAppName'] := VpnAppName;
|
|
Result.S['ForceScreenLock'] := ForceScreenLock;
|
|
Result.S['NetworkExceptType'] := NetworkExceptType;
|
|
Result.S['NetworkBlockType'] := NetworkBlockType;
|
|
Result.S['AgentPatchVersion'] := AgentPatchVersion;
|
|
Result.S['AgentPatchExeName'] := AgentPatchExeName;
|
|
Result.S['VpnMethod'] := VpnMethod;
|
|
Result.S['NoticeContent'] := NoticeContent;
|
|
Result.S['RestricMac'] := RestricMac;
|
|
Result.B['CheckAllowMAC'] := CheckAllowMAC;
|
|
Result.S['RestricDate'] := RestricDate;
|
|
Result.S['UnsafeActions'] := UnsafeActions;
|
|
Result.S['EulaTitle'] := EulaTitle;
|
|
Result.S['EulaBody'] := EulaBody;
|
|
Result.B['IsRestricDate'] := IsRestricDate;
|
|
Result.B['IsEulaSubmit'] := IsEulaSubmit;
|
|
Result.B['IsEnableCheck'] := IsEnableCheck;
|
|
Result.B['IsWaterMark'] := IsWaterMark;
|
|
Result.B['IsMasking'] := IsMasking;
|
|
Result.B['IsDefPortBlock'] := IsDefPortBlock;
|
|
Result.B['IsSmbPortBlock'] := IsSmbPortBlock;
|
|
Result.B['IsAgentUpdateExist'] := IsAgentUpdateExist;
|
|
Result.B['IsFixedVerUpdate'] := IsFixedVerUpdate;
|
|
Result.B['IsAllowAccess'] := IsAllowAccess;
|
|
Result.B['IsTemporaryConn'] := IsTemporaryConn;
|
|
Result.B['IsAgentDelete'] := IsAgentDelete;
|
|
Result.B['IsNoticeEnable'] := IsNoticeEnable;
|
|
Result.B['IsPreventSettingChange'] := IsPreventSettingChange;
|
|
Result.B['IsClipboardExcept'] := IsClipboardExcept;
|
|
Result.B['IsUseAfterReport'] := IsUseAfterReport;
|
|
Result.B['IsPreventDownloads'] := IsPreventDownloads;
|
|
Result.B['IsUninstallAble'] := IsUninstallAble;
|
|
Result.I['UninstKind'] := Integer(UninstKind);
|
|
Result.B['IsWifiPublicBlock'] := IsWifiPublicBlock;
|
|
Result.B['IsMobileHotspotExp'] := IsMobileHotspotExp;
|
|
Result.B['IsAppBlackDate'] := IsAppBlackDate;
|
|
Result.B['IsAppBlackTime'] := IsAppBlackTime;
|
|
Result.B['IsLongtimeDisconn'] := IsLongtimeDisconn;
|
|
Result.B['IsShowPolicy'] := IsShowPolicy;
|
|
Result.I['PoViewKind'] := Integer(PoViewKind);
|
|
Result.B['IsShowAInfo'] := IsShowAInfo;
|
|
Result.B['IsMustSecuApp'] := IsMustSecuApp;
|
|
Result.B['IsBlockApp'] := IsBlockApp;
|
|
Result.B['IsBlockAppLog'] := IsBlockAppLog;
|
|
Result.B['IsBlockAppNotice'] := IsBlockAppNotice;
|
|
Result.B['IsMonApp'] := IsMonApp;
|
|
Result.B['IsMonAppNoti'] := IsMonAppNoti;
|
|
Result.S['MonAppList'] := MonAppList;
|
|
Result.B['UseFileTag'] := UseFileTag;
|
|
Result.B['DetectFixedDisk'] := DetectFixedDisk;
|
|
Result.I['ScreenLogo'] := Integer(ScreenLogo);
|
|
Result.B['ScreenLogoVisible'] := ScreenLogoVisible;
|
|
Result.B['ScreenLogoInvisible'] := ScreenLogoInvisible;
|
|
Result.I['ScreenBlockAppExp'] := Integer(ScreenBlockAppExp);
|
|
Result.I['CaptureBlockUrlKind'] := Integer(CaptureBlockUrlKind);
|
|
Result.B['AppRcdNoti'] := AppRcdNoti;
|
|
Result.B['AppRcdActive'] := AppRcdActive;
|
|
Result.I['AppRcdMaxMin'] := AppRcdMaxMin;
|
|
Result.S['AppRcdApps'] := AppRcdApps;
|
|
Result.D['AppBlackDateB'] := AppBlackDateB;
|
|
Result.D['AppBlackDateE'] := AppBlackDateE;
|
|
Result.I['VulDueTimeSec'] := VulDueTimeSec;
|
|
Result.I['AppBlackTimeB'] := AppBlackTimeB;
|
|
Result.I['AppBlackTimeE'] := AppBlackTimeE;
|
|
Result.I['PersonalInfoFileMax'] := PersonalInfoFileMax;
|
|
Result.I['HeartbeatTime'] := HeartbeatTime;
|
|
Result.I['TemporaryConnMin'] := TemporaryConnMin;
|
|
Result.S['UninstallPW'] := UninstallPW;
|
|
Result.S['ScreenLogoApps'] := ScreenLogoApps;
|
|
Result.S['ScreenBlockAppsExp'] := ScreenBlockAppsExp;
|
|
Result.S['IgrCaptureApps'] := IgrCaptureApps;
|
|
Result.S['SoftwareListB'] := SoftwareListB;
|
|
Result.S['SoftwareListW'] := SoftwareListW;
|
|
Result.S['NetworkBlockList'] := NetworkBlockList;
|
|
Result.B['IsNetBlockDay'] := IsNetBlockDay;
|
|
Result.D['NetBlockDayB'] := NetBlockDayB;
|
|
Result.D['NetBlockDayE'] := NetBlockDayE;
|
|
Result.S['NetworkExceptList'] := NetworkExceptList;
|
|
Result.S['SMBPortExceptList'] := SMBPortExceptList;
|
|
Result.S['CaptureBlockApps'] := CaptureBlockApps;
|
|
Result.S['CaptureBlockUrls'] := CaptureBlockUrls;
|
|
Result.S['ScreenLockPwd'] := ScreenLockPwd;
|
|
Result.S['WifiBlockNames'] := WifiBlockNames;
|
|
Result.S['ClipboardExceptApp'] := ClipboardExceptApp;
|
|
Result.I['ExtraPortEnableType'] := ExtraPortEnableType;
|
|
Result.I['UnsafeActionsMin'] := UnsafeActionsMin;
|
|
Result.B['IsSecuEndActions'] := IsSecuEndActions;
|
|
Result.I['ForceScreenLockMin'] := ForceScreenLockMin;
|
|
Result.I['ForceShutdownMin'] := ForceShutdownMin;
|
|
Result.I['WifiCtrlKind'] := Integer(WifiCtrlKind);
|
|
Result.B['WifiGpsOn'] := WifiGpsOn;
|
|
Result.I['UsbBlockKind'] := Integer(UsbBlockKind);
|
|
Result.B['AbleUsbExceptReq'] := AbleUsbExceptReq;
|
|
Result.B['AbleMtpExceptReq'] := AbleMtpExceptReq;
|
|
Result.B['AbleBtExceptReq'] := AbleBtExceptReq;
|
|
Result.B['AbleCdExceptReq'] := AbleCdExceptReq;
|
|
Result.I['AppInstKind'] := Integer(AppInstKind);
|
|
Result.B['IsDrmAttAbleFB'] := IsDrmAttAbleFB;
|
|
Result.O['FileMon'] := TTgJson.ValueToJsonObject<TFileMonPolicy>(FileMon);
|
|
Result.B['FileOpenMon'] := FileOpenMon;
|
|
Result.O['FmCreateCol'] := TTgJson.ValueToJsonObject<TFileColPo>(FmCreateCol);
|
|
Result.O['FmModifyCol'] := TTgJson.ValueToJsonObject<TFileColPo>(FmModifyCol);
|
|
Result.O['FmModifyCol'] := TTgJson.ValueToJsonObject<TFileColPo>(FmModifyCol);
|
|
Result.O['FileBlock'] := TTgJson.ValueToJsonObject<TFileMonPolicy>(FileBlock);
|
|
Result.O['DrmCF'] := TTgJson.ValueToJsonObject<TContentFilter>(DrmCF);
|
|
Result.B['IsForceShutdown'] := IsForceShutdown;
|
|
Result.B['IsUnsafeActions'] := IsUnsafeActions;
|
|
Result.B['bCaptureBlockApps_'] := bCaptureBlockApps_;
|
|
Result.B['FileMonOnlyLog'] := FileMonOnlyLog;
|
|
Result.O['EtcAB'] := TTgJson.ValueToJsonObject<TAttachBlockPolicy>(EtcAB);
|
|
Result.O['WebbAB'] := TTgJson.ValueToJsonObject<TAttachBlockPolicy>(WebbAB);
|
|
Result.O['OutlookAB'] := TTgJson.ValueToJsonObject<TAttachBlockPolicy>(OutlookAB);
|
|
Result.I['ShareFolder'] := Integer(ShareFolder);
|
|
Result.I['FileCollectPlan'] := Integer(FileCollectPlan);
|
|
Result.I['FileCollectKind'] := Integer(FileCollectKind);
|
|
Result.I['ScanBlockKind'] := Integer(ScanBlockKind);
|
|
Result.I['ScreenLockKind'] := Integer(ScreenLockKind);
|
|
Result.I['CapAppMonKind'] := Integer(CapAppMonKind);
|
|
Result.B['IsNotiBCA'] := IsNotiBCA;
|
|
Result.B['FileMonNoLog'] := FileMonNoLog;
|
|
Result.I['PwChkTerm'] := Integer(PwChkTerm);
|
|
Result.D['FileCollectDate'] := FileCollectDate;
|
|
Result.S['EtcABApps'] := EtcABApps;
|
|
Result.S['FileMonExt'] := FileMonExt;
|
|
Result.S['TgFileCollect'] := TgFileCollect;
|
|
Result.S['TgFileCollectKwd'] := TgFileCollectKwd;
|
|
Result.S['WebABUrlList'] := WebABUrlList;
|
|
Result.I['PwChkTermDay'] := PwChkTermDay;
|
|
Result.I['BlockFRename'] := Integer(BlockFRename);
|
|
Result.I['BlockFdRename'] := Integer(BlockFdRename);
|
|
Result.I['ClipBlockKind'] := Integer(ClipBlockKind);
|
|
Result.B['CbPopup'] := CbPopup;
|
|
Result.B['CbImgBlock'] := CbImgBlock;
|
|
Result.B['DoClipOcr'] := DoClipOcr;
|
|
Result.O['OutPo'] := TTgJson.ValueToJsonObject<TOutlookPolicy>(OutPo);
|
|
Result.I['MtpBlockKind'] := Integer(MtpBlockKind);
|
|
Result.B['USBPopup'] := USBPopup;
|
|
Result.B['BTPopup'] := BTPopup;
|
|
Result.B['CDPopup'] := CDPopup;
|
|
Result.B['MTPPopup'] := MTPPopup;
|
|
Result.I['BlueBlockKind'] := Integer(BlueBlockKind);
|
|
Result.I['CdromBlockKind'] := Integer(CdromBlockKind);
|
|
Result.I['WebbMonKind'] := Integer(WebbMonKind);
|
|
Result.B['IsDrmAttAble'] := IsDrmAttAble;
|
|
Result.B['IsDrmDecrypt'] := IsDrmDecrypt;
|
|
Result.B['EtcNicBlock'] := EtcNicBlock;
|
|
Result.B['EtcNicBlockNoti'] := EtcNicBlockNoti;
|
|
Result.S['EtcNicBlockExcept'] := EtcNicBlockExcept;
|
|
Result.B['IsDomainBlock'] := IsDomainBlock;
|
|
Result.B['IsStartupScreenLock'] := IsStartupScreenLock;
|
|
Result.B['AutoRunBlock'] := AutoRunBlock;
|
|
Result.B['HostEnable'] := HostEnable;
|
|
Result.B['RouteEnable'] := RouteEnable;
|
|
Result.B['IsDailyEulaCheck'] := IsDailyEulaCheck;
|
|
Result.B['IsEmpVerify'] := IsEmpVerify;
|
|
Result.B['IsVpnAndCondition'] := IsVpnAndCondition;
|
|
Result.I['NotifyType'] := Integer(NotifyType);
|
|
Result.I['NotiCloseSec'] := NotiCloseSec;
|
|
Result.I['NotifyKind'] := Integer(NotifyKind);
|
|
Result.B['IsNotiSystem'] := IsNotiSystem;
|
|
Result.I['OsPatchCheck'] := Integer(OsPatchCheck);
|
|
Result.I['DrmAccessKind'] := Integer(DrmAccessKind);
|
|
Result.I['DrmModifyKind'] := Integer(DrmModifyKind);
|
|
Result.S['BlockFRenames'] := BlockFRenames;
|
|
Result.S['BlockDirFileRenames'] := BlockDirFileRenames;
|
|
Result.S['UrlBlockList'] := UrlBlockList;
|
|
Result.S['UrlBlockExcpList'] := UrlBlockExcpList;
|
|
Result.S['DomainBlockList'] := DomainBlockList;
|
|
Result.S['MtpExcept'] := MtpExcept;
|
|
Result.S['MtpExceptVender'] := MtpExceptVender;
|
|
Result.S['BlueExcept'] := BlueExcept;
|
|
Result.S['BlueExceptVender'] := BlueExceptVender;
|
|
Result.S['CdromExcept'] := CdromExcept;
|
|
Result.S['UsbExceptVender'] := UsbExceptVender;
|
|
Result.S['AllowConn'] := AllowConn;
|
|
Result.S['BlockPortList'] := BlockPortList;
|
|
Result.S['VpnHour'] := VpnHour;
|
|
Result.S['VpnIpList'] := VpnIpList;
|
|
Result.S['VpnRcAppList'] := VpnRcAppList;
|
|
Result.S['NacCheckUrl'] := NacCheckUrl;
|
|
Result.S['ScreenLogoData'] := ScreenLogoData;
|
|
|
|
Result.B['WinCapScrLogoOff'] := WinCapScrLogoOff;
|
|
Result.B['UseIpScrLogoBold'] := UseIpScrLogoBold;
|
|
Result.B['UseIdleScrLogoBold'] := UseIdleScrLogoBold;
|
|
Result.I['MinIdleScrLogoBold'] := MinIdleScrLogoBold;
|
|
Result.B['UseRemoteScrLogoBold'] := UseRemoteScrLogoBold;
|
|
Result.B['BlockChangeTime'] := BlockChangeTime;
|
|
Result.I['HealthCheckMilSec'] := HealthCheckMilSec;
|
|
Result.I['ScreenLogoUpdateMin'] := ScreenLogoUpdateMin;
|
|
Result.I['ScreenLogoAlpha'] := ScreenLogoAlpha;
|
|
Result.B['IsIgrScrCapKeyCB'] := IsIgrScrCapKeyCB;
|
|
Result.B['HideMainUI'] := HideMainUI;
|
|
Result.B['IsOldPolicy'] := IsOldPolicy;
|
|
Result.I['CfZipDepth'] := CfZipDepth;
|
|
Result.I['CfTimeoutSec'] := CfTimeoutSec;
|
|
Result.I['CfLimitMB'] := CfLimitMB;
|
|
|
|
// 원본파일 수집크기 제한
|
|
Result.I['WebABLimitMB'] := WebABLimitMB;
|
|
Result.I['AppABLimitMB'] := AppABLimitMB;
|
|
Result.I['OutABLimitMB'] := OutABLimitMB;
|
|
Result.I['FileMonLimitMB'] := FileMonLimitMB;
|
|
Result.I['FileBlkLimitMB'] := FileBlkLimitMB;
|
|
Result.I['FileExpMinMB'] := FileExpMinMB;
|
|
Result.I['FileExpMaxMB'] := FileExpMaxMB;
|
|
Result.I['WebABMinMB'] := WebABMinMB;
|
|
Result.I['AppABMinMB'] := AppABMinMB;
|
|
Result.I['OutABMinMB'] := OutABMinMB;
|
|
Result.I['FileMonMinMB'] := FileMonMinMB;
|
|
Result.I['FileBlkMinMB'] := FileBlkMinMB;
|
|
Result.I['OutFileBlockMB'] := OutFileBlockMB;
|
|
Result.I['WebFileBlockMB'] := WebFileBlockMB;
|
|
Result.I['AppFileBlockMB'] := AppFileBlockMB;
|
|
|
|
Result.I['PrtMinMB'] := PrtMinMB;
|
|
Result.I['PrtMaxMB'] := PrtMaxMB;
|
|
|
|
Result.B['WifiBlockPopup'] := WifiBlockPopup;
|
|
Result.B['WifiAllowPopup'] := WifiAllowPopup;
|
|
Result.B['OutBodyAllowPopup'] := OutBodyAllowPopup;
|
|
Result.B['OutFileAllowPopup'] := OutFileAllowPopup;
|
|
Result.B['ShareFldBlockPopup'] := ShareFldBlockPopup;
|
|
Result.B['ShareFldAllowPopup'] := ShareFldAllowPopup;
|
|
Result.B['UsbAllowPopup'] := UsbAllowPopup;
|
|
Result.B['MtpAllowPopup'] := MtpAllowPopup;
|
|
Result.B['BtAllowPopup'] := BtAllowPopup;
|
|
Result.B['CdAllowPopup'] := CdAllowPopup;
|
|
Result.B['PrtAllowPopup'] := PrtAllowPopup;
|
|
Result.B['HdMonPopup'] := HdMonPopup;
|
|
|
|
Result.B['IsPcStatePower'] := IsPcStatePower;
|
|
Result.B['IsPcStateIpCh'] := IsPcStateIpCh;
|
|
|
|
Result.I['FileMonEncDelaySec'] := FileMonEncDelaySec;
|
|
Result.B['IsUrlCatchLogo'] := IsUrlCatchLogo;
|
|
Result.S['LogoUrlList'] := LogoUrlList;
|
|
Result.I['PrtCollThumLimit'] := PrtCollThumLimit;
|
|
Result.B['IsPrtCollectThum'] := IsPrtCollectThum;
|
|
Result.B['IsIgrCollectCutWebAB'] := IsIgrCollectCutWebAB;
|
|
Result.B['IsAllowLogWebAB'] := IsAllowLogWebAB;
|
|
Result.B['IsIgrCollectCutAppAB'] := IsIgrCollectCutAppAB;
|
|
Result.B['IsAllowLogAppAB'] := IsAllowLogAppAB;
|
|
|
|
Result.S['WebAbSigs'] := WebAbSigs;
|
|
Result.S['WebAbFNames'] := WebAbFNames;
|
|
Result.S['EtcAbSigs'] := EtcAbSigs;
|
|
Result.S['EtcAbFNames'] := EtcAbFNames;
|
|
Result.S['PrtNameH'] := PrtNameH;
|
|
Result.S['PrtWaterAppH'] := PrtWaterAppH;
|
|
Result.S['PrtWaterAppHig'] := PrtWaterAppHig;
|
|
Result.S['SmbPortEx'] := SmbPortEx;
|
|
Result.I['AipEncMSec'] := AipEncMSec;
|
|
Result.S['CfFblkExts'] := CfFblkExts;
|
|
Result.S['WebAbExts'] := WebAbExts;
|
|
Result.S['EtcAbExts'] := EtcAbExts;
|
|
Result.I['FileExpMin'] := FileExpMin;
|
|
Result.I['LogKeepDays'] := LogKeepDays;
|
|
Result.I['BtConNotiDSec'] := BtConNotiDSec;
|
|
|
|
sTemp := '';
|
|
for i := 0 to PrtOcrTxtExtList.Count - 1 do
|
|
SumString(sTemp, PrtOcrTxtExtList[i], '|');
|
|
Result.S['GetPrtOcrTxt'] := sTemp;
|
|
|
|
Result.S['WebABLogUrlList'] := WebABLogUrlList;
|
|
Result.S['EtcAbLogList'] := EtcAbLogList;
|
|
|
|
// 공유폴더 감시/차단
|
|
Result.O['ShFileCrMon'] := TTgJson.ValueToJsonObject<TShFileCrMon>(ShFileCrMon);
|
|
|
|
// 취약점 점검 정책
|
|
Result.B['VulOsVersion'] := VulOsVersion;
|
|
Result.B['VulAntiVirus'] := VulAntiVirus;
|
|
Result.B['VulPassword'] := VulPassword;
|
|
Result.B['VulScreenSaver'] := VulScreenSaver;
|
|
Result.B['VulFirewall'] := VulFirewall;
|
|
|
|
// 오프라인 정책
|
|
Result.B['UseExpPo'] := UseExpPo;
|
|
Result.I['ExpPoLimit'] := ExpPoLimit;
|
|
Result.I['ExpPoMin'] := ExpPoMin;
|
|
Result.S['ExpPoAgree'] := ExpPoAgree;
|
|
|
|
// 오프라인 로그
|
|
Result.I['OffLogKind'] := Integer(OffLogKind);
|
|
Result.I['OffLogDays'] := OffLogDays;
|
|
Result.I['OffLogMaxMB'] := OffLogMaxMB;
|
|
Result.B['UseOffLogDay'] := UseOffLogDay;
|
|
Result.B['UseOffLogMaxMB'] := UseOffLogMaxMB;
|
|
|
|
Result.S['IgrUsbSerialList'] := IgrUsbSerialList.CommaText;
|
|
Result.S['IgrUsbSerials'] := IgrUsbSerials;
|
|
Result.S['IgrUsbSerialsKn'] := IgrUsbSerialsKn;
|
|
|
|
Result.O['Print'] := TTgJson.ValueToJsonObject<TPrintPolicy>(Print);
|
|
Result.S['PrinterIpExcept'] := PrinterIpExcept;
|
|
Result.S['PrtWtExpUrl'] := PrtWtExpUrl;
|
|
Result.S['PrtWtExpDocName'] := PrtWtExpDocName;
|
|
Result.S['PrtWtExpPrtName'] := PrtWtExpPrtName;
|
|
Result.S['PrtWtExpProcName'] := PrtWtExpProcName;
|
|
Result.S['PrtApvExpUrl'] := PrtApvExpUrl;
|
|
Result.S['PrtApvExpDocName'] := PrtApvExpDocName;
|
|
Result.S['PrtApvExpPrtName'] := PrtApvExpPrtName;
|
|
Result.S['PrtApvExpProcName'] := PrtApvExpProcName;
|
|
Result.O['PrtWaterCfg'] := TTgJson.ValueToJsonObject<TPrtWaterCfg>(PrtWaterCfg);
|
|
|
|
Result.B['PrintApproval'] := PrintApproval;
|
|
Result.B['PrintApprovalPost'] := PrintApprovalPost;
|
|
Result.B['UsbApproval'] := UsbApproval;
|
|
Result.B['WebUrlApproval'] := WebUrlApproval;
|
|
Result.B['BtApproval'] := BtApproval;
|
|
Result.B['CdApproval'] := CdApproval;
|
|
Result.B['MtpApproval'] := MtpApproval;
|
|
Result.B['DrmApproval'] := DrmApproval;
|
|
Result.B['ExFApproval'] := ExFApproval;
|
|
Result.B['CapApproval'] := CapApproval;
|
|
Result.B['BlockNoUrl'] := BlockNoUrl;
|
|
Result.B['BlockNoUrlAB'] := BlockNoUrlAB;
|
|
Result.B['BlockWidgetAB'] := BlockWidgetAB;
|
|
Result.B['UrlBlockNoti'] := UrlBlockNoti;
|
|
Result.B['UrlAllowNoti'] := UrlAllowNoti;
|
|
Result.B['WebAAllowNoti'] := WebAAllowNoti;
|
|
Result.B['AppAAllowNoti'] := AppAAllowNoti;
|
|
|
|
Result.I['LogLv'] := LogLv;
|
|
Result.B['LogEnc'] := LogEnc;
|
|
Result.B['AipOff'] := AipOff;
|
|
Result.I['TextLimit'] := TextLimit;
|
|
Result.I['PrtDPI'] := PrtDPI;
|
|
Result.I['ChkConSec'] := ChkConSec;
|
|
Result.B['DrmPopupNo'] := DrmPopupNo;
|
|
Result.B['PrtPopupNo'] := PrtPopupNo;
|
|
Result.B['PrtWaterPop'] := PrtWaterPop;
|
|
Result.B['OpenDetect'] := OpenDetect;
|
|
Result.B['IgrNetPathAB'] := IgrNetPathAB;
|
|
Result.B['CodePo'] := CodePo;
|
|
Result.B['NoOutlRcvr'] := NoOutlRcvr;
|
|
|
|
Result.S['sPoId_'] := sPoId_;
|
|
|
|
// 클립보드 추가
|
|
Result.B['IsCBCollect'] := IsCBCollect;
|
|
Result.S['CBCollectApp'] := CBCollectApp;
|
|
Result.O['CbCF'] := TTgJson.ValueToJsonObject<TContentFilter>(CbCF);
|
|
|
|
Result.I['SecuExitWaitSec'] := SecuExitWaitSec;
|
|
|
|
Result.B['IsTempGroup'] := IsTempGroup;
|
|
|
|
// 블루투스 차단, USB, 파일 차단 기능 추가
|
|
_Trace('IntBtBlockNewFile mode :%d', [Integer(IntBtBlockNewFile.mode)], 1);
|
|
Result.O['IntBtBlockNewFile'] := TTgJson.ValueToJsonObject<TIntBlockNewFile>(IntBtBlockNewFile);
|
|
Result.O['IntUsbBlockNewFile'] := TTgJson.ValueToJsonObject<TIntBlockNewFile>(IntUsbBlockNewFile);
|
|
Result.O['IntUsbToUsbBlockNewFile'] := TTgJson.ValueToJsonObject<TIntBlockNewFile>(IntUsbToUsbBlockNewFile);
|
|
Result.O['IntCdromBlockFileNew'] := TTgJson.ValueToJsonObject<TIntBlockNewFile>(IntCdromBlockNewFile);
|
|
Result.O['IntMtpUsbBlockNewFile'] := TTgJson.ValueToJsonObject<TIntBlockNewFile>(IntMtpBlockNewFile);
|
|
|
|
except
|
|
on E: Exception do
|
|
ETgException.TraceException(Self, E, 'Fail .. GetPolicyToJsonObj()');
|
|
end;
|
|
end;
|
|
|
|
procedure TPrefModel.ProcessAfterSetPolicy;
|
|
begin
|
|
try
|
|
if sPoFName_ = '01' then // 보안모드만
|
|
begin
|
|
if IsCJ_Affiliates then
|
|
begin
|
|
if Pos('@ALL', IgrUsbSerials.ToUpper) > 0 then
|
|
SetRegValueInteger(HKEY_LOCAL_MACHINE, REG_HE, 'PoIgU', 2, true)
|
|
else
|
|
SetRegValueInteger(HKEY_LOCAL_MACHINE, REG_HE, 'PoIgU', BooleanToInt((IgrUsbSerialList.Count > 0) or (UsbExceptVender <> ''), 1, 0), true);
|
|
end;
|
|
|
|
if gTrace <> nil then
|
|
begin
|
|
if not gTrace.LevelLock and not gTrace.IsAllocConsole and (gTrForm = nil) and (gTrace.Level <> LogLv) then
|
|
gTrace.Level := LogLv;
|
|
|
|
if gTrace.LogEnc <> LogEnc then
|
|
gTrace.LogEnc := LogEnc;
|
|
end;
|
|
end;
|
|
except
|
|
on E: Exception do
|
|
ETgException.TraceException(Self, E, 'Fail .. ProcessAfterSetPolicy()');
|
|
end;
|
|
end;
|
|
|
|
procedure TPrefModel.SetPolicyFromJsonObj(aO: ISuperObject);
|
|
|
|
function GetBlockFileNew(const sKeyName: string): TIntBlockNewFile;
|
|
var
|
|
i: Integer;
|
|
sTemp: String;
|
|
O: ISuperObject;
|
|
begin
|
|
|
|
O := SO(aO.S[sKeyName]);
|
|
if O = nil then
|
|
begin
|
|
_Trace('GetBlockFileNew, nil',1);
|
|
Exit;
|
|
end;
|
|
|
|
var mode := O.S['mode'];
|
|
if mode = 'true' then
|
|
Result.mode := abkBlock
|
|
else if mode ='log' then
|
|
Result.mode := abkLog
|
|
else
|
|
Result.mode := abkNone;
|
|
|
|
Result.userAlert := O.B['userAlert'];
|
|
Result.origTextCol := O.B['origTextCol'];
|
|
Result.fileNameChk := O.B['fileNameChk'];
|
|
|
|
if O.O['origFileCol'] <> nil then
|
|
begin
|
|
Result.origFileCol_use := O.O['origFileCol'].B['use'];
|
|
Result.origFileCol_maxMb := O.O['origFileCol'].I['maxMb'];
|
|
Result.origFileCol_minMb := O.O['origFileCol'].I['minMb'];
|
|
end else begin
|
|
Result.origFileCol_use := False;
|
|
end;
|
|
|
|
if (O.O['extList'] <> nil) and (O.O['extList'].DataType = stArray) then
|
|
begin
|
|
sTemp := '';
|
|
for i := 0 to O.A['extList'].Length - 1 do
|
|
SumString(sTemp, O.A['extList'].S[i], '|');
|
|
Result.extList := sTemp;
|
|
end;
|
|
|
|
if (O.O['excList'] <> nil) and (O.O['excList'].DataType = stArray) then
|
|
begin
|
|
sTemp := '';
|
|
for i := 0 to O.A['excList'].Length - 1 do
|
|
SumString(sTemp, O.A['excList'].S[i], '|');
|
|
Result.excList := sTemp;
|
|
end;
|
|
|
|
if O.O['contentsFilter'] <> nil then
|
|
begin
|
|
Result.contentsFilter_use := O.O['contentsFilter'].B['use'];
|
|
if Result.contentsFilter_use then
|
|
begin
|
|
if (O.O['contentsFilter'].O['list'] <> nil) and (O.O['contentsFilter'].O['list'].DataType = stArray) then
|
|
begin
|
|
sTemp := '';
|
|
for i := 0 to O.O['contentsFilter'].A['list'].Length - 1 do
|
|
SumString(sTemp, O.O['contentsFilter'].A['list'].S[i], '|');
|
|
Result.contentsFilter_list := sTemp;
|
|
end;
|
|
end;
|
|
|
|
|
|
end else begin
|
|
Result.origFileCol_use := False;
|
|
end;
|
|
|
|
if O.O['blockByFilename'] <> nil then
|
|
begin
|
|
Result.blockByFilename_use := O.O['blockByFilename'].B['use'];
|
|
if Result.blockByFilename_use then
|
|
begin
|
|
if (O.O['blockByFilename'].O['list'] <> nil) and (O.O['blockByFilename'].O['list'].DataType = stArray) then
|
|
begin
|
|
sTemp := '';
|
|
for i := 0 to O.O['blockByFilename'].A['list'].Length - 1 do
|
|
SumString(sTemp, O.O['blockByFilename'].A['list'].S[i], '|');
|
|
Result.blockByFilename_list := sTemp;
|
|
end;
|
|
end;
|
|
|
|
end else begin
|
|
Result.blockByFilename_use := False;
|
|
end;
|
|
|
|
if O.O['blockBySig'] <> nil then
|
|
begin
|
|
Result.blockBySig_use := O.O['blockBySig'].B['use'];
|
|
if Result.blockBySig_use then
|
|
begin
|
|
if (O.O['blockBySig'].O['list'] <> nil) and (O.O['blockBySig'].O['list'].DataType = stArray) then
|
|
begin
|
|
sTemp := '';
|
|
for i := 0 to O.O['blockBySig'].A['list'].Length - 1 do
|
|
SumString(sTemp, O.O['blockBySig'].A['list'].S[i], '|');
|
|
Result.blockBySig_list := sTemp;
|
|
end;
|
|
end;
|
|
|
|
end else begin
|
|
Result.blockBySig_use := False;
|
|
end;
|
|
|
|
if O.O['blockBySizeLimit'] <> nil then
|
|
begin
|
|
Result.blockBySizeLimit_use := O.O['blockBySizeLimit'].B['use'];
|
|
Result.blockBySizeLimit_minMb := O.O['blockBySizeLimit'].I['minMb'];
|
|
end else begin
|
|
Result.blockBySizeLimit_use := False;
|
|
end;
|
|
end;
|
|
begin
|
|
try
|
|
with aO do
|
|
begin
|
|
IsOldPolicy := B['IsOldPolicy'];
|
|
|
|
PolicyId := S['PolicyId'];
|
|
PolicyGroup := S['PolicyGroup'];
|
|
PolicyName := S['PolicyName'];
|
|
DeptName := S['DeptName'];
|
|
Language := S['Language'];
|
|
VpnAppName := S['VpnAppName'];
|
|
ForceScreenLock := S['ForceScreenLock'];
|
|
NetworkExceptType := S['NetworkExceptType'];
|
|
NetworkBlockType := S['NetworkBlockType'];
|
|
AgentPatchVersion := S['AgentPatchVersion'];
|
|
AgentPatchExeName := S['AgentPatchExeName'];
|
|
VpnMethod := S['VpnMethod'];
|
|
NoticeContent := S['NoticeContent'];
|
|
RestricMac := S['RestricMac'];
|
|
CheckAllowMAC := B['CheckAllowMAC'];
|
|
RestricDate := S['RestricDate'];
|
|
UnsafeActions := S['UnsafeActions'];
|
|
EulaTitle := S['EulaTitle'];
|
|
EulaBody := S['EulaBody'];
|
|
IsRestricDate := B['IsRestricDate'];
|
|
IsEulaSubmit := B['IsEulaSubmit'];
|
|
IsEnableCheck := B['IsEnableCheck'];
|
|
IsWaterMark := B['IsWaterMark'];
|
|
IsMasking := B['IsMasking'];
|
|
IsDefPortBlock := B['IsDefPortBlock'];
|
|
IsSmbPortBlock := B['IsSmbPortBlock'];
|
|
IsAgentUpdateExist := B['IsAgentUpdateExist'];
|
|
IsFixedVerUpdate := B['IsFixedVerUpdate'];
|
|
IsAllowAccess := B['IsAllowAccess'];
|
|
IsTemporaryConn := B['IsTemporaryConn'];
|
|
IsAgentDelete := B['IsAgentDelete'];
|
|
IsNoticeEnable := B['IsNoticeEnable'];
|
|
IsPreventSettingChange := B['IsPreventSettingChange'];
|
|
IsClipboardExcept := B['IsClipboardExcept'];
|
|
IsUseAfterReport := B['IsUseAfterReport'];
|
|
IsPreventDownloads := B['IsPreventDownloads'];
|
|
IsUninstallAble := B['IsUninstallAble'];
|
|
UninstKind := TUninstKind(I['UninstKind']);
|
|
IsWifiPublicBlock := B['IsWifiPublicBlock'];
|
|
IsMobileHotspotExp := B['IsMobileHotspotExp'];
|
|
IsAppBlackDate := B['IsAppBlackDate'];
|
|
IsAppBlackTime := B['IsAppBlackTime'];
|
|
IsLongtimeDisconn := B['IsLongtimeDisconn'];
|
|
IsShowPolicy := B['IsShowPolicy'];
|
|
PoViewKind := TPoViewKind(I['PoViewKind']);
|
|
IsShowAInfo := B['IsShowAInfo'];
|
|
IsMustSecuApp := B['IsMustSecuApp'];
|
|
IsBlockApp := B['IsBlockApp'];
|
|
IsBlockAppLog := B['IsBlockAppLog'];
|
|
IsBlockAppNotice := B['IsBlockAppNotice'];
|
|
IsMonApp := B['IsMonApp'];
|
|
IsMonAppNoti := B['IsMonAppNoti'];
|
|
MonAppList := S['MonAppList'];
|
|
UseFileTag := B['UseFileTag'];
|
|
DetectFixedDisk := B['DetectFixedDisk'];
|
|
ScreenLogo := TIfSecureKind(I['ScreenLogo']);
|
|
ScreenLogoVisible := B['ScreenLogoVisible'];
|
|
ScreenLogoInvisible := B['ScreenLogoInvisible'];
|
|
ScreenBlockAppExp := TIfSecureKind(I['ScreenBlockAppExp']);
|
|
CaptureBlockUrlKind := TBlockKind(I['CaptureBlockUrlKind']);
|
|
AppRcdNoti := B['AppRcdNoti'];
|
|
AppRcdActive := B['AppRcdActive'];
|
|
AppRcdMaxMin := I['AppRcdMaxMin'];
|
|
AppRcdApps := S['AppRcdApps'];
|
|
AppBlackDateB := D['AppBlackDateB'];
|
|
AppBlackDateE := D['AppBlackDateE'];
|
|
VulDueTimeSec := I['VulDueTimeSec'];
|
|
AppBlackTimeB := I['AppBlackTimeB'];
|
|
AppBlackTimeE := I['AppBlackTimeE'];
|
|
PersonalInfoFileMax := I['PersonalInfoFileMax'];
|
|
HeartbeatTime := I['HeartbeatTime'];
|
|
TemporaryConnMin := I['TemporaryConnMin'];
|
|
UninstallPW := S['UninstallPW'];
|
|
ScreenLogoApps := S['ScreenLogoApps'];
|
|
ScreenBlockAppsExp := S['ScreenBlockAppsExp'];
|
|
IgrCaptureApps := S['IgrCaptureApps'];
|
|
SoftwareListB := S['SoftwareListB'];
|
|
SoftwareListW := S['SoftwareListW'];
|
|
NetworkBlockList := S['NetworkBlockList'];
|
|
NetworkExceptList := S['NetworkExceptList'];
|
|
SMBPortExceptList := S['SMBPortExceptList'];
|
|
IsNetBlockDay := B['IsNetBlockDay'];
|
|
NetBlockDayB := D['NetBlockDayB'];
|
|
NetBlockDayE := D['NetBlockDayE'];
|
|
CaptureBlockApps := S['CaptureBlockApps'];
|
|
CaptureBlockUrls := S['CaptureBlockUrls'];
|
|
ScreenLockPwd := S['ScreenLockPwd'];
|
|
WifiBlockNames := S['WifiBlockNames'];
|
|
ClipboardExceptApp := S['ClipboardExceptApp'];
|
|
ExtraPortEnableType := I['ExtraPortEnableType'];
|
|
UnsafeActionsMin := I['UnsafeActionsMin'];
|
|
IsSecuEndActions := B['IsSecuEndActions'];
|
|
ForceScreenLockMin := I['ForceScreenLockMin'];
|
|
ForceShutdownMin := I['ForceShutdownMin'];
|
|
WifiCtrlKind := TWifiCtrlKind(I['WifiCtrlKind']);
|
|
WifiGpsOn := B['WifiGpsOn'];
|
|
UsbBlockKind := TUsbBlockKind(I['UsbBlockKind']);
|
|
AbleUsbExceptReq := B['AbleUsbExceptReq'];
|
|
AbleMtpExceptReq := B['AbleMtpExceptReq'];
|
|
AbleBtExceptReq := B['AbleBtExceptReq'];
|
|
AbleCdExceptReq := B['AbleCdExceptReq'];
|
|
AppInstKind := TAppInstKind(I['AppInstKind']);
|
|
IsDrmAttAbleFB := B['IsDrmAttAbleFB'];
|
|
FileMon := TTgJson.GetDataAsType<TFileMonPolicy>(O['FileMon']);
|
|
FileOpenMon := B['FileOpenMon'];
|
|
FmCreateCol := TTgJson.GetDataAsType<TFileColPo>(O['FmCreateCol']);
|
|
FmModifyCol := TTgJson.GetDataAsType<TFileColPo>(O['FmModifyCol']);
|
|
fmRenameCol := TTgJson.GetDataAsType<TFileColPo>(O['fmRenameCol']);
|
|
// FileMon.OnlyUSB := true; // TEST_KJ
|
|
FileBlock := TTgJson.GetDataAsType<TFileMonPolicy>(O['FileBlock']);
|
|
DrmCF := TTgJson.GetDataAsType<TContentFilter>(O['DrmCF']);
|
|
IsForceShutdown := B['IsForceShutdown'];
|
|
IsUnsafeActions := B['IsUnsafeActions'];
|
|
bCaptureBlockApps_ := B['bCaptureBlockApps_'];
|
|
FileMonOnlyLog := B['FileMonOnlyLog'];
|
|
|
|
ZeroMemory(@EtcAB, SizeOf(EtcAB));
|
|
if O['EtcAB'] <> nil then
|
|
begin
|
|
// EtcAB := TTgJson.GetDataAsType<TAttachBlockPolicy>(O['EtcAB']);
|
|
EtcAB.Kind := TAttachBlockKind(O['EtcAB'].I['Kind']);
|
|
if O['EtcAB'].O['ContentFilter'] <> nil then
|
|
begin
|
|
EtcAB.ContentFilter.bActive := O['EtcAB'].O['ContentFilter'].B['bActive'];
|
|
EtcAB.ContentFilter.sPatterns := O['EtcAB'].O['ContentFilter'].S['sPatterns'];
|
|
EtcAB.ContentFilter.nHitLimit := O['EtcAB'].O['ContentFilter'].I['nHitLimit'];
|
|
end;
|
|
EtcAB.bPopup := O['EtcAB'].B['bPopup'];
|
|
EtcAB.bReadBlock := O['EtcAB'].B['bReadBlock'];
|
|
EtcAB.bWriteBlock := O['EtcAB'].B['bWriteBlock'];
|
|
EtcAB.bCollectTxt := O['EtcAB'].B['bCollectTxt'];
|
|
EtcAB.bCollectFile := O['EtcAB'].B['bCollectFile'];
|
|
|
|
EtcAB.bUpAllowLog := O['EtcAB'].B['bUpAllowLog'];
|
|
EtcAB.bUpBlockLog := O['EtcAB'].B['bUpBlockLog'];
|
|
EtcAB.bUpColAllowTxt := O['EtcAB'].B['bUpColAllowTxt'];
|
|
EtcAB.bUpColAllowFile := O['EtcAB'].B['bUpColAllowFile'];
|
|
EtcAB.bUpColBlockTxt := O['EtcAB'].B['bUpColBlockTxt'];
|
|
EtcAB.bUpColBlockFile := O['EtcAB'].B['bUpColBlockFile'];
|
|
EtcAB.bDlAllowLog := O['EtcAB'].B['bDlAllowLog'];
|
|
EtcAB.bDlBlockLog := O['EtcAB'].B['bDlBlockLog'];
|
|
EtcAB.bDlColAllowTxt := O['EtcAB'].B['bDlColAllowTxt'];
|
|
EtcAB.bDlColAllowFile := O['EtcAB'].B['bDlColAllowFile'];
|
|
end;
|
|
|
|
ZeroMemory(@WebbAB, SizeOf(WebbAB));
|
|
if O['WebbAB'] <> nil then
|
|
begin
|
|
// WebbAB := TTgJson.GetDataAsType<TAttachBlockPolicy>(O['WebbAB']);
|
|
WebbAB.Kind := TAttachBlockKind(O['WebbAB'].I['Kind']);
|
|
if O['WebbAB'].O['ContentFilter'] <> nil then
|
|
begin
|
|
WebbAB.ContentFilter.bActive := O['WebbAB'].O['ContentFilter'].B['bActive'];
|
|
WebbAB.ContentFilter.sPatterns := O['WebbAB'].O['ContentFilter'].S['sPatterns'];
|
|
WebbAB.ContentFilter.nHitLimit := O['WebbAB'].O['ContentFilter'].I['nHitLimit'];
|
|
end;
|
|
WebbAB.bPopup := O['WebbAB'].B['bPopup'];
|
|
WebbAB.bReadBlock := O['WebbAB'].B['bReadBlock'];
|
|
WebbAB.bWriteBlock := O['WebbAB'].B['bWriteBlock'];
|
|
WebbAB.bCollectTxt := O['WebbAB'].B['bCollectTxt'];
|
|
WebbAB.bCollectFile := O['WebbAB'].B['bCollectFile'];
|
|
|
|
WebbAB.bUpAllowLog := O['WebbAB'].B['bUpAllowLog'];
|
|
WebbAB.bUpBlockLog := O['WebbAB'].B['bUpBlockLog'];
|
|
WebbAB.bUpColAllowTxt := O['WebbAB'].B['bUpColAllowTxt'];
|
|
WebbAB.bUpColAllowFile := O['WebbAB'].B['bUpColAllowFile'];
|
|
WebbAB.bUpColBlockTxt := O['WebbAB'].B['bUpColBlockTxt'];
|
|
WebbAB.bUpColBlockFile := O['WebbAB'].B['bUpColBlockFile'];
|
|
WebbAB.bDlAllowLog := O['WebbAB'].B['bDlAllowLog'];
|
|
WebbAB.bDlBlockLog := O['WebbAB'].B['bDlBlockLog'];
|
|
WebbAB.bDlColAllowTxt := O['WebbAB'].B['bDlColAllowTxt'];
|
|
WebbAB.bDlColAllowFile := O['WebbAB'].B['bDlColAllowFile'];
|
|
end;
|
|
|
|
ZeroMemory(@OutlookAB, SizeOf(OutlookAB));
|
|
if O['OutlookAB'] <> nil then
|
|
begin
|
|
// OutlookAB := TTgJson.GetDataAsType<TAttachBlockPolicy>(O['OutlookAB']);
|
|
OutlookAB.Kind := TAttachBlockKind(O['OutlookAB'].I['Kind']);
|
|
if O['OutlookAB'].O['ContentFilter'] <> nil then
|
|
begin
|
|
OutlookAB.ContentFilter.bActive := O['OutlookAB'].O['ContentFilter'].B['bActive'];
|
|
OutlookAB.ContentFilter.sPatterns := O['OutlookAB'].O['ContentFilter'].S['sPatterns'];
|
|
OutlookAB.ContentFilter.nHitLimit := O['OutlookAB'].O['ContentFilter'].I['nHitLimit'];
|
|
end;
|
|
OutlookAB.bPopup := O['OutlookAB'].B['bPopup'];
|
|
OutlookAB.bReadBlock := true; // O['OutlookAB'].B['bReadBlock'];
|
|
// OutlookAB.bWriteBlock := O['OutlookAB'].B['bWriteBlock'];
|
|
OutlookAB.bCollectTxt := O['OutlookAB'].B['bCollectTxt'];
|
|
OutlookAB.bCollectFile := O['OutlookAB'].B['bCollectFile'];
|
|
end;
|
|
|
|
ShareFolder := TShareFolderKind(I['ShareFolder']);
|
|
FileCollectPlan := TFileCollectPlan(I['FileCollectPlan']);
|
|
FileCollectKind := TFileCollectKind(I['FileCollectKind']);
|
|
ScanBlockKind := TScanBlockKind(I['ScanBlockKind']);
|
|
ScreenLockKind := TScreenLockKind(I['ScreenLockKind']);
|
|
CapAppMonKind := TCapAppMonKind(I['CapAppMonKind']);
|
|
IsNotiBCA := B['IsNotiBCA'];
|
|
FileMonNoLog := B['FileMonNoLog'];
|
|
PwChkTerm := TPwChkTerm(I['PwChkTerm']);
|
|
FileCollectDate := D['FileCollectDate'];
|
|
EtcABApps := S['EtcABApps'];
|
|
FileMonExt := S['FileMonExt'];
|
|
TgFileCollect := S['TgFileCollect'];
|
|
TgFileCollectKwd := S['TgFileCollectKwd'];
|
|
WebABUrlList := S['WebABUrlList'];
|
|
PwChkTermDay := I['PwChkTermDay'];
|
|
BlockFRename := TBlockFRename(I['BlockFRename']);
|
|
BlockFdRename := TBlockFdRename(I['BlockFdRename']);
|
|
ClipBlockKind := TClipBlockKind(I['ClipBlockKind']);
|
|
CbPopup := B['CbPopup'];
|
|
CbImgBlock := B['CbImgBlock'];
|
|
DoClipOcr := B['DoClipOcr'];
|
|
OutPo := TTgJson.GetDataAsType<TOutlookPolicy>(O['OutPo']);
|
|
MtpBlockKind := TUsbBlockKind(I['MtpBlockKind']);
|
|
BlueBlockKind := TDevBlockKind(I['BlueBlockKind']);
|
|
CdromBlockKind := TUsbBlockKind(I['CdromBlockKind']);
|
|
USBPopup := B['USBPopup'];
|
|
BTPopup := B['BTPopup'];
|
|
CDPopup := B['CDPopup'];
|
|
MTPPopup := B['MTPPopup'];
|
|
WebbMonKind := TWebbMonKind(I['WebbMonKind']);
|
|
IsDrmAttAble := B['IsDrmAttAble'];
|
|
IsDrmDecrypt := B['IsDrmDecrypt'];
|
|
EtcNicBlock := B['EtcNicBlock'];
|
|
EtcNicBlockNoti := B['EtcNicBlockNoti'];
|
|
EtcNicBlockExcept := S['EtcNicBlockExcept'];
|
|
IsDomainBlock := B['IsDomainBlock'];
|
|
IsStartupScreenLock := B['IsStartupScreenLock'];
|
|
AutoRunBlock := B['AutoRunBlock'];
|
|
HostEnable := B['HostEnable'];
|
|
RouteEnable := B['RouteEnable'];
|
|
IsDailyEulaCheck := B['IsDailyEulaCheck'];
|
|
IsEmpVerify := B['IsEmpVerify'];
|
|
IsVpnAndCondition := B['IsVpnAndCondition'];
|
|
NotifyType := TNotifyType(I['NotifyType']);
|
|
NotiCloseSec := I['NotiCloseSec'];
|
|
NotifyKind := TNotifyKind(I['NotifyKind']);
|
|
IsNotiSystem := B['IsNotiSystem'];
|
|
OsPatchCheck := TOsPatchCheck(I['OsPatchCheck']);
|
|
DrmAccessKind := TDrmAccessKind(I['DrmAccessKind']);
|
|
DrmModifyKind := TDrmAccessKind(I['DrmModifyKind']);
|
|
BlockFRenames := S['BlockFRenames'];
|
|
BlockDirFileRenames := S['BlockDirFileRenames'];
|
|
UrlBlockList := S['UrlBlockList'];
|
|
UrlBlockExcpList := S['UrlBlockExcpList'];
|
|
DomainBlockList := S['DomainBlockList'];
|
|
MtpExcept := S['MtpExcept'];
|
|
MtpExceptVender := S['MtpExceptVender'];
|
|
BlueExcept := S['BlueExcept'];
|
|
BlueExceptVender := S['BlueExceptVender'];
|
|
CdromExcept := S['CdromExcept'];
|
|
UsbExceptVender := S['UsbExceptVender'];
|
|
AllowConn := S['AllowConn'];
|
|
BlockPortList := S['BlockPortList'];
|
|
VpnHour := S['VpnHour'];
|
|
VpnIpList := S['VpnIpList'];
|
|
VpnRcAppList := S['VpnRcAppList'];
|
|
NacCheckUrl := S['NacCheckUrl'];
|
|
ScreenLogoData := S['ScreenLogoData'];
|
|
|
|
WinCapScrLogoOff := B['WinCapScrLogoOff'];
|
|
UseIpScrLogoBold := B['UseIpScrLogoBold'];
|
|
UseIdleScrLogoBold := B['UseIdleScrLogoBold'];
|
|
MinIdleScrLogoBold := I['MinIdleScrLogoBold'];
|
|
UseRemoteScrLogoBold := B['UseRemoteScrLogoBold'];
|
|
BlockChangeTime := B['BlockChangeTime'];
|
|
HealthCheckMilSec := I['HealthCheckMilSec'];
|
|
HealthCheckMilSec := I['HealthCheckMilSec'];
|
|
ScreenLogoUpdateMin := I['ScreenLogoUpdateMin'];
|
|
ScreenLogoAlpha := I['ScreenLogoAlpha'];
|
|
IsIgrScrCapKeyCB := B['IsIgrScrCapKeyCB'];
|
|
HideMainUI := B['HideMainUI'];
|
|
CfZipDepth := I['CfZipDepth'];
|
|
CfTimeoutSec := I['CfTimeoutSec'];
|
|
CfLimitMB := I['CfLimitMB'];
|
|
|
|
// 원본파일 수집크기 제한
|
|
WebABLimitMB := I['WebABLimitMB'];
|
|
AppABLimitMB := I['AppABLimitMB'];
|
|
OutABLimitMB := I['OutABLimitMB'];
|
|
FileMonLimitMB := I['FileMonLimitMB'];
|
|
FileBlkLimitMB := I['FileBlkLimitMB'];
|
|
FileExpMinMB := I['FileExpMinMB'];
|
|
FileExpMaxMB := I['FileExpMaxMB'];
|
|
WebABMinMB := I['WebABMinMB'];
|
|
AppABMinMB := I['AppABMinMB'];
|
|
OutABMinMB := I['OutABMinMB'];
|
|
FileMonMinMB := I['FileMonMinMB'];
|
|
FileBlkMinMB := I['FileBlkMinMB'];
|
|
OutFileBlockMB := I['OutFileBlockMB'];
|
|
WebFileBlockMB := I['WebFileBlockMB'];
|
|
AppFileBlockMB := I['AppFileBlockMB'];
|
|
|
|
PrtMinMB := I['PrtMinMB'];
|
|
PrtMaxMB := I['PrtMaxMB'];
|
|
if PrtMaxMB = 0 then
|
|
PrtMaxMB := 20;
|
|
|
|
WifiBlockPopup := B['WifiBlockPopup'];
|
|
WifiAllowPopup := B['WifiAllowPopup'];
|
|
OutBodyAllowPopup := B['OutBodyAllowPopup'];
|
|
OutFileAllowPopup := B['OutFileAllowPopup'];
|
|
ShareFldBlockPopup := B['ShareFldBlockPopup'];
|
|
ShareFldAllowPopup := B['ShareFldAllowPopup'];
|
|
UsbAllowPopup := B['UsbAllowPopup'];
|
|
MtpAllowPopup := B['MtpAllowPopup'];
|
|
BtAllowPopup := B['BtAllowPopup'];
|
|
CdAllowPopup := B['CdAllowPopup'];
|
|
PrtAllowPopup := B['PrtAllowPopup'];
|
|
HdMonPopup := B['HdMonPopup'];
|
|
|
|
IsPcStatePower := B['IsPcStatePower'];
|
|
IsPcStateIpCh := B['IsPcStateIpCh'];
|
|
|
|
FileMonEncDelaySec := I['FileMonEncDelaySec'];
|
|
if (CUSTOMER_TYPE = CUSTOMER_KDNVN) and (FileMonEncDelaySec = 0) then
|
|
FileMonEncDelaySec := 600;
|
|
IsUrlCatchLogo := B['IsUrlCatchLogo'];
|
|
LogoUrlList := S['LogoUrlList'];
|
|
IsPrtCollectThum := B['IsPrtCollectThum'];
|
|
PrtCollThumLimit := I['PrtCollThumLimit'];
|
|
IsIgrCollectCutWebAB := B['IsIgrCollectCutWebAB'];
|
|
IsAllowLogWebAB := B['IsAllowLogWebAB'];
|
|
IsIgrCollectCutAppAB := B['IsIgrCollectCutAppAB'];
|
|
IsAllowLogAppAB := B['IsAllowLogAppAB'];
|
|
|
|
WebAbSigs := S['WebAbSigs'];
|
|
WebAbFNames := S['WebAbFNames'];
|
|
EtcAbSigs := S['EtcAbSigs'];
|
|
EtcAbFNames := S['EtcAbFNames'];
|
|
PrtNameH := S['PrtNameH'];
|
|
PrtWaterAppH := S['PrtWaterAppH'];
|
|
PrtWaterAppHig := S['PrtWaterAppHig'];
|
|
SmbPortEx := S['SmbPortEx'];
|
|
AipEncMSec := I['AipEncMSec'];
|
|
CfFblkExts := S['CfFblkExts'];
|
|
WebAbExts := S['WebAbExts'];
|
|
EtcAbExts := S['EtcAbExts'];
|
|
FileExpMin := I['FileExpMin'];
|
|
if FileExpMin = 0 then
|
|
FileExpMin := 60;
|
|
LogKeepDays := I['LogKeepDays'];
|
|
if LogKeepDays = 0 then
|
|
LogKeepDays := 10;
|
|
BtConNotiDSec := I['BtConNotiDSec'];
|
|
SplitString(UpperCase(S['GetPrtOcrTxt']), '|', PrtOcrTxtExtList);
|
|
WebABLogUrlList := S['WebABLogUrlList'];
|
|
EtcAbLogList := S['EtcAbLogList'];
|
|
|
|
// 공유폴더 감시/차단
|
|
if O['ShFileCrMon'] <> nil then
|
|
ShFileCrMon := TTgJson.GetDataAsType<TShFileCrMon>(O['ShFileCrMon']);
|
|
|
|
// 취약점 점검 정책
|
|
VulOsVersion := B['VulOsVersion'];
|
|
VulAntiVirus := B['VulAntiVirus'];
|
|
VulPassword := B['VulPassword'];
|
|
VulScreenSaver := B['VulScreenSaver'];
|
|
VulFirewall := B['VulFirewall'];
|
|
|
|
// 오프라인 정책
|
|
UseExpPo := B['UseExpPo'];
|
|
ExpPoLimit := I['ExpPoLimit'];
|
|
ExpPoMin := I['ExpPoMin'];
|
|
ExpPoAgree := S['ExpPoAgree'];
|
|
|
|
// 오프라인 로그
|
|
OffLogKind := TOffLogKind(I['OffLogKind']);
|
|
OffLogDays := I['OffLogDays'];
|
|
OffLogMaxMB := I['OffLogMaxMB'];
|
|
UseOffLogDay := B['UseOffLogDay'];
|
|
UseOffLogMaxMB := B['UseOffLogMaxMB'];
|
|
|
|
IgrUsbSerialList.CommaText := S['IgrUsbSerialList'];
|
|
IgrUsbSerials := S['IgrUsbSerials'];
|
|
IgrUsbSerialsKn := S['IgrUsbSerialsKn'];
|
|
|
|
Print := TTgJson.GetDataAsType<TPrintPolicy>(O['Print']);
|
|
PrinterIpExcept := S['PrinterIpExcept'];
|
|
PrtWtExpUrl := S['PrtWtExpUrl'];
|
|
PrtWtExpDocName := S['PrtWtExpDocName'];
|
|
PrtWtExpPrtName := S['PrtWtExpPrtName'];
|
|
PrtWtExpProcName := S['PrtWtExpProcName'];
|
|
PrtApvExpUrl := S['PrtApvExpUrl'];
|
|
PrtApvExpDocName := S['PrtApvExpDocName'];
|
|
PrtApvExpPrtName := S['PrtApvExpPrtName'];
|
|
PrtApvExpProcName := S['PrtApvExpProcName'];
|
|
PrtWaterCfg := TTgJson.GetDataAsType<TPrtWaterCfg>(O['PrtWaterCfg']);
|
|
|
|
PrintApproval := B['PrintApproval'];
|
|
PrintApprovalPost := B['PrintApprovalPost'];
|
|
UsbApproval := B['UsbApproval'];
|
|
WebUrlApproval := B['WebUrlApproval'];
|
|
BtApproval := B['BtApproval'];
|
|
CdApproval := B['CdApproval'];
|
|
MtpApproval := B['MtpApproval'];
|
|
DrmApproval := B['DrmApproval'];
|
|
ExFApproval := B['ExFApproval'];
|
|
CapApproval := B['CapApproval'];
|
|
|
|
BlockNoUrl := B['BlockNoUrl'];
|
|
BlockNoUrlAB := B['BlockNoUrlAB'];
|
|
BlockWidgetAB := B['BlockWidgetAB'];
|
|
UrlBlockNoti := B['UrlBlockNoti'];
|
|
UrlAllowNoti := B['UrlAllowNoti'];
|
|
// WebABlockNoti := B['WebABlockNoti'];
|
|
WebAAllowNoti := B['WebAAllowNoti'];
|
|
// AppABlockNoti := B['AppABlockNoti'];
|
|
AppAAllowNoti := B['AppAAllowNoti'];
|
|
|
|
LogLv := I['LogLv'];
|
|
LogEnc := B['LogEnc'];
|
|
AipOff := B['AipOff'];
|
|
TextLimit := I['TextLimit'];
|
|
PrtDPI := I['PrtDPI'];
|
|
case PrtDPI of
|
|
100, 200, 300,
|
|
400, 500, 600 : ;
|
|
else PrtDPI := nDefPrtDPI_;
|
|
end;
|
|
ChkConSec := I['ChkConSec'];
|
|
if ChkConSec = 0 then
|
|
ChkConSec := 10
|
|
else if ChkConSec > 999 then
|
|
ChkConSec := 999;
|
|
DrmPopupNo := B['DrmPopupNo'];
|
|
PrtPopupNo := B['PrtPopupNo'];
|
|
PrtWaterPop := B['PrtWaterPop'];
|
|
OpenDetect := B['OpenDetect'];
|
|
IgrNetPathAB := B['IgrNetPathAB'];
|
|
CodePo := B['CodePo'];
|
|
NoOutlRcvr := B['NoOutlRcvr'];
|
|
|
|
// {$IFDEF DEBUG} // TEST_KJ
|
|
// Print.PrintWater := pwActive;
|
|
// {$ENDIF}
|
|
sPoId_ := S['sPoId_'];
|
|
|
|
// 클립보드 추가
|
|
IsCBCollect := B['IsCBCollect'];
|
|
CBCollectApp := S['CBCollectApp'];
|
|
CbCF := TTgJson.GetDataAsType<TContentFilter>(O['CbCF']);
|
|
|
|
IsTempGroup := B['IsTempGroup'];
|
|
|
|
SecuExitWaitSec := I['SecuExitWaitSec'];
|
|
|
|
//mgkim 프로세스 시작 시 정책 읽어ㅏ야함..
|
|
IntBtBlockNewFile:= TTgJson.GetDataAsType<TIntBlockNewFile>(O['IntBtBlockNewFile']);
|
|
// IntBtBlockNewFile := GetBlockFileNew(O['int_btBlockNewFile']);
|
|
_Trace('블루 투스 파일 차단 정책 끝 : mode : %d',[Integer(IntBtBlockNewFile.mode)], 1);
|
|
IntUsbBlockNewFile:= TTgJson.GetDataAsType<TIntBlockNewFile>(O['IntUsbBlockNewFile']);
|
|
// IntUsbBlockNewFile := GetBlockFileNew(O['int_usbBlockNewFile']);
|
|
|
|
_Trace('Usb 차단 정책 끝 : mode : %d',[Integer(IntUsbBlockNewFile.mode)], 1);
|
|
IntUsbToUsbBlockNewFile:= TTgJson.GetDataAsType<TIntBlockNewFile>(O['IntUsbToUsbBlockNewFile']);
|
|
// IntUsbToUsbBlockNewFile := GetBlockFileNew(O['int_usbToUsbBlockNewFile']);
|
|
|
|
_Trace('Usb TO Usb 차단 정책 끝 : mode : %d',[Integer(IntUsbToUsbBlockNewFile.mode)], 1);
|
|
IntCdromBlockNewFile:= TTgJson.GetDataAsType<TIntBlockNewFile>(O['IntCdromBlockNewFile']);
|
|
// IntCdromBlockNewFile := GetBlockFileNew(O['int_cdBlockNewFile']);
|
|
|
|
_Trace('Cdrom 차단 정책 끝 : mode : %d',[Integer(IntCdromBlockNewFile.mode)], 1);
|
|
IntMtpBlockNewFile:= TTgJson.GetDataAsType<TIntBlockNewFile>(O['IntMtpUsbBlockNewFile']);
|
|
// IntMtpBlockNewFile := GetBlockFileNew(O['int_mtpBlockNewFile']);
|
|
|
|
_Trace('Mtp 차단 정책 끝 : mode : %d',[Integer(IntMtpBlockNewFile.mode)], 1);
|
|
|
|
SetOldDefault;
|
|
end;
|
|
|
|
ProcessAfterSetPolicy;
|
|
bLoaded_ := (PolicyId <> '') and (PolicyId.ToLower <> 'false');
|
|
except
|
|
on E: Exception do
|
|
ETgException.TraceException(Self, E, 'Fail .. SetPolicyFromJsonObj()');
|
|
end;
|
|
end;
|
|
|
|
{ TManagerCttSch }
|
|
|
|
Constructor TManagerCttSch.Create;
|
|
begin
|
|
Inherited Create;
|
|
TaskEntList_ := TCttSchTaskEntList.Create;
|
|
TaskEntList_.OnNotify := OnTaskEntNotify;
|
|
Load;
|
|
end;
|
|
|
|
Destructor TManagerCttSch.Destroy;
|
|
begin
|
|
FreeAndNil(TaskEntList_);
|
|
Inherited;
|
|
end;
|
|
|
|
procedure TManagerCttSch.OnTaskEntNotify(Sender: TObject; const Item: PCttSchTaskEnt; Action: TCollectionNotification);
|
|
begin
|
|
if Action = cnRemoved then
|
|
Dispose(Item);
|
|
end;
|
|
|
|
function TManagerCttSch.GetTaskEntByScanId(sScanId: String): PCttSchTaskEnt;
|
|
var
|
|
i: Integer;
|
|
begin
|
|
for i := 0 to TaskEntList_.Count - 1 do
|
|
if CompareText(sScanId, TaskEntList_[i].sScanId) = 0 then
|
|
Exit(TaskEntList_[i]);
|
|
Result := nil;
|
|
end;
|
|
|
|
procedure TManagerCttSch.CompleteTask(sScanId: String; dtComp: TDateTime = 0);
|
|
var
|
|
pEnt: PCttSchTaskEnt;
|
|
begin
|
|
pEnt := GetTaskEntByScanId(sScanId);
|
|
if pEnt = nil then
|
|
begin
|
|
New(pEnt);
|
|
pEnt.sScanId := sScanId;
|
|
TaskEntList_.Add(pEnt);
|
|
end;
|
|
|
|
pEnt.dtRecentLC := Now;
|
|
if dtComp = 0 then
|
|
dtComp := pEnt.dtRecentLC;
|
|
|
|
pEnt.dtRecent := dtComp;
|
|
Save;
|
|
end;
|
|
|
|
function TManagerCttSch.GetTastRecentDT(sScanId: String): TDateTime;
|
|
var
|
|
pEnt: PCttSchTaskEnt;
|
|
begin
|
|
pEnt := GetTaskEntByScanId(sScanId);
|
|
if pEnt <> nil then
|
|
begin
|
|
Result := pEnt.dtRecent;
|
|
if Result = 0 then
|
|
Result := pEnt.dtRecentLC;
|
|
end else
|
|
Result := 0;
|
|
end;
|
|
|
|
function TManagerCttSch.GetTastRecentLcDT(sScanId: String): TDateTime;
|
|
var
|
|
pEnt: PCttSchTaskEnt;
|
|
begin
|
|
pEnt := GetTaskEntByScanId(sScanId);
|
|
if pEnt <> nil then
|
|
begin
|
|
Result := pEnt.dtRecentLC;
|
|
if Result = 0 then
|
|
Result := pEnt.dtRecent;
|
|
end else
|
|
Result := 0;
|
|
end;
|
|
|
|
procedure TManagerCttSch.Clear;
|
|
begin
|
|
TaskEntList_.Clear;
|
|
Save;
|
|
end;
|
|
|
|
procedure TManagerCttSch.Save;
|
|
var
|
|
O, OA: ISuperObject;
|
|
ss: TStringStream;
|
|
i: Integer;
|
|
sPath: String;
|
|
begin
|
|
try
|
|
if sPath = '' then
|
|
sPath := GetRunExePathDir + DIR_CONF + DAT_CTTSCH;
|
|
|
|
if TaskEntList_.Count > 0 then
|
|
begin
|
|
OA := TSuperObject.Create(stArray);
|
|
for i := 0 to TaskEntList_.Count - 1 do
|
|
OA.AsArray.Add(TTgJson.ValueToJsonObject<TCttSchTaskEnt>(TaskEntList_[i]^));
|
|
|
|
O := SO;
|
|
O.O['List'] := OA;
|
|
|
|
Guard(ss, TStringStream.Create(
|
|
EncStrToBinStr(ekAes256cbc, PASS_MODEL, O.AsString), TEncoding.UTF8));
|
|
|
|
if ForceDirectories(ExtractFilePath(sPath)) then
|
|
ss.SaveToFile(sPath);
|
|
end else
|
|
if FileExists(sPath) then
|
|
DeleteFile(PChar(sPath));
|
|
except
|
|
on E: Exception do
|
|
ETgException.TraceException(Self, E, 'Fail .. Save()');
|
|
end;
|
|
end;
|
|
|
|
procedure TManagerCttSch.Load;
|
|
var
|
|
sPath: String;
|
|
ss: TStringStream;
|
|
O: ISuperObject;
|
|
i: Integer;
|
|
pEnt: PCttSchTaskEnt;
|
|
begin
|
|
TaskEntList_.Clear;
|
|
sPath := GetRunExePathDir + DIR_CONF + DAT_CTTSCH;
|
|
if not FileExists(sPath) then
|
|
exit;
|
|
|
|
try
|
|
Guard(ss, TStringStream.Create('', TEncoding.UTF8));
|
|
ss.LoadFromFile(sPath);
|
|
|
|
O := SO(DecBinStrToStr(ekAes256cbc, PASS_MODEL, ss.DataString));
|
|
if O <> nil then
|
|
begin
|
|
if O.O['List'] = nil then
|
|
exit;
|
|
|
|
if O.O['List'].DataType <> stArray then
|
|
exit;
|
|
|
|
for i := 0 to O.A['List'].Length - 1 do
|
|
begin
|
|
New(pEnt);
|
|
// pEnt^ := TTgJson.GetDataAsType<TCttSchTaskEnt>(O.A['List'].O[i]);
|
|
pEnt.sScanId := O.A['List'].O[i].S['sScanId'];
|
|
pEnt.dtRecent := JavaToDelphiDateTime(O.A['List'].O[i].I['dtRecent']);
|
|
pEnt.dtRecentLC := JavaToDelphiDateTime(O.A['List'].O[i].I['dtRecentLC']);
|
|
TaskEntList_.Add(pEnt);
|
|
end;
|
|
end;
|
|
except
|
|
on E: Exception do
|
|
ETgException.TraceException(Self, E, 'Load()');
|
|
end;
|
|
end;
|
|
|
|
{ TManagerCttSchExcept }
|
|
|
|
Constructor TManagerCttSchExcept.Create;
|
|
begin
|
|
Inherited Create;
|
|
HashList_ := TStringList.Create;
|
|
Load;
|
|
end;
|
|
|
|
Destructor TManagerCttSchExcept.Destroy;
|
|
begin
|
|
FreeAndNil(HashList_);
|
|
Inherited;
|
|
end;
|
|
|
|
function TManagerCttSchExcept.AddFileHash(sPath: String): Boolean;
|
|
var
|
|
sHash: String;
|
|
begin
|
|
Result := false;
|
|
try
|
|
sHash := GetFileToSha256(sPath);
|
|
if (sHash <> '') and (HashList_.IndexOf(sHash) = -1) then
|
|
begin
|
|
HashList_.Add(sHash);
|
|
Result := true;
|
|
end;
|
|
except
|
|
on E: Exception do
|
|
ETgException.TraceException(Self, E, 'Fail .. AddFileHash()');
|
|
end;
|
|
end;
|
|
|
|
function TManagerCttSchExcept.HasFileHash(sPath: String): Boolean;
|
|
begin
|
|
try
|
|
Result := HashList_.IndexOf(GetFileToSha256(sPath)) <> -1;
|
|
except
|
|
on E: Exception do
|
|
begin
|
|
Result := false;
|
|
ETgException.TraceException(Self, E, 'Fail .. HasFileHash()');
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
procedure TManagerCttSchExcept.Save;
|
|
begin
|
|
try
|
|
HashList_.SaveToFile(GetRunExePathDir + DIR_CONF + DAT_CTTSCHEXCEPT, TEncoding.ANSI);
|
|
except
|
|
on E: Exception do
|
|
ETgException.TraceException(Self, E, 'Fail .. Save()');
|
|
end;
|
|
end;
|
|
|
|
procedure TManagerCttSchExcept.Load;
|
|
var
|
|
sPath: String;
|
|
begin
|
|
try
|
|
sPath := GetRunExePathDir + DIR_CONF + DAT_CTTSCHEXCEPT;
|
|
if FileExists(sPath) then
|
|
HashList_.LoadFromFile(sPath, TEncoding.ANSI);
|
|
except
|
|
on E: Exception do
|
|
ETgException.TraceException(Self, E, 'Fail .. Load()');
|
|
end;
|
|
end;
|
|
|
|
{ TManagerCampExcept }
|
|
|
|
Constructor TManagerCampExcept.Create;
|
|
begin
|
|
Inherited Create;
|
|
PathList_ := TStringList.Create;
|
|
PathList_.CaseSensitive := false;
|
|
Load;
|
|
end;
|
|
|
|
Destructor TManagerCampExcept.Destroy;
|
|
begin
|
|
FreeAndNil(PathList_);
|
|
Inherited;
|
|
end;
|
|
|
|
procedure TManagerCampExcept.AddFile(sPath: String);
|
|
begin
|
|
try
|
|
PathList_.Add(sPath);
|
|
except
|
|
on E: Exception do
|
|
ETgException.TraceException(Self, E, 'Fail .. AddFile()');
|
|
end;
|
|
end;
|
|
|
|
function TManagerCampExcept.IsExceptFile(sPath: String): Boolean;
|
|
begin
|
|
try
|
|
Result := PathList_.IndexOf(sPath) <> -1;
|
|
except
|
|
on E: Exception do
|
|
begin
|
|
Result := false;
|
|
ETgException.TraceException(Self, E, 'Fail .. IsExceptFile()');
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
procedure TManagerCampExcept.Save;
|
|
var
|
|
fs: TFileStream;
|
|
ss: TStringStream;
|
|
enc: TTgEncrypt;
|
|
begin
|
|
try
|
|
Guard(enc, TTgEncrypt.Create(PASS_STRENC));
|
|
Guard(fs, TFileStream.Create(GetRunExePathDir + DIR_CONF + DAT_CAMPEXCEPT, fmCreate));
|
|
Guard(ss, TStringStream.Create(PathList_.Text, TEncoding.UTF8));
|
|
enc.EncryptStream(ss, fs, 'BS1');
|
|
except
|
|
on E: Exception do
|
|
ETgException.TraceException(Self, E, 'Fail .. Save()');
|
|
end;
|
|
end;
|
|
|
|
procedure TManagerCampExcept.Load;
|
|
var
|
|
sPath: String;
|
|
fs: TFileStream;
|
|
ss: TStringStream;
|
|
enc: TTgEncrypt;
|
|
begin
|
|
try
|
|
PathList_.Clear;
|
|
|
|
sPath := GetRunExePathDir + DIR_CONF + DAT_CAMPEXCEPT;
|
|
if FileExists(sPath) then
|
|
begin
|
|
Guard(enc, TTgEncrypt.Create(PASS_STRENC));
|
|
Guard(fs, TFileStream.Create(GetRunExePathDir + DIR_CONF + DAT_CAMPEXCEPT, fmOpenRead or fmShareDenyNone));
|
|
Guard(ss, TStringStream.Create('', TEncoding.UTF8));
|
|
|
|
if enc.DecryptStream(fs, ss, 'BS1') then
|
|
begin
|
|
PathList_.Text := ss.DataString;
|
|
end;
|
|
end;
|
|
except
|
|
on E: Exception do
|
|
ETgException.TraceException(Self, E, 'Fail .. Load()');
|
|
end;
|
|
end;
|
|
|
|
{ TManagerPrtWaterExcept }
|
|
|
|
Constructor TManagerPrtWaterExcept.Create;
|
|
begin
|
|
Inherited Create;
|
|
HashList_ := TStringList.Create;
|
|
HashEntList_ := TList<PPweEnt>.Create;
|
|
HashEntList_.OnNotify := OnEntNotify;
|
|
Load;
|
|
end;
|
|
|
|
Destructor TManagerPrtWaterExcept.Destroy;
|
|
begin
|
|
FreeAndNil(HashEntList_);
|
|
FreeAndNil(HashList_);
|
|
Inherited;
|
|
end;
|
|
|
|
procedure TManagerPrtWaterExcept.OnEntNotify(Sender: TObject; const Item: PPweEnt; Action: TCollectionNotification);
|
|
begin
|
|
if Action = cnRemoved then
|
|
Dispose(Item);
|
|
end;
|
|
|
|
function TManagerPrtWaterExcept.AddFileHash(sPath: String): Boolean;
|
|
var
|
|
sHash,
|
|
sTempPath: String;
|
|
i: Integer;
|
|
pEnt: PPweEnt;
|
|
begin
|
|
Result := false;
|
|
try
|
|
sHash := GetFileToSha256(sPath);
|
|
if sHash = '' then
|
|
begin
|
|
// 사용중으로 실패할 수 있다.
|
|
sTempPath := GetRunExePathDir + 'Temp\';
|
|
if ForceDirectories(sTempPath) then
|
|
begin
|
|
sTempPath := sTempPath + ExtractFileName(sPath);
|
|
if CopyFile(PChar(sPath), PChar(sTempPath), false) then
|
|
begin
|
|
sHash := GetFileToSha256(sTempPath);
|
|
DeleteFile(PChar(sTempPath));
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
if (sHash = '') or (HashList_.IndexOf(sHash) <> -1) then
|
|
exit;
|
|
|
|
New(pEnt);
|
|
pEnt.dtReg := Now;
|
|
pEnt.sHash := sHash;
|
|
HashEntList_.Add(pEnt);
|
|
HashList_.Add(sHash);
|
|
Result := true;
|
|
except
|
|
on E: Exception do
|
|
ETgException.TraceException(Self, E, 'Fail .. AddFileHash()');
|
|
end;
|
|
end;
|
|
|
|
function TManagerPrtWaterExcept.HasFileHash(sPath: String): Boolean;
|
|
var
|
|
sHash,
|
|
sTempPath: String;
|
|
i: Integer;
|
|
begin
|
|
Result := false;
|
|
try
|
|
sHash := GetFileToSha256(sPath);
|
|
if sHash = '' then
|
|
begin
|
|
// 사용중으로 실패할 수 있다.
|
|
sTempPath := GetRunExePathDir + 'Temp\';
|
|
if ForceDirectories(sTempPath) then
|
|
begin
|
|
sTempPath := sTempPath + ExtractFileName(sPath);
|
|
if CopyFile(PChar(sPath), PChar(sTempPath), false) then
|
|
begin
|
|
sHash := GetFileToSha256(sTempPath);
|
|
DeleteFile(PChar(sTempPath));
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
if sHash = '' then
|
|
exit;
|
|
|
|
i := HashList_.IndexOf(sHash);
|
|
if i <> -1 then
|
|
begin
|
|
if DaysBetween(HashEntList_[i].dtReg, Now) = 0 then
|
|
Result := true;
|
|
end;
|
|
except
|
|
on E: Exception do
|
|
ETgException.TraceException(Self, E, 'Fail .. HasFileHash()');
|
|
end;
|
|
end;
|
|
|
|
function TManagerPrtWaterExcept.CountHash: Integer;
|
|
begin
|
|
try
|
|
Result := HashEntList_.Count;
|
|
except
|
|
on E: Exception do
|
|
ETgException.TraceException(Self, E, 'Fail .. CountHash()');
|
|
end;
|
|
end;
|
|
|
|
procedure TManagerPrtWaterExcept.Save;
|
|
var
|
|
i: Integer;
|
|
OA, O: ISuperObject;
|
|
begin
|
|
try
|
|
OA := TSuperObject.Create(stArray);
|
|
for i := HashEntList_.Count - 1 downto 0 do
|
|
begin
|
|
if DaysBetween(HashEntList_[i].dtReg, Now) >= 1 then
|
|
begin
|
|
HashEntList_.Delete(i);
|
|
HashList_.Delete(i);
|
|
end else
|
|
OA.AsArray.Add(TTgJson.ValueToJsonObject<TPweEnt>(HashEntList_[i]^));
|
|
end;
|
|
|
|
O := SO;
|
|
O.O['List'] := OA;
|
|
SaveJsonObjToFile(O, GetRunExePathDir + DIR_CONF + DAT_PRTWTEXCEPT);
|
|
except
|
|
on E: Exception do
|
|
ETgException.TraceException(Self, E, 'Fail .. Save()');
|
|
end;
|
|
end;
|
|
|
|
procedure TManagerPrtWaterExcept.Load;
|
|
var
|
|
sPath: String;
|
|
O: ISuperObject;
|
|
q: Integer;
|
|
Ent: TPweEnt;
|
|
pEnt: PPweEnt;
|
|
begin
|
|
try
|
|
HashEntList_.Clear;
|
|
HashList_.Clear;
|
|
|
|
sPath := GetRunExePathDir + DIR_CONF + DAT_PRTWTEXCEPT;
|
|
if LoadJsonObjFromFile(O, sPath) then
|
|
begin
|
|
if (O.O['List'] = nil) or (O.O['List'].DataType <> stArray) then
|
|
exit;
|
|
|
|
for q := 0 to O.A['List'].Length - 1 do
|
|
begin
|
|
Ent := TTgJson.GetDataAsType<TPweEnt>(O.A['List'][q]);
|
|
if DaysBetween(Ent.dtReg, Now) = 0 then
|
|
begin
|
|
New(pEnt);
|
|
pEnt^ := Ent;
|
|
HashEntList_.Add(pEnt);
|
|
HashList_.Add(pEnt.sHash);
|
|
end;
|
|
end;
|
|
end;
|
|
except
|
|
on E: Exception do
|
|
ETgException.TraceException(Self, E, 'Fail .. Load()');
|
|
end;
|
|
end;
|
|
|
|
{ TManagerCltFld }
|
|
|
|
Constructor TManagerCltFld.Create;
|
|
begin
|
|
Inherited Create;
|
|
TaskEntList_ := TCltFldTaskEntList.Create;
|
|
TaskEntList_.OnNotify := OnTaskEntNotify;
|
|
Load;
|
|
end;
|
|
|
|
Destructor TManagerCltFld.Destroy;
|
|
begin
|
|
FreeAndNil(TaskEntList_);
|
|
Inherited;
|
|
end;
|
|
|
|
procedure TManagerCltFld.OnTaskEntNotify(Sender: TObject; const Item: PCltFldTaskEnt; Action: TCollectionNotification);
|
|
begin
|
|
if Action = cnRemoved then
|
|
Dispose(Item);
|
|
end;
|
|
|
|
function TManagerCltFld.GetTaskEntByScanId(sCollectId: String): PCltFldTaskEnt;
|
|
var
|
|
i: Integer;
|
|
begin
|
|
for i := 0 to TaskEntList_.Count - 1 do
|
|
if CompareText(sCollectId, TaskEntList_[i].sCollectId) = 0 then
|
|
Exit(TaskEntList_[i]);
|
|
Result := nil;
|
|
end;
|
|
|
|
procedure TManagerCltFld.CompleteTask(sCollectId: String);
|
|
var
|
|
pEnt: PCltFldTaskEnt;
|
|
begin
|
|
pEnt := GetTaskEntByScanId(sCollectId);
|
|
if pEnt = nil then
|
|
begin
|
|
New(pEnt);
|
|
pEnt.sCollectId := sCollectId;
|
|
TaskEntList_.Add(pEnt);
|
|
end;
|
|
pEnt.dtRecent := Now;
|
|
Save;
|
|
end;
|
|
|
|
function TManagerCltFld.GetTastRecentDT(sScanId: String): TDateTime;
|
|
var
|
|
pEnt: PCltFldTaskEnt;
|
|
begin
|
|
pEnt := GetTaskEntByScanId(sScanId);
|
|
if pEnt <> nil then
|
|
Result := pEnt.dtRecent
|
|
else
|
|
Result := 0;
|
|
end;
|
|
|
|
procedure TManagerCltFld.Save;
|
|
var
|
|
O, OA: ISuperObject;
|
|
ss: TStringStream;
|
|
i: Integer;
|
|
sPath: String;
|
|
begin
|
|
try
|
|
OA := TSuperObject.Create(stArray);
|
|
for i := 0 to TaskEntList_.Count - 1 do
|
|
OA.AsArray.Add(TTgJson.ValueToJsonObject<TCltFldTaskEnt>(TaskEntList_[i]^));
|
|
|
|
O := SO;
|
|
O.O['List'] := OA;
|
|
|
|
Guard(ss, TStringStream.Create(
|
|
EncStrToBinStr(ekAes256cbc, PASS_MODEL, O.AsString), TEncoding.UTF8));
|
|
|
|
if sPath = '' then
|
|
sPath := GetRunExePathDir + DIR_CONF + DAT_CLTFLD;
|
|
|
|
if ForceDirectories(ExtractFilePath(sPath)) then
|
|
ss.SaveToFile(sPath);
|
|
except
|
|
on E: Exception do
|
|
ETgException.TraceException(Self, E, 'Fail .. Save()');
|
|
end;
|
|
end;
|
|
|
|
procedure TManagerCltFld.Load;
|
|
var
|
|
sPath: String;
|
|
ss: TStringStream;
|
|
O: ISuperObject;
|
|
i: Integer;
|
|
pEnt: PCltFldTaskEnt;
|
|
begin
|
|
TaskEntList_.Clear;
|
|
sPath := GetRunExePathDir + DIR_CONF + DAT_CLTFLD;
|
|
if not FileExists(sPath) then
|
|
exit;
|
|
|
|
try
|
|
Guard(ss, TStringStream.Create('', TEncoding.UTF8));
|
|
ss.LoadFromFile(sPath);
|
|
|
|
O := SO(DecBinStrToStr(ekAes256cbc, PASS_MODEL, ss.DataString));
|
|
if O <> nil then
|
|
begin
|
|
if O.O['List'] = nil then
|
|
exit;
|
|
|
|
if O.O['List'].DataType <> stArray then
|
|
exit;
|
|
|
|
for i := 0 to O.A['List'].Length - 1 do
|
|
begin
|
|
New(pEnt);
|
|
pEnt^ := TTgJson.GetDataAsType<TCltFldTaskEnt>(O.A['List'].O[i]);
|
|
TaskEntList_.Add(pEnt);
|
|
end;
|
|
end;
|
|
except
|
|
on E: Exception do
|
|
ETgException.TraceException(Self, E, 'Load()');
|
|
end;
|
|
end;
|
|
|
|
end.
|