linux和windows系统问题相关

windows大量无效用户已注销仍然存在进程和会话

winlogon.exe 卡死问题

taskkill /f /im winlogon.exe /t

SSH端口转发

package main

import (
	"crypto/md5"
	b64 "encoding/base64"
	"encoding/hex"
	"fmt"
	"io"
	"log"
	"net"
	"os"
	"sync"
	"syscall"
	"time"

	"golang.org/x/crypto/ssh"
	"golang.org/x/crypto/ssh/terminal"
	"strings"
)
/**
CGO_ENABLED=0 GOOS=windows GOARCH=amd64 go build -ldflags '-w -s' main.go
go build -ldflags "-s -w" main.go
upx main.exe
*/
type Tunnel struct {
	Remote string
	Local  string
}

type SSHTunnel struct {
	sshClient  *ssh.Client
	Addr       string
	User       string
	Pass       string
	Tunnels    []Tunnel
	BufferSise int64
	Timeout    time.Duration
}

func (st *SSHTunnel) Close() {
	if nil != st.sshClient {
		st.sshClient.Close()
	}
}

func (st *SSHTunnel) GetSSHClient() (*ssh.Client, error) {
	if st.sshClient != nil {
		return st.sshClient, nil
	}
	var auth []ssh.AuthMethod
	auth = make([]ssh.AuthMethod, 0)
	auth = append(auth, ssh.Password(st.Pass))

	sc := &ssh.ClientConfig{
		User: st.User,
		Auth: auth,
		HostKeyCallback: func(hostname string, remote net.Addr, key ssh.PublicKey) error {
			return nil
		},
		Timeout: st.Timeout * time.Millisecond,
	}
	var err error
	st.sshClient, err = ssh.Dial("tcp", st.Addr, sc)
	if err != nil {
		return nil, err
	}
	log.Printf("连接到服务器成功: %s", st.Addr)
	return st.sshClient, err
}

func (st *SSHTunnel) ClientClose() {
	if st.sshClient != nil {
		st.sshClient.Close()
		st.sshClient = nil
	}
}

func (st *SSHTunnel) connect(t Tunnel) {
	ll, err := net.Listen("tcp", t.Local)
	if err != nil {
		log.Printf(`开启本地端口监听失败: %s, %s`, t.Local, err)
		return
	}
	defer func() {
		ll.Close()
		log.Printf(`断开隧道连接：%s <=> %s`, t.Local, t.Remote)
	}()
	log.Printf(`开启隧道：%s <=> %s`, t.Local, t.Remote)
	sno := int64(0)
	for {
		lc, err := ll.Accept()
		if err != nil {
			log.Printf(`接受来自本地的连接失败: %s`, err)
			return
		}
		log.Printf(`接收到本地连接 => %s`, t.Local)
		sc, err := st.GetSSHClient()
		if err != nil {
			log.Printf(`连接到服务器失败: %s`, err)
			lc.Close()
			continue
		}
		rc, err := sc.Dial("tcp", t.Remote)
		if err != nil {
			log.Printf(`连接到远程主机失败: %s`, err)
			st.ClientClose()
			lc.Close()
			continue
		}
		log.Printf(`连接到远程主机 => %s `, t.Remote)
		sno = sno + 1
		cid := fmt.Sprintf("%s <=> %s: %d", t.Local, t.Remote, sno)
		st.transfer(cid, lc, rc)
	}
}
//端口检测
func raw_connect(host string, ports []string) bool{
	for _, port := range ports {
		timeout := time.Second
		conn, err := net.DialTimeout("tcp", net.JoinHostPort(host, port), timeout)
		if err != nil {
			//fmt.Println("Connecting error:", err)
			log.Println("链接错误")
			return false
		}
		if conn != nil {
			defer conn.Close()
			//fmt.Println("Opened", net.JoinHostPort(host, port))
			return true
		}
	}
	return false
}

func main() {
	/***
	mac地址
	 */

	if getmac("8c:ec:4b:43:96:d1") ||getmac("08:94:ef:6e:e1:8e"){
		if len(os.Args) == 1 {
			log.Println(`ERROR`)
			os.Exit(1)
		}
		p := os.Args[1]
		md5 := md5.New()
		md5.Write([]byte(p))
		MD5Str := hex.EncodeToString(md5.Sum(nil))
		log.Println(MD5Str)
		if strings.EqualFold(MD5Str,"验证密码MD5"){ //
            A := "域名:端口"
			B := "ssh登录用户名"
			C := "ssh登录密码"
			AA, _ :=b64.StdEncoding.DecodeString(A)
			AAA,_ :=b64.StdEncoding.DecodeString("域名base64") 
            AAAA,_:=b64.StdEncoding.DecodeString("IP:端口的base64") 
			BB, _ :=b64.StdEncoding.DecodeString(B)
			CC, _ :=b64.StdEncoding.DecodeString(C)
			if raw_connect(BytesToString(AAA),[]string{"端口"})==false {
				AA =AAAA
			}
			println("开始使用吧~~")
			sts :=[]SSHTunnel{{
				Addr:BytesToString(AA),
				User:BytesToString(BB),
				Pass:BytesToString(CC),
				Tunnels:[]Tunnel {{
					Remote:"127.0.0.1:6666",
					Local:"0.0.0.0:6666",
				},
				{
					Remote:"127.0.0.1:7777",
					Local:"0.0.0.0:7777",
				},
				},
			},
			}
			//if len(os.Args) == 1 {
			//	log.Println(`缺少配置文件路径参数`)
			//	return
			//}
			//p := os.Args[1]
			//f, err := ioutil.ReadFile(p)
			//if err != nil {
			//	log.Printf(`载入配置文件出错: %s`, err)
			//	os.Exit(-1)
			//}
			//err = json.Unmarshal(f, &sts)
			//if nil != err {
			//	log.Printf(`解析配置文件内容出错: %s`, err)
			//	os.Exit(-1)
			//}

			var wg sync.WaitGroup
			for _, st := range sts {
				st.check()
				wg.Add(1)
				go func() {
					start(st)
					wg.Done()
				}()
				log.Printf(`启动隧道配置：%s`, st.Addr)
			}
			wg.Wait()
		}else {
			log.Println("Error")
			os.Exit(1)
		}

	}else {
		os.Exit(1)
	}
}

func (st *SSHTunnel) setPass() {
	//fmt.Printf("请输入登陆密码[%s@%s]:", st.User, st.Addr)
	bytePassword, _ := terminal.ReadPassword(int(syscall.Stdin))
	st.Pass = string(bytePassword)
	//fmt.Println()
}

func (st *SSHTunnel) check() {
	if len(st.Pass) == 0 {
		st.setPass()
	}

	if st.BufferSise == 0 {
		st.BufferSise = 5 * 1024
	}

	if st.Timeout == 0 {
		st.Timeout = 3000
	}

	st.initSSHClient()
}

func (st *SSHTunnel) initSSHClient() {
	_, err := st.GetSSHClient()
	if nil != err {
		error := err.Error()
		log.Printf(`连接主机失败: %s`, error)
		if strings.Contains(error, "unable to authenticate") {
			st.Pass = ""
			st.setPass()
			st.initSSHClient()
			return
		}
		if strings.Contains(error, "i/o timeout") {
			log.Printf(`连接到服务器超时: %s`, st.Addr)
			os.Exit(-1)
		}
	}
}

func start(st SSHTunnel) {
	defer st.Close()
	var wg sync.WaitGroup
	for _, t := range st.Tunnels {
		wg.Add(1)
		go func(tunnel Tunnel) {
			st.connect(tunnel)
			wg.Done()
		}(t)
	}
	wg.Wait()
}

func (st SSHTunnel) transfer(cid string, lc net.Conn, rc net.Conn) {
	copyBufPool := sync.Pool{
		New: func() interface{} {
			b := make([]byte, st.BufferSise)
			return &b
		},
	}
	go func() {
		defer lc.Close()
		defer rc.Close()
		log.Printf(`连接下行通道：%s`, cid)
		bufp := copyBufPool.Get().(*[]byte)
		defer copyBufPool.Put(bufp)
		io.CopyBuffer(lc, rc, *bufp)
		log.Printf(`断开下行通道：%s`, cid)
	}()
	go func() {
		defer rc.Close()
		defer lc.Close()
		log.Printf(`连接上行通道：%s`, cid)
		bufp := copyBufPool.Get().(*[]byte)
		defer copyBufPool.Put(bufp)
		io.CopyBuffer(rc, lc, *bufp)
		log.Printf(`断开上行通道：%s`, cid)
	}()
}
func getmac(m string) bool {
	// 获取本机的MAC地址
	interfaces,err := net.Interfaces()
	if err != nil {
		panic("Error : " + err.Error())
	}
	var t int =0
	for _,inter := range interfaces {
		//var mac []byte
		//mac = inter.HardwareAddr //获取本机MAC地址
		mac :=inter.HardwareAddr.String()
		//fmt.Println("MAC = ",mac)
		if mac == m {
			t=t+1
		}
	}
	if t>=1 {
		return true
	}else {
		return false
	}
}

func BytesToString(data []byte) string {
	return string(data[:])
}

RDS 5.7的物理备份恢复到本地的方法

https://yq.aliyun.com/articles/688509

需要本地安装的软件:

- mysql 5.7.24 版本
- Percona Xtrabackup 2.4.12

注意事项:

- 本地必须是linux系统.
- 不能有占用3306端口的其它程序执行.
- 本次在 centos7.2 64 位系统下测试通过

恢复的详细步骤如下:

1. 登录到RDS 控制台, 找到对应地域,在实例管理中,选择备份恢复,数据备份,点”下载”.如图:
   
2. 在弹出的窗口中,选择复制外网地址,如图:
   
3. ssh登录到ecs, 执行下载命令,格式为:

wget -c '<数据备份文件外网下载地址>' -O <自定义文件名>.tar.gz

1. 对下载的数据文件进行解压.命令如下:

tar -izxvf <数据备份文件名>.tar.gz -C /home/mysql/data

1. 查看解压后的文件:

ls /home/mysql/data

命令执行成功后，系统会返回如下结果,以 d 开头的蓝色目录表示数据库名称

1. 下载并解压 percona Xtrabackup 2.4.12,并将解压后的目录改名为Xtrabackup2.4.12

wget -c 'https://www.percona.com/downloads/XtraBackup/Percona-XtraBackup-2.4.12/binary/tarball/percona-xtrabackup-2.4.12-Linux-x86_64.libgcrypt11.tar.gz' -O  Xtrabackup2.4.12.tar.gz
tar zxvf  Xtrabackup2.4.12.tar.gz
mv percona-xtrabackup-2.4.12-Linux-x86_64 Xtrabackup2.4.12

1. 用 innobackex 恢复解压后的数据.命令如下:

   innobackupex --defaults-file=/home/landv/Desktop/fu/backup-my.cnf --apply-log /home/landv/Desktop/fu/

./Xtrabackup2.4.12/bin/innobackupex --defaults-file=/home/mysql/data/backup-my.cnf --apply-log  /home/mysql/data/

若系统返回如下类似结果，则说明备份文件已成功恢复到本地数据库。

1. 查看有没有在运行的mysql或占用3306端口的程序.命令如下:
   

如上图结果为空,表示没有.

1. 修改backup-my.cnf ,具体操作步骤如下:
   I: 用vi打开backup-my.cnf

vi /home/mysql/data/backup-my.cnf

II:按字母i键,进入编辑模式,注释如下参数,即在行首添加#号,并在尾部添加 skip-grant-tables项.

#innodb_log_checksum_algorithm=strict_crc32
#innodb_fast_checksum=false
#innodb_page_size=16384
#innodb_log_block_size=512
#redo_log_version=1
#server_uuid=e4323bd1-072f-11e9-97a1-7cd30ad32d28
#master_key_id=0

修改后的配置文件应是如下内容:

