Skip to content

A
AD-Control-Golang
Commit cd9ec223 by 陶腾飞
Options

2022-03-29 全新2.0

parent 6b6b8c89
Showing with 2666 additions and 2040 deletions
.gitignore
......@@ -2,7 +2,9 @@ test/
testwalk/
testmain/
exe/
pkg/
catHardware/
.vscode/
*.bat
*.ps1
*.exe
.vscode/
README.MD
# AD-Control-Golang
# AD-Control-Golang 2.0
## 程序简介
## 一、程序简介
本程序是从AD-Control升级而来,并融合了在AD上经常使用的工具.
## 程序作用简要
## 二、程序作用简要
### 1. Users.exe - 域用户使用的程序
### 1. Users.exe - 域用户的小工具
UI:
在域计算机上以用户权限运行在任务栏托盘的位置上
在域计算机上以用户方式运行在任务栏托盘的位置上
启动说明：
在开机时,由组策略的文件替换功能，从文件共享中复制到C:\Windows\System32下，并运行。
在开机时,由GPO的开机启动策略从主控的smb中复制到%tmp%后运行
具体功能：
1. 电源选项
2. 软件安装
3. 实用工具
3. 文件共享
> 1. 账号管理
> 2. 用户管理
> 3. 电源选项
> 4. 实用工具(软件安装等)
> 5. 文件共享
### 2. 域控制器使用的Daemon.exe
### 2. Daemon.exe 域控制器守护进程
运行方式：
`go run .\daemon.go`
```
.\daemon.exe
```
主要功能：
接收域和企业微信的消息并处理与反馈
接收域和企业微信的消息并处理与反馈、接受小工具的日志并存储
### 3. adct.exe 域控制工具
......@@ -35,14 +37,19 @@ UI:
通过adct来控制域用户、域计算机来完成部分功能
具体功能：
1. 定时操作
2. 汇报情况
3. 强制备份
4. 主机唤醒
> 1. 定时操作
> 2. 汇报情况
> 3. 主机唤醒
> 4. 同步cmdb
> 5. 硬件信息收集
> 6. 获取token
## 三、[cmdb](http://cmdb.zhiweidata.top/instances/types/28)
## 更新情况
通过daemon和users配合GPO一起同步更新。登录时用的token通过任务计划每间隔1小时自动获取。
## 四、更新说明
- 2020/05/15 v0.7 加入Error Json，walk.Resouce.Icon()使用绝对路径，修改users.exe的报错机制
- 2020/05/18 v0.8 更新 大屏主机的文件共享，取消TXHD的凌晨关机.
......@@ -73,10 +80,11 @@ UI:
- 2020/10/26 v1.10.1 修复批量打开失败问题
- 2020/10/27 v1.10.2 优化软件安装和重启小工具的程序逻辑,更新64位的程序清单和新ico文件
- 2020/11/05 v1.10.3 更新备份策略
- 2022/03/29 v2.0.0 删除备份策略,同步域计算机信息到cmdb,添加账户、主机管理管理,唤醒策略更新,日志统一收集处理,运维平台添加管理员指令
## 其他说明
## 五、其他说明
### lxn/walk的修改
### [lxn/walk](https://github.com/lxn/walk)的修改
1. 解决托盘菜单中按钮点击一次，会跳出2次的问题
......
adct/adct.go
package main
import (
pub "AD-Control-Golang/public"
"encoding/json"
"flag"
"fmt"
"os"
"strings"
)
func initLog(){
var logpath string
const INFO = pub.INFO
const ERROR = pub.ERROR
const NULL = pub.NULL
func main() {
var reportText = flag.String(pub.Msg_Report, "", "report to AD")
var wolMacText = flag.String("wolmac", "", "input MACAddress for waking pc")
var wolHostText = flag.String("wolhost", "", "input hostname for waking pc")
var wolAllText = flag.Bool("wolall", false, "wake all Domain Computer")
var hourText = flag.Bool("hour", false, "exec task at the time")
var cmdbtokenText = flag.Bool("cmdbtoken", false, "")
var loglevel = flag.String("loglevel", INFO, "")
// 作为PC启动
if pub.RunAsPC(pub.User_computername){
logpath = `C:\windows\system32\`
// 作为用户启动
}else{
logpath = pub.Dir_userprofile + `\`
}
pub.Loger = pub.NewLoger(logpath + "adct.log")
}
func main(){
initLog()
var reportText = flag.String( pub.Msg_Report ,"" ,"report to AD")
var passText = flag.String( "pass" ,"" ,"input passwork,but not need")
var wolmacText = flag.String( "wolmac" ,"" ,"input MACAddress for waking pc")
var wolhostText = flag.String( "wolhost" ,"" ,"input hostname for waking pc")
var wolallText = flag.Bool( "wolall" ,false ,"wake all Domain Computer")
var hourText = flag.Bool( "hour" ,false ,"exec task at the time")
flag.Parse()
if *hourText { flag_hour( );return}
if *reportText != "" { flag_report( reportText );return}
if *wolmacText != "" { flag_wolmac( wolmacText );return}
if *wolhostText != "" { flag_wolhost( wolhostText );return}
if *wolallText { flag_wolall( passText );return}
if *loglevel != "" {
loglevelSet(strings.ToLower(*loglevel))
}
if *hourText {
hour()
} else if *reportText != "" {
pub.DomainComputer()
flag_report(*reportText)
return
} else if *wolMacText != "" {
pub.DomainCotroller()
wolMac(wolMacText)
} else if *wolHostText != "" {
pub.DomainCotroller()
wolHost(wolHostText)
} else if *wolAllText {
pub.DomainCotroller()
wolALL()
} else if *cmdbtokenText {
pub.DomainCotroller()
pub.CmdbTokenUpdate()
}
return
}
func flag_report(s *string){
// 发送消息
pub.SendServerReport(*s)
func loglevelSet(l string) {
switch l {
case pub.INFO:
pub.Loglevel = l
case pub.DEBUG:
pub.Loglevel = l
case "debu":
pub.Loglevel = pub.DEBUG
default:
os.Exit(-1)
}
}
func flag_hour(){
// 发送消息
func flag_report(s string) {
var d []byte
var err error
switch s {
case pub.Msg_Report_WillTurnOnPC:
var cir pub.CIRecordStartup
cir.Bumen, err = cir.GetDept()
if err != nil {
os.Exit(-1)
}
cir.GetHardWare()
cir.Ip = pub.GetIPFromNslookup()
cir.Mac = pub.GetMacaddressFromIP(cir.Ip)
cir.Start_time = pub.GetNowTimeString()
d, err = json.Marshal(cir)
if err != nil {
pub.LOG(ERROR, s, err.Error())
os.Exit(-1)
}
case pub.Msg_Report_WillTurnOffPC:
var cir pub.CIRecordShutdown
cir.Shutdown_time = pub.GetNowTimeString()
d, err = json.Marshal(cir)
if err != nil {
pub.LOG(ERROR, s, err.Error())
os.Exit(-1)
}
}
pub.SendADMsg(pub.Msg_Report, pub.GJreportString(s, string(d)))
}
// 定点执行
func hour() {
nh := pub.GetHour()
switch nh{
default :
//pub.Execcmd_nowait(`即将关机，如需取消，点击小工具-电源管理-取消自动关机 或运行Z:\tools\【工具】取消关机.bat`)
//pub.Execcmd_nowait(`shutdown -s -t 300`)
break
switch nh {
default:
break
}
}
func flag_wolmac(mac * string){
//直接指定mac地址，不带主机名参数
pub.Wol_enter("",mac)
//直接指定mac地址，不带主机名参数
func wolMac(mac *string) {
pub.LOG(INFO, "wol_mac", fmt.Sprintf("mac:%s", *mac))
pub.Wol_enter("", mac)
}
func flag_wolhost(pc *string){
mac := pub.Reg_query_key_one(
pub.Reg_Root_ac,
pub.Reg_Path_home_ac+*pc,
pub.Reg_Name_MACaddress)
pub.PntInfof("pc:%s,mac:%s",*pc,mac)
pub.Wol_enter(*pc,&mac)
func wolHost(pc *string) {
// coding
var mac string
pub.LOG(INFO, "wol_host", fmt.Sprintf("pc:%s,mac:%s", *pc, mac))
pub.Wol_enter(*pc, &mac)
//暂未开发
}
func flag_wolall(pass * string){
pclist,err :=pub.Reg_query_list(pub.Reg_Root_ac,pub.Reg_Path_home_ac)
if err != nil{
pub.PntError(err)
}
//limit :=1
for _,pc := range pclist{
mac := pub.Reg_query_key_one(
pub.Reg_Root_ac,
pub.Reg_Path_home_ac+pc,
pub.Reg_Name_MACaddress)
// 没有主机信息没有记录到注册表
if mac == ""{
pub.PntError(pc,"查找注册表失败")
continue
}else{
// 延时计数重置
// if limit <= 10 {
// pub.Delay(10)
// limit=0
// }
// 唤醒入口
pub.Wol_enter(pc,&mac)
// 随机延时
//pub.RandDelay(10)
//limit +=1
}
}
}
\ No newline at end of file
func wolALL() {
// coding get pclist
// limit :=1
//for _, pc := range pclist {
// 没有主机信息没有记录到注册表
//pub.LOG(ERROR, "wol_all", fmt.Sprintf("%s查找失败", pc))
// else{
// // 延时计数重置
// if limit <= 10 {
// pub.Delay(10)
// limit=0
// }
// // 唤醒入口
// pub.Wol_enter(pc, &mac)
// // 随机延时
// pub.RandDelay(10)
// limit +=1
// }
//}
}
daemon/daemon.go
......@@ -2,16 +2,50 @@ package main
import (
pub "AD-Control-Golang/public"
"net"
"net/http"
"os"
)
var l *os.File
func main() {
// 在家目录中写入日志
pub.Loger = pub.NewLoger(pub.Dir_userprofile + `\daemon.log`)
l, _ = os.OpenFile(`H:\logs\users.log`, os.O_RDWR|os.O_CREATE|os.O_APPEND, 0766)
//pub.Loglevel = pub.DEBUG
go listenLog()
listenMsg()
}
func listenMsg() {
http.HandleFunc("/", pub.DealMsgEnter)
http.ListenAndServe(pub.DaemonListen, nil)
}
func listenLog() {
addr, err := net.ResolveUDPAddr("udp", "0.0.0.0"+pub.DaemonLogListen)
if err != nil {
pub.LOG(pub.ERROR, pub.ERROR, err)
return
}
conn, err := net.ListenUDP("udp", addr)
if err != nil {
pub.LOG(pub.ERROR, pub.ERROR, err)
}
pub.PrintLog("start daemon!")
defer conn.Close()
pub.LOG(pub.INFO, pub.NULL, "start LOG daemon!")
for {
data := make([]byte, 2000)
n, _, err := conn.ReadFromUDP(data)
if err != nil {
pub.LOG(pub.ERROR, pub.ERROR, err)
continue
}
data[n] = byte('\n')
l.Write(data[0 : n+1])
http.HandleFunc("/", pub.DealMsgEnter)
http.ListenAndServe(pub.DaemonListen,nil)
}
\ No newline at end of file
}
}
public/cmdb.go 0 → 100644
package public
import (
"bytes"
"encoding/json"
"fmt"
"io"
"io/ioutil"
"net/http"
"strings"
)
var client = http.Client{}
const cmdb_Dept string = "bumen"
const cmdb_Product_name string = "product_name"
const cmdb_Username string = "username"
func cmdbKVtoJSON(k, v string) (string, error) {
var err error
var b []byte
switch k {
case cmdb_Product_name:
var a CIRecorProduct_name
a.Product_name = v
b, err = json.Marshal(&a)
case cmdb_Username:
var a CIRecordUsername
a.Username = v
b, err = json.Marshal(&a)
}
return string(b), err
}
func cmdbExistRecord(k, v string) (int, bool) {
var count string = "1"
var cmdbPath string = "api/v0.1/ci/s?q="
search := fmt.Sprintf("%s:%s", k, v)
url := fmt.Sprintf("%s/%s_type:%s,%s&count=%s", cmdbUrl, cmdbPath, cmdbCITypeComputer, search, count)
LOG(DEBUG, CMDB, url)
var cir CIRecordReq
data, err := cmdbGET(url)
if err != nil {
LOG(ERROR, CMDB, err)
return 0, false
}
if err := json.Unmarshal(data, &cir); err != nil {
LOG(ERROR, CMDB, err)
return 0, false
}
LOG(DEBUG, "CMDB_EXITE", string(data))
switch cir.Numfound {
case 0:
var cir CIRecordResult
if err := cir.BasicInfo(v); err != nil {
LOG(ERROR, CMDB, err)
return 0, false
}
cir.Uni_one = fmt.Sprintf("%v", NowTimestampNano())
cmdbPath = "api/v0.1/ci"
url = fmt.Sprintf("%s/%s", cmdbUrl, cmdbPath)
jsondata, jsonerr := cir.String()
LOG(DEBUG, "CMDB_NEW", fmt.Sprintf("路径:%s\n参数:%s", url, string(jsondata)))
if jsonerr != nil {
LOG(ERROR, CMDB, jsonerr)
return 0, false
}
if _, err := cmdbPOST(url, jsondata); err != nil {
LOG(ERROR, CMDB, err)
return 0, false
} else {
l := fmt.Sprintf("CMDB\nnew host %s:%s", k, v)
LOG(INFO, "CMDB_NEW", l)
SendWxworkTextToAdmins(l)
}
case 1:
LOG(DEBUG, "CMDB_NEW", fmt.Sprintf("存在%s:%d", v, cir.R[0].Ci_id))
return cir.R[0].Ci_id, true
default:
LOG(ERROR, "CMDB_NEW", v+"存在多条记录")
return 0, false
}
return 0, false
}
func cmdbUpdateRecordFromJSON(datastr string, ci int) error {
var cmdbPath string = fmt.Sprintf("api/v0.1/ci/%d", ci)
url := fmt.Sprintf("%s/%s", cmdbUrl, cmdbPath)
LOG(DEBUG, CMDB, url)
data, err := cmdbPUT(url, []byte(datastr))
if err != nil {
LOG(ERROR, "CMDB_UPDATE", err)
return err
}
var cirr CIRecordUpdateReq
if err := json.Unmarshal(data, &cirr); err != nil {
LOG(ERROR, "CMDB_UPDATE_UNMARSHAL", err)
return err
}
if cirr.Ci_id == ci {
return nil
}
return nil
}
func CmdbTokenUpdate() {
type res struct {
Token string `json:"token"`
}
var r res
msg_type := CMDB + "_TOKEN"
cmdbPath := "api/login"
url := fmt.Sprintf("%s/%s", cmdbUrl, cmdbPath)
LOG(DEBUG, CMDB, url)
data, err := cmdbPOST(url, []byte(cmdbPass))
if err != nil {
LOG(ERROR, msg_type, err)
return
}
if err := json.Unmarshal(data, &r); err != nil {
LOG(ERROR, msg_type, err)
return
}
if len(r.Token) == 0 {
LOG(ERROR, msg_type, "token获取失败")
} else {
Reg_Write_DC(Reg_Key_cmdbtoken, string(r.Token))
LOG(INFO, msg_type, "token更新完成")
}
}
func cmdbGetCI(k, v string) (int, error) {
var count string = "1"
var cmdbPath string = "api/v0.1/ci/s?q="
search := fmt.Sprintf("%s:%s", k, v)
url := fmt.Sprintf("%s/%s_type:%s,%s&count=%s", cmdbUrl, cmdbPath, cmdbCITypeComputer, search, count)
LOG(DEBUG, CMDB, url)
var cir CIRecordReq
data, err := cmdbGET(url)
if err != nil {
LOG(ERROR, CMDB, err)
return 0, err
}
if err := json.Unmarshal(data, &cir); err != nil {
LOG(ERROR, CMDB, err)
return 0, err
}
LOG(DEBUG, "CMDB_EXITE", string(data))
switch cir.Numfound {
case 0:
return 0, fmt.Errorf("不存在记录")
case 1:
return cir.R[0].Ci_id, nil
default:
return 0, fmt.Errorf("存在多条记录")
}
}
func cmdbPOST(url string, reqdata []byte) ([]byte, error) {
buf := bytes.NewBuffer(nil)
buf.Write(reqdata)
h, err := http.NewRequest("POST", url, buf)
if err != nil {
return nil, err
}
h.Header.Add("Content-Type", "application/json")
// 如果需要token，则从注册表获取，token的获取是来自任务计划自动更新
// 如果,仅仅访问api/login,则不需要去获取token
if strings.Index(url, "api/login") == -1 {
h.Header.Add("Access-Token", Reg_Query_DC(Reg_Key_cmdbtoken))
}
res, err := (&client).Do(h)
if err != nil {
return nil, err
}
defer res.Body.Close()
data, errdata := ioutil.ReadAll(res.Body)
if res.StatusCode != 200 {
LOG(ERROR, "CMDB_POST", fmt.Sprintf("状态码:%d,路径:%s,返回数据:%s,参数:%s", res.StatusCode, url, string(data), string(reqdata)))
return nil, err
}
if errdata != nil && errdata == io.EOF {
return data, nil
} else if errdata != nil {
return nil, err
}
return data, nil
}
func cmdbPUT(url string, reqdata []byte) ([]byte, error) {
buf := bytes.NewBuffer(nil)
buf.Write(reqdata)
h, err := http.NewRequest("PUT", url, buf)
if err != nil {
return nil, err
}
h.Header.Add("Content-Type", "application/json")
// 如果需要token，则从注册表获取，token的获取是来自任务计划自动更新
// 如果,仅仅访问api/login,则不需要去获取token
if strings.Index(url, "api/login") == -1 {
h.Header.Add("Access-Token", Reg_Query_DC(Reg_Key_cmdbtoken))
}
res, err := (&client).Do(h)
if err != nil {
return nil, err
}
defer res.Body.Close()
data, errdata := ioutil.ReadAll(res.Body)
if res.StatusCode != 200 {
LOG(ERROR, "CMDB_PUT", fmt.Sprintf("状态码:%d,路径:%s,返回数据:%s,参数:%s", res.StatusCode, url, string(data), string(reqdata)))
return nil, err
}
if errdata != nil && errdata == io.EOF {
return data, nil
} else if errdata != nil {
return nil, err
}
return data, nil
}
func cmdbGET(url string) ([]byte, error) {
h, err := http.NewRequest("GET", url, nil)
if err != nil {
LOG(ERROR, "CMDB_GET", err)
return nil, err
}
res, err := (&client).Do(h)
if err != nil {
LOG(ERROR, "CMDB_GET", fmt.Sprintf("状态码:%d,路径:%s", res.StatusCode, url))
return nil, err
}
defer res.Body.Close()
if res.StatusCode != 200 {
LOG(ERROR, "CMDB_GET", fmt.Sprintf("状态码:%d,路径:%s", res.StatusCode, url))
return nil, err
}
data, errdata := ioutil.ReadAll(res.Body)
if errdata != nil && errdata == io.EOF {
return nil, nil
} else if errdata != nil {
return nil, err
}
return data, nil
}
public/cmdbjson.go 0 → 100644
package public
import (
"encoding/json"
"fmt"
"sync"
)
type CIRecordReq struct {
Counter CIRecordComputer `json:"counter"`
Facet CIRecordFacet `json:"facet"`
Numfound int `json:"numfound"`
Page int `json:"page"`
R []CIRecordResult `json:"result"`
Total int `json:"total"`
}
type CIRecordComputer struct {
Computer int `json:"Computer"`
}
type CIRecordFacet struct {
}
type CIRecordResult struct {
Bumen string `json:"bumen"` // 部门
Username string `json:"username"` // 姓名
Position string `json:"position"` // 具体位置
Seat string `json:"seat"` // 主机座位坐标
Product_name string `json:"product_name"` // 主机名
Ip string `json:"ip"` // ip
Mac string `json:"mac"` // mac地址
Start_time string `json:"start_time"` // 启动时间
Shutdown_time string `json:"shutdown_time"` // 关机时间
Cpu string `json:"cpu"` // cpu
Disk string `json:"disk"` // 硬盘
Memory string `json:"memory"` // 内存
Flag string `json:"flag"` // 标签
Buy_time string `json:"buy_time"`
Ci_id int `json:"ci_id"`
Ci_type string `json:"ci_type"`
Get_time string `json:"get_time"`
Mark string `json:"mark"`
Screen_info string `json:"screen_info"`
Type_id int `json:"type_id"`
Uni_one string `json:"uni_one"`
Unique string `json:"unique"`
Zcbh_pm string `json:"zcbh_pm"`
}
type CIRecordStartup struct {
Bumen string `json:"bumen"` // 部门
Ip string `json:"ip"` // ip
Mac string `json:"mac"` // mac地址
Start_time string `json:"start_time"` // 启动时间
Cpu string `json:"cpu"` // cpu
Disk string `json:"disk"` // 硬盘
Memory string `json:"memory"` // 内存
}
type CIRecord struct {
Bumen string `json:"bumen"` // 部门
Username string `json:"username"` // 姓名
Position string `json:"position"` // 具体位置
Seat string `json:"seat"` // 主机座位坐标
Product_name string `json:"product_name"` // 主机名
Ip string `json:"ip"` // ip
Mac string `json:"mac"` // mac地址
Start_time string `json:"start_time"` // 启动时间
Shutdown_time string `json:"shutdown_time"` // 关机时间
Cpu string `json:"cpu"` // cpu
Disk string `json:"disk"` // 硬盘
Memory string `json:"memory"` // 内存
}
type CIRecordUpdateReq struct {
Ci_id int `json:"ci_id"`
}
type CIRecordShutdown struct {
Shutdown_time string `json:"shutdown_time"` // 关机时间
}
type CIRecorProduct_name struct {
Product_name string `json:"product_name"` // 主机名
}
type CIRecordUsername struct {
Username string `json:"username"` // 姓名
}
func (cir *CIRecordResult) BasicInfo(v string) error {
var err error
cir.Product_name = v
hostnameSplit, err := GetHostnamePart(cir.Product_name)
if err != nil {
return err
}
cir.Position = cir.position(hostnameSplit[0], hostnameSplit[1])
if cir.Position == ERROR {
return fmt.Errorf("主机命令错误")
}
cir.Seat = hostnameSplit[2]
cir.Ci_type = cmdbCITypeComputer
return err
}
func (cir *CIRecordStartup) GetHardWare() {
var wg sync.WaitGroup
wg.Add(3)
// cpu
go func() {
defer wg.Done()
cpuCount, cpuName, cpuCores, cpuLogicalProcessors := getHardwareCPUForPS()
cir.Cpu = fmt.Sprintf("%s * %s %s核 %s线程", cpuCount, cpuName, cpuCores, cpuLogicalProcessors)
}()
// 内存
go func() {
defer wg.Done()
Capacity, Speed, MemoryType, mCount := getHardwareMemoryForPS()
for i := 0; i <= mCount; i++ {
cir.Memory += fmt.Sprintf("%dGB %sMhz %s,", Capacity[i], Speed[i], MemoryType[i])
}
cir.Memory = cir.Memory[0 : len(cir.Memory)-1]
}()
// 硬盘
go func() {
defer wg.Done()
_, Sizen, MediaType, hCount := getHardwareHardDiskForPS(false)
for i := 0; i <= hCount; i++ {
cir.Disk += fmt.Sprintf("%dGB %s,", Sizen[i], MediaType[i])
}
cir.Disk = cir.Disk[0 : len(cir.Disk)-1]
}()
wg.Wait()
}
func (cir *CIRecordResult) position(location, dept string) string {
const cmdbPosition1 string = "7"
const cmdbPosition2 string = "12"
const cmdbPosition3 string = "zhengzhou"
var resutlt string
switch location {
case "NB":
switch dept {
case "JL":
resutlt = cmdbPosition1
case "ZJ":
resutlt = cmdbPosition1
case "MT":
resutlt = cmdbPosition1
case "DD":
resutlt = cmdbPosition1
case "JR":
resutlt = cmdbPosition1
case "TXHD":
resutlt = cmdbPosition1
case "TXMT":
resutlt = cmdbPosition1
case "JS":
resutlt = cmdbPosition1
case "JD":
resutlt = cmdbPosition2
case "HW":
resutlt = cmdbPosition2
case "BGYJ":
resutlt = cmdbPosition2
default:
resutlt = ERROR
}
case "ZZ":
resutlt = cmdbPosition3
default:
resutlt = ERROR
}
return resutlt
}
func (cir *CIRecordStartup) GetDept() (string, error) {
hostnameSplit, err := GetHostnamePart(User_computername)
var result string
if err != nil {
LOG(ERROR, "", err)
return "", err
}
switch hostnameSplit[1] {
case "JL":
result = "巨量组"
case "ZJ":
result = "字节组"
case "MT":
result = "美团组"
case "DD":
result = "滴滴组"
case "JR":
result = "金融组"
case "TXHD":
result = "腾讯互动组"
case "TXMT":
result = "腾讯危机组"
case "JS":
result = "技术组"
case "JD":
result = "京东组"
case "HW":
result = "华为组"
case "BGYJ":
result = "报告研究中心"
default:
result = ERROR
}
return result, nil
}
func (cir *CIRecordResult) String() ([]byte, error) {
return json.Marshal(cir)
}
public/env.go
package public
// AD-Control //
// other //
const Host_adserver string = "ADSERVER"
const Host_thserver string = "THSERVER"
const DaemonListen string = ":16823"
const ADServerDaemon string = Host_adserver + DaemonListen
const THServerDaemon string = Host_thserver + DaemonListen
const Version string = "1.10.2"
const Bak_Version string = "1105"
var Active bool = true
var Active bool = true
const SymbolHostname = "-"
// user //
// AD-Control //
var User_computername string = GetEnv("COMPUTERNAME")
var User_homeshare string = GetEnv("HOMESHARE")
var User_userdomain string = GetEnv("USERDOMAIN")
var User_name string = GetEnv("USERNAME")
var User_dept string = GetEnv("DEPT")
var User_tmp string = GetEnv("tmp")
var User_sid string = Reg_query_key_one(HKCU,`Software\Microsoft\Windows\CurrentVersion\FileAssociations`,"UserSid")
var User_sessionID string = Reg_query_item_one(HKU,User_sid+`\Volatile Environment`)
//var User_name_display string = GetEnvFqdn("CN")
const Version string = "2.0.0"
const Host_adserver string = "ADSERVER"
const Host_thserver string = "THSERVER"
const Host_zzserver string = "ZZSERVER"
const DaemonListen string = ":16823"
const DaemonLogListen string = ":16824"
const ADServerDaemon string = Host_adserver + DaemonListen
const ADServerLogDaemon string = Host_adserver + DaemonLogListen
const THServerDaemon string = Host_thserver + DaemonListen
// user //
var User_computername string = GetEnv("COMPUTERNAME")
var User_homeshare string = GetEnv("HOMESHARE")
var User_userdomain string = GetEnv("USERDOMAIN")
var User_name string = GetEnv("USERNAME")
var User_tmp string = GetEnv("tmp")
var User_sid string = reg_query_key_one(HKCU, `Software\Microsoft\Windows\CurrentVersion\FileAssociations`, "UserSid")
var User_sessionID string = Reg_query_item_one(HKU, User_sid+`\Volatile Environment`)
var User_name_display string = GetEnvFqdn("CN")
// SMB Folder//
const SMB_adserver string = `\\` + Host_adserver + `\`
const SMB_ADSoft string = SMB_adserver + `software\`
const SMB_ADMain string = SMB_adserver + `ADMAIN\`
var SMB_ADMainDept string = SMB_ADMain + User_dept
var SMB_ADMainDeptShare string = SMB_ADMain + User_dept + `\` + "部门共享"
const SMB_ADSoftlike string = SMB_ADSoft + "softlike"
const SMB_ADSoftApplication string = SMB_ADSoft + `application\`
const SMB_ADSoftTool string = SMB_ADSoft + `tools\`
const SMB_ADSoftOthTool string = SMB_ADSoft + `othtools\`
const SMB_ADSoftPlusSync string = SMB_ADSoft + `plus\sync\`
const SMB_adserver string = `\\` + Host_adserver + `\`
const SMB_ADSoft string = SMB_adserver + `software\`
const SMB_ADSoftlike string = SMB_ADSoft + "softlike"
const SMB_ADSoftApplication string = SMB_ADSoft + `application\`
const SMB_ADSoftTool string = SMB_ADSoft + `tools\`
const SMB_ADSoftOthTool string = SMB_ADSoft + `othtools\`
const SMB_ADSoftPlus string = SMB_ADSoft + `plus\`
// Local Folder //
var Dir_userprofile string = GetEnv("USERPROFILE")
var Dir_appdata string = GetEnv("appdata")
var Dir_tmp string = GetEnv("tmp")
var Dir_Windows string = GetEnv("windir") + `\`
const Dir_DocuBase string = `C:\Users\Public\Documents\AD-Control\`
const Dir_ADsoftware_local string = `H:\software\softlike\`
const Dir_DCSave string = `D:\DomainUserBackupV2`
var Dir_WeDrive = [2] string {Dir_appdata + `\Tencent\WXWork\Data`,Dir_userprofile + `\Documents\WXWork`}
var Dir_Be = []string {Dir_DocuBase}
var Dir_Sync_Config string = Dir_appdata + `\Sync App Settings\_SYNCAPP\`
// Local File //
var File_Sync_profile string = "default profile.xml"
var File_Sync_profile_full string = Dir_Sync_Config + "default profile.xml"
var File_Sync_settings string = "default settings.xml"
var File_Sync_settings_full string = Dir_Sync_Config + "default settings.xml"
var Dir_userprofile string = GetEnv("USERPROFILE")
var Dir_appdata string = GetEnv("appdata")
var Dir_tmp string = GetEnv("tmp")
var Dir_Windows string = GetEnv("windir") + `\`
const Dir_ADsoftware_local string = `H:\software\softlike\`
// application ////
// application //
const App_adct string = SMB_ADSoftApplication + "adct.exe"
const App_MultiSplit string = SMB_ADSoftOthTool + "win_MultiSplit.exe"
const App_SyncExe string = App_Sync + `.exe`
const App_Sync string = `syncappw`
const App_Sync_full string = `C:\Progra~1\zhiwei\AllWay_Sync\Bin\` + App_SyncExe
const App_adct string = SMB_ADSoftApplication + "adct.exe"
const App_MultiSplit string = SMB_ADSoftOthTool + "win_MultiSplit.exe"
// reg info //
const (
HKCU = iota
HKLM
HKU
HKCU = iota
HKLM
HKU
)
const Reg_Root_ac int = HKLM
const Reg_Root_dc int = HKCU
const Reg_Path_home string = `SOFTWARE\ADControl`
const Reg_Path_home_ac string = Reg_Path_home + `\DomainComputer\` // use for adserver,not for dc
const Reg_Path_home_du string = Reg_Path_home + `\DomainUsers\` // use for adserver,not for dc
const Reg_Path_home_zhu string = Reg_Path_home + `\ZhiWeiUsers\` // use for adserver,not for dc
const Reg_Name_TurnOnTime string = "TurnOnTime"
const Reg_Name_TurnOffTime string = "TurnOffTime"
const Reg_Name_LoginUserName string = "loginUser"
const Reg_Name_LoginTime string = "loginTime"
const Reg_Name_LogOffTime string = "LogOffTime"
const Reg_Name_BackupOverTime string = "BackupOverTime"
const Reg_Name_WeDriveDir string = "WeDriveDir"
const Reg_Name_MACaddress string = "MACaddress"
const Reg_Name_MACAddress string = "MACAddress"
const Reg_Name_PrimaryUser string = "PrimaryUser"
const Reg_Name_PowerStatus string = "PowerStatus"
const Reg_Name_LogStatus string = "LogStatus"
const Reg_Name_BackupVersion string = "BackupVersion"
const Reg_Name_PrimayComputerName string = "PrimayComputerName"
const Reg_Name_BeWakedID string = "BeWakedID"
const Reg_Name_CloseView string = "CloseView"
const reg_LM_ADCONTROL string = `software\AD-Control`
// reg value //
var Reg_Value_WeDriveDir string = Reg_query_key_one(HKCU,Reg_Path_home,Reg_Name_WeDriveDir)
var Reg_Value_ON string = "ON"
var Reg_Value_OFF string = "OFF"
var Reg_Value_LogStatus_IN string = "IN"
var Reg_Value_LogStatus_OUT string = "OUT"
const Reg_Key_cmdbtoken string = "cmdb_token"
const Reg_Value_ON string = "ON"
const Reg_Value_OFF string = "OFF"
// other //
const Link_WxworkBot string = `https://qyapi.weixin.qq.com/cgi-bin/webhook/send?key=59107f72-5b72-4a20-a33c-fdb1cd46f2c6`
const Cmd_c string = "cmd /c "
const Cmd_k string = "cmd /k "
const Cmd_K_Start string = "cmd /k start "
const Link_WxworkBot string = `https://qyapi.weixin.qq.com/cgi-bin/webhook/send?key=59107f72-5b72-4a20-a33c-fdb1cd46f2c6`
const Cmd_c string = "cmd /c "
const Cmd_k string = "cmd /k "
const Cmd_K_Start string = "cmd /k start "
// wxwork key //
const WxworkTokenMsgSend string = "AvAQlFNxy1UQB3CjRml3GfKf7Y"
const WxworkEncodingAseKey string = "AwLPVXc1MxPmqo7dzw8CYbbWku0nZlDwWDVCSknqEFy"
const WxworkReceiverId string = "ww49cfd580625083c9"
const WxworkCorid string = "ww49cfd580625083c9"
const WxworkCorpSecret string = "ckANI7SsRh0v_zu2uN7gitRHvTwqRAh8oG1a20xJo_I"
const WxWorkAgentID string = "1000014"
const WxworkTokenMsgSend string = "AvAQlFNxy1UQB3CjRml3GfKf7Y"
const WxworkEncodingAseKey string = "AwLPVXc1MxPmqo7dzw8CYbbWku0nZlDwWDVCSknqEFy"
const WxworkReceiverId string = "ww49cfd580625083c9"
const WxworkCorid string = "ww49cfd580625083c9"
const WxworkCorpSecret string = "ckANI7SsRh0v_zu2uN7gitRHvTwqRAh8oG1a20xJo_I"
const WxWorkAgentID string = "1000014"
// log level //
var Loglevel string = INFO
const INFO string = "info"
const ERROR string = "error"
const DEBUG string = "debug"
const NULL string = ""
// log type //
const CMDB string = "cmdb"
// cmdb //
const cmdbUrl string = "http://192.168.0.21:5000"
const cmdbCITypeComputer string = "28"
const cmdbPass string = `{"password":"3f7eba3920866b2c2375ba61117c42bf","username":"tengfei"}`
public/error.go
......@@ -2,30 +2,27 @@ package public
import (
"errors"
)
var Error_Lost_Parameter = errors.New("Lost Paramter")
var Error_Json_Parse = errors.New("ERROR JSON PARSE")
var Error_Lost_Parameter = errors.New("Lost Paramter")
var Error_Null_Command = errors.New("NULL COMMAND")
var Error_Null_RegQuery = errors.New("Null Reg Query")
var Error_Null_File = errors.New("Not Find File")
var Error_Null_Folder = errors.New("Not File Folder")
var Error_Null_Icon_File = errors.New("Not File Icon File")
var Error_Null_Reg_Query = errors.New("Not Found Reg Query Result")
var Error_Null_Command = errors.New("NULL COMMAND")
var Error_Null_RegQuery = errors.New("Null Reg Query")
var Error_Null_Folder_WeDrive = errors.New("Not Find Folder WxDrive ")
var Error_Null_App_Sync = errors.New("Not Find Application AllWay Sync")
var Error_Null_File = errors.New("Not Find File")
var Error_Null_Folder = errors.New("Not File Folder")
var Error_Null_Icon_File = errors.New("Not File Icon File")
var Error_Null_Reg_Query = errors.New("Not Found Reg Query Result")
var Error_Fail_File_Open = errors.New("Fail File Open")
var Error_Fail_Token = errors.New("Get Token Fail")
var Error_Fail_File_Write = errors.New("Fail File Write")
var Error_Not_Msg = errors.New("isn't defined msg")
var Error_Fail_File_Open = errors.New("Fail File Open")
var Error_Fail_Token = errors.New("Get Token Fail")
var Error_Fail_File_Write = errors.New("Fail File Write")
var Error_Fail_TCP_STR = "ERROR"
var Error_Not_Msg = errors.New("isn't defined msg")
var Error_WXWork_Down = errors.New(Error_WXWork_Down_STR)
var Error_WXWork_Down_STR = "后台更新中..."
var Error_WXWork_Down = errors.New(Error_WXWork_Down_STR)
var Error_WXWork_Down_STR = "后台错误"
var Error_WXWork_NotDominUser_STR = "您的主机暂时不支持该功能"
var Error_WXWork_NotDominUser_STR = "您的主机暂时不支持该功能"
func NewError(s string) error{
return errors.New(s)
}
\ No newline at end of file
const Error_CMDB_UPDATE_REQ = "更新失败"
const Sccessful_CMDB_UPDATE_REQ = "更新成功"
public/json.go 0 → 100644
package public
import (
"bytes"
"encoding/json"
"fmt"
)
// 获取 消息类型
func GetMsgType(b []byte) string {
//{"msgtype":"report","...":"..."}
// 提取第一个冒号后的第二位和第一个逗号的前一位
// 也就是msgtype的内容
return string(b[bytes.IndexByte(b, ':')+2 : bytes.IndexByte(b, ',')-1])
}
// 解析Json 并放到变量中
func ParseJson(unmsg []byte, v interface{}) {
if err := json.Unmarshal(unmsg, v); err != nil {
LOG(ERROR, "Parse Json Error", fmt.Sprintf("%v %v", err, v))
}
}
// Json 转 Byte
func ReParseJson(v *interface{}) []byte {
textbyte, err := json.Marshal(*v)
if err != nil {
LOG(ERROR, "Json to byte Error", fmt.Sprintf("%v %v", err, v))
}
return textbyte
}
public/ldap.go
......@@ -7,26 +7,26 @@ import (
func LDAP_Get_PCGroup() []string {
l, err := ldap.DialURL("ldap://127.0.0.1:389")
if err != nil {
PntError(err)
LOG(ERROR, NULL, err)
}
defer l.Close()
if err = l.Bind(AD_User_zhiwei, "1Q2W3e4r");err != nil {
PntError(err)
if err = l.Bind(AD_User_zhiwei, "1Q2W3e4r"); err != nil {
LOG(ERROR, NULL, err)
}
searchRequest := ldap.NewSearchRequest(
"ou=情报部门,dc=zhiweireach,dc=com",
ldap.ScopeWholeSubtree,ldap.NeverDerefAliases, 0, 0, false,
ldap.ScopeWholeSubtree, ldap.NeverDerefAliases, 0, 0, false,
"(cn=*-PC)",
//"(&(objectClass=organizationalPerson))",
//"(&(objectClass=organizationalPerson))",
[]string{"cn"},
nil,
)
sr, err := l.Search(searchRequest)
if err != nil {
PntError(err)
LOG(ERROR, NULL, err)
}
pcgroup := make([]string,len(sr.Entries))
pcgroup := make([]string, len(sr.Entries))
for i, entry := range sr.Entries {
// 完整输出 entry.DN
// 输出特定目录 entry.GetAttributeValue("cn")
......@@ -34,28 +34,28 @@ func LDAP_Get_PCGroup() []string {
}
return pcgroup
}
func LDAP_nameTopinyin(name string) string{
func LDAP_nameTopinyin(name string) string {
l, err := ldap.DialURL("ldap://127.0.0.1:389")
if err != nil {
PntError(err)
LOG(ERROR, NULL, err)
}
defer l.Close()
if err = l.Bind(AD_User_zhiwei, "1Q2W3e4r");err != nil {
PntError(err)
if err = l.Bind(AD_User_zhiwei, "1Q2W3e4r"); err != nil {
LOG(ERROR, NULL, err)
}
searchRequest := ldap.NewSearchRequest(
//"ou=情报部门,dc=zhiweireach,dc=com",
"ou=情报部门,dc=zhiweireach,dc=com",
ldap.ScopeWholeSubtree,ldap.NeverDerefAliases, 0, 0, false,
ldap.ScopeWholeSubtree, ldap.NeverDerefAliases, 0, 0, false,
"(cn="+name+")",
//"(&(objectClass=organizationalPerson))",
//"(&(objectClass=organizationalPerson))",
[]string{"sAMAccountName"},
nil,
)
sr, err := l.Search(searchRequest)
if err != nil {
PntError(err)
LOG(ERROR, NULL, err)
}
return sr.Entries[0].GetAttributeValue("sAMAccountName")
}
\ No newline at end of file
}
public/log.go 0 → 100644
package public
import (
"encoding/json"
"fmt"
"path/filepath"
"runtime"
"strings"
"time"
"github.com/color-master"
)
type logs struct {
Time string `json:"_Time"`
Hook string `json:"_Hook"`
Version string `json:"_Version"`
Host string `json:"_Host"`
Level string `json:"Level"`
MsgType string `json:"MsgType"`
Message string `json:"Message"`
}
func logBase() logs {
var l logs
filename, line, funcname := "???", 0, "???"
pc, filename, line, ok := runtime.Caller(2)
if ok {
funcname = runtime.FuncForPC(pc).Name() // main.(*MyStruct).foo
funcname = filepath.Ext(funcname) // .foo
funcname = strings.TrimPrefix(funcname, ".") // foo
filename = filepath.Base(filename) // /full/path/basename.go => basename.go
}
l.Time = time.Now().Format("2006-01-02 15:04:05 Monday")
l.Hook = fmt.Sprintf("%s:%d:%s", filename, line, funcname)
l.Version = Version
return l
}
func logDeal(level string, l *logs) {
textbyte, err := json.Marshal(l)
if err != nil {
SendWxworkTextToAdmins(err.Error())
}
if DomainComputer() {
SendLog(string(textbyte))
return
}
if DomainCotroller() {
switch level {
// 绿色
case INFO:
color.Info.Println(string(textbyte))
// 红色
case ERROR:
color.Error.Println(string(textbyte))
// 蓝色
case DEBUG:
color.Debug.Println(string(textbyte))
// 绿色
default:
color.Info.Println(string(textbyte))
}
return
}
}
func LOG(level string, msgtype string, args ...interface{}) {
if (Loglevel != DEBUG) && (level == DEBUG) {
return
}
l := logBase()
l.Host = User_computername
l.Level = level
l.MsgType = msgtype
l.Message = fmt.Sprint(fmt.Sprint(args...))
logDeal(level, &l)
}
public/msg_deal.go
package public
import(
"net/http"
"io/ioutil"
"strings"
import (
"fmt"
"io/ioutil"
"net/http"
"strings"
)
//
//
// 消息入口
//
func DealMsgEnter(w http.ResponseWriter, r *http.Request) {
msgtype := r.URL.Path[1:]
url :=r.URL.RawQuery
unmsg,err := ioutil.ReadAll(r.Body)
if err!=nil{
PntError(err)
w.Write([]byte(""))
msgtype := r.URL.Path[1:]
url := r.URL.RawQuery
unmsg, err := ioutil.ReadAll(r.Body)
if err != nil {
LOG(ERROR, NULL, err)
w.Write([]byte(""))
}
ret := DealMsg(msgtype,url,unmsg)
w.Write(ret)
ret := DealMsg(msgtype, url, unmsg)
w.Write(ret)
}
func DealMsg(msgtype, url string, unmsg []byte) []byte {
var ret []byte
switch msgtype{
// 报告 消息
case Msg_Report:
var pmsg MJreport
PntReport(string(unmsg))
ParseJson(unmsg,&pmsg)
ice := pmsg.MsgDeal()
ret = ReParseJson(&ice)
// 执行 消息
case Msg_Exec:
var pmsg MJexec
PntExec(string(unmsg))
ParseJson(unmsg,&pmsg)
ice := pmsg.MsgDeal()
ret = ReParseJson(&ice)
// 备份 消息
case Msg_Backup:
var pmsg MJbackup
PntBackup(string(unmsg))
ParseJson(unmsg,&pmsg)
ice := pmsg.MsgDeal()
ret = ReParseJson(&ice)
// 唤醒 消息
case Msg_Wake:
var pmsg MJwake
ParseJson(unmsg,&pmsg)
ice := pmsg.MsgDeal()
ret = ReParseJson(&ice)
// 错误 消息
case Msg_Error:
PntError(string(unmsg))
var pmsg MJerror
ParseJson(unmsg,&pmsg)
ice := pmsg.MsgDeal()
ret = ReParseJson(&ice)
default:
pmsg := ParseWX(url,&unmsg)
go pmsg.MsgDealSend()
}
switch msgtype {
// 报告 消息
case Msg_Report:
var pmsg MJreport
// LOG(INFO, "REPORT", string(unmsg))
ParseJson(unmsg, &pmsg)
ice := pmsg.MsgDeal()
ret = ReParseJson(&ice)
// 执行 消息
case Msg_Exec:
var pmsg MJexec
// LOG(INFO, "EXEC", string(unmsg))
ParseJson(unmsg, &pmsg)
ice := pmsg.MsgDeal()
ret = ReParseJson(&ice)
// 唤醒 消息
case Msg_Wake:
var pmsg MJwake
ParseJson(unmsg, &pmsg)
ice := pmsg.MsgDeal()
ret = ReParseJson(&ice)
// 错误 消息
case Msg_Error:
LOG(ERROR, NULL, string(unmsg))
var pmsg MJerror
ParseJson(unmsg, &pmsg)
ice := pmsg.MsgDeal()
ret = ReParseJson(&ice)
default:
pmsg := ParseWX(url, &unmsg)
go pmsg.MsgDealSend()
}
return ret
}
//
//
//
// 具体消息实现
//
// 关于 report 报告 的 消息处理
func (rep *MJreport)MsgDeal() interface{} {
switch rep.Instruction{
case Msg_Report_InitBak:
PrintLog(rep.Computername,"初始化备份")
if !IsPrimaryUser(rep.Username) || RunAsPC(rep.Username){
return nil
}
return GJbackup()
case Msg_Report_ReadyBak:
PrintLog(rep.Computername,"开始备份")
return rep
case Msg_Report_OverBak:
PrintLog(rep.Computername,"结束备份")
Pskill(rep.Computername,App_Sync)
return rep
case Msg_Report_WillTurnOffPC:
rep.Reg_Write_ADDC(
Reg_Name_TurnOffTime,
UnixTimeParse(&rep.Timestamp))
rep.Reg_Write_ADDC(
Reg_Name_PowerStatus,
Reg_Value_OFF)
case Msg_Report_WillTurnOnPC:
// 如果是被开机唤醒
id := rep.Reg_Query_ADDC(Reg_Name_BeWakedID)
if id != ""{
SendWxworkTextToAUser(id,"主机已启动,一切就绪~")
rep.Reg_Write_ADDC(Reg_Name_BeWakedID,"")
}
// 记录 开机 时间
rep.Reg_Write_ADDC(
Reg_Name_TurnOnTime,
UnixTimeParse(&rep.Timestamp))
//记录 电源状态
rep.Reg_Write_ADDC(
Reg_Name_PowerStatus,
Reg_Value_ON)
case Msg_Report_WillLogInUser:
rep.Reg_Write_ADDC(
Reg_Name_LoginUserName,
rep.Username)
rep.Reg_Write_ADDC(
Reg_Name_LoginTime,
UnixTimeParse(&rep.Timestamp))
rep.Reg_Write_ADDC(
Reg_Name_LogStatus,
Reg_Value_LogStatus_IN)
case Msg_Report_WillLogOutUser:
rep.Reg_Write_ADDC(
Reg_Name_LoginUserName,
rep.Username)
rep.Reg_Write_ADDC(
Reg_Name_LogOffTime,
UnixTimeParse(&rep.Timestamp))
rep.Reg_Write_ADDC(
Reg_Name_LogStatus,
Reg_Value_LogStatus_OUT)
default:
PntOth("Default Report Json ",rep.Instruction)
}
return nil
}
func (rep *MJreport) MsgDeal() interface{} {
switch rep.Instruction {
case Msg_Report_WillTurnOffPC:
switch rep.Status {
// 服务器
case Msg_status_commit:
// 第一次仅仅会更新部分字段，第二次会更新全部字段
if ci, r := cmdbExistRecord(cmdb_Product_name, rep.Computername); !r {
break
} else {
err := cmdbUpdateRecordFromJSON(rep.DataStr, ci)
if err != nil {
LOG(ERROR, "CMDB_UPDATE", err)
} else {
LOG(INFO, "CMDB_UPDATE", rep.Computername)
}
}
// 客户端处理
case Msg_status_deal:
return nil
}
// coding
// rep.Reg_Write_ADDC(
// Reg_Name_TurnOffTime,
// rep.Reg_Write_ADDC(
// Reg_Name_PowerStatus,
// Reg_Value_OFF)
case Msg_Report_WillTurnOnPC:
switch rep.Status {
// 服务器
case Msg_status_commit:
if ci, r := cmdbExistRecord(cmdb_Product_name, rep.Computername); !r {
break
} else {
err := cmdbUpdateRecordFromJSON(rep.DataStr, ci)
if err != nil {
LOG(ERROR, "CMDB_UPDATE", err)
} else {
LOG(INFO, "CMDB_UPDATE", rep.Computername)
}
}
// 客户端
case Msg_status_deal:
return nil
}
// 关于 exec 执行 的 消息处理
// coding
// 如果是被开机唤醒
// id = rep.Reg_Query_ADDC(Reg_Name_BeWakedID)
// if id != "" {
// SendWxworkTextToAUser(id, "主机已启动,一切就绪~")
// // rep.Reg_Write_ADDC(Reg_Name_BeWakedID, "")
// }
// coding
// 记录 开机 时间
// rep.Reg_Write_ADDC(
// Reg_Name_TurnOnTime,
// 记录 电源状态
// rep.Reg_Write_ADDC(
// Reg_Name_PowerStatus,
// Reg_Value_ON)
case Msg_Report_WillLogInUser:
case Msg_Report_WillLogOutUser:
// 更新主要计算机
case Msg_Report_UpdatePrimaryHost:
switch rep.Status {
// 服务器
case Msg_status_commit:
ci, err := cmdbGetCI(cmdb_Product_name, rep.Computername)
if err != nil {
rep.DataStr = Error_CMDB_UPDATE_REQ
LOG(ERROR, rep.Instruction, err)
break
}
a, err := cmdbKVtoJSON(cmdb_Username, rep.DataStr)
if err != nil {
rep.DataStr = Error_CMDB_UPDATE_REQ
LOG(ERROR, rep.Instruction, err)
break
}
if err := cmdbUpdateRecordFromJSON(a, ci); err != nil {
rep.DataStr = Error_CMDB_UPDATE_REQ
LOG(ERROR, rep.Instruction, err)
break
}
LOG(INFO, rep.Instruction, fmt.Sprintf("%s is %s's PrimryComputer", cmdb_Product_name, rep.DataStr))
rep.DataStr = Sccessful_CMDB_UPDATE_REQ
// 客户端
case Msg_status_deal:
if rep.DataStr != "" {
Msg(rep.DataStr)
}
}
default:
LOG(ERROR, "Default Report Json ", rep.Instruction)
}
func (exec *MJexec)MsgDeal()interface{}{
// 状态变更
switch exec.Status {
case Msg_Exec_State_Request:
exec.Status = Msg_Exec_State_Ack
case Msg_Exec_State_Ack:
exec.Status = Msg_Exec_State_Over
case Msg_Exec_State_Over:
if exec.IfMsg {Msg(exec.Explain)}
return nil
}
// 消息处理
switch exec.Instruction{
case Msg_Exec_TurnOffPC:
exec.Command = Msg_Exec_TurnOffPC_cmd
exec.PsExec()
exec.Status = Msg_Exec_State_Over
case Msg_Exec_LogOffUser:
exec.Command = Msg_Exec_LogOffUser_cmd
exec.PsExec()
exec.Status = Msg_Exec_State_Over
case Msg_Exec_RebootWindows:
exec.Command = Msg_Exec_RebootWindows_cmd
exec.PsExec()
exec.Status = Msg_Exec_State_Over
case Msg_Exec_HideShowIcon:
var hidetype string
if exec.DataBool {
hidetype = "-"
}else{
hidetype = "+"
}
exec.Command = "attrib "+ hidetype+`h `+ exec.DataStr
exec.PsExec()
exec.IfMsg = true
exec.Explain = "图标已"+exec.Explain
exec.Status = Msg_Exec_State_Over
case Msg_Exec_InstallSoftware:
// 对于 msi 格式,从\\adserver目录使用msiexec安装
// 共享则需要everyone的读取权限
if strings.HasSuffix(exec.Command,".msi"){
full_cmd := "msiexec /i " + SMB_ADSoftlike + `\` + exec.Command + " /qb"
PsExec_sdi(exec.Computername,full_cmd,exec.SessionID)
// 对于 exe 格式,从 ADMIN$ 复制到C:\windows，再执行
} else {
PsExec_sfdic(exec.Computername,Dir_ADsoftware_local + exec.Command,exec.SessionID)
}
exec.Status = Msg_Exec_State_Over
case Msg_Exec_OpenAdminEXE:
PsExec_sdi(exec.Computername,exec.Command,exec.SessionID)
exec.Status = Msg_Exec_State_Over
default:
Execcmd_nowait(exec.Command)
}
return exec
// 修改状态
switch rep.Status {
// 服务器
case Msg_status_commit:
rep.Status = Msg_status_deal
// 客户端
case Msg_status_deal:
return nil
}
return rep
}
// 关于 exec 执行 的 消息处理
func (exec *MJexec) MsgDeal() interface{} {
// 状态变更
switch exec.Status {
case Msg_Exec_State_Request:
exec.Status = Msg_Exec_State_Ack
case Msg_Exec_State_Ack:
exec.Status = Msg_Exec_State_Over
case Msg_Exec_State_Over:
if exec.IfMsg {
Msg(exec.Explain)
}
return nil
}
// 关于 backup 备份 的 消息处理
func (bak * MJbackup)MsgDeal() interface{}{
switch bak.Instruction{
case Msg_Backup_Status_Init:
bak.Timestamp = NowTimestamp()
bak.Username = User_name
bak.Computername = User_computername
bak.Explain = "Backup Init"
bak.Instruction = Msg_Backup_Status_Continue
PntInfo(bak.Explain)
// 如果版本不是最新
currentVersion := Reg_Query_DC(Reg_Name_BackupVersion)
if (bak.Version != currentVersion) ||
NotExist(Dir_Sync_Config + File_Sync_profile){
MkdirAll(Dir_Sync_Config)
// 1 复制 最新文件
if _,err := CopyFile(File_Sync_profile_full, SMB_ADSoftPlusSync + File_Sync_profile);err !=nil{
return GJerror(err)
}
if _,err := CopyFile(File_Sync_settings_full, SMB_ADSoftPlusSync + File_Sync_settings);err !=nil{
return GJerror(err)
}
// 2 更新 新版本
Reg_Write_DC(Reg_Name_BackupVersion,bak.Version)
bak.Explain = "Backup update config"
PntInfo(bak.Explain)
}
SendADMsg(bak.MsgType,bak)
return nil
// 判断是否能进行备份
case Msg_Backup_Status_Continue:
bak.Timestamp = NowTimestamp()
bak.Instruction = Msg_Backup_Status_Run
return bak
// 消息处理
switch exec.Instruction {
case Msg_Exec_TurnOffPC:
exec.Command = Msg_Exec_TurnOffPC_cmd
exec.PsExec()
exec.Status = Msg_Exec_State_Over
case Msg_Exec_LogOffUser:
exec.Command = Msg_Exec_LogOffUser_cmd
exec.PsExec()
exec.Status = Msg_Exec_State_Over
case Msg_Exec_RebootWindows:
exec.Command = Msg_Exec_RebootWindows_cmd
exec.PsExec()
exec.Status = Msg_Exec_State_Over
case Msg_Exec_HideShowIcon:
var hidetype string
if exec.DataBool {
hidetype = "-"
} else {
hidetype = "+"
}
exec.Command = fmt.Sprintf(`attrib %sh "%s"`, hidetype, exec.DataStr)
exec.PsExec()
exec.IfMsg = true
exec.Explain = "图标已" + exec.Explain
exec.Status = Msg_Exec_State_Over
case Msg_Exec_InstallSoftware:
// 对于 msi 格式,从\\adserver目录使用msiexec安装
// 共享则需要everyone的读取权限
if strings.HasSuffix(exec.Command, ".msi") {
full_cmd := "msiexec /i " + SMB_ADSoftlike + `\` + exec.Command + " /qb"
PsExec_sdi(exec.Computername, full_cmd, exec.SessionID)
// 对于 exe 格式,从 ADMIN$ 复制到C:\windows，再执行
} else {
PsExec_sfdic(exec.Computername, Dir_ADsoftware_local+exec.Command, exec.SessionID)
}
case Msg_Backup_Status_Run:
go Msg("开始备份用户文件，这是为了防止磁盘损坏而进行的步骤，最小化即可，有疑问@陶腾飞")
Execcmd_nowait_noargs(App_Sync_full)
default:
PntErrorf("%s %v",bak.Instruction,Error_Not_Msg)
}
exec.Status = Msg_Exec_State_Over
case Msg_Exec_OpenAdminEXE:
PsExec_sdi(exec.Computername, exec.Command, exec.SessionID)
exec.Status = Msg_Exec_State_Over
return nil
default:
Execcmd_nowait(exec.Command)
}
return exec
}
// 关于 wake 唤醒 的 消息处理
func (wake * MJwake)MsgDeal() interface{}{
func (wake *MJwake) MsgDeal() interface{} {
switch wake.Instruction {
case Msg_Wake_Status_Req:
wake.Instruction = Msg_Wake_Status_Over
go Wol_enter(wake.Computername,&wake.MACAddress)
go Wol_enter(wake.Computername, &wake.MACAddress)
return wake
case Msg_Wake_Status_Over:
......@@ -303,207 +275,223 @@ func (wake * MJwake)MsgDeal() interface{}{
return nil
}
// 关于 error 错误 的 消息处理
func (err * MJerror)MsgDeal() interface{}{
//SendWX(err.Instruction)
return nil
func (err *MJerror) MsgDeal() interface{} {
//SendWX(err.Instruction)
return nil
}
// 关于 wxwork 企业微信 的 消息处理
func (wxwork *MJwxwork) MsgDealSend() {
switch wxwork.Instruction {
case WXEK_zwDevopsPowerWake:
// 关于 wxwork 企业微信 的 消息处理
wxwork.SendText("收到唤醒指令，正在处理,")
//var domainUser bool = true
var pc, mac string
var err error
// coding
// 在注册表中查询 域用户 记录
// if err = Reg_IfExist_item(Reg_Root_ac, Reg_Path_home_du+wxwork.Name); err == nil {
// pc = wxwork.Reg_Query_ADUsers(Reg_Name_PrimayComputerName)
// mac = wxwork.Reg_Query_ADUsers(Reg_Name_MACAddress)
// 在注册表中查询 知微用户 记录
// } else if err = Reg_IfExist_item(Reg_Root_ac, Reg_Path_home_zhu+wxwork.Name); err == nil {
// pc = wxwork.Reg_Query_ZhiWeiUsers(Reg_Name_PrimayComputerName)
// mac = wxwork.Reg_Query_ZhiWeiUsers(Reg_Name_MACAddress)
// domainUser = false
// } else {
// wxwork.Result = Error_WXWork_NotDominUser_STR
// break
// }
// 查看电源状态
status, err := PSTest_Connection(pc)
LOG(INFO, "Wxwork_Rec", fmt.Sprintf("host:%s,mac:%s,name:%s,execstatus:%s,status:%v", pc, mac, wxwork.Name, "wakeup", status))
if err != nil {
wxwork.Result = Error_WXWork_Down_STR
break
}
if status {
wxwork.Result = "已经开机了哦~"
break
}
func (wxwork * MJwxwork)MsgDealSend() {
switch wxwork.Instruction {
case WXEK_zwDevopsPowerWake:
wxwork.SendText("收到唤醒指令，正在处理")
var domainUser bool = true
var pc,mac string
var err error
// 在注册表中查询 域用户 记录
if err = Reg_IfExist_item(Reg_Root_ac,Reg_Path_home_du + wxwork.Name); err == nil{
pc = wxwork.Reg_Query_ADUsers(Reg_Name_PrimayComputerName)
mac = wxwork.Reg_Query_ADUsers(Reg_Name_MACAddress)
// 在注册表中查询 知微用户 记录
}else if err = Reg_IfExist_item(Reg_Root_ac,Reg_Path_home_zhu + wxwork.Name); err == nil{
pc = wxwork.Reg_Query_ZhiWeiUsers(Reg_Name_PrimayComputerName)
mac = wxwork.Reg_Query_ZhiWeiUsers(Reg_Name_MACAddress)
domainUser = false
}else{
wxwork.Result = Error_WXWork_NotDominUser_STR
break
}
// 查看电源状态
status,err := PSTest_Connection(pc)
PntWXRec(pc,mac,wxwork.Name,"wakeup",status)
if err !=nil{
wxwork.Result = Error_WXWork_Down_STR
break
}
if status {
wxwork.Result = "已经开机了哦~"
break
}
// 只有域用户有效
// 写入被唤醒的ID用于判断是否是被企业微信唤醒
if domainUser{
Reg_Write_ADDC(pc,Reg_Name_BeWakedID,wxwork.UserID)
}
// 进行唤醒
go Wol_enter(pc,&mac)
go func(userid string){
for i:=0;i<10;i++{
Delay(30)
status,_ := PSTest_Connection(pc)
if status {
SendWxworkTextToAUser(userid,"主机已启动！")
return
}
}
}(wxwork.UserID)
wxwork.Result = "开始唤醒，请等待~"
case WXEK_zwDevopsPowerReboot:
// 只有域用户有效
// 写入被唤醒的ID用于判断是否是被企业微信唤醒
// if domainUser {
// Reg_Write_ADDC(pc, Reg_Name_BeWakedID, wxwork.UserID)
// }
// 进行唤醒
go Wol_enter(pc, &mac)
go func(userid string) {
for i := 0; i < 10; i++ {
Delay(30)
status, _ := PSTest_Connection(pc)
if status {
SendWxworkTextToAUser(userid, "主机已启动！")
return
}
}
}(wxwork.UserID)
wxwork.Result = "开始唤醒，请等待~"
case WXEK_zwDevopsPowerReboot:
var pc string
wxwork.SendText("收到重启指令，正在处理")
// 检查是否是域用户
err := Reg_IfExist_item(Reg_Root_ac,Reg_Path_home_du + wxwork.Name)
if err !=nil{
wxwork.Result = Error_WXWork_NotDominUser_STR
break
}
// 检查注册表的主机 是否存在
pc := wxwork.Reg_Query_ADUsers(Reg_Name_PrimayComputerName)
if pc == ""{
wxwork.Result = Error_WXWork_Down_STR
break
}
// 检查 主机连接情况
status,err := PSTest_Connection(pc)
if err != nil{
wxwork.Result = Error_WXWork_Down_STR
break
}
if !status{
wxwork.Result = "主机已关机或无法连接主机"
break
// coding
// 检查是否是域用户
// err := Reg_IfExist_item(Reg_Root_ac, Reg_Path_home_du+wxwork.Name)
// if err != nil {
// wxwork.Result = Error_WXWork_NotDominUser_STR
// break
// }
// coding
// 检查注册表的主机 是否存在
// pc := wxwork.Reg_Query_ADUsers(Reg_Name_PrimayComputerName)
// if pc == "" {
// wxwork.Result = Error_WXWork_Down_STR
// break
// }
// 检查 主机连接情况
status, err := PSTest_Connection(pc)
if err != nil {
wxwork.Result = Error_WXWork_Down_STR
break
}
if !status {
wxwork.Result = "主机已关机或无法连接主机"
break
}
PntWXRec(pc,wxwork.Name,"reboot",status)
Execcmd_wait(`shutdown -r -t 0 -m \\`+ pc)
Reg_Write_ADDC(pc,Reg_Name_BeWakedID,wxwork.UserID)
go func(name,userid string){
var rebooted bool = false
for i:=0;i<30;i++{
status,_ := PSTest_Connection(pc)
if !status {
rebooted = true
}
if status && rebooted {
SendWxworkTextToAUserWithName(name,userid,"重启完成~")
return
}
}
}(wxwork.Name,wxwork.UserID)
wxwork.Result = "开始重启，请等待~"
break
case WXEK_zwDevopsPowerTurnOFF:
LOG(INFO, "Wxwork_Rec", fmt.Sprintf("host:%s,name:%s,execstatus:%s,status:%v", pc, wxwork.Name, "reboot", status))
Execcmd_wait(`shutdown -r -t 0 -m \\` + pc)
// Reg_Write_ADDC(pc, Reg_Name_BeWakedID, wxwork.UserID)
go func(name, userid string) {
var rebooted bool = false
for i := 0; i < 30; i++ {
status, _ := PSTest_Connection(pc)
if !status {
rebooted = true
}
if status && rebooted {
wxwork.SendText("重启完成~")
return
}
}
}(wxwork.Name, wxwork.UserID)
wxwork.Result = "开始重启，请等待~"
break
case WXEK_zwDevopsPowerTurnOFF:
var pc string
wxwork.SendText("收到关机指令，正在处理")
// 检查是否是域用户
err := Reg_IfExist_item(Reg_Root_ac,Reg_Path_home_du + wxwork.Name)
if err !=nil{
wxwork.Result = Error_WXWork_NotDominUser_STR
break
}
// 检查注册表的主机 是否存在
pc := wxwork.Reg_Query_ADUsers(Reg_Name_PrimayComputerName)
if pc == ""{
wxwork.Result = Error_WXWork_Down_STR
break
}
// 检查 主机连接情况
status,err := PSTest_Connection(pc)
if err != nil{
wxwork.Result = Error_WXWork_Down_STR
break
}
if !status{
wxwork.Result = "主机已关机或无法连接主机"
break
// coding
// 检查是否是域用户
// err := Reg_IfExist_item(Reg_Root_ac, Reg_Path_home_du+wxwork.Name)
// if err != nil {
// wxwork.Result = Error_WXWork_NotDominUser_STR
// break
// }
// 检查注册表的主机 是否存在
// pc := wxwork.Reg_Query_ADUsers(Reg_Name_PrimayComputerName)
// if pc == "" {
// wxwork.Result = Error_WXWork_Down_STR
// break
// }
// 检查 主机连接情况
status, err := PSTest_Connection(pc)
if err != nil {
wxwork.Result = Error_WXWork_Down_STR
break
}
if !status {
wxwork.Result = "主机已关机或无法连接主机"
break
}
PntWXRec(pc,wxwork.Name,"shutdown",status)
Execcmd_wait(`shutdown -s -t 0 -m \\`+ pc)
Reg_Write_ADDC(pc,Reg_Name_BeWakedID,wxwork.UserID)
go func(name,userid string){
for i:=0;i<10;i++{
Delay(30)
status,_ := PSTest_Connection(pc)
if !status {
SendWxworkTextToAUserWithName(name,userid,"关机已完成~")
return
}
}
}(wxwork.Name,wxwork.UserID)
wxwork.Result = "开始关机，请等待~"
case WXEK_zwDevopsPowerStatus:
LOG(INFO, "Wxwork_Rec", fmt.Sprintf("host:%s,name:%s,execstatus:%s,status:%v", pc, wxwork.Name, "shutdown", status))
Execcmd_wait(`shutdown -s -t 0 -m \\` + pc)
//Reg_Write_ADDC(pc, Reg_Name_BeWakedID, wxwork.UserID)
go func(name, userid string) {
for i := 0; i < 10; i++ {
Delay(30)
status, _ := PSTest_Connection(pc)
if !status {
wxwork.SendText("关机已完成~")
return
}
}
}(wxwork.Name, wxwork.UserID)
wxwork.Result = "开始关机，请等待~"
case WXEK_zwDevopsPowerStatus:
wxwork.SendText("收到查询指令，正在处理")
var domainUser bool = true
var pc string
var err error
// 在注册表中查询 域用户 记录
if err = Reg_IfExist_item(Reg_Root_ac,Reg_Path_home_du + wxwork.Name); err == nil{
pc = wxwork.Reg_Query_ADUsers(Reg_Name_PrimayComputerName)
// 在注册表中查询 知微用户 记录
}else if err = Reg_IfExist_item(Reg_Root_ac,Reg_Path_home_zhu + wxwork.Name); err == nil{
pc = wxwork.Reg_Query_ZhiWeiUsers(Reg_Name_PrimayComputerName)
domainUser = false
}else{
wxwork.Result = Error_WXWork_NotDominUser_STR
break
var domainUser bool = true
var pc string
var err error
// coding
// 在注册表中查询 域用户 记录
// if err = Reg_IfExist_item(Reg_Root_ac, Reg_Path_home_du+wxwork.Name); err == nil {
// pc = wxwork.Reg_Query_ADUsers(Reg_Name_PrimayComputerName)
// // 在注册表中查询 知微用户 记录
// } else if err = Reg_IfExist_item(Reg_Root_ac, Reg_Path_home_zhu+wxwork.Name); err == nil {
// pc = wxwork.Reg_Query_ZhiWeiUsers(Reg_Name_PrimayComputerName)
// domainUser = false
// } else {
// wxwork.Result = Error_WXWork_NotDominUser_STR
// break
// }
// 检查 主机连接情况
status, err := PSTest_Connection(pc)
if err != nil {
wxwork.Result = Error_WXWork_Down_STR
LOG(ERROR, NULL, err)
break
}
// 检查 主机连接情况
status,err := PSTest_Connection(pc)
if err != nil{
wxwork.Result = Error_WXWork_Down_STR
break
LOG(INFO, "Wxwork_Rec", fmt.Sprintf("host:%s,name:%s,execstatus:%s,status:%v", pc, wxwork.Name, "check", status))
if status {
wxwork.Result = "主机已启动"
} else if !status && !domainUser {
wxwork.Result = "主机已关闭或禁用了ICMP（请允许防火墙）"
} else {
wxwork.Result = "主机已关闭"
}
PntWXRec(pc,wxwork.Name,"check",status)
if status{
wxwork.Result = "主机已启动"
}else if !status && !domainUser{
wxwork.Result = "主机已关闭或禁用了ICMP（请允许防火墙）"
} else {
wxwork.Result = "主机已关闭"
}
}
default:
wxwork.Content = ToEnglishSymbol(wxwork.Content)
switch wxwork.Name {
case "陶腾飞":
if strings.HasPrefix(wxwork.Content, "pwsh") {
hostname := wxwork.Content[5:]
PsExec_sdi(hostname, "powershell", "1")
}
default:
wxwork.SendText("【自动回复】\n电脑问题请找技术部运维组陶腾飞。联系方式：17815918180（同微信）")
}
}
wxwork.SendResult()
}
public/msg_init.go
package public
// msg env ////////////////////////////////////////////////////////////////
const EndSign byte = 125
const msgerror string = "error"
const EndSign byte = 125
const msgerror string = "error"
// msg status //////////////////////////////////////////////////////////////
const Msg_status_commit string = "commit"
const Msg_status_deal string = "deal"
// msg type ////////////////////////////////////////////////////////////////
const Msg_Report string = "report"
const Msg_Exec string = "exec"
const Msg_Backup string = "backup"
const Msg_Error string = "error"
const Msg_Wxwork string = "wxwork"
const Msg_Wake string = "wake"
const Msg_Report string = "report"
const Msg_Exec string = "exec"
const Msg_Error string = "error"
const Msg_Wxwork string = "wxwork"
const Msg_Wake string = "wake"
// base word ////////////////////////////////////////////////////////////////
const LogInUser string = "LogInUser"
const LogOutUser string = "LogOutUser"
const WillLogInUser string = "WillLogInUser"
const WillLogOutUser string = "WillLogOutUser"
const TurnOnPC string = "TurnOnPC"
const TurnOffPC string = "TurnOffPC"
const WillTurnOnPC string = "WillTurnOnPC"
const WillTurnOffPC string = "WillTurnOffPC"
const LogInUser string = "LogInUser"
const LogOutUser string = "LogOutUser"
const WillLogInUser string = "WillLogInUser"
const WillLogOutUser string = "WillLogOutUser"
const TurnOnPC string = "TurnOnPC"
const TurnOffPC string = "TurnOffPC"
const WillTurnOnPC string = "WillTurnOnPC"
const WillTurnOffPC string = "WillTurnOffPC"
const UpdatePrimaryHost string = "UpdatePrimaryHost"
// msg report type ///////////////////////////////////////////////////////////
const Msg_Report_LoginInUser string = LogInUser
const Msg_Report_LogOutUser string = LogInUser
const Msg_Report_WillLogInUser string = WillLogInUser
const Msg_Report_WillLogOutUser string = WillLogOutUser
const Msg_Report_TurnOnPC string = TurnOnPC
const Msg_Report_TurnOffPC string = TurnOffPC
const Msg_Report_WillTurnOnPC string = WillTurnOnPC
const Msg_Report_WillTurnOffPC string = WillTurnOffPC
const Msg_Report_OverCopyToWeDrive string = "overcopytowedrive"
const Msg_Report_OverCopyToDeptShare string = "OverCopyToDeptShare"
const Msg_Report_ReadyBak string = "readybak"
const Msg_Report_InitBak string = "initbak"
const Msg_Report_OverBak string = "overbak"
const Msg_Report_DCInfo string = "DCInfo"
// msg backup type //////////////////////////////////////////////////////////////
const Msg_Backup_Status_Init string = "init"
const Msg_Backup_Status_Continue string = "Continue"
const Msg_Backup_Status_Run string = "run"
const Msg_Report_LoginInUser string = LogInUser
const Msg_Report_LogOutUser string = LogInUser
const Msg_Report_WillLogInUser string = WillLogInUser
const Msg_Report_WillLogOutUser string = WillLogOutUser
const Msg_Report_TurnOnPC string = TurnOnPC
const Msg_Report_TurnOffPC string = TurnOffPC
const Msg_Report_WillTurnOnPC string = WillTurnOnPC
const Msg_Report_WillTurnOffPC string = WillTurnOffPC
const Msg_Report_UpdatePrimaryHost string = UpdatePrimaryHost
// msg exec type ////////////////////////////////////////////////////////////////
const (
Msg_Exec_Cmder_ADServer = iota
Msg_Exec_Cmder_ADServer = iota
Msg_Exec_Cmder_LocalDaemon
Msg_Exec_Cmder_LocalUser
)
const Msg_Exec_State_Request string = "request"
const Msg_Exec_State_Ack string = "ack"
const Msg_Exec_State_Over string = "over"
const Msg_Exec_TurnOffPC string = TurnOffPC
const Msg_Exec_TurnOffPC_cmd string = "shutdown -s -t 300"
const Msg_Exec_LogOffUser string = LogOutUser
const Msg_Exec_LogOffUser_cmd string = "shutdown -l"
const Msg_Exec_RebootWindows string = "rebootWindows"
const Msg_Exec_RebootWindows_cmd string = "shutdown -r -t 15"
const Msg_Exec_InstallSoftware string = "installsoftware"
const Msg_Exec_HideShowIcon string = "HideShowIcon"
const Msg_Exec_OpenAdminEXE string = "OpenAdmin"
const Msg_Exec_State_Request string = "request"
const Msg_Exec_State_Ack string = "ack"
const Msg_Exec_State_Over string = "over"
const Msg_Exec_TurnOffPC string = TurnOffPC
const Msg_Exec_TurnOffPC_cmd string = "shutdown -s -t 300"
const Msg_Exec_LogOffUser string = LogOutUser
const Msg_Exec_LogOffUser_cmd string = "shutdown -l"
const Msg_Exec_RebootWindows string = "rebootWindows"
const Msg_Exec_RebootWindows_cmd string = "shutdown -r -t 15"
const Msg_Exec_InstallSoftware string = "installsoftware"
const Msg_Exec_HideShowIcon string = "HideShowIcon"
const Msg_Exec_OpenAdminEXE string = "OpenAdmin"
// msg wkae type ////////////////////////////////////////////////////////////////
const Msg_Wake_Status_Req string = "WakeReq"
const Msg_Wake_Status_Over string = "WakeOver"
// wxwork event key ////////////////////////////////////////////////////////////////
const WXEK_zwDevopsPowerWake string = "zwdevops_power_wake"
const WXEK_zwDevopsPowerTurnOFF string = "zwdevops_power_turnoff"
const WXEK_zwDevopsPowerReboot string = "zwdevops_power_reboot"
const WXEK_zwDevopsPowerStatus string = "zwdevops_power_status"
const Msg_Wake_Status_Req string = "WakeReq"
const Msg_Wake_Status_Over string = "WakeOver"
// wxwork event key ////////////////////////////////////////////////////////////////
const WXEK_zwDevopsPowerWake string = "zwdevops_power_wake"
const WXEK_zwDevopsPowerTurnOFF string = "zwdevops_power_turnoff"
const WXEK_zwDevopsPowerReboot string = "zwdevops_power_reboot"
const WXEK_zwDevopsPowerStatus string = "zwdevops_power_status"
// Registry Root
const (
Msg_Reg_Query = iota
Msg_Reg_Query = iota
Msg_Reg_Read
)
......@@ -106,200 +84,177 @@ const (
//
// Basic Json Fromat ///////////////////////////////////////////////////////
type MJbase struct{
MsgType string `json:"msgtype"`
Status string `json:"status"`
Explain string `json:"explain"`
Username string `json:"username"`
Computername string `json:"computername"`
Timestamp int64 `json:"timestamp"`
DataBool bool `json:"databool"`
DataStr string `json:"datastr"`
Instruction string `json:"instruction"`
type MJbase struct {
MsgType string `json:"msgtype"`
Status string `json:"status"`
Explain string `json:"explain"`
Username string `json:"username"`
Computername string `json:"computername"`
Timestamp int64 `json:"timestamp"`
DataBool bool `json:"databool"`
DataStr string `json:"datastr"`
Instruction string `json:"instruction"`
Version string `json:"version"`
}
// report Json Format //////////////////////////////////////////////////////
type MJreport struct {
MJbase
Version string `json:"version"`
}
// Exec Json Fromat ///////////////////////////////////////////////////////
type MJexec struct {
MJbase
Command string `json:"command"`
SessionID string `json:"sessionid"`
IfDelay bool `josn:"ifDelay"`
IfMsg bool `josn:"ifMsg"`
Delay string `json:"delay"`
}
// backup Json Format /////////////////////////////////////////////////////
type MJbackup struct{
MJbase
Version string `json:"version"`
Command string `json:"command"`
SessionID string `json:"sessionid"`
IfDelay bool `josn:"ifDelay"`
IfMsg bool `josn:"ifMsg"`
Delay string `json:"delay"`
}
// wake Json Format /////////////////////////////////////////////////////
type MJwake struct {
MJbase
MACAddress string
MACAddress string
}
// error Json Format /////////////////////////////////////////////////////
type MJerror struct{
type MJerror struct {
MJbase
}
// wxwork Json Format /////////////////////////////////////////////////////
type MJwxwork struct {
Instruction string
UserID string
Name string
Result string
Content string
Instruction string
UserID string
Name string
Result string
Content string
}
//
//
// quickly Get & Set Json
// quickly Get & Set Json
//
// Report
func GJreport(s string) interface{}{
func GJreportString(s string, d string) interface{} {
var rep MJreport
rep.init(s)
rep.DataStr = d
return rep
}
func (rep * MJreport)Reg_Write_ADDC(key , value string){
Reg_Write_key_one(
Reg_Root_ac,
Reg_Path_home_ac + rep.Computername,
key,
value)
func GJreport(s string) interface{} {
var rep MJreport
rep.init(s)
return rep
}
func (rep * MJreport)Reg_Query_ADDC(key string) string{
return Reg_query_key_one(
Reg_Root_ac,
Reg_Path_home_ac + rep.Computername,
key)
func (rep *MJreport) Reg_Write_ADDC(key, value string) {
// Reg_Write_key_one(
// Reg_Root_ac,
// Reg_Path_home_ac+rep.Computername,
// key,
// value)
}
func (rep * MJreport)Pskill(cmd string){
Pskill(rep.Computername,cmd)
func (rep *MJreport) Reg_Query_ADDC(key string) {
// return Reg_query_key_one(
// Reg_Root_ac,
// Reg_Path_home_ac+rep.Computername,
// key)
}
func (rep * MJreport)init(Report string) {
rep.Username = User_name
rep.Computername = User_computername
rep.Timestamp = NowTimestamp()
rep.MsgType = Msg_Report
rep.Instruction = Report
rep.Version = Version
func (rep *MJreport) Pskill(cmd string) {
Pskill(rep.Computername, cmd)
}
func (rep *MJreport) init(Report string) {
rep.Username = User_name
rep.Computername = User_computername
rep.Status = Msg_status_commit
rep.MsgType = Msg_Report
rep.Instruction = Report
rep.Version = Version
}
// Exec
func GJexec(s string) MJexec{
func GJexec(s string) MJexec {
var exec MJexec
exec.Init(s)
return exec
}
func GJexecInstallSoftware(s string) interface{}{
func GJexecInstallSoftware(s string) interface{} {
var exec MJexec
exec.Init(s)
exec.Instruction = Msg_Exec_InstallSoftware
exec.Command = s
exec.Instruction = Msg_Exec_InstallSoftware
exec.Command = s
return exec
}
func GJexecDIYFlag(flag,command string) MJexec{
func GJexecDIYFlag(flag, command string) MJexec {
var exec MJexec
exec.Init(flag)
exec.Command = command
exec.Command = command
return exec
}
func (exec * MJexec)Init(s string){
exec.Username = User_name
exec.Computername = User_computername
exec.Timestamp = NowTimestamp()
exec.MsgType = Msg_Exec
exec.Instruction = s
exec.SessionID = User_sessionID
exec.Status = Msg_Exec_State_Request
exec.IfMsg = false
func (exec *MJexec) Init(s string) {
exec.Username = User_name
exec.Computername = User_computername
exec.MsgType = Msg_Exec
exec.Instruction = s
exec.SessionID = User_sessionID
exec.Status = Msg_Exec_State_Request
exec.IfMsg = false
}
func (exec * MJexec)PsExec(){
PsExec_sd(exec.Computername,exec.Command)
func (exec *MJexec) PsExec() {
PsExec_sd(exec.Computername, exec.Command)
}
// Backup
func GJbackup()interface{}{
var bak MJbackup
bak.init()
return bak
}
func (bak * MJbackup)init() {
bak.Timestamp = NowTimestamp()
bak.MsgType = Msg_Backup
bak.Version = Bak_Version
bak.Instruction = Msg_Backup_Status_Init
}
// wake
func GJwake(host,mac string) interface{} {
func GJwake(host, mac string) interface{} {
var wake MJwake
wake.MsgType = Msg_Wake
wake.MsgType = Msg_Wake
wake.Instruction = Msg_Wake_Status_Req
wake.Computername = host
wake.MACAddress = mac
wake.Instruction = Msg_Wake_Status_Req
wake.Computername = host
wake.MACAddress = mac
return wake
}
// error
func GJerror(e error)interface{}{
func GJerror(e error) interface{} {
var err MJerror
err.init(e)
return err
}
func (err * MJerror)init (e error){
err.Username = User_name
err.Timestamp = NowTimestamp()
err.Computername = User_computername
err.MsgType = Msg_Error
err.Instruction = e.Error()
func (err *MJerror) init(e error) {
err.Username = User_name
err.Computername = User_computername
err.MsgType = Msg_Error
err.Instruction = e.Error()
}
// wxwork
func (wxwork * MJwxwork)SendText(text string) {
SendWxworkTextToAUser(wxwork.UserID,text)
func (wxwork *MJwxwork) SendText(text string) {
SendWxworkTextToAUser(wxwork.UserID, text)
}
func (wxwork *MJwxwork) Reg_Query_ADUsers(key string) string {
// return Reg_query_key_one(
// Reg_Root_ac,
// Reg_Path_home_du+wxwork.Name,
// key)
return ""
}
func (wxwork * MJwxwork)Reg_Query_ADUsers(key string) string{
return Reg_query_key_one(
Reg_Root_ac,
Reg_Path_home_du + wxwork.Name,
key)
func (wxwork *MJwxwork) Reg_Query_ZhiWeiUsers(key string) string {
// return Reg_query_key_one(
// Reg_Root_ac,
// Reg_Path_home_zhu+wxwork.Name,
// key)
return ""
}
func (wxwork * MJwxwork)Reg_Query_ZhiWeiUsers(key string) string{
return Reg_query_key_one(
Reg_Root_ac,
Reg_Path_home_zhu + wxwork.Name,
key)
func (wxwork *MJwxwork) SendResult() {
SendWxworkTextToAUser(wxwork.UserID, wxwork.Result)
}
func (wxwork * MJwxwork)SendResult(){
SendWxworkTextToAUser(wxwork.UserID,wxwork.Result)
}
\ No newline at end of file
public/print.go deleted 100644 → 0
package public
import (
"log"
"os"
"fmt"
)
var Loger * log.Logger
func NewLoger(s string) * log.Logger{
var Log_file_obj * os.File
var err error
if Log_file_obj,err = os.OpenFile(
s,os.O_RDWR|os.O_CREATE|os.O_APPEND, 0766);
err !=nil && DomainComputer(){
PrintLog(fmt.Errorf("%s %v-%v",s,Error_Fail_File_Open,err))
}
return log.New(Log_file_obj,"",log.LstdFlags)
}
func Sprintf(f string,v ...interface{})string {
return fmt.Sprintf(f,v ...)
}
//
//
// Print Type
//
func PrintLog(v ...interface{}){
log.SetPrefix("Output ")
log.Println(v ...)
}
func PntInfo(v ...interface{}){
Loger.SetPrefix("Info ")
Loger.Println(v ...)
}
func PntInfof(f string,v ...interface{}){
Loger.SetPrefix("Info ")
Loger.Printf(f,v ...)
}
func PntReport(v ...interface{}){
Loger.SetPrefix("Report ")
Loger.Println(v ...)
}
func PntExec(v ...interface{}){
Loger.SetPrefix("Exec ")
Loger.Println(v ...)
}
func PntBackup(v ...interface{}){
Loger.SetPrefix("Bakcup ")
Loger.Println(v ...)
}
func PntError(v ...interface{}){
Loger.SetPrefix("Error ")
PrintLog(v ...)
Loger.Println(v ...)
}
func PntErrorf(f string,v ...interface{}){
Loger.SetPrefix("Error ")
PrintLog(v ...)
Loger.Printf(f,v ...)
}
func PntOth(v ...interface{}){
Loger.SetPrefix("Other ")
Loger.Println(v ...)
}
func PntWol(v ...interface{}){
Loger.SetPrefix("WOL ")
Loger.Println(v ...)
}
func PntWolRemote(v ...interface{}){
Loger.SetPrefix("WOLREMOTE ")
Loger.Println(v ...)
}
func PntSend(v ...interface{}){
Loger.SetPrefix("Send ")
Loger.Println(v ...)
}
func PntWXRec(v ...interface{}){
log.SetPrefix("WXRec ")
log.Println(v ...)
Loger.SetPrefix("WXRec ")
Loger.Println(v ...)
}
func PntWxSend(v ...interface{}){
Loger.SetPrefix("WxSend ")
Loger.Println(v ...)
log.SetPrefix("WxSend ")
log.Println(v ...)
}
public/public.go deleted 100644 → 0
package public
import (
"encoding/json"
"bytes"
)
// 获取 消息类型
func GetMsgType(b []byte)string{
//{"msgtype":"report","...":"..."}
// 提取第一个冒号后的第二位和第一个逗号的前一位
// 也就是msgtype的内容
return string(b[bytes.IndexByte(b,':')+2:bytes.IndexByte(b,',')-1])
}
// 解析Json 并放到变量中
func ParseJson(unmsg []byte,v interface{}){
// 填写
if err := json.Unmarshal(unmsg,v) ;err != nil{
PntError("Parse Json Error",err)
PntError("Parse Json Error",string(unmsg))
}
}
// Json 转 Byte
func ReParseJson(v * interface{}) []byte{
textbyte,err := json.Marshal(*v)
if err !=nil {
PntError("Json to byte Error ",v,err)
}
return textbyte
}
func AutoGetWeDriveDir() (string,error) {
for _,i := range Dir_WeDrive{
if NotExist(i){
continue
}
i += `\`
n := GetNewFolder(i,"Global")
f := i + n + `\WeDrive\知微数据`
if Exist(f){
return f,nil
}
}
return "",Error_Null_Folder_WeDrive
}
func AutoFillInWeDriveDir() {
if RunAsPC(User_name){Exit() }
d := Reg_Query_DC(Reg_Name_WeDriveDir)
if d == "" || NotExist(d){
if a,err := AutoGetWeDriveDir(); err != nil{
SendServerError(err)
} else {
Reg_Write_DC(Reg_Name_WeDriveDir,a)
}
}
}
public/send.go
package public
import (
"encoding/json"
"net/http"
"io/ioutil"
"bytes"
"encoding/json"
"fmt"
"io/ioutil"
"net"
"net/http"
)
func SendServerReport(s string) {
SendADMsg(Msg_Report,GJreport(s))
SendADMsg(Msg_Report, GJreport(s))
}
func SendServerExec(v interface{}) {
SendADMsg(Msg_Exec,v)
SendADMsg(Msg_Exec, v)
}
func SendServerError(err error) {
SendADMsg(Msg_Error,GJerror(err))
SendADMsg(Msg_Error, GJerror(err))
}
// base server msg
func SendADMsg(msgtype string ,v interface{}){
SendMsg(ADServerDaemon,msgtype,v)
func SendADMsg(msgtype string, v interface{}) {
SendMsg(ADServerDaemon, msgtype, v)
}
func SendTHMsg(msgtype string ,v interface{}){
SendMsg(THServerDaemon,msgtype,v)
func SendTHMsg(msgtype string, v interface{}) {
SendMsg(THServerDaemon, msgtype, v)
}
// base msg
func SendMsg(server,msgtype string ,v interface{}) {
func SendMsg(server, msgtype string, v interface{}) {
//将结构体 转化成 byte
textbyte,err := json.Marshal(v)
if err !=nil {
PntError("Json to String Error ",v,err)
// 将结构体 转化成 byte
textbyte, err := json.Marshal(v)
if err != nil {
LOG(ERROR, "Json to byte Error", fmt.Sprintf("%v %v", err, v))
}
link := fmt.Sprintf("http://%s/%s",server,msgtype)
PntSend(link,string(textbyte))
//发送数据
link := fmt.Sprintf("http://%s/%s", server, msgtype)
// 发送数据
resp, err := http.Post(
link,
"application/json; charset=utf-8",
bytes.NewReader(textbyte))
if err != nil {
PntError(err)
LOG(ERROR, NULL, err)
}
defer resp.Body.Close()
// 读取数据
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
PntError(err)
LOG(ERROR, NULL, err)
}
// 处理数据
DealMsg(GetMsgType(body),"",body)
if len(body) > 0 {
DealMsg(GetMsgType(body), "", body)
}
}
func SendLog(message string) {
conn, err := net.Dial("udp", ADServerLogDaemon)
if err != nil {
SendWxworkTextToAdmins(fmt.Sprintf("主机名:%s\n错误:%s\n发送数据%s", User_computername, err.Error(), message))
}
defer conn.Close()
if _, err := conn.Write([]byte(message)); err != nil {
SendWxworkTextToAdmins(fmt.Sprintf("主机名:%s\n错误:%s\n发送数据%s", User_computername, err.Error(), message))
}
// lineLen := len(message)
// n := 0
// for written := 0; written < lineLen; written += n {
// // 消息长度
// // if lineLen-written > config.SERVER_RECV_LEN {
// // toWrite = line[written : written+config.SERVER_RECV_LEN]
// // } else {
// // toWrite = line[written:]
// // }
// }
}
// 发送Get请求
func SendGetRequest(link * string) ([]byte,error){
func SendGetRequest(link *string) ([]byte, error) {
resp, err := http.Get(*link)
if err != nil {
return nil,err
return nil, err
}
defer resp.Body.Close()
body, err := ioutil.ReadAll(resp.Body)
return body,err
return body, err
}
// 发送 带Data的Post请求
func SendPostRequestWithData(link * string,data interface {}) ([]byte,error){
func SendPostRequestWithData(link *string, data interface{}) ([]byte, error) {
resp, err := http.Post(
*link,
"application/json; charset=utf-8",
bytes.NewReader(ReParseJson(&data)))
if err != nil {
return nil,err
return nil, err
}
defer resp.Body.Close()
body, err := ioutil.ReadAll(resp.Body)
return body,err
return body, err
}
// 发送 到 微信机器人
func SendWX(Content string){
func SendWX(Content string) {
if Adserver() {
if GetEnv("sendwx")!="1"{return}
if GetEnv("sendwx") != "1" {
return
}
}
// Content不支持发送Json，
w := []byte(`
{
"msgtype": "text",
"text": {
"content": "`+Content+`"
"content": "` + Content + `"
}
}`)
http.Post(Link_WxworkBot,"application/json; charset=utf-8",bytes.NewBuffer(w))
http.Post(Link_WxworkBot, "application/json; charset=utf-8", bytes.NewBuffer(w))
}
func SendWxworkTextToAUser(id,text string) error{
func SendWxworkTextToAUser(id, text string) error {
// 获取 最新 token
t,err := GetWXWorkToken()
if err !=nil{
t, err := GetWXWorkToken()
if err != nil {
return err
}
// 初始化 消息推送 结构体
var wsmt WxSendMsgText
wsmt.Init()
wsmt.Touser=id
wsmt.Text.Content=text
link:=fmt.Sprintf("https://qyapi.weixin.qq.com/cgi-bin/message/send?access_token=%s",t)
wsmt.Touser = id
wsmt.Text.Content = text
link := fmt.Sprintf("https://qyapi.weixin.qq.com/cgi-bin/message/send?access_token=%s", t)
// 发送 Post 请求
res,err := SendPostRequestWithData(&link,&wsmt)
if err !=nil {
res, err := SendPostRequestWithData(&link, &wsmt)
if err != nil {
return err
}
// 解析 Post 响应 数据
var wsmr WxSendMsgRec
ParseJson(res,&wsmr)
if wsmr.ErrCode != 0{
return NewError(wsmr.ErrMsg)
ParseJson(res, &wsmr)
if wsmr.ErrCode != 0 {
return fmt.Errorf("%s", wsmr.ErrMsg)
}
return nil
}
func SendWxworkTextToAUserWithName(name ,id,text string) error{
PntWxSend(name,text)
return SendWxworkTextToAUser(id,text)
func SendWxworkTextToAdmins(text string) error {
return SendWxworkTextToAUser("TaoTengFei", text)
}
public/string.go 0 → 100644
package public
import (
"strings"
)
var punctuationMap = map[rune]rune{
8216: 39, // '
8217: 39, // '
8220: 34, // "
8221: 34, // "
12290: 46, // .
12304: 91, // [
12305: 93, // ]
65281: 33, // !
65288: 40, // (
65289: 41, // )
65292: 44, // ,
65306: 58, // :
65307: 59, // ;
65311: 63, // ?
}
func ToEnglishSymbol(text string) string {
text = strings.Map(func(r rune) rune {
if v, ok := punctuationMap[r]; ok {
return v
}
return r
}, text)
return text
}
public/time.go
package public
import (
"time"
"math/rand"
"time"
)
//
//
// time func
......@@ -15,27 +14,34 @@ import (
func NowTimestamp() int64 {
return time.Now().Unix()
}
func NowTimestampNano() int64 {
return time.Now().UnixNano()
}
// 将时间戳解析成字符串
func UnixTimeParse(t *int64) string {
return time.Unix(*t,0).String()
return time.Unix(*t, 0).String()
}
// 获取 字符串格式化 时间
func GetStrTime() string{
return time.Now().String()
func GetNowTimeString() string {
return time.Now().Format("2006-01-02 15:04:05 Monday")
}
// 输出当前小时
func GetHour() int{
func GetHour() int {
return time.Now().Hour()
}
// 输出当前小时
func GetDateHour() (int,int) {
t:=time.Now()
_,_,d := t.Date()
h,_,_ := t.Clock()
return d,h
func GetDateHour() (int, int) {
t := time.Now()
_, _, d := t.Date()
h, _, _ := t.Clock()
return d, h
}
func ParseTime(s string) (time.Time,error) {
return time.Parse("2006-01-02 15:04:05.999999999 -0700 MST",s)
func ParseTime(s string) (time.Time, error) {
return time.Parse("2006-01-02 15:04:05 Monday", s)
}
//
......@@ -44,16 +50,18 @@ func ParseTime(s string) (time.Time,error) {
//
// 返回 随机数
func Rand(i * int)int{
func Rand(i *int) int {
rand.Seed(time.Now().UnixNano())
return rand.Intn(*i)
}
// 程序挂起 i 秒
func Delay(i int){
<-time.After(time.Duration(i)*time.Second)
func Delay(i int) {
<-time.After(time.Duration(i) * time.Second)
}
// 随机挂起 x 秒
func RandDelay(i int){
func RandDelay(i int) {
ri := Rand(&i)
time.Sleep(time.Duration(ri) * time.Second)
}
public/user.go
package public
import(
import (
"fmt"
"strings"
)
//
//
// AD User env //
//
const AD_User_main_admin string = "zhiweiadserver"
const AD_User_tengfei string = "tengfei"
const AD_User_taotengfei string = "taotengfei"
const AD_User_zhiwei string = "zhiwei@zhiweireach.com"
const AD_User_main_admin string = "zhiweiadserver"
const AD_User_tengfei string = "tengfei"
const AD_User_taotengfei string = "taotengfei"
const AD_User_zhiwei string = "zhiwei@zhiweireach.com"
//
//
// User
// User
//
func GetPrimaryUser(pc string) string {
name := Reg_query_key_one(
Reg_Root_ac,
Reg_Path_home_ac + pc,
Reg_Name_PrimaryUser)
PntInfo(pc,name)
return name
// coding
// LOG(INFO, "GetPrimaryUser", fmt.Sprintf("pc:%s,name:%s", pc, name))
return ""
}
func IsPrimaryUser(s string) bool{
if strings.Index(s,"zhiwei") == -1{
func IsPrimaryUser(s string) bool {
if strings.Index(s, "zhiwei") == -1 {
return true
}
return false
}
func AdminUser( user * string )bool{
switch *user{
func AdminUser(user *string) bool {
switch *user {
case AD_User_taotengfei:
return true
case AD_User_tengfei:
......@@ -45,49 +42,57 @@ func AdminUser( user * string )bool{
}
return false
}
func TheUser(s string)bool{
if s == User_name || AdminUser(&s) { return true}
return false
}
func RunAsUser(s string)bool{
if s[len(s)-1] != '$' {
return true
} else {
return false
}
}
func RunAsPC(s string)bool{
if s[len(s)-1] == '$' {
func PublicUser() bool {
if strings.Index(User_name_display, "专用账户") != -1 {
return true
} else {
return false
}
return false
}
//
//
// If computer
// If computer
//
func DomainComputer() bool{
if Host_adserver != User_computername {return true}
return false
func DomainComputer() bool {
return !DomainCotroller()
}
func Adserver() bool{
if Host_adserver == User_computername {return true}
func Adserver() bool {
if Host_adserver == User_computername {
return true
}
return false
}
func BeSecNetwork(hostname * string) bool{
func DomainCotroller() bool {
var r bool
switch User_computername {
case Host_adserver:
r = true
case Host_thserver:
r = true
case Host_zzserver:
r = true
}
return r
}
func BeSecNetwork(hostname *string) bool {
//自动转大写
*hostname = strings.ToUpper(*hostname)
//京东和HB组报告研究中心组，是第二个网络
if strings.HasPrefix(*hostname,"HB") || strings.HasPrefix(*hostname,"JD") || strings.HasPrefix(*hostname,"BGYJZX"){
if strings.HasPrefix(*hostname, "HB") || strings.HasPrefix(*hostname, "JD") || strings.HasPrefix(*hostname, "BGYJZX") {
return true
}
return false
}
\ No newline at end of file
}
func GetHostnamePart(hostname string) ([]string, error) {
n := strings.Split(strings.ToUpper(hostname), SymbolHostname)
if len(n) != 4 {
return nil, fmt.Errorf("错误的主机格式:%s", hostname)
}
return n, nil
}
public/win.go
package public
import(
"os"
import (
"fmt"
"io"
"io/ioutil"
"os"
"os/exec"
"github.com/lxn/walk"
"strconv"
"strings"
"io/ioutil"
"github.com/golang/sys/windows/registry"
"github.com/lxn/walk"
"golang.org/x/sys/windows/registry"
"golang.org/x/text/encoding/simplifiedchinese"
)
//
//
// Get Env
//
// 获取环境变量
func GetEnv(e string) string{
func GetEnv(e string) string {
return os.Getenv(e)
}
// 获取fqdn
func GetEnvFqdn(s string)string{
cmd,err := exec.Command("whoami","/fqdn").Output()
if err !=nil {
PntError(err)
func GetEnvFqdn(s string) string {
cmd, err := exec.Command("whoami", "/fqdn").Output()
if err != nil {
LOG(ERROR, NULL, err)
}
out,err := simplifiedchinese.GBK.NewDecoder().Bytes(cmd)
if err !=nil {
PntError(err)
out, err := simplifiedchinese.GBK.NewDecoder().Bytes(cmd)
if err != nil {
LOG(ERROR, NULL, err)
}
for _,each := range strings.Split(string(out),","){
if strings.Index(each,s) != -1{
return each[3:]
for _, each := range strings.Split(string(out), ",") {
if strings.Index(each, s) != -1 {
return each[3:]
}
}
return ""
}
//
//
// local exec
//
func execcmd_base(cmdargs string) (string,[]string,error){
func execcmd_base(cmdargs string) (string, []string, error) {
if cmdargs == "" {
return "",nil,Error_Null_Command
return "", nil, Error_Null_Command
}
var app string
var appargs []string
spaceindex:=strings.Index(cmdargs," ")
if spaceindex != -1{
app = cmdargs[:spaceindex]
appargs = strings.Split(cmdargs[spaceindex+1:]," ")
}else{
app = cmdargs
appargs[0] = ""
spaceindex := strings.Index(cmdargs, " ")
if spaceindex != -1 {
app = cmdargs[:spaceindex]
appargs = strings.Split(cmdargs[spaceindex+1:], " ")
} else {
app = cmdargs
appargs[0] = ""
}
PntInfo(app,appargs)
return app,appargs,nil
LOG(INFO, "CMD", cmdargs)
return app, appargs, nil
}
func Execcmd_nowait(cmdargs string){
app,appargs,err :=execcmd_base(cmdargs)
if err !=nil{
PntError(err)
return
func Execcmd_nowait(cmdargs string) {
app, appargs, err := execcmd_base(cmdargs)
if err != nil {
LOG(ERROR, NULL, err)
return
}
if err := exec.Command(app,appargs...).Start();err !=nil {
PntError(err)
if err := exec.Command(app, appargs...).Start(); err != nil {
LOG(ERROR, NULL, err)
}
}
func Execcmd_copy(source,target string){
cmd := exec.Command("cmd", "/k", "copy","/y",`"`+source+`"` ,`"`+target+`"`)
if err := cmd.Start();err !=nil {
PntError(err)
}
if err := cmd.Wait() ;err !=nil{
PntError("Command finished with error: ",err)
func Execcmd_copy(source, target string) {
cmd := exec.Command("cmd", "/k", "copy", "/y", `"`+source+`"`, `"`+target+`"`)
if err := cmd.Start(); err != nil {
LOG(ERROR, "cmd_start", err)
}
if err := cmd.Wait(); err != nil {
LOG(ERROR, "cmd_wait", err)
}
}
func Execcmd_wait(cmdargs string){
app,appargs,err :=execcmd_base(cmdargs)
if err !=nil{
PntError(err)
func Execcmd_wait(cmdargs string) {
app, appargs, err := execcmd_base(cmdargs)
if err != nil {
LOG(ERROR, NULL, err)
return
}
cmd := exec.Command(app,appargs...)
cmd := exec.Command(app, appargs...)
if err := cmd.Start(); err != nil {
PntError(err)
LOG(ERROR, NULL, err)
}
err = cmd.Wait()
if err !=nil{
PntError(err)
if err != nil {
LOG(ERROR, NULL, err)
}
}
func Execcmd_output(cmdargs string)[]byte{
app,appargs,err :=execcmd_base(cmdargs)
if err !=nil{
PntError(err)
func Execcmd_output(cmdargs string) []byte {
app, appargs, err := execcmd_base(cmdargs)
if err != nil {
LOG(ERROR, "execcmd_base", err)
return nil
}
if out,err2 := exec.Command(app,appargs...).CombinedOutput();err2 !=nil {
PntError(err2)
}else{
if out, err2 := exec.Command(app, appargs...).CombinedOutput(); err2 != nil {
LOG(ERROR, "CombinedOutput", err2)
} else {
return out
}
return nil
}
func Execcmd_wait_noargs(app string){
func Execcmd_wait_noargs(app string) {
cmd := exec.Command(app)
if err := cmd.Start(); err != nil {
PntError(err)
LOG(ERROR, NULL, err)
}
if err := cmd.Wait();err !=nil{
PntError(err)
if err := cmd.Wait(); err != nil {
LOG(ERROR, NULL, err)
}
}
func Execcmd_nowait_noargs(app string){
if err := exec.Command(app).Start(); err != nil {
PntError(err)
func Execcmd_nowait_noargs(app string) {
if err := exec.Command(app).Start(); err != nil {
LOG(ERROR, NULL, err)
}
}
//
//
// PowerShell
//
func PSCommandOutput(cmd string) (string,error) {
func PSCommandOutput(cmd string) (string, error) {
if cmd == "" {
return "",Error_Lost_Parameter
return "", Error_Lost_Parameter
}
cmd = "powershell -command "+cmd
app,appargs,err := execcmd_base(cmd)
if err !=nil{
return "",err
cmd = "powershell -command " + cmd
app, appargs, err := execcmd_base(cmd)
if err != nil {
return "", err
}
r,err := exec.Command(app,appargs...).Output()
if err !=nil {
return "",err
r, err := exec.Command(app, appargs...).Output()
if err != nil {
return "", err
}
out,err := simplifiedchinese.GBK.NewDecoder().Bytes(r)
if err !=nil {
return "",err
out, err := simplifiedchinese.GBK.NewDecoder().Bytes(r)
if err != nil {
return "", err
}
return string(out),nil
return string(out), nil
}
func PSCommandOutputNoSplit(cmd string) (string,error) {
if cmd == "" {
return "",Error_Lost_Parameter
func PSCommandOutputNoSplit(cmd string) (string, error) {
cmd = "powershell -command " + cmd
app, appargs, err := execcmd_base(cmd)
if err != nil {
return "", err
}
r,err := exec.Command("powershell","-command",cmd).Output()
if err !=nil {
return "",err
out, err := exec.Command(app, appargs...).Output()
if err != nil {
return "", err
}
return string(r),nil
return string(out), nil
}
func PSTest_Connection(host string) (bool,error) {
func PSTest_Connection(host string) (bool, error) {
if host == "" {
return false,Error_Lost_Parameter
return false, Error_Lost_Parameter
}
t,err := exec.Command("powershell","-command","Test-Connection",host,"-quiet").Output()
if err !=nil {
return false,err
t, err := exec.Command("powershell", "-command", "Test-Connection", host, "-quiet").Output()
if err != nil {
return false, err
}
switch string(t[:len(t)-2]) {
case "True":
return true,nil
return true, nil
default:
return false,nil
return false, nil
}
}
// local
//
//
// local
//
func ChooseFile(explain , initDir string) string {
func ChooseFile(explain, initDir string) string {
fg := new(walk.FileDialog)
fg.Title = explain
fg.InitialDirPath = initDir
fg.ShowOpen(*new(walk.Form))
return fg.FilePath
}
func ChooseFolder(explain , initDir string) string {
func ChooseFolder(explain, initDir string) string {
fg := new(walk.FileDialog)
fg.Title = explain
fg.InitialDirPath = initDir
fg.ShowBrowseFolder(*new(walk.Form))
return fg.FilePath
}
func OpenWindow(s string){
Execcmd_nowait("explorer "+s)
func OpenWindow(s string) {
Execcmd_nowait("explorer " + s)
}
//
//
// remote exec
//
// 以管理员，立刻返回
func PsExec_sd(pc ,cmd string) {
psExecCommand := `psexec \\` + pc + " -s -d "+cmd
func PsExec_sd(pc, cmd string) {
psExecCommand := `psexec \\` + pc + " -s -d " + cmd
Execcmd_nowait(psExecCommand)
}
// 以管理员，立刻返回，指定会话，执行远程程序
func PsExec_sdi(pc ,cmd ,sessionid string) {
psExecCommand := `psexec \\` + pc + " -s -d -i "+sessionid +" "+cmd
func PsExec_sdi(pc, cmd, sessionid string) {
psExecCommand := `psexec \\` + pc + " -s -d -i " + sessionid + " " + cmd
Execcmd_nowait(psExecCommand)
}
// 以管理员，立刻返回，指定会话，发送本地程序要远程主机，再执行
func PsExec_sdic(pc ,cmd ,sessionid string) {
psExecCommand := `psexec \\` + pc + " -s -d -i "+sessionid + " -c "+cmd
func PsExec_sdic(pc, cmd, sessionid string) {
psExecCommand := `psexec \\` + pc + " -s -d -i " + sessionid + " -c " + cmd
Execcmd_nowait(psExecCommand)
}
// 以管理员，立刻返回，指定会话，（即使文件存在）发送本地程序要远程主机，再执行
func PsExec_sfdic(pc ,cmd ,sessionid string) {
psExecCommand := `psexec \\` + pc + " -s -f -d -i "+sessionid + " -c "+cmd
func PsExec_sfdic(pc, cmd, sessionid string) {
psExecCommand := `psexec \\` + pc + " -s -f -d -i " + sessionid + " -c " + cmd
Execcmd_nowait(psExecCommand)
}
// 以管理员，立刻返回
func Pskill(pc ,cmd string) {
psExecCommand := `pskill \\` + pc + " "+cmd
func Pskill(pc, cmd string) {
psExecCommand := `pskill \\` + pc + " " + cmd
Execcmd_nowait(psExecCommand)
}
//
//
// msg show
//
// UI：显示带确定的消息框
func Msg(message string) {
walk.MsgBox(*new(walk.Form), "提示", message, walk.MsgBoxIconInformation)
// 显示带确定的消息框
func Msg(message string) {
walk.MsgBox(*new(walk.Form), "提示", message, walk.MsgBoxIconInformation)
}
// UI:显示带确定和取消的消息框
// 点击确定按钮：返回1，
// 点击取消按钮：返回2
func Msg_YesNo(message string) int {
return walk.MsgBox(*new(walk.Form), "提示", message, walk.MsgBoxOKCancel)
func Msg_YesNo(message string) int {
return walk.MsgBox(*new(walk.Form), "提示", message, walk.MsgBoxOKCancel)
}
// 调用外部命令的MsgBox
func MsgBox(message string){
Execcmd_nowait("msg * /TIME:60 "+ message)
func MsgBox(message string) {
Execcmd_nowait("msg * /TIME:60 " + message)
}
// 提示并关机
func MsgShutdown(msg string) {
go Msg(msg)
Execcmd_nowait(Msg_Exec_TurnOffPC_cmd)
}
// 调用外部命令的指定计算机的消息的MsgBox
func SysMsgBox(pc,message string){
Execcmd_nowait("msg * /SERVER:"+pc+" /TIME:60 "+ message)
func SysMsgBox(pc, message string) {
Execcmd_nowait("msg * /SERVER:" + pc + " /TIME:60 " + message)
}
// 高级UI提示消息
func MsgAdvUI(ni *walk.NotifyIcon, message string) {
if err := ni.ShowCustom(
"提示",
message, nil); err != nil {
LOG(ERROR, NULL, err)
}
}
//
//
// regedit base
//
// regedit
func reg_prase(root * int) registry.Key{
switch *root{
func reg_prase(root *int) registry.Key {
switch *root {
case HKCU:
return registry.CURRENT_USER
case HKU:
......@@ -282,132 +281,111 @@ func reg_prase(root * int) registry.Key{
}
return registry.LOCAL_MACHINE
}
func Reg_Exist_item(root int,path string ) {
//_,exist,err :=
registry.CreateKey(reg_prase(&root),path,registry.ALL_ACCESS)
func Reg_Exist_item(root int, path string) {
//_,exist,err :=
registry.CreateKey(reg_prase(&root), path, registry.ALL_ACCESS)
}
func Reg_query_item_one(root int ,path string) string {
if k, kerr := registry.OpenKey(reg_prase(&root),path, registry.READ);kerr==nil{
func Reg_IfExist_item(root int, path string) error {
k, err := registry.OpenKey(reg_prase(&root), path, registry.READ)
defer k.Close()
return err
}
func Reg_query_item_one(root int, path string) string {
if k, kerr := registry.OpenKey(reg_prase(&root), path, registry.READ); kerr == nil {
defer k.Close()
if sk,err := k.ReadSubKeyNames(1); err ==nil{
if sk, err := k.ReadSubKeyNames(1); err == nil {
return sk[0]
} else{
} else {
return ""
}
} else {
return ""
}
}
func Reg_query_list(root int ,path string) ([]string,error) {
if k, kerr := registry.OpenKey(reg_prase(&root),path, registry.READ);kerr==nil{
func Reg_query_list(root int, path string) ([]string, error) {
if k, kerr := registry.OpenKey(reg_prase(&root), path, registry.READ); kerr == nil {
defer k.Close()
if sk,err := k.ReadSubKeyNames(0); err ==nil{
return sk,nil
} else{
return nil,Error_Null_Reg_Query
if sk, err := k.ReadSubKeyNames(0); err == nil {
return sk, nil
} else {
return nil, Error_Null_Reg_Query
}
} else {
return nil,Error_Null_Reg_Query
return nil, Error_Null_Reg_Query
}
}
func Reg_IfExist_item(root int ,path string) error {
k,err := registry.OpenKey(reg_prase(&root),path, registry.READ)
defer k.Close()
return err
}
func Reg_query_item(root int ,path string) []string {
if k, kerr := registry.OpenKey(reg_prase(&root),path, registry.READ);kerr==nil{
func Reg_query_item(root int, path string) []string {
if k, kerr := registry.OpenKey(reg_prase(&root), path, registry.READ); kerr == nil {
defer k.Close()
if sk,err := k.ReadSubKeyNames(0); err ==nil{
if sk, err := k.ReadSubKeyNames(0); err == nil {
return sk
} else{
} else {
return nil
}
} else {
return nil
}
}
func Reg_query_key_one(root int, path, key string) string {
if k, kerr := registry.OpenKey(reg_prase(&root),path, registry.READ);kerr==nil{
func reg_query_key_one(root int, path, key string) string {
if k, kerr := registry.OpenKey(reg_prase(&root), path, registry.READ); kerr == nil {
defer k.Close()
if sk,_,err := k.GetStringValue(key); err ==nil{
if sk, _, err := k.GetStringValue(key); err == nil {
return sk
} else{
} else {
return ""
}
} else {
return ""
}
}
func Reg_Write_key_one(root int, path, name, value string) {
if k, kerr := registry.OpenKey(reg_prase(&root),path, registry.WRITE);kerr==nil{
func reg_Write_key_one(root int, path, name, value string) {
if k, kerr := registry.OpenKey(reg_prase(&root), path, registry.WRITE); kerr == nil {
defer k.Close()
k.SetStringValue(name, value)
}
}
//
//
// reg func for domain computer
//
func Reg_Write_DC( key, value string){
Reg_Write_key_one(
Reg_Root_dc,
Reg_Path_home,
key,
value)
func Reg_Write_DC(key, value string) {
reg_Write_key_one(HKLM, reg_LM_ADCONTROL, key, value)
}
func Reg_Query_DC(key string) string {
return Reg_query_key_one(
Reg_Root_dc,
Reg_Path_home,
key)
return reg_query_key_one(HKLM, reg_LM_ADCONTROL, key)
}
//
//
// reg func for AD
//
func Reg_Query_ADPC(pc ,key string)string {
return Reg_query_key_one(
Reg_Root_ac,
Reg_Path_home_ac + pc,
key)
func Reg_Query_ADPC(pc, key string) string {
// coding
return ""
}
func Reg_Write_ADDC(pc,key, value string){
Reg_Write_key_one(
Reg_Root_ac,
Reg_Path_home_ac + pc,
key,
value)
func Reg_Write_ADDC(pc, key, value string) {
// coding
}
func Reg_Query_ADUsers(name ,key string)string {
return Reg_query_key_one(
Reg_Root_ac,
Reg_Path_home_du + name,
key)
func Reg_Query_ADUsers(name, key string) string {
// coding
return ""
}
//
//
// File operate
//
// 存在文件
func Exist(path string) bool {
_, err := os.Stat(path) // os.Stat获取文件信息
_, err := os.Stat(path) // os.Stat获取文件信息
return !os.IsNotExist(err)
return !os.IsNotExist(err)
}
// 不存在文件
func NotExist(path string) bool {
_, err := os.Stat(path) //os.Stat获取文件信息
_, err := os.Stat(path) //os.Stat获取文件信息
return os.IsNotExist(err)
}
// 是否为文件夹
func IsDir(path string) bool {
s, err := os.Stat(path)
......@@ -416,6 +394,7 @@ func IsDir(path string) bool {
}
return s.IsDir()
}
// 是否为文件
func IsFile(path string) bool {
return !IsDir(path)
......@@ -425,16 +404,16 @@ func CopyFile(dstFileName string, srcFileName string) (written int64, err error)
srcFile, err := os.Open(srcFileName)
if err != nil {
PntErrorf("open file err = %v\n", err)
LOG(ERROR, NULL, fmt.Sprintf("open file err = %v\n", err))
return
}
defer srcFile.Close()
// dstFile, err := os.OpenFile(dstFileName, os.O_WRONLY | os.O_CREATE, 0755)
dstFile, err := os.OpenFile(dstFileName, os.O_WRONLY | os.O_CREATE | os.O_TRUNC, 0755)
dstFile, err := os.OpenFile(dstFileName, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0755)
if err != nil {
PntErrorf("open file err = %v\n", err)
LOG(ERROR, NULL, fmt.Sprintf("open file err = %v\n", err))
return
}
......@@ -443,46 +422,46 @@ func CopyFile(dstFileName string, srcFileName string) (written int64, err error)
return io.Copy(dstFile, srcFile)
}
func RemoveFile(name string)error{
func RemoveFile(name string) error {
return os.Remove(name)
}
//
//
// Folder operate
//
// 创建文件夹
func Mkdir(dir string){
os.Mkdir(dir,os.ModeSetuid)
func mkdir(dir string) {
os.Mkdir(dir, os.ModeSetuid)
}
func MkdirAll(dir string) error {
return os.MkdirAll(dir,os.ModeSetuid)
return os.MkdirAll(dir, os.ModeSetuid)
}
func ExistFolder(dir string){
if NotExist(dir) { Mkdir(dir) }
func ExistFolder(dir string) {
if NotExist(dir) {
mkdir(dir)
}
}
// 读取文件夹目录
func ReadDir(s string) ([]os.FileInfo,error){
f,err := ioutil.ReadDir(s)
return f,err
func ReadDir(s string) ([]os.FileInfo, error) {
f, err := ioutil.ReadDir(s)
return f, err
}
// 获取最新修改的文件夹
func GetNewFolder(rdir ,extdir string) string {
f,err := ioutil.ReadDir(rdir)
if err !=nil{
PntError(err)
}
firstModTime := f[0].ModTime()
firstName := f[0].Name()
for _,i := range f{
func GetNewFolder(rdir, extdir string) string {
f, err := ioutil.ReadDir(rdir)
if err != nil {
LOG(ERROR, NULL, err)
}
firstModTime := f[0].ModTime()
firstName := f[0].Name()
for _, i := range f {
fileModTime := i.ModTime()
filename := i.Name()
if i.IsDir() && i.Name() != extdir{
if firstModTime.Before(fileModTime){
firstModTime = fileModTime
firstName = filename
filename := i.Name()
if i.IsDir() && i.Name() != extdir {
if firstModTime.Before(fileModTime) {
firstModTime = fileModTime
firstName = filename
}
}
......@@ -490,19 +469,167 @@ func GetNewFolder(rdir ,extdir string) string {
return firstName
}
//
//
// application
//
func Exit(){
// application
func Exit() {
os.Exit(1)
}
func ExitNormal(){
func ExitNormal() {
os.Exit(0)
}
func MsgShutdown(msg string){
go Msg(msg)
Execcmd_nowait(Msg_Exec_TurnOffPC_cmd)
PntInfo(Msg_Exec_TurnOffPC_cmd)
}
\ No newline at end of file
// 获取硬件信息
func getHardwareCPUForPS() (string, string, string, string) {
var c, j int
var cpuCount, cpuName, cpuCores, cpuLogicalProcessors string
cpuUN, _ := PSCommandOutputNoSplit("Get-WmiObject -Class Win32_Processor | select Name,NumberOfCores,NumberOfLogicalProcessors | format-list")
for _, line := range strings.Split(cpuUN, "\n") {
if strings.Index(line, "Name") != -1 {
mi := strings.TrimSpace(strings.Split(line, ":")[1])
cpuName = mi
c++
} else if strings.Index(line, "NumberOfCores") != -1 {
mi := strings.TrimSpace(strings.Split(line, ":")[1])
cpuCores = mi
c++
} else if strings.Index(line, "NumberOfLogicalProcessors") != -1 {
mi := strings.TrimSpace(strings.Split(line, ":")[1])
cpuLogicalProcessors = mi
c++
}
if c == 3 {
c = 0
j++
}
cpuCount = strconv.Itoa(j)
}
return cpuCount, cpuName, cpuCores, cpuLogicalProcessors
}
func getHardwareMemoryForPS() ([]int, []string, []string, int) {
Capacity := make([]int, 2)
Speed := make([]string, 2)
MemoryType := make([]string, 2)
var c, j int
menUN, _ := PSCommandOutputNoSplit("Get-WmiObject -Class Win32_PhysicalMemory -Property Capacity,Speed,MemoryType")
for _, line := range strings.Split(menUN, "\n") {
if strings.Index(line, "Capacity") != -1 {
mi := strings.TrimSpace(strings.Split(line, ":")[1])
m, _ := strconv.ParseInt(mi, 10, 64)
if j >= 2 {
Capacity = append(Capacity, int(m/1024/1024/1024))
} else {
Capacity[j] = int(m / 1024 / 1024 / 1024)
}
c++
} else if strings.Index(line, "Speed") != -1 {
m := strings.TrimSpace(strings.Split(line, ":")[1])
if j >= 2 {
Speed = append(Speed, m)
} else {
Speed[j] = m
}
c++
} else if strings.Index(line, "MemoryType") != -1 {
m := strings.TrimSpace(strings.Split(line, ":")[1])
switch m {
case "21":
m = "DDR2"
case "22":
m = "DDR2 FB-DIMM"
case "24":
m = "DDR3"
case "26":
m = "DDR4"
default:
m = ""
}
if j >= 2 {
MemoryType = append(MemoryType, m)
} else {
MemoryType[j] = m
}
}
if c == 2 {
j++
c = 0
}
}
return Capacity, Speed, MemoryType, j - 1
}
func getHardwareHardDiskForPS(mini bool) ([]string, []int64, []string, int) {
MediaType := make([]string, 2)
FriendlyName := make([]string, 2)
Sizen := make([]int64, 2)
var c, j int
diskUN, _ := PSCommandOutputNoSplit("Get-PhysicalDisk |select mediaType,FriendlyName,Size | format-list")
for _, line := range strings.Split(diskUN, "\n") {
if strings.Index(line, "MediaType") != -1 {
m := strings.TrimSpace(strings.Split(line, ":")[1])
// 如果是小白
if mini {
switch m {
case "SSD":
m = "固态硬盘"
case "HDD":
m = "机械硬盘"
}
}
if j >= 2 {
MediaType = append(MediaType, m)
} else {
MediaType[j] = m
}
c++
} else if strings.Index(line, "FriendlyName") != -1 {
m := strings.TrimSpace(strings.Split(line, ":")[1])
if j >= 2 {
FriendlyName = append(FriendlyName, m)
} else {
FriendlyName[j] = m
}
c++
} else if strings.Index(line, "Size") != -1 {
Size := strings.TrimSpace(strings.Split(line, ":")[1])
Sizei, _ := strconv.ParseInt(Size, 10, 64)
m := Sizei / 1024 / 1024 / 1024
if j >= 2 {
Sizen = append(Sizen, m)
} else {
Sizen[j] = m
}
c++
}
if c == 3 {
j++
c = 0
}
}
return FriendlyName, Sizen, MediaType, j - 1
}
// 从nslookup中获取IP
func GetIPFromNslookup() string {
cmd := fmt.Sprintf("(Resolve-DnsName $env:computername -server %s -Type A).IPAddress", Host_adserver)
result, _ := PSCommandOutputNoSplit(cmd)
return strings.TrimSpace(result)
}
func GetMacaddressFromIP(ip string) string {
cmd := fmt.Sprintf("(Get-NetAdapter -InterfaceIndex (Get-NetIPAddress -IPAddress %s).InterfaceIndex ).MacAddress", ip)
result, _ := PSCommandOutputNoSplit(cmd)
return strings.TrimSpace(result)
}
public/wol.go
package public
import (
"bytes"
"encoding/hex"
"errors"
"fmt"
"net"
"strings"
"bytes"
"encoding/hex"
"errors"
"fmt"
"net"
"strings"
)
// 源码地址
// https://github.com/zzustu/wol
// 网络唤醒魔包技术白皮书地址
// https://www.amd.com/system/files/TechDocs/20213.pdf
func Wol_enter(pc string, mac *string) {
LOG(INFO, "WOL", fmt.Sprintf("pc:%s,mac:%s", pc, *mac))
func Wol_enter(pc string,mac *string ){
// 如果是704，且只有主控进行唤醒操作
if BeSecNetwork(&pc) && Adserver(){
SendTHMsg(Msg_Wake,GJwake(pc,*mac))
// 否则本地直接唤醒（用于辅控在其他的网络唤醒）
// 如果测试其他网络的滑行情况，需要注释else代码块
}else {
PntWol(pc,*mac)
if err := wol(*mac); err != nil{
PntError(err)
}
if err := wol(*mac); err != nil {
LOG(ERROR, NULL, err)
}
// 如果是704，且只有主控进行唤醒操作
// if BeSecNetwork(&pc) && Adserver(){
// SendTHMsg(Msg_Wake,GJwake(pc,*mac))
// // 否则本地直接唤醒（用于辅控在其他的网络唤醒）
// // 如果测试其他网络的滑行情况，需要注释else代码块
// }else {
// PntWol(pc,*mac)
// if err := wol(*mac); err != nil{
// LOG(ERROR,NULL,err)
// }
// }
}
func wol(mac string) error{
func wol(mac string) error {
hw := strings.Replace(strings.Replace(mac, ":", "", -1), "-", "", -1)
if len(hw) != 12 {
return fmt.Errorf("MAC: [%s] 输入不正确.\n", mac)
}
hw := strings.Replace(strings.Replace(mac, ":", "", -1), "-", "", -1)
if len(hw) != 12 {
macHex, err := hex.DecodeString(hw)
if err != nil {
return fmt.Errorf("MAC: [%s] 输入不正确.\n", mac)
}
macHex, err := hex.DecodeString(hw)
if err != nil {
return fmt.Errorf("MAC: [%s] 输入不正确.\n", mac)
}
// 广播MAC地址 FF:FF:FF:FF:FF:FF
var bcast = []byte{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}
var buff bytes.Buffer
buff.Write(bcast)
for i := 0; i < 16; i++ {
buff.Write(macHex)
}
// 获得唤醒魔包
mp := buff.Bytes()
if len(mp) != 102 {
return fmt.Errorf("MAC: [%s] 输入不正确.\n", mac)
}
return sendMagicPacket(mp, "")
}
// 广播MAC地址 FF:FF:FF:FF:FF:FF
var bcast = []byte{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}
var buff bytes.Buffer
buff.Write(bcast)
for i := 0; i < 16; i++ {
buff.Write(macHex)
}
// 获得唤醒魔包
mp := buff.Bytes()
if len(mp) != 102 {
return fmt.Errorf("MAC: [%s] 输入不正确.\n", mac)
}
return sendMagicPacket(mp, "")
}
// 向指定网卡发送唤醒魔包
func sendMagicPacket(mp []byte, nic string)error{
sender := net.UDPAddr{}
if len(nic) != 0 {
ip, err := interfaceIPv4ByName(nic)
if err != nil {
return fmt.Errorf("网卡[%s]错误: %s", nic, err)
}
sender.IP = ip
}
target := net.UDPAddr{
IP: net.IPv4bcast,
}
conn, err := net.DialUDP("udp", &sender, &target)
if err != nil {
return fmt.Errorf("创建UDP错误：%v", err)
}
defer func() {
_ = conn.Close()
}()
_, err = conn.Write(mp)
if err != nil {
return fmt.Errorf("唤醒失败：[%s]", err)
} else {
func sendMagicPacket(mp []byte, nic string) error {
sender := net.UDPAddr{}
if len(nic) != 0 {
ip, err := interfaceIPv4ByName(nic)
if err != nil {
return fmt.Errorf("网卡[%s]错误: %s", nic, err)
}
sender.IP = ip
}
target := net.UDPAddr{
IP: net.IPv4bcast,
}
conn, err := net.DialUDP("udp", &sender, &target)
if err != nil {
return fmt.Errorf("创建UDP错误：%v", err)
}
defer func() {
_ = conn.Close()
}()
_, err = conn.Write(mp)
if err != nil {
return fmt.Errorf("唤醒失败：[%s]", err)
} else {
return nil
}
}
}
// 通过网卡名称获取该网卡绑定的IPv4
func interfaceIPv4ByName(nic string) (net.IP, error) {
inter, err := net.InterfaceByName(nic)
if err != nil {
return nil, err
}
// 检查网卡是否正在工作
if (inter.Flags & net.FlagUp) == 0 {
return nil, errors.New("网卡未工作")
}
addrs, err := inter.Addrs()
if err != nil {
return nil, err
}
for _, addr := range addrs {
if ip, ok := addr.(*net.IPNet); ok {
if ipv4 := ip.IP.To4(); ipv4 != nil {
return ipv4, nil
}
}
}
return nil, errors.New("找不到网卡绑定的IP")
}
\ No newline at end of file
inter, err := net.InterfaceByName(nic)
if err != nil {
return nil, err
}
// 检查网卡是否正在工作
if (inter.Flags & net.FlagUp) == 0 {
return nil, errors.New("网卡未工作")
}
addrs, err := inter.Addrs()
if err != nil {
return nil, err
}
for _, addr := range addrs {
if ip, ok := addr.(*net.IPNet); ok {
if ipv4 := ip.IP.To4(); ipv4 != nil {
return ipv4, nil
}
}
}
return nil, errors.New("找不到网卡绑定的IP")
}
public/wxmsg.go
package public
import(
"encoding/xml"
"net/url"
import (
"AD-Control-Golang/wxbizmsgcrypt"
"encoding/xml"
"fmt"
"net/url"
)
func ParseWX(d string,byteBody* []byte) MJwxwork{
func ParseWX(d string, byteBody *[]byte) MJwxwork {
var err error
var wxmsg wxXml
var w MJwxwork
var w MJwxwork
// 建立 企业微信 加密方法
wxcpt := wxbizmsgcrypt.NewWXBizMsgCrypt(WxworkTokenMsgSend, WxworkEncodingAseKey, WxworkReceiverId, wxbizmsgcrypt.XmlType)
// 解析 地址 参数
// ?msg_signature=5c45ff5e21c57e6ad56bac8758b79b1d9ac89fd3&timestamp=1409659589&nonce=263014780&echostr=P9nAzCzyDtyTWESHep1vC5X9xho%2FqYX3Zpb4yKa9SKld1DsH3Iyt3tP3zNdtp%2B4RPcs8TgAE7OaBO%2BFZXvnaqQ%3D%3D
m,_ := url.ParseQuery(d)
m, _ := url.ParseQuery(d)
// 验证消息
// res, cryptErr := wxcpt.VerifyURL(m["msg_signature"][0],m["timestamp"][0], m["nonce"][0],m["echostr"][0])
// if nil != cryptErr {
// PrintLog("verifyUrl fail", cryptErr)
// }
// PrintLog("verifyUrl success code:", string(res))
// LogInfo("verifyUrl fail", cryptErr)
// }
// LogInfo("verifyUrl success code:", string(res))
// fmt.Fprintf(w,string(res))
// return
......@@ -36,35 +36,34 @@ func ParseWX(d string,byteBody* []byte) MJwxwork{
m["nonce"][0],
*byteBody)
if err != nil {
PntError("DecryptMsg fail", cerr)
LOG(ERROR, NULL, "DecryptMsg fail", cerr)
w.Result = Error_WXWork_Down_STR
return w
}
// 解析具体消息
if nil != xml.Unmarshal(msg,&wxmsg){
PntError("Unmarshal fail")
if nil != xml.Unmarshal(msg, &wxmsg) {
LOG(ERROR, NULL, "Unmarshal fail")
w.Result = Error_WXWork_Down_STR
return w
}
}
// 获取 查阅同事的token
wtBricklayer,err := GetWXWorkToken()
if err != nil{
PntError(err)
wtBricklayer, err := GetWXWorkToken()
if err != nil {
LOG(ERROR, NULL, err)
w.Result = Error_WXWork_Down_STR
return w
}
// 查询 姓名
name,err := GetBricklayerName(wtBricklayer,wxmsg.FromUsername)
if err !=nil {
PntError(err)
name, err := GetBricklayerName(wtBricklayer, wxmsg.FromUsername)
if err != nil {
LOG(ERROR, NULL, err)
w.Result = Error_WXWork_Down_STR
return w
}
// 企业微信 消息 处理
// wxmsg.Content是接收到的文本消息ID
// wxmsg.EventKey是菜单事件
......@@ -75,9 +74,8 @@ func ParseWX(d string,byteBody* []byte) MJwxwork{
w.Name = name
w.Content = wxmsg.Content
return w
// 先回复空，再异步发送处理结果
return w
// // 建立 回复消息模板
// xml,t,nonce := wxmsg.createXML(result)
......@@ -87,57 +85,57 @@ func ParseWX(d string,byteBody* []byte) MJwxwork{
// nonce := strconv.Itoa(t.Nanosecond())
// timestamp := strconv.FormatInt(t.Unix(),10)
// wxmsg.Content = res
// xml,err := xml.Marshal(&wxmsg)
// if err != nil {
// PntError(err)
// if err != nil {
// LOG(ERROR,NULL,err)
// }
// return string(xml),timestamp,nonce
// }
// // 加密消息
// cryptMsg, cryptErr := wxcpt.EncryptMsg(xml, t, nonce)
// if nil != cryptErr {
// PntError("DecryptMsg fail", cryptErr)
// if nil != cryptErr {
// LOG(ERROR,NULL,"DecryptMsg fail", cryptErr)
// return Error_WXWork_Down_STR
// }
// return string(cryptMsg)
}
// 读取企业通讯录的成员信息
// 官方说明: https://work.weixin.qq.com/api/doc/90000/90135/90196
func GetBricklayerName(token, userid string) (string,error) {
link := fmt.Sprintf("https://qyapi.weixin.qq.com/cgi-bin/user/get?access_token=%s&userid=%s",token,userid)
data,err := SendGetRequest(&link)
if err !=nil {
PntError(err)
return "",Error_WXWork_Down
func GetBricklayerName(token, userid string) (string, error) {
link := fmt.Sprintf("https://qyapi.weixin.qq.com/cgi-bin/user/get?access_token=%s&userid=%s", token, userid)
data, err := SendGetRequest(&link)
if err != nil {
LOG(ERROR, NULL, err)
return "", Error_WXWork_Down
}
var bi wxJsonBricklayerInfo
ParseJson(data,&bi)
if bi.Errcode !=0 {
PntError(bi.Errmsg)
return "",Error_WXWork_Down
ParseJson(data, &bi)
if bi.Errcode != 0 {
LOG(ERROR, NULL, bi.Errmsg)
return "", Error_WXWork_Down
}
return bi.Name,nil
return bi.Name, nil
}
func GetWXWorkToken() (string,error) {
link := fmt.Sprintf("https://qyapi.weixin.qq.com/cgi-bin/gettoken?corpid=%s&corpsecret=%s",WxworkCorid,WxworkCorpSecret)
func GetWXWorkToken() (string, error) {
link := fmt.Sprintf("https://qyapi.weixin.qq.com/cgi-bin/gettoken?corpid=%s&corpsecret=%s", WxworkCorid, WxworkCorpSecret)
data,err := SendGetRequest(&link)
if err !=nil {
return "",err
data, err := SendGetRequest(&link)
if err != nil {
return "", err
}
var wt WxToken
ParseJson(data,&wt)
if wt.Errcode== 0 {
return wt.Access_token,nil
ParseJson(data, &wt)
if wt.Errcode == 0 {
return wt.Access_token, nil
} else {
PntError(err)
return "",Error_Fail_File_Write
LOG(ERROR, NULL, err)
return "", Error_Fail_File_Write
}
}
\ No newline at end of file
}
users/menu.go
package main
import (
pub "AD-Control-Golang/public"
"fmt"
"strings"
"github.com/lxn/walk"
. "github.com/lxn/walk/declarative"
"strings"
pub "AD-Control-Golang/public"
)
const (
urlKey = iota
baiduKey
)
func menuInitName(ni *walk.NotifyIcon) {
//---------------------------------------------------------
//
// Power
//
//---------------------------------------------------------
text := fmt.Sprintf("姓名: %s", pub.User_name_display)
na := walk.NewAction()
if err := na.SetText(text); err != nil {
pub.LOG(pub.ERROR, NULL, err)
}
na.SetEnabled(false)
if err := ni.ContextMenu().Actions().Add(na); err != nil {
pub.LOG(pub.ERROR, NULL, err)
}
}
// Power --------------------------------------------------
// 电源菜单
func menuInitPower(ni * walk.NotifyIcon){
func menuInitPower(ni *walk.NotifyIcon) {
fa := "电源选项"
sub := [...]string{"保持开机","取消关机计时"}
sub := [...]string{"保持开机", "取消关机计时"}
// 建立空菜单
nm,err := walk.NewMenu()
nm, err := walk.NewMenu()
if err != nil {
pub.PntError(err)
pub.LOG(pub.ERROR, NULL, err)
}
for i,buttonText := range sub{
for i, buttonText := range sub {
// 建立 子按钮
na := walk.NewAction()
if err := na.SetText(buttonText); err != nil {
pub.PntError(err)
pub.LOG(pub.ERROR, NULL, err)
}
// 为子按钮 添加事件
switch i{
switch i {
case 0:
na.Triggered().Attach(pKeppRunning)
na.Triggered().Attach(pKeepRunning)
case 1:
na.Triggered().Attach(pCancelCloseWindows)
......@@ -48,9 +55,9 @@ func menuInitPower(ni * walk.NotifyIcon){
nm.Actions().Add(na)
}
//将菜单添加到托盘
sysmenu,err := ni.ContextMenu().Actions().AddMenu(nm)
sysmenu, err := ni.ContextMenu().Actions().AddMenu(nm)
if err != nil {
pub.PntError(err)
pub.LOG(pub.ERROR, NULL, err)
}
// 主菜单 属性
......@@ -58,37 +65,134 @@ func menuInitPower(ni * walk.NotifyIcon){
sysmenu.SetVisible(true)
sysmenu.SetEnabled(true)
}
// 电源管理 保持开机
func pKeppRunning(){
// 电源管理 保持开机
func pKeepRunning() {
pub.Active = false
pub.Msg("将保持开机，至次日9点恢复")
pub.LOG(INFO, "USERS_POWER", "执行 电源管理-保持开机")
}
// 电源管理 取消自动关机
func pCancelCloseWindows(){
func pCancelCloseWindows() {
pub.Execcmd_output("shutdown -a")
pub.LOG(INFO, "USERS_POWER", "执行 电源管理-取消自动关机")
}
// 账号管理
func menuInitAccountManager(ni *walk.NotifyIcon) {
fa := "账号管理"
sub := [...]string{"申请个人账号"}
// 建立空菜单
nm, err := walk.NewMenu()
if err != nil {
pub.LOG(pub.ERROR, NULL, NULL, err)
}
//lastone := len(sub)-1
for i, buttonText := range sub {
// 建立 子按钮
//na := walk.NewAction()
na := walk.NewAction()
if err := na.SetText(buttonText); err != nil {
pub.LOG(pub.ERROR, NULL, NULL, err)
}
nm.Actions().Add(na)
// 为子按钮 添加事件
switch i {
case 0:
na.Triggered().Attach(tAccountManagerSignUP)
}
}
//将菜单添加到托盘
sysmenu, err := ni.ContextMenu().Actions().AddMenu(nm)
if err != nil {
pub.LOG(pub.ERROR, NULL, err)
}
// 主菜单 属性
sysmenu.SetText(fa)
sysmenu.SetVisible(true)
sysmenu.SetEnabled(true)
}
// 账号管理 申请个人账号
func tAccountManagerSignUP() {
if !pub.PublicUser() {
pub.Msg("您已经正在使用个人账号!")
return
}
pub.Msg("功能开发中")
}
// 账号管理
func menuInitHostManager(ni *walk.NotifyIcon) {
fa := "主机管理"
text := fmt.Sprintf("主机名: %s", pub.User_computername)
sub := [...]string{text, "绑定主机"}
// 建立空菜单
nm, err := walk.NewMenu()
if err != nil {
pub.LOG(pub.ERROR, NULL, NULL, err)
}
//lastone := len(sub)-1
for i, buttonText := range sub {
// 建立 子按钮
//na := walk.NewAction()
na := walk.NewAction()
if err := na.SetText(buttonText); err != nil {
pub.LOG(pub.ERROR, NULL, NULL, err)
}
nm.Actions().Add(na)
if i == 0 {
na.SetEnabled(false)
}
// 为子按钮 添加事件
switch i {
case 1:
na.Triggered().Attach(tHostManagerBind)
}
}
//将菜单添加到托盘
sysmenu, err := ni.ContextMenu().Actions().AddMenu(nm)
if err != nil {
pub.LOG(pub.ERROR, NULL, err)
}
// 主菜单 属性
sysmenu.SetText(fa)
sysmenu.SetVisible(true)
sysmenu.SetEnabled(true)
}
func tHostManagerBind() {
pub.Msg_YesNo(`执行本操作后，通过企业微信的"知微运维平台"的电源管理的主机将是本机。`)
pub.SendADMsg(pub.Msg_Report, pub.GJreportString(pub.Msg_Report_UpdatePrimaryHost, pub.User_name_display))
}
//---------------------------------------------------------------
//
// Kinds of Tools
//
//---------------------------------------------------------------
// Kinds of Tools ---------------------------------------------------------------
// 其他工具
func menuInitTools(ni * walk.NotifyIcon){
func menuInitTools(ni *walk.NotifyIcon) {
fa := "工具集合"
sub := [...]string{"Excel关键词分割","备份用户文件","优雅批量打开网页","隐藏/显示桌面图标","更新手机代理程序","PDF转换","窗口拦截","软件安装","重启小工具"}
sub := [...]string{"Excel关键词分割", "优雅批量打开网页", "隐藏/显示桌面图标", "更新手机代理程序", "PDF转换", "窗口拦截", "软件安装", "重启小工具"}
// 建立空菜单
nm,err := walk.NewMenu()
nm, err := walk.NewMenu()
if err != nil {
pub.PntError(err)
pub.LOG(pub.ERROR, NULL, err)
}
//lastone := len(sub)-1
for i,buttonText := range sub{
for i, buttonText := range sub {
// 过滤按钮
// switch i{
// case lastone:
......@@ -98,28 +202,26 @@ func menuInitTools(ni * walk.NotifyIcon){
// 建立 子按钮
na := walk.NewAction()
if err := na.SetText(buttonText); err != nil {
pub.PntError(err)
pub.LOG(pub.ERROR, NULL, err)
}
// 为子按钮 添加事件
switch i{
switch i {
case 0:
na.Triggered().Attach(tMultiSplit)
case 1:
na.Triggered().Attach(tBakcupUser)
case 2:
na.Triggered().Attach(tBatchOpenWeb)
case 3:
case 2:
na.Triggered().Attach(tHideShowIcon)
case 4:
case 3:
na.Triggered().Attach(tUpdateATool)
case 5:
case 4:
na.Triggered().Attach(tPdfTrans)
case 6:
case 5:
na.Triggered().Attach(tWindowsBlock)
case 7:
case 6:
na.Triggered().Attach(tSoftwareInstall)
case 8:
case 7:
na.Triggered().Attach(tRebootUsers)
}
......@@ -128,56 +230,56 @@ func menuInitTools(ni * walk.NotifyIcon){
}
//将菜单添加到托盘
sysmenu,err := ni.ContextMenu().Actions().AddMenu(nm)
sysmenu, err := ni.ContextMenu().Actions().AddMenu(nm)
if err != nil {
pub.PntError(err)
pub.LOG(pub.ERROR, NULL, err)
}
// 主菜单 属性
sysmenu.SetText(fa)
sysmenu.SetVisible(true)
sysmenu.SetEnabled(true)
}
// 其他工具 Excel关键词分割器
func tMultiSplit(){
func tMultiSplit() {
pub.Execcmd_nowait(pub.Cmd_K_Start + pub.App_MultiSplit)
pub.LOG(INFO, "USERS_TOOLS", "执行 其他工具-Excel关键词分割器")
}
// 其他工具 优雅批量打开网页
func tBatchOpenWeb(){
func tBatchOpenWeb() {
go pub.Msg("务必在新浏览器窗口中进行批量打开，且在浏览器中设置允许弹窗。")
chrome := `C:\Progra~2\Google\Chrome\Application\chrome.exe http://mp.zhiweireach.com`
pub.Execcmd_nowait(chrome)
pub.LOG(INFO, "USERS_TOOLS", "执行 其他工具-优雅批量打开网页")
}
// 其他工具 备份用户文件
func tBakcupUser(){
if pub.Msg_YesNo("是否执行一次手动备份用户文件夹。目标文件夹："+pub.Dir_userprofile)==1{
pub.SendServerReport(pub.Msg_Report_InitBak)
}
}
// 其他工具 Pdf转换
func tPdfTrans(){
// 其他工具 PDF转换
func tPdfTrans() {
AcrobatDC := `C:\Application\AcrobatDC\AcrobatDCPortable.exe`
if pub.NotExist(AcrobatDC){
go pub.Msg(`Acrobat DC不存在，请先从"软件安装"中安装`)
if pub.NotExist(AcrobatDC) {
go pub.Msg(`Acrobat DC不存在!请先从"软件安装"中安装`)
return
}
go pub.Msg(`Acrobat DC正在打开`)
pub.SendServerExec(pub.GJexecDIYFlag(pub.Msg_Exec_OpenAdminEXE,AcrobatDC))
pub.SendServerExec(pub.GJexecDIYFlag(pub.Msg_Exec_OpenAdminEXE, AcrobatDC))
pub.LOG(INFO, "USERS_TOOLS", "执行 其他工具-PDF转换")
return
}
// 其他工具 更新手机代理程序
func tUpdateATool(){
func tUpdateATool() {
pub.Execcmd_wait(`xcopy \\adserver\software\phoneproxy\ATools\win-unpacked C:\Application\win-unpacked /D /S /E /C /y`)
pub.Msg("更新完成")
pub.LOG(INFO, "USERS_TOOLS", "执行 其他工具-更新手机代理程序")
}
// 其他工具 隐藏/显示桌面图标
func tHideShowIcon(){
func tHideShowIcon() {
pub.Msg("注：并非所有图标都会列出，没有列出的图标请手动隐藏（右键文件，打开属性，勾选隐藏，点击确定）")
mw := &MyMainWindow{model: NewEnvModel()}
mw := &MyMainWindow{model: HideShowIconModel()}
if _, err := (MainWindow{
AssignTo: &mw.MainWindow,
......@@ -187,265 +289,153 @@ func tHideShowIcon(){
Layout: VBox{},
Children: []Widget{
ListBox{
AssignTo: &mw.lb,
Model: mw.model,
OnItemActivated: mw.tHideShowIconDeal,
AssignTo: &mw.lb,
Model: mw.model,
OnItemActivated: mw.tHideShowIconDeal,
},
PushButton{
Text: "隐藏/显示",
Text: "隐藏/显示",
OnClicked: mw.tHideShowIconDeal,
},
},
}.Run()); err != nil {
pub.Msg("执行错误")
pub.PntError(err)
pub.LOG(pub.ERROR, NULL, err)
}
pub.LOG(INFO, "USERS_TOOLS", "执行 其他工具-隐藏/显示桌面图标")
}
func HideShowIconModel() *EnvModel {
r, err := pub.PSCommandOutput(`Get-ChildItem -Force -Filter *.lnk C:\Users\Public\Desktop -Name`)
if err != nil {
pub.Msg("执行失败")
return nil
}
list := strings.Split(r, "\n")
m := &EnvModel{items: make([]EnvItem, len(list)-1)}
for i := 0; i < len(list)-1; i++ {
unlnk := list[i][:len(list[i])-5]
m.items[i] = EnvItem{unlnk}
}
return m
}
func (mw *MyMainWindow) tHideShowIconDeal() {
app := (&mw.model.items[mw.lb.CurrentIndex()]).name
fullAppDir := `C:\Users\public\desktop\` + app + `.lnk`
var exec pub.MJexec
exec.Init(pub.Msg_Exec_HideShowIcon)
exec.DataStr = fullAppDir
r, err := pub.PSCommandOutputNoSplit(fmt.Sprintf(`(Get-Item "%s" -Force ).Attributes`, fullAppDir))
if err != nil {
pub.Msg("执行失败")
return
}
if strings.Index(r, "Hidden") == -1 {
exec.Explain = "隐藏"
exec.DataBool = false
} else {
exec.Explain = "显示"
exec.DataBool = true
}
pub.SendServerExec(exec)
}
// 其他工具 火绒窗口拦截工具
func tWindowsBlock(){
func tWindowsBlock() {
PopBlock := `C:\Progra~2\zhiwei\huorong_windows_block\PopBlock.exe`
if pub.NotExist(PopBlock){
if pub.NotExist(PopBlock) {
go pub.Msg(`火绒窗口拦截工具没有安装，请先从小工具中"软件安装"中进行安装`)
return
}
pub.SendServerExec(pub.GJexecDIYFlag(pub.Msg_Exec_OpenAdminEXE,PopBlock))
return
pub.SendServerExec(pub.GJexecDIYFlag(pub.Msg_Exec_OpenAdminEXE, PopBlock))
pub.LOG(INFO, "USERS_TOOLS", "执行 其他工具-火绒窗口拦截工具")
}
// 其他工具 软件安装
func tSoftwareInstall(){
func tSoftwareInstall() {
softpath := `Z:\softlike\`
softname := pub.ChooseFile("请选择单个文件",softpath)
if softname== ""{
if pub.NotExist(softpath) {
pub.Execcmd_wait("gpupdate /force /target:user")
}
softname := pub.ChooseFile("请选择安装包", softpath)
if softname == "" {
return
}
if strings.HasPrefix(softname,softpath) {
softname = strings.TrimPrefix(softname,softpath)
go pub.Msg("等待弹出安装窗口，请稍等。。")
if strings.HasPrefix(softname, softpath) {
softname = strings.TrimPrefix(softname, softpath)
go pub.Msg("正在复制安装包，请稍等!")
pub.SendServerExec(pub.GJexecInstallSoftware(softname))
}else{
go pub.Msg("请勿修改文件路径！")
} else {
go pub.Msg("安装失败：不是指定的文件路径！")
}
pub.LOG(INFO, "USERS_TOOLS", "执行 其他工具-软件安装")
}
// 其他工具 重启用户程序
func tRebootUsers(){
func tRebootUsers() {
go pub.Msg("正在刷新，请稍后！")
pub.Execcmd_wait(`cmd /c copy /y \\adserver\software\application\users.exe %tmp%`)
pub.Execcmd_nowait_noargs(pub.User_tmp + `\users.exe`)
pub.ExitNormal()
pub.LOG(INFO, "USERS_TOOLS", "执行 其他工具-重启用户程序")
}
//---------------------------------------------------------------
//
// File share
//
//---------------------------------------------------------------
// 文件共享 （包含域用户和大屏主机的文件共享）
func menuInitFileShares(ni * walk.NotifyIcon){
// 文件共享 （包含大屏主机的文件共享）
func menuInitFileShares(ni *walk.NotifyIcon) {
fa := "文件共享"
// 建立空菜单
mfs,err := walk.NewMenu()
mfs, err := walk.NewMenu()
if err != nil {
pub.PntError(err)
}
// 说明：添加 域用户 文件共享
// 方法：列举目录名，生成菜单
// 其次，列举额目录中的名单作为按钮添加到菜单
deptList,err := pub.ReadDir(pub.SMB_ADMain)
if err !=nil {
pub.PntError(err)
}
for _,memberList := range deptList {
nm,err := walk.NewMenu()
if err != nil {
pub.PntError(err)
}
deptshare := memberList.Name()
// 不在 其他共享 里 显示自己部门的共享
if deptshare == pub.User_dept{
continue
}
if deptshare == "DfsrPrivate"{
continue
}
member,err := pub.ReadDir(pub.SMB_ADMain + deptshare)
if err != nil {
pub.PntError(err)
}
for _,mem := range member{
wokrer := mem.Name()
// 建立 子按钮
na := walk.NewAction()
if err := na.SetText(strings.TrimSuffix(wokrer,".lnk")); err != nil {
pub.PntError(err)
}
// 为子按钮 添加事件
na.Triggered().Attach(func(){pub.OpenWindow(pub.SMB_ADMain + deptshare + `\` + wokrer);return})
// 将 子按钮 添加到 菜单
nm.Actions().Add(na)
}
if m,err := mfs.Actions().AddMenu(nm);err != nil{
pub.PntError(err)
}else{
m.SetText(deptshare)
m.SetVisible(true)
m.SetEnabled(true)
}
pub.LOG(pub.ERROR, NULL, err)
}
// 添加
na := walk.NewAction()
if err := na.SetText("会议室的大脸机"); err != nil {
pub.PntError(err)
}else{
pub.LOG(pub.ERROR, NULL, err)
} else {
//将菜单添加到托盘
na.Triggered().Attach(func(){pub.OpenWindow(`ftp://adserver`)})
if err := mfs.Actions().Add(na);err != nil{
pub.PntError(err)
na.Triggered().Attach(func() {
pub.OpenWindow(`ftp://adserver`)
pub.LOG(INFO, "USERS_SHARE", "执行 其他工具-会议室的大脸机")
})
if err := mfs.Actions().Add(na); err != nil {
pub.LOG(pub.ERROR, NULL, err)
}
}
//将菜单添加到托盘
sysmenu,err := ni.ContextMenu().Actions().AddMenu(mfs)
if err != nil {
pub.PntError(err)
}
// 主菜单 属性
sysmenu.SetText(fa)
sysmenu.SetVisible(true)
sysmenu.SetEnabled(true)
}
//---------------------------------------------------------------
//
// My share
//
//---------------------------------------------------------------
// 我的共享:本部门的共享
func menuInitMyShares(ni * walk.NotifyIcon){
fa := "我的共享"
// 建立空菜单
nm,err2 := walk.NewMenu()
if err2 !=nil {
pub.PntError(err2)
}
// 读取我的部门共享目录
deptList,err3 := pub.ReadDir(pub.SMB_ADMainDept)
if err3 !=nil {
pub.PntError(err3)
}
for _,mem := range deptList{
wokrer := mem.Name()
// 建立 子按钮
na := walk.NewAction()
if err := na.SetText(strings.TrimSuffix(wokrer,".lnk")); err != nil {
pub.PntError(err)
}
// 为子按钮 添加事件
na.Triggered().Attach(func(){pub.OpenWindow(pub.SMB_ADMainDept +`\`+ wokrer);return})
// 将 子按钮 添加到 菜单
nm.Actions().Add(na)
}
//将菜单添加到托盘
sysmenu,err := ni.ContextMenu().Actions().AddMenu(nm)
sysmenu, err := ni.ContextMenu().Actions().AddMenu(mfs)
if err != nil {
pub.PntError(err)
pub.LOG(pub.ERROR, NULL, err)
}
// 主菜单 属性
sysmenu.SetText(fa)
sysmenu.SetVisible(true)
sysmenu.SetEnabled(true)
}
//---------------------------------------------------------------
//
// Windows Menu Deal
//
//---------------------------------------------------------------
// Windows Menu Deal ----------------------------------------------
type MyMainWindow struct {
*walk.MainWindow
model *EnvModel
lb *walk.ListBox
}
func (mw *MyMainWindow) tHideShowIconDeal() {
app := (&mw.model.items[mw.lb.CurrentIndex()]).name
fullAppDir := `C:\Users\public\desktop\`+app+`.lnk`
var exec pub.MJexec
exec.Init(pub.Msg_Exec_HideShowIcon)
exec.DataStr = fullAppDir
r,err :=pub.PSCommandOutputNoSplit(`(Get-Item `+fullAppDir+` -Force ).Attributes`)
if err !=nil{
pub.Msg("执行失败")
return
}
if strings.Index(r,"Hidden") == -1{
exec.Explain = "隐藏"
exec.DataBool = false
} else {
exec.Explain = "显示"
exec.DataBool = true
}
pub.SendServerExec(exec)
}
type EnvItem struct {
name string
name string
}
type EnvModel struct {
walk.ListModelBase
items []EnvItem
}
func NewEnvModel() *EnvModel {
r,err :=pub.PSCommandOutput(`Get-ChildItem -Force -Filter *.lnk C:\Users\Public\Desktop -Name`)
if err !=nil{
pub.Msg("执行失败")
return nil
}
list := strings.Split(r,"\n")
m := &EnvModel{items: make([]EnvItem, len(list)-1)}
for i:=0;i<len(list)-1;i++{
unlnk :=list[i][:len(list[i])-5]
m.items[i] = EnvItem{unlnk}
}
return m
}
func (m *EnvModel) ItemCount() int {
return len(m.items)
}
func (m *EnvModel) Value(index int) interface{} {
return m.items[index].name
}
users/users.go
......@@ -10,59 +10,73 @@ void getMouse()
*/
import "C"
import (
"github.com/lxn/walk"
pub "AD-Control-Golang/public"
"fmt"
"os"
"github.com/lxn/walk"
)
func GetMousePos() (int,int) {
const INFO = pub.INFO
const ERROR = pub.ERROR
const NULL = pub.NULL
// 由windows SDK（C语言）获取鼠标坐标
func GetMousePos() (int, int) {
C.getMouse()
x :=int(C.point.x)
x := int(C.point.x)
y := int(C.point.y)
return x,y
return x, y
}
func userInit() string{
pub.Loger = pub.NewLoger(pub.Dir_appdata + `\users.log`)
pub.PntInfo("start users!")
pub.Reg_Exist_item(pub.HKCU,pub.Reg_Path_home)
userEnvInit()
// Users程序初始化函数
func userInit() string {
// 获取 图标文件 路径
var icoDir =[]string {
// 获取并返回 图标文件 路径
var icoDir = []string{
`AD-Control.ico`,
pub.Dir_tmp + `\AD-Control.ico`,
`C:\windows\system32\AD-Control.ico`,
`C:\Users\Public\Documents\AD-Control\AD-Control.ico`}
for _,i := range icoDir{
if pub.Exist(i){
for _, i := range icoDir {
if pub.Exist(i) {
return i
}
}
pub.SendServerError(pub.Error_Null_Icon_File)
pub.LOG(ERROR, "ICON", fmt.Sprintf("主机名:%s\n错误:%s", pub.User_computername, pub.Error_Null_Icon_File))
return ""
}
func menuInit(ni * walk.NotifyIcon){
// 菜单初始化
// 这些函数位于menu.go
func menuInit(ni *walk.NotifyIcon) {
menuInitName(ni)
menuInitAccountManager(ni)
menuInitHostManager(ni)
menuInitPower(ni)
menuInitTools(ni)
menuInitFileShares(ni)
menuInitMyShares(ni)
menuInitTools(ni)
}
func isActive(){
// 鼠标活动检测
// 检测方式，每隔一小时判断鼠标坐标是否与之前相
func isActive() {
for {
d,h := pub.GetDateHour()
ox,oy := GetMousePos()
d, h := pub.GetDateHour()
ox, oy := GetMousePos()
pub.Delay(3602)
// 新的一天
// 如果是早上9点，重置鼠标活动检测状态
if d == 9 {
pub.Active = true
}
// 非工作时间的新的一小时
if (h >=19 || h<8) && pub.Active{
x,y := GetMousePos()
if (h >= 19 || h < 8) && pub.Active {
x, y := GetMousePos()
// 如果处于闲置状态
if ox == x && oy == y {
......@@ -72,52 +86,60 @@ func isActive(){
}
}
}
func userEnvInit(){
if pub.Reg_Query_DC(pub.Reg_Name_CloseView) != pub.Reg_Value_ON {
pub.Execcmd_nowait(pub.Cmd_c + pub.SMB_ADSoftTool+`【修复】关闭excel和word保护视图.bat`)
pub.Reg_Write_DC(pub.Reg_Name_CloseView,pub.Reg_Value_OFF)
}
// 用户环境初始化（对于新用户）
func userEnvInit() {
// 关闭保护视图
// if pub.Reg_Query_DC(pub.Reg_Name_CloseView) != pub.Reg_Value_ON {
// pub.Execcmd_nowait(pub.Cmd_c + pub.SMB_ADSoftTool + `【修复】关闭excel和word保护视图.bat`)
// pub.Reg_Write_DC(pub.Reg_Name_CloseView, pub.Reg_Value_ON)
// }
}
func main() {
if pub.Adserver() {
os.Exit(-1)
}
// 用户 初始化
icodir := userInit()
userEnvInit()
go isActive()
// 程序 初始化
mw,err := walk.NewMainWindow()
mw, err := walk.NewMainWindow()
if err != nil {
pub.PntError(err)
pub.LOG(ERROR, NULL, err)
}
// 图标资源 初始化
icon, err := walk.Resources.Icon(icodir)
if err != nil {
pub.PntError(err)
pub.LOG(ERROR, NULL, err)
}
// 后台图标应用 初始化
ni, err := walk.NewNotifyIcon(mw)
if err != nil {
pub.PntError(err)
pub.LOG(ERROR, NULL, err)
}
defer ni.Dispose()
// Set the icon and a tool tip text.
if err := ni.SetIcon(icon); err != nil {
pub.PntError(err)
}
if err := ni.SetToolTip("Click for info or use the context menu to exit."); err != nil {
pub.PntError(err)
pub.LOG(ERROR, NULL, err)
}
menuInit(ni)
// The notify icon is hidden initially, so we have to make it visible.
if err := ni.SetVisible(true); err != nil {
pub.PntError(err)
pub.LOG(ERROR, NULL, err)
}
pub.MsgAdvUI(ni, "运维小工具已运行")
pub.LOG(INFO, NULL, "start!")
// 循环 运行窗体
mw.Run()
}
wxbizmsgcrypt/wxwork.go
package wxbizmsgcrypt
import(
"crypto/sha1"
import (
"bytes"
"crypto/aes"
"crypto/cipher"
"bytes"
"strings"
"fmt"
"sort"
"crypto/sha1"
"encoding/base64"
"math/rand"
"encoding/binary"
"encoding/xml"
"fmt"
"math/rand"
"sort"
"strings"
)
const letterBytes = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
const (
ValidateSignatureError int = -40001
ParseXmlError int = -40002
ComputeSignatureError int = -40003
IllegalAesKey int = -40004
ValidateCorpidError int = -40005
EncryptAESError int = -40006
DecryptAESError int = -40007
IllegalBuffer int = -40008
EncodeBase64Error int = -40009
DecodeBase64Error int = -40010
GenXmlError int = -40010
ParseJsonError int = -40012
GenJsonError int = -40013
IllegalProtocolType int = -40014
ParseXmlError int = -40002
ComputeSignatureError int = -40003
IllegalAesKey int = -40004
ValidateCorpidError int = -40005
EncryptAESError int = -40006
DecryptAESError int = -40007
IllegalBuffer int = -40008
EncodeBase64Error int = -40009
DecodeBase64Error int = -40010
GenXmlError int = -40010
ParseJsonError int = -40012
GenJsonError int = -40013
IllegalProtocolType int = -40014
)
type ProtocolType int
const (
XmlType ProtocolType = 1
XmlType ProtocolType = 1
)
type CryptError struct{
ErrCode int
ErrMsg string
type CryptError struct {
ErrCode int
ErrMsg string
}
func NewCryptError(err_code int, err_msg string) * CryptError{
return &CryptError{ErrCode:err_code, ErrMsg: err_msg}
func NewCryptError(err_code int, err_msg string) *CryptError {
return &CryptError{ErrCode: err_code, ErrMsg: err_msg}
}
type WXBizMsg4Recv struct {
Tousername string `xml:"ToUserName"`
Encrypt string `xml:"Encrypt"`
Agentid string `xml:"AgentID"`
Tousername string `xml:"ToUserName"`
Encrypt string `xml:"Encrypt"`
Agentid string `xml:"AgentID"`
}
type CDATA struct{
type CDATA struct {
Value string `xml:",cdata"`
}
type WXBizMsg4Send struct {
XMLName xml.Name `xml:"xml"`
Encrypt CDATA `xml:"Encrypt"`
Signature CDATA `xml:"MsgSignature"`
Timestamp string `xml:"TimeStamp"`
Nonce CDATA `xml:"Nonce"`
XMLName xml.Name `xml:"xml"`
Encrypt CDATA `xml:"Encrypt"`
Signature CDATA `xml:"MsgSignature"`
Timestamp string `xml:"TimeStamp"`
Nonce CDATA `xml:"Nonce"`
}
func NewWXBizMsg4Send(encrypt, signature, timestamp, nonce string) * WXBizMsg4Send {
return &WXBizMsg4Send{Encrypt:CDATA{Value:encrypt}, Signature:CDATA{Value:signature}, Timestamp:timestamp, Nonce:CDATA{Value:nonce}}
func NewWXBizMsg4Send(encrypt, signature, timestamp, nonce string) *WXBizMsg4Send {
return &WXBizMsg4Send{Encrypt: CDATA{Value: encrypt}, Signature: CDATA{Value: signature}, Timestamp: timestamp, Nonce: CDATA{Value: nonce}}
}
type ProtocolProcessor interface {
parse(src_data []byte) (* WXBizMsg4Recv, * CryptError)
serialize(msg_send * WXBizMsg4Send) ([]byte, * CryptError)
parse(src_data []byte) (*WXBizMsg4Recv, *CryptError)
serialize(msg_send *WXBizMsg4Send) ([]byte, *CryptError)
}
type WXBizMsgCrypt struct{
token string
encoding_aeskey string
receiver_id string
type WXBizMsgCrypt struct {
token string
encoding_aeskey string
receiver_id string
protocol_processor ProtocolProcessor
}
type XmlProcessor struct{
type XmlProcessor struct {
}
func (self * XmlProcessor) parse(src_data []byte) (* WXBizMsg4Recv, * CryptError) {
func (self *XmlProcessor) parse(src_data []byte) (*WXBizMsg4Recv, *CryptError) {
var msg4_recv WXBizMsg4Recv
err := xml.Unmarshal(src_data, &msg4_recv)
if nil != err {
......@@ -93,15 +94,15 @@ func (self * XmlProcessor) parse(src_data []byte) (* WXBizMsg4Recv, * CryptError
return &msg4_recv, nil
}
func (self * XmlProcessor) serialize(msg4_send * WXBizMsg4Send) ([]byte, * CryptError){
xml_msg, err := xml.Marshal(msg4_send)
if nil != err {
return nil, NewCryptError(GenXmlError, err.Error())
}
return xml_msg, nil
func (self *XmlProcessor) serialize(msg4_send *WXBizMsg4Send) ([]byte, *CryptError) {
xml_msg, err := xml.Marshal(msg4_send)
if nil != err {
return nil, NewCryptError(GenXmlError, err.Error())
}
return xml_msg, nil
}
func NewWXBizMsgCrypt(token, encoding_aeskey, receiver_id string, protocol_type ProtocolType) * WXBizMsgCrypt{
func NewWXBizMsgCrypt(token, encoding_aeskey, receiver_id string, protocol_type ProtocolType) *WXBizMsgCrypt {
var protocol_processor ProtocolProcessor
if protocol_type != XmlType {
panic("unsupport protocal")
......@@ -109,19 +110,19 @@ func NewWXBizMsgCrypt(token, encoding_aeskey, receiver_id string, protocol_type
protocol_processor = new(XmlProcessor)
}
return &WXBizMsgCrypt{token:token, encoding_aeskey:(encoding_aeskey+"="), receiver_id:receiver_id, protocol_processor:protocol_processor}
return &WXBizMsgCrypt{token: token, encoding_aeskey: (encoding_aeskey + "="), receiver_id: receiver_id, protocol_processor: protocol_processor}
}
func (self * WXBizMsgCrypt) randString(n int) string {
func (self *WXBizMsgCrypt) randString(n int) string {
b := make([]byte, n)
for i := range b {
b[i] = letterBytes[rand.Int63() % int64(len(letterBytes))]
b[i] = letterBytes[rand.Int63()%int64(len(letterBytes))]
}
return string(b)
}
func (self * WXBizMsgCrypt) pKCS7Padding(plaintext string, block_size int) []byte {
padding := block_size- (len(plaintext) % block_size)
func (self *WXBizMsgCrypt) pKCS7Padding(plaintext string, block_size int) []byte {
padding := block_size - (len(plaintext) % block_size)
padtext := bytes.Repeat([]byte{byte(padding)}, padding)
var buffer bytes.Buffer
buffer.WriteString(plaintext)
......@@ -129,47 +130,47 @@ func (self * WXBizMsgCrypt) pKCS7Padding(plaintext string, block_size int) []byt
return buffer.Bytes()
}
func (self * WXBizMsgCrypt) pKCS7Unpadding(plaintext []byte, block_size int) ([]byte, * CryptError) {
plaintext_len := len(plaintext)
if nil == plaintext || plaintext_len == 0 {
return nil, NewCryptError(DecryptAESError, "pKCS7Unpadding error nil or zero")
}
if plaintext_len % block_size != 0 {
return nil, NewCryptError(DecryptAESError, "pKCS7Unpadding text not a multiple of the block size")
}
padding_len := int(plaintext[plaintext_len - 1])
return plaintext[:plaintext_len - padding_len], nil
func (self *WXBizMsgCrypt) pKCS7Unpadding(plaintext []byte, block_size int) ([]byte, *CryptError) {
plaintext_len := len(plaintext)
if nil == plaintext || plaintext_len == 0 {
return nil, NewCryptError(DecryptAESError, "pKCS7Unpadding error nil or zero")
}
if plaintext_len%block_size != 0 {
return nil, NewCryptError(DecryptAESError, "pKCS7Unpadding text not a multiple of the block size")
}
padding_len := int(plaintext[plaintext_len-1])
return plaintext[:plaintext_len-padding_len], nil
}
func (self * WXBizMsgCrypt) cbcEncrypter(plaintext string) ([]byte, * CryptError) {
aeskey, err := base64.StdEncoding.DecodeString(self.encoding_aeskey)
if nil != err {
return nil, NewCryptError(DecodeBase64Error, err.Error())
}
const block_size = 32
pad_msg := self.pKCS7Padding(plaintext, block_size)
func (self *WXBizMsgCrypt) cbcEncrypter(plaintext string) ([]byte, *CryptError) {
aeskey, err := base64.StdEncoding.DecodeString(self.encoding_aeskey)
if nil != err {
return nil, NewCryptError(DecodeBase64Error, err.Error())
}
const block_size = 32
pad_msg := self.pKCS7Padding(plaintext, block_size)
block, err := aes.NewCipher(aeskey)
if err != nil {
return nil, NewCryptError(EncryptAESError, err.Error())
}
block, err := aes.NewCipher(aeskey)
if err != nil {
return nil, NewCryptError(EncryptAESError, err.Error())
}
ciphertext := make([]byte, len(pad_msg))
iv := aeskey[:aes.BlockSize]
ciphertext := make([]byte, len(pad_msg))
iv := aeskey[:aes.BlockSize]
mode := cipher.NewCBCEncrypter(block, iv)
mode := cipher.NewCBCEncrypter(block, iv)
mode.CryptBlocks(ciphertext, pad_msg)
base64_msg := make([]byte, base64.StdEncoding.EncodedLen(len(ciphertext)))
base64.StdEncoding.Encode(base64_msg, ciphertext)
mode.CryptBlocks(ciphertext, pad_msg)
base64_msg := make([]byte, base64.StdEncoding.EncodedLen(len(ciphertext)))
base64.StdEncoding.Encode(base64_msg, ciphertext)
return base64_msg, nil
return base64_msg, nil
}
func (self * WXBizMsgCrypt) cbcDecrypter(base64_encrypt_msg string) ([]byte, * CryptError){
func (self *WXBizMsgCrypt) cbcDecrypter(base64_encrypt_msg string) ([]byte, *CryptError) {
aeskey, err := base64.StdEncoding.DecodeString(self.encoding_aeskey)
if nil != err {
return nil, NewCryptError(DecodeBase64Error, err.Error())
return nil, NewCryptError(DecodeBase64Error, err.Error())
}
encrypt_msg, err := base64.StdEncoding.DecodeString(base64_encrypt_msg)
......@@ -179,17 +180,17 @@ func (self * WXBizMsgCrypt) cbcDecrypter(base64_encrypt_msg string) ([]byte, * C
block, err := aes.NewCipher(aeskey)
if err != nil {
return nil, NewCryptError(DecryptAESError, err.Error())
return nil, NewCryptError(DecryptAESError, err.Error())
}
if len(encrypt_msg) < aes.BlockSize {
return nil, NewCryptError(DecryptAESError, "encrypt_msg size is not valid")
return nil, NewCryptError(DecryptAESError, "encrypt_msg size is not valid")
}
iv := aeskey[:aes.BlockSize]
if len(encrypt_msg) % aes.BlockSize != 0 {
return nil, NewCryptError(DecryptAESError, "encrypt_msg not a multiple of the block size")
if len(encrypt_msg)%aes.BlockSize != 0 {
return nil, NewCryptError(DecryptAESError, "encrypt_msg not a multiple of the block size")
}
mode := cipher.NewCBCDecrypter(block, iv)
......@@ -199,93 +200,91 @@ func (self * WXBizMsgCrypt) cbcDecrypter(base64_encrypt_msg string) ([]byte, * C
return encrypt_msg, nil
}
func (self * WXBizMsgCrypt) calSignature(timestamp, nonce, data string) string{
sort_arr := []string{self.token, timestamp, nonce, data}
sort.Strings(sort_arr);
var buffer bytes.Buffer
for _, value := range sort_arr {
buffer.WriteString(value)
}
sha := sha1.New()
sha.Write(buffer.Bytes())
signature := fmt.Sprintf("%x", sha.Sum(nil))
return string(signature)
func (self *WXBizMsgCrypt) calSignature(timestamp, nonce, data string) string {
sort_arr := []string{self.token, timestamp, nonce, data}
sort.Strings(sort_arr)
var buffer bytes.Buffer
for _, value := range sort_arr {
buffer.WriteString(value)
}
sha := sha1.New()
sha.Write(buffer.Bytes())
signature := fmt.Sprintf("%x", sha.Sum(nil))
return string(signature)
}
func (self * WXBizMsgCrypt) ParsePlainText(plaintext[]byte)([]byte, uint32, []byte, []byte, * CryptError){
const block_size = 32
plaintext, err := self.pKCS7Unpadding(plaintext, block_size)
if nil != err {
return nil, 0, nil, nil, err
}
text_len := uint32(len(plaintext))
if text_len < 20 {
return nil, 0, nil, nil, NewCryptError(IllegalBuffer, "plain is to small 1")
}
random := plaintext[:16]
msg_len := binary.BigEndian.Uint32(plaintext[16:20])
if text_len < (20 + msg_len) {
return nil, 0, nil, nil, NewCryptError(IllegalBuffer, "plain is to small 2")
}
msg := plaintext[20: 20 + msg_len]
receiver_id := plaintext[20+msg_len:]
return random, msg_len, msg, receiver_id, nil
func (self *WXBizMsgCrypt) ParsePlainText(plaintext []byte) ([]byte, uint32, []byte, []byte, *CryptError) {
const block_size = 32
plaintext, err := self.pKCS7Unpadding(plaintext, block_size)
if nil != err {
return nil, 0, nil, nil, err
}
text_len := uint32(len(plaintext))
if text_len < 20 {
return nil, 0, nil, nil, NewCryptError(IllegalBuffer, "plain is to small 1")
}
random := plaintext[:16]
msg_len := binary.BigEndian.Uint32(plaintext[16:20])
if text_len < (20 + msg_len) {
return nil, 0, nil, nil, NewCryptError(IllegalBuffer, "plain is to small 2")
}
msg := plaintext[20 : 20+msg_len]
receiver_id := plaintext[20+msg_len:]
return random, msg_len, msg, receiver_id, nil
}
func (self * WXBizMsgCrypt) VerifyURL(msg_signature, timestamp, nonce, echostr string) ([]byte, * CryptError){
signature := self.calSignature(timestamp, nonce, echostr)
func (self *WXBizMsgCrypt) VerifyURL(msg_signature, timestamp, nonce, echostr string) ([]byte, *CryptError) {
signature := self.calSignature(timestamp, nonce, echostr)
if strings.Compare(signature, msg_signature) != 0{
return nil, NewCryptError(ValidateSignatureError, "signature not equal")
}
if strings.Compare(signature, msg_signature) != 0 {
return nil, NewCryptError(ValidateSignatureError, "signature not equal")
}
plaintext, err := self.cbcDecrypter(echostr)
if nil != err {
return nil, err
}
plaintext, err := self.cbcDecrypter(echostr)
if nil != err {
return nil, err
}
_, _, msg, receiver_id, err := self.ParsePlainText(plaintext)
if nil != err {
return nil, err
}
_, _, msg, receiver_id, err := self.ParsePlainText(plaintext)
if nil != err {
return nil, err
}
if len(self.receiver_id) > 0 && strings.Compare(string(receiver_id), self.receiver_id) != 0 {
fmt.Println(string(receiver_id), self.receiver_id, len(receiver_id), len(self.receiver_id))
return nil, NewCryptError(ValidateCorpidError, "receiver_id is not equil")
}
if len(self.receiver_id) > 0 && strings.Compare(string(receiver_id), self.receiver_id) != 0 {
return nil, NewCryptError(ValidateCorpidError, "receiver_id is not equil")
}
return msg, nil
return msg, nil
}
func (self *WXBizMsgCrypt) EncryptMsg(reply_msg, timestamp, nonce string) ([]byte, *CryptError) {
rand_str := self.randString(16)
var buffer bytes.Buffer
buffer.WriteString(rand_str)
func (self * WXBizMsgCrypt) EncryptMsg(reply_msg, timestamp, nonce string) ([]byte, * CryptError){
rand_str := self.randString(16)
var buffer bytes.Buffer
buffer.WriteString(rand_str)
msg_len_buf := make([]byte, 4)
binary.BigEndian.PutUint32(msg_len_buf, uint32(len(reply_msg)))
buffer.Write(msg_len_buf)
buffer.WriteString(reply_msg);
buffer.WriteString(self.receiver_id);
msg_len_buf := make([]byte, 4)
binary.BigEndian.PutUint32(msg_len_buf, uint32(len(reply_msg)))
buffer.Write(msg_len_buf)
buffer.WriteString(reply_msg)
buffer.WriteString(self.receiver_id)
tmp_ciphertext, err := self.cbcEncrypter(buffer.String());
if nil != err {
return nil, err
}
ciphertext := string(tmp_ciphertext)
tmp_ciphertext, err := self.cbcEncrypter(buffer.String())
if nil != err {
return nil, err
}
ciphertext := string(tmp_ciphertext)
signature := self.calSignature(timestamp, nonce, ciphertext)
signature := self.calSignature(timestamp, nonce, ciphertext)
msg4_send := NewWXBizMsg4Send(ciphertext, signature, timestamp, nonce)
return self.protocol_processor.serialize(msg4_send)
msg4_send := NewWXBizMsg4Send(ciphertext, signature, timestamp, nonce)
return self.protocol_processor.serialize(msg4_send)
}
func (self * WXBizMsgCrypt) DecryptMsg(msg_signature, timestamp, nonce string, post_data []byte) ([]byte, * CryptError){
func (self *WXBizMsgCrypt) DecryptMsg(msg_signature, timestamp, nonce string, post_data []byte) ([]byte, *CryptError) {
msg4_recv, crypt_err := self.protocol_processor.parse(post_data)
if nil != crypt_err {
return nil, crypt_err
......@@ -293,25 +292,23 @@ func (self * WXBizMsgCrypt) DecryptMsg(msg_signature, timestamp, nonce string, p
signature := self.calSignature(timestamp, nonce, msg4_recv.Encrypt)
if strings.Compare(signature, msg_signature) != 0{
if strings.Compare(signature, msg_signature) != 0 {
return nil, NewCryptError(ValidateSignatureError, "signature not equal")
}
}
plaintext, crypt_err := self.cbcDecrypter(msg4_recv.Encrypt)
if nil != crypt_err {
return nil, crypt_err
}
return nil, crypt_err
}
_, _, msg, receiver_id, crypt_err := self.ParsePlainText(plaintext)
if nil != crypt_err {
return nil, crypt_err
}
return nil, crypt_err
}
if len(self.receiver_id) > 0 && strings.Compare(string(receiver_id), self.receiver_id) != 0 {
return nil, NewCryptError(ValidateCorpidError, "receiver_id is not equil")
}
return msg, nil
return msg, nil
}
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment