windows的checklist，自行编译exe文件

package main

import (
	"fmt"
	"github.com/axgle/mahonia"
	"golang.org/x/sys/windows/registry"
	"io/ioutil"
	"os"
	"os/exec"
	"os/user"
	"runtime"
	"strings"
	"syscall"
)

// 修改脚本前熟悉所有命令函数，切勿对系统造成影响，创建的东西要记得删除

// SecEdit.exe /export /cfg C:\\systeminfo.txt 獲取系統策略信息

//获取软件安装列表
// X64
// dir Registry::HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall -Name
// X86
// dir Registry::HKEY_LOCAL_MACHINE\SOFTWARE\Wow6432Node\Microsoft\Windows\CurrentVersion\Uninstall\ -Name

func gopro()  {

	fmt.Println("************************************读取系统配置中*******************************")
	// 生產系統配置文件
	Getsystemset()
	// 读取系统文件
	systemsetconfig := readsystemset()
	fmt.Println()

	fmt.Println("************************************输出系统信息*********************************")
	// 获取系统信息
	Getsystem()
	// 获取系统的架构
	Getsystemframework()
	// 获取系统的内核版本
	Getsystemversion()

	fmt.Println("************************************获取用户信息*********************************")
	// 获取系统用户
	Getsystemuserdata()
	// 获取当前用户信息
	Getcurrentuserinfo()
	// 获取系统默认账户
	Getsystemdefaultuser(systemsetconfig)
	// 获取administrator组用户20201125
	getAdmingroupuser()

	fmt.Println("************************************获取端口信息*********************************")
	// 打印系统端口数据
	Getsystemport()


	fmt.Println("************************************打印系统密码策略******************************")
	// 获取密码策略
	Getsystempwdpolicy(systemsetconfig)
	// 密码过期提醒
	passwd_Expired(systemsetconfig)

	fmt.Println("***********************************获取系统安全审计策略****************************")
	// 获取系统安全策略
	Getsystemaudit(systemsetconfig)
	// eventlog服务状态
	getEventlogstat()

	fmt.Println("*************************************智能卡选项**********************************")
	// 智能卡移除操作
	smart_card_remove(systemsetconfig)
	// 交互式登录是否需要智能卡
	smart_card_login(systemsetconfig)

	fmt.Println("************************************获取系统共享目录******************************")
	// 查看共享
	net_share()

	fmt.Println("************************************获取系统屏保状态******************************")
	// 查看是否看起屏保
	getScreenSaver()

	fmt.Println("************************************系统自动播放功能******************************")
	// 系统媒体和设备自动播放功能
	sysmediaauto()

	fmt.Println("************************************系统SAM访问设置******************************")
	// 网络访问SAM访问设置数据
	GetSystemSAMcontrol()

	fmt.Println("************************************系统进程输出*********************************")
	// 進程輸出
	getSystemtasklist()

	fmt.Println("************************************系统服务输出*********************************")
	// 获取服务器当前运行服务
	getCurrentservice()

	fmt.Println("************************************系统安装软件*********************************")
	// 	获取系统安装的软件
	getSystemapp()

	fmt.Println("************************************查看安装补丁********************************")
	// 获取系统当前安装补丁
	getSystemhotfix()

	// 收尾工作
	Delfile()

}



// 功能啓動模塊
func main()  {
	var commnd string

	gopro()

	// 杜绝直接关闭
	fmt.Println("点击回车键退出脚本")
	fmt.Scanf("%s", &commnd)
}


//获取系统administrator组的用户
func getAdmingroupuser() string {
	output, err := exec.Command("cmd", "/C", "net", "localgroup", "administrators").Output()
	if err != nil {
		fmt.Println("查看administrators组用户命令执行不成功，请尝试手工自行判断")
		return ""
	}
	outputdata := ConvertToString(string(output), "GBK", "UTF-8")
	outputdata = str_check(outputdata)
	lastdata := strings.Split(outputdata, " ")
	fmt.Println("当前系统administrators组中存在的用户如下")
	for i:=6; i<len(lastdata)-1; i++{
		fmt.Println(lastdata[i])
	}
	//fmt.Println(lastdata)
	//result := lastdata[4:len(lastdata)-1]
	//fmt.Println(outputdata)
	return ""
}