# The MySQL server
[mysqld]
innodb_checksum_algorithm=crc32
#innodb_log_checksum_algorithm=strict_crc32
innodb_data_file_path=ibdata1:200M:autoextend
innodb_log_files_in_group=2
innodb_log_file_size=1048576000
#innodb_fast_checksum=false
#innodb_page_size=16384
#innodb_log_block_size=512
innodb_undo_directory=./
innodb_undo_tablespaces=0
server_id=1960504189
#redo_log_version=1
#server_uuid=e4323bd1-072f-11e9-97a1-7cd30ad32d28
#master_key_id=0
skip-grant-tables

–skip-grant-tables 加到配置文件里面没有用，请加到启动命令里面

III:按esc键,录入 :x 退出并保存修改.

1. 修改目录属组和权限
2. mysql:mysql -R /home/mysql/data/
3. 755 -R /home/mysql/data/
4. 执行命令，启动MySQL,命令如下:

mysqld_safe --defaults-file=/home/mysql/data/backup-my.cnf --datadir=/home/mysql/data/  --user=mysql --skip-grant-tables

注意: mysqld_safe 必须是已经加入到了系统环境变量中,否则需要写上该命令的绝对路径.

1. 检查是否启动成功.
   命令仍为:

ps -ef|grep -i mysql|grep -v grep

如下图所示,表示启动成功.

1. 登录mysql.因为设置了 skip-grant-tables,所以无须密码.命令为:

mysql

下图表示登录成功:

1. 查看并修改超级账号 aliyun_root 的密码. 命令为:

select host,user from mysql.user;
update mysql.user set authentication_string=password('新密码') where user='aliyun_root';

这时会报错,Unknown system variable ‘maintain_user_list’,如图:

表示有触发器.
注意: 在mysql5.7 中, aliyun_root 才是真正超级权限账号.

1. 查看并删除触发器.命令如下:

select trigger_schema,trigger_name from information_schema.triggers;

结果如图,发现有两个sys库下的触发器.

删除这两个触发器,命令如下:

drop trigger sys.sys_config_insert_set_user;
drop trigger sys.sys_config_update_set_user;

如下图所示,表示删除成功了.

1. 再次修改密码,仍然报错.错误和14步骤中一致.这时我们还要删除触发器文件.先退出mysql,在 shell 下查找.TRG 结尾的文件,命令如下:

find /home/mysql/data/ -iname *.trg

结果如下图,表示触发器文件还在.

为避免误删除其它文件,我们先将它移到家目录下.命令如下:

mv /home/mysql/data/mysql/*.TRG ~

再次查询,保证移除成功,下图表示移除成功.

1. 再次登录并修改 aliyun_root 的密码.命令同上,下图表示修改成功.
   

我们退出mysql.然后关闭 mysql 服务.命令为:

mysqladmin shutdown

1. 修改 backup-my.cnf, 注释 skip-grant-tables, 保存, 并再次启动mysql.
2. 这次登录需要密码验证,登录命令为:

mysql -ualiyun_root -p -h127.0.0.1

回车,录入刚修改的密码后,就能登录了.如图表示成功登录.

1. 因为 aliyun_root 是超级账号,有超级权限.所以可以做任何操作.

好的,整个恢复步骤就完成了.

mysqldump -uroot -proot --databases db1  >/tmp/user.sql

mysqld_safe 使用过后，deepin系统需要重启，重启大发好。

linux常用软件

• Winetricks

• FineBI

• WPS

• Dbeaver

• visual Studio Code

• chrome

• Chromium

• 百度网盘

• 中望CAD

• 向日葵远程控制

• Typora -MD编辑器

• FileZilla -ftp客户端

• Open Broadcaster Software –屏幕串流工具

• 迅雷极速版

• qBittorrent -BT 下载工具

• GIMP –绘图工具

• XMind –思维导图

• PlayOnLinux -wine工具

• 亿图思维导图

• GtkHash -GtkHash是一个用来计算消息摘要和checksum的工具，当前支持的哈希函数包括：MD5、SHA1、SHA256、SHA512、RIPEMD、TIGER、WHIRLPOOL。

• VirtualBox 6.0 虚拟机管理器

• VNC Viewer vnc客户端

• Remmina 远程工具

• Glade -gtk 界面设计工具

• Calibre -Calibre是一个“一站式”的电子书管理软件，支持EPUB、MOBI、PDF等大多数格式的电子书。您可以把Calibre当做电子书图书馆来进行图书管理，也可以使用它来进行电子书的格式转换、阅读等。

• Kedis -redis 客户端

• QTCreator -QTIDE

• Wireshark -网络抓包工具

• JetBrains Toolbox

• FBReader -FBReader是一款阅读器，支持ePub，fb2，mobi，rtf，html文件格式，可以在线或者离线阅读。通过FBReader阅读软件，您可以享受更多的阅读乐趣。您可以根据需要任意设置颜色、字体、按键绑定或者是更改对话框中的其他属性。快来享受掌中阅读的乐趣吧。

• ChmSee -ChmSee是一个在Linux下阅读CHM格式帮助文件的软件，对中文支持良好，目前支持简体和英文编码的CHM文件。chmsee具有与Firefox类似的分页浏览标签，能够自动检测编码，可以收藏书签，以及设置字体等。

• Zeal -Zeal 是一个简单的离线 API 文档浏览器，仿照 Dash写成，支持多文档集搜索和自定义快捷键，支持离线编辑, 还提供有各种插件，能够与 Sublime、Vim、Atom、Emacs、IDEA 等文本编辑器或 IDE 集成使用，可以兼容所有的Dash文档。

• 福昕阅读器 -福昕阅读器是一款PDF文档阅读器，对中文的支持度非常高。福昕阅读器作为全球最流行的PDF阅读器，能够快速打开、浏览、审阅、注释、签署及打印任何PDF文件。

• VLC -VLC是一款自由、开源的跨平台多媒体播放器及框架，它支持大多数的音频与视频解码器及文件格式，还可以播放大多数多媒体文件，以及DVD、音频CD、VCD及各类流媒体协议

• 网易云音乐

• 搜狗输入法

• 文档查看器 -Evince是一个支持多种格式的文件浏览器，可以用来阅读如PDF、Postscript、djvu、tiff、dvi等格式的文件。evince还具有文档的索引支持、加密文档的查看和打印支持等功能。通过evince的书签和缩略图功能，您可以很方便的查看页面。

• npm

• yarn

• nvm

• nuget

• lnmp

• rvm

• ssh

• Vlang

• golang

• dotnet

• docker

• Virtual Machine Manager –kvm 管理器 https://virt-manager.org/download/

linux锁屏命令

列出当前所有的会话。这是默认命令。
sudo loginctl list-sessions

锁定/解锁会话(如果会话支持屏幕锁)。
如果指定了会话ID，那么将锁定/解锁指定的会话，否则将锁定/解锁当前调用者的会话。
sudo loginctl lock-session [ID…]
sudo loginctl unlock-session [ID…]

锁定/解锁所有支持屏幕锁的会话。
sudo loginctl lock-sessions
sudo loginctl unlock-sessions

linux 小技巧

获取当前电量信息，是否连接电源

upower -i $(upower -e | grep 'BAT') | grep -E "state|to\ full|percentage"

--state: charging 正在充电

          discharging 断开电源

--time to full: 充电完成时间

--percentage: 电池电量百分比

python 批量截取名称并重命名

#!/usr/bin/python
# -*- coding: UTF-8 -*-

import os, sys

# 打开文件
path = "/home/landv/Desktop/l/"
dirs = os.listdir( path )

# 输出所有文件和文件夹
for file in dirs:
    if os.path.splitext(file)[1] == '.jpg':  
        new=file[0:6]#截取文件名前六个字符        
        os.rename(file,new)#进行重命名
        #print file

shell 批量删除小括号和顿号

rename 's/\(//' *
rename 's/\)//' *
rename 's/\、//' *
rename 's/\ //' *

批量修改图片尺寸

convert -resize 50%x50% *
mogrify -quality 80% *

github初始化库修改分支

echo "# gobfuscate" >> README.md
git init
git add README.md
git commit -m "first commit"
git branch -M main
git remote add origin git@github.com:landv/gobfuscate.git
git push -u origin main

git remote add origin git@github.com:landv/gost.git
git branch -M main
git push -u origin main