// 获取系统安装的app
func getSystemapp() string {

	i := 0
	fmt.Println("本机安装软件如下：")

	// 路径记录
	X64output, X64err := exec.Command("powershell", "/C", "dir", "Registry::HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Uninstall", "-Name").Output()
	X86output, X86err := exec.Command("powershell", "/C", "dir", "Registry::HKEY_LOCAL_MACHINE\\SOFTWARE\\Wow6432Node\\Microsoft\\Windows\\CurrentVersion\\Uninstall\\", "-Name").Output()
	if X64err != nil{
		//fmt.Println(X64err)
		fmt.Println("读取64位系统注册表不成功，表现为读取64位软件")
		return ""
	}
	if X86err != nil{
		fmt.Println("读取64位系统注册表不成功，表现为读取32位软件")
		return ""
	}
	X64outputdata := strings.TrimSpace(ConvertToString(string(X64output), "GBK", "UTF-8"))
	X86outputdata := strings.TrimSpace(ConvertToString(string(X86output), "GBK", "UTF-8"))
	lastX64 := strings.Split(X64outputdata, "\n")
	lastX86 := strings.Split(X86outputdata,"\n")
	for X64d:=0; X64d<len(lastX64); X64d++{
		i++
		if strings.Contains(lastX64[X64d], "{"){
			x64path := "SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Uninstall\\"+strings.TrimSpace(lastX64[X64d])
			//fmt.Printf("%T", x64path)
			ke_va, err := registry.OpenKey(registry.LOCAL_MACHINE, x64path, registry.QUERY_VALUE)
			if err != nil{
				return ""
			}
			defer ke_va.Close()
			Displayname, _, err := ke_va.GetStringValue("DisplayName")
			if err != nil{
				return ""
			}
			fmt.Println("[", i, "]", Displayname)
		}else {
			fmt.Println("[", i, "]", lastX64[X64d])
		}
		//fmt.Println(lastX64[X64d])
	}
	for X86d:=0; X86d<len(lastX86); X86d++{
		i++
		if strings.Contains(lastX86[X86d], "{"){
			x86path := "SOFTWARE\\Wow6432Node\\Microsoft\\Windows\\CurrentVersion\\Uninstall\\"+strings.TrimSpace(lastX86[X86d])
			ke_va, err := registry.OpenKey(registry.LOCAL_MACHINE, x86path, registry.QUERY_VALUE)

			if err != nil{
				return ""
			}
			defer ke_va.Close()
			Displayname, _, err := ke_va.GetStringValue("DisplayName")
			if err != nil{
				//fmt.Println(Displayname)
				return ""
			}
			fmt.Println("[", i, "]", Displayname)
		}else {
			fmt.Println("[", i, "]", lastX86[X86d])
		}
		//fmt.Println(lastX86[X86d])
	}
	//fmt.Println(X64outputdata)
	//fmt.Println(X86outputdata)
	return ""
}

// 获取系统当权运行服务
func getCurrentservice() string {
	output, err := exec.Command("cmd", "/C", "net", "start").Output()
	if err != nil {
		return ""
	}
	outputdata := strings.TrimSpace(ConvertToString(string(output), "GBK", "UTF-8"))
	lastdata := strings.Split(outputdata, "\n")
	lastdata = lastdata[2:len(lastdata)-2]
	fmt.Println("Windows当前已启动以下服务：")
	for i:=0; i<len(lastdata); i++ {
		fmt.Println(strings.TrimSpace(lastdata[i]))
	}
	//fmt.Print(outputdata)
	return ""
}

// 获取系统安装补丁
func getSystemhotfix() string {
	output, err := exec.Command("cmd", "/C", "wmic", "qfe", "GET", "hotfixid").Output()
	if err != nil {
		return ""
	}
	outputdata := ConvertToString(string(output), "GBK", "UTF-8")
	lastdata := strings.TrimSpace(strings.Split(outputdata, "HotFixID")[1])
	fmt.Println("系统安装的补丁如下：")
	fmt.Print(lastdata)
	fmt.Println()
	return ""
}

// 获取系统进程列表
func getSystemtasklist() string {
	output, _ := exec.Command("cmd", "/C", "tasklist").Output()
	outputdata := ConvertToString(string(output), "GBK", "UTF-8")
	fmt.Print("进程表查看")
	fmt.Printf(outputdata)
	return ""
}

// 获取系统eventlog服务状态
func getEventlogstat() string {
	ke_va, err := registry.OpenKey(registry.LOCAL_MACHINE, `SYSTEM\CurrentControlSet\Services\EventLog`, registry.QUERY_VALUE)
	if err != nil {
		return ""
	}
	defer ke_va.Close()

	start, _, err := ke_va.GetIntegerValue("start")
	if start == 4 {
		fmt.Println("Event log启动类型已禁用")
	}else if start == 3 {
		fmt.Println("Event log启动类型为手动")
	}else if start == 2 {
		fmt.Println("Event log启动类型为自动")
	}else if start == 1 {
		fmt.Println("Event log启动类型为自动（延迟启动）")
	}
	return ""
}


// 获取系统网络访问SAM设置
func GetSystemSAMcontrol() string  {
	ke_va, err := registry.OpenKey(registry.LOCAL_MACHINE, `SYSTEM\CurrentControlSet\Control\LSA`, registry.QUERY_VALUE)
	if err != nil{
		return ""
	}
	defer ke_va.Close()
	// 不允许SAM账户的匿名枚举
	restrictanonymoussam, _, err := ke_va.GetIntegerValue("restrictanonymoussam")
	// 不允许SAM账户和共享的匿名枚举
	restrictanonymous, _, err := ke_va.GetIntegerValue("restrictanonymous")

	if restrictanonymoussam == 1{
		fmt.Println("不允许SAM账户的匿名枚举功能已开启")
	}else if restrictanonymoussam == 0{
		fmt.Println("不允许SAM账户的匿名枚举功能已禁用")
	}

	if restrictanonymous == 1{
		fmt.Println("不允许SAM账户和共享的匿名枚举功能已开启")
	}else if restrictanonymous == 0{
		fmt.Println("不允许SAM账户和共享的匿名枚举功能已禁用")
	}

	//fmt.Println(restrictanonymoussam)
	return ""
}

// 系统媒体和设备自动播放功能
func sysmediaauto() string {
	ke_va, err := registry.OpenKey(registry.LOCAL_MACHINE, `SYSTEM\CurrentControlSet\Services\cdrom`, registry.QUERY_VALUE)
	if err != nil{
		return ""
	}
	defer ke_va.Close()
	//key, _, err := ke_va.GetStringValue("AutoRun")
	key, _, err := ke_va.GetIntegerValue("AutoRun")
	if err != nil{
		return ""
	}
	if key == 1 {
		fmt.Println("系统媒体和设备自动播放功能已开启")
	}else if key == 0 {
		fmt.Println("系统媒体和设备自动播放功能已关闭")
	}
	//fmt.Println(key)
	return ""
}

// 查看系统是否开启共享
func net_share() string {
	data, _ := exec.Command("cmd", "/C", "net", "share").Output()
	outputdata := ConvertToString(string(data), "GBK", "UTF-8")
	//fmt.Println(outputdata)
	//outputdata = str_check(outputdata)
	fmt.Println(outputdata)
	//lastdata := strings.Split(outputdata, " ")
	//result := lastdata[4:len(lastdata)-1]
	//fmt.Println("共享名\t\t资源\t\t注解")
	//for i:=0; i<len(result); i++{
	//	fmt.Printf("%s\t\t", result[i])
	//	if i%3 == 2 && i != 0{
	//		fmt.Println()
	//	}
	//	if i%3 == 0 && strings.Contains(result[i], "IPC"){
	//		result[i+1] = ""
	//		result[i+2] = "远程IPC"
	//	}
	//}
	return ""
}

// 交互式登录是否需要智能卡
func smart_card_login(policy string) string {
	smart_card := strings.TrimSpace(strings.Split(strings.Split(strings.Split(policy, "ScForceOption")[1], "MACHINE")[0], ",")[1])
	//fmt.Println(smart_card)
	if smart_card == "0" {
		fmt.Println("用户无需使用智能卡就可以登录系统")
	}else if smart_card == "1" {
		fmt.Println("用户需要使用智能卡才能登录系统")
	}
	return ""
}

// 智能卡移除操作
func smart_card_remove(policy string) string {
	smart_cart := strings.Split(strings.Split(policy, "ScRemoveOption")[1], "\"")[1]
	if smart_cart == "0"{
		fmt.Println("当智能卡移除时，系统无任何操作")
	}else if smart_cart == "1" {
		fmt.Println("当智能卡移除时，系统锁定工作站")
	}else if smart_cart == "2" {
		fmt.Println("当智能卡移除时，系统强制注销")
	}
	return ""
}

// 密码过期提醒
func passwd_Expired(policy string) string {
	passauit := strings.Split(strings.Split(policy, "[Privilege Rights]")[0], "[Registry Values]")[1]
	//fmt.Printf("%s", passauit)
	getNum := strings.TrimSpace(strings.Split(strings.Split(strings.Split(passauit, "PasswordExpiryWarning")[1], "MACHINE")[0], ",")[1])
	fmt.Println("系统密码过期前" + getNum + "天系统会有相应的过期提醒")
	return ""
}

// 收尾工作
func Delfile() string {
	err := os.Remove("C:\\systemset.txt")
	if err != nil{
		return ""
	}
	return ""
}

// 获取系统安全审计策略
func Getsystemaudit( policy string) string {
	Winaudit := strings.Split(strings.Split(policy, "[Registry Values]")[0], "[Event Audit]")[1]
	// 未开启状态
	Winaudit = strings.Replace(Winaudit, "AuditSystemEvents = 0", "审核系统事件功能未开启", 1)
	Winaudit = strings.Replace(Winaudit, "AuditLogonEvents = 0", "审核登录事件功能未开启", 1)
	Winaudit = strings.Replace(Winaudit, "AuditObjectAccess = 0", "审核对象访问功能未开启", 1)
	Winaudit = strings.Replace(Winaudit, "AuditPrivilegeUse = 0", "审核特权使用功能未开启", 1)
	Winaudit = strings.Replace(Winaudit, "AuditPolicyChange = 0", "审核策略更改功能未开启", 1)
	Winaudit = strings.Replace(Winaudit, "AuditAccountManage = 0", "审核账户管理功能未开启", 1)
	Winaudit = strings.Replace(Winaudit, "AuditProcessTracking = 0", "审核进程追踪功能未开启", 1)
	Winaudit = strings.Replace(Winaudit, "AuditDSAccess = 0", "审核目录服务访问功能未开启", 1)
	Winaudit = strings.Replace(Winaudit, "AuditAccountLogon = 0", "审核账户登录事件功能未开启", 1)

	// 仅记录成功事件日志
	Winaudit = strings.Replace(Winaudit, "AuditSystemEvents = 1", "审核系统事件功能 成功", 1)
	Winaudit = strings.Replace(Winaudit, "AuditLogonEvents = 1", "审核登录事件功能 成功", 1)
	Winaudit = strings.Replace(Winaudit, "AuditObjectAccess = 1", "审核对象访问功能 成功", 1)
	Winaudit = strings.Replace(Winaudit, "AuditPrivilegeUse = 1", "审核特权使用功能 成功", 1)
	Winaudit = strings.Replace(Winaudit, "AuditPolicyChange = 1", "审核策略更改功能 成功", 1)
	Winaudit = strings.Replace(Winaudit, "AuditAccountManage = 1", "审核账户管理功能 成功", 1)
	Winaudit = strings.Replace(Winaudit, "AuditProcessTracking = 1", "审核进程追踪功能 成功", 1)
	Winaudit = strings.Replace(Winaudit, "AuditDSAccess = 1", "审核目录服务访问功能 成功", 1)
	Winaudit = strings.Replace(Winaudit, "AuditAccountLogon = 1", "审核账户登录事件功能 成功", 1)

	// 仅记录失败事件日志
	Winaudit = strings.Replace(Winaudit, "AuditSystemEvents = 2", "审核系统事件功能 失败", 1)
	Winaudit = strings.Replace(Winaudit, "AuditLogonEvents = 2", "审核登录事件功能 失败", 1)
	Winaudit = strings.Replace(Winaudit, "AuditObjectAccess = 2", "审核对象访问功能 失败", 1)
	Winaudit = strings.Replace(Winaudit, "AuditPrivilegeUse = 2", "审核特权使用功能 失败", 1)
	Winaudit = strings.Replace(Winaudit, "AuditPolicyChange = 2", "审核策略更改功能 失败", 1)
	Winaudit = strings.Replace(Winaudit, "AuditAccountManage = 2", "审核账户管理功能 失败", 1)
	Winaudit = strings.Replace(Winaudit, "AuditProcessTracking = 2", "审核进程追踪功能 失败", 1)
	Winaudit = strings.Replace(Winaudit, "AuditDSAccess = 2", "审核目录服务访问功能 失败", 1)
	Winaudit = strings.Replace(Winaudit, "AuditAccountLogon = 2", "审核账户登录事件功能 失败", 1)

	// 记录成功、失败事件日志
	Winaudit = strings.Replace(Winaudit, "AuditSystemEvents = 3", "审核系统事件功能 成功、失败", 1)
	Winaudit = strings.Replace(Winaudit, "AuditLogonEvents = 3", "审核登录事件功能 成功、失败", 1)
	Winaudit = strings.Replace(Winaudit, "AuditObjectAccess = 3", "审核对象访问功能 成功、失败", 1)
	Winaudit = strings.Replace(Winaudit, "AuditPrivilegeUse = 3", "审核特权使用功能 成功、失败", 1)
	Winaudit = strings.Replace(Winaudit, "AuditPolicyChange = 3", "审核策略更改功能 成功、失败", 1)
	Winaudit = strings.Replace(Winaudit, "AuditAccountManage = 3", "审核账户管理功能 成功、失败", 1)
	Winaudit = strings.Replace(Winaudit, "AuditProcessTracking = 3", "审核进程追踪功能 成功、失败", 1)
	Winaudit = strings.Replace(Winaudit, "AuditDSAccess = 3", "审核目录服务访问功能 成功、失败", 1)
	Winaudit = strings.Replace(Winaudit, "AuditAccountLogon = 3", "审核账户登录事件功 成功、失败", 1)

	fmt.Print(Winaudit)
	return ""
}

// 获取系统administrator,guest账户状态
func Getsystemdefaultuser(policy string) string{
	Windefault := strings.Split(strings.Split(strings.Split(policy, "[Event Audit]")[0], "[System Access]")[1], "LSAAnonymousNameLookup = 0")[1]
	Windefault = strings.Replace(Windefault, "EnableAdminAccount = 0", "administrator账户未开启", 1)
	Windefault = strings.Replace(Windefault, "EnableAdminAccount = 1", "administrator账户已开启", 1)
	Windefault = strings.Replace(Windefault, "EnableGuestAccount = 0", "Guest账户未开启", 1)
	Windefault = strings.Replace(Windefault, "EnableGuestAccount = 1", "Guest账户已开启", 1)
	fmt.Print(Windefault)
	return ""
}

// 获取系统密码策略
//MinimumPasswordAge = 0  //密码最短留存期
//MaximumPasswordAge = 42 //密码最长留存期
//MinimumPasswordLength = 0   //密码长度最小值
//PasswordComplexity = 0  //密码必须符合复杂性要求
//PasswordHistorySize = 0 //强制密码历史 N个记住的密码
//LockoutBadCount = 5 //账户锁定阈值
//ResetLockoutCount = 30  //账户锁定时间
//LockoutDuration = 30    //复位账户锁定计数器
//RequireLogonToChangePassword = 0 *下次登录必须更改密码
//ForceLogoffWhenHourExpire = 0   *强制过期
func Getsystempwdpolicy(policy string) string {
	pwdpolicy := strings.Split(strings.Split(strings.Split(policy, "[Event Audit]")[0], "[System Access]")[1], "NewAdministratorName")[0]
	//fmt.Printf("%s", pwdpolicy)
	pwdpolicy = strings.Replace(pwdpolicy, "MinimumPasswordAge =", "密码最短留存期为", 1)
	pwdpolicy = strings.Replace(pwdpolicy, "MaximumPasswordAge =", "密码最长留存期为", 1)
	pwdpolicy = strings.Replace(pwdpolicy, "MinimumPasswordLength =", "密码长度最小值为",1)
	pwdpolicy = strings.Replace(pwdpolicy, "PasswordComplexity = 0", "密码复杂度检验功能未开启",1)
	pwdpolicy = strings.Replace(pwdpolicy, "PasswordComplexity = 1", "密码复杂度检验功能已开启",1)
	pwdpolicy = strings.Replace(pwdpolicy, "PasswordHistorySize =", "强制密码历史记住的数量为",1)
	pwdpolicy = strings.Replace(pwdpolicy, "LockoutBadCount =", "账户锁定阈值为",1)
	pwdpolicy = strings.Replace(pwdpolicy, "ResetLockoutCount =", "账户锁定时间",1)
	pwdpolicy = strings.Replace(pwdpolicy, "LockoutDuration =", "复位账户锁定计数器",1)
	pwdpolicy = strings.Replace(pwdpolicy, "RequireLogonToChangePassword = 0", "下次登录必须更改密码功能未开启",1)
	pwdpolicy = strings.Replace(pwdpolicy, "RequireLogonToChangePassword = 1", "下次登录必须更改密码功能已开启",1)
	pwdpolicy = strings.Replace(pwdpolicy, "ForceLogoffWhenHourExpire = 0", "密码强制过期功能未开启",1)
	pwdpolicy = strings.Replace(pwdpolicy, "ForceLogoffWhenHourExpire = 1", "密码强制过期功能已开启",1)
	fmt.Println(pwdpolicy)
	return ""
}

// 讀取系統配置文件
func readsystemset() string {
	filedata, err := ioutil.ReadFile("C:\\systemset.txt")
	if err != nil{
		fmt.Println("系统配置文件读取不成功")
		return ""
	}
	filestr := string(filedata)
	//fmt.Printf("%T", filestr)
	// windows中的空格可能不是空格，哈哈哈哈
	fileres := strings.Replace(filestr, "\x00", "", -1)
	return fileres
}

// 生成配置文件在C盤目錄下
func Getsystemset() {
	data := exec.Command("cmd", "/C", "secedit", "/export", "/cfg", "C:\\systemset.txt")
	if err := data.Run(); err != nil {
		fmt.Println("Error: ", err)
	}else {
		fmt.Println("配置文件已生成")
	}
}

// 獲取當前用戶信息
func Getcurrentuserinfo() string {
	if userinfo, err := user.Current(); err == nil {
		fmt.Printf("用户姓名：%s\n", userinfo.Username)
		fmt.Printf("用户地址：%s\n", userinfo.HomeDir)
		//fmt.Printf("用户组：%s\n", userinfo.Name)
	}
	return ""
}

// 获取系统用户数据
func Getsystemuserdata() string  {
	output, _ := exec.Command("cmd", "/C", "net", "user").Output()
	outputdata := string(output)
	//fmt.Print(ConvertToString(outputdata, "GBK", "UTF-8"))
	outputdata = str_check(outputdata)
	//fmt.Print(outputdata)
	checkdata := strings.Split(outputdata, " ")
	checkdata = checkdata[3:len(checkdata)-1]
	fmt.Printf("共计%d个用户，分别是%s\n", len(checkdata), checkdata)
	//fmt.Print(checkdata)
	return ""
}

// 獲取系統TCP端口
func Getsystemport() string {
	output, _ := exec.Command("cmd", "/C", "netstat", "-ano").Output()
	outputdata := string(output)
	outputdata = str_check(outputdata)
	checkdata := strings.Split(outputdata, "UDP")[0]
	TCPdata := strings.Split(checkdata, "TCP")[1:]
	fmt.Print(set_string_len("本地地址"))
	fmt.Print(set_string_len("外部地址")+ "\n")
	for i:=0; i<len(TCPdata); i++{
		localip_port := strings.Split(string(TCPdata[i]), " ")[1]
		foregin_port := strings.Split(string(TCPdata[i]), " ")[2]
		localip_port = set_string_len(localip_port)
		fmt.Print(localip_port, "\t\t\t", foregin_port)
		//fmt.Print(len(localip_port))
		fmt.Print("\n")
	}

	return ""
}

// 获取当前系统
func Getsystem() string {
	system := runtime.GOOS
	fmt.Printf("当前系统：%s\n", system)
	return ""
}

// 获取系统架构
func Getsystemframework() string {
	systemframework := runtime.GOARCH
	fmt.Printf("当前系统架构：%s\n", systemframework)
	return ""
}

//获取当前系统版本
func Getsystemversion() string {
	version, err := syscall.GetVersion()
	if err != nil {
		return ""
	}
	fmt.Printf("当前系统版本：%d.%d (%d)\n", byte(version), uint8(version>>8), version>>16 )
	return ""
}

// string字符串的空格处理
func str_check(str string) string{
	var re_str string
	re_str = strings.Join(strings.Fields(str), " ")
	return string(re_str)
}

// 控制字符串长度
func set_string_len(str string) string{
	for {
		if len(str) < 18{
			str = str + " "
		}else if len(str) >= 18{
			break
		}
	}
	return str
}

// 字符串转换UTF-8 模式
func ConvertToString(src string, srcCode string, tagCode string) string {
	srcCoder := mahonia.NewDecoder(srcCode)
	srcResult := srcCoder.ConvertString(src)
	tagCoder := mahonia.NewDecoder(tagCode)
	_, cdata, _ := tagCoder.Translate([]byte(srcResult), true)
	result := string(cdata)
	return result
}

// 获取屏幕保护状态
func getScreenSaver() string {
	//fmt.Println("ls")
	ke_va, err := registry.OpenKey(registry.CURRENT_USER, `Control Panel\Desktop`, registry.QUERY_VALUE)
	if err != nil{
		fmt.Println("屏幕保护未开启")
		return ""
	}
	defer ke_va.Close()
	//screensaveactive, _, err := ke_va.GetStringValue("ScreenSaveActive")
	screensaverissecure, _, err := ke_va.GetStringValue("ScreenSaverIsSecure")
	screensavetimeout, _, err := ke_va.GetStringValue("ScreenSaveTimeOut")
	if err != nil{
		fmt.Println("数据采集异常，屏幕保护未开启")
		return ""
	}

	if screensaverissecure == "1" {
		fmt.Println("屏幕保护程序已勾选“在恢复时显示登录屏幕”")
	}else if screensaverissecure == "0" {
		fmt.Println("屏幕保护程序未勾选“在恢复时显示登录屏幕”")
		fmt.Println("屏幕保护超时时间为", screensavetimeout, "秒")
	}

	//fmt.Println(key)
	//if screensaveactive == "1" && screensaverissecure == "1"{
	//	fmt.Println("屏幕保护已开启")
	//	fmt.Println("屏幕保护超时时间为", screensavetimeout, "秒" )
	//}else if screensaveactive == "0" && screensaverissecure == "1"{
	//	fmt.Println("屏幕保护已开启")
	//	fmt.Println("屏幕保护超时时间为", screensavetimeout, "秒" )
	//}else if screensaveactive == "1" && screensaverissecure == "0"{
	//	fmt.Println("建议使用手工判断")
	//	fmt.Println("如果屏保开启，屏幕保护超时时间为", screensavetimeout, "秒" )
	//}else if screensaveactive == "0" && screensaverissecure == "0"{
	//	fmt.Println("屏幕保护未开启")
	//}
	return ""
}

　　运行截图：

 

 

 

多给我点个赞呗