使用Python3自带GUI、RSA、SQLite3做的密码管理软件

 

 

#_*_ coding:utf8 _*_

## Python3 密码管理 V1.0
## 2020-05-28
## 使用密钥对加密解密密码，密文存入本地SQLite3数据库，使用时直接右键解密到粘贴板中

import os               # 操作Windows文件用
import time
import random
#import hashlib
import rsa

## 数据库
import sqlite3

## 图形化模块
from tkinter import *
from tkinter import filedialog  # 选择文件用
import tkinter.messagebox       # 弹出提示对话框
from tkinter import ttk         # 下拉菜单控件在ttk中

top = Tk()                          # 初始化Tk()
top.title('Python3 密码管理 V1.0')  # 设置标题
width = 800                     # 设置窗口宽
height = 700                    # 设置窗口高
# 获取屏幕尺寸以计算布局参数，使窗口居屏幕中央
screenwidth = top.winfo_screenwidth()  
screenheight = top.winfo_screenheight() 
alignstr = '%dx%d+%d+%d' % (width, height, (screenwidth-width)/2, (screenheight-height)/2)   
top.geometry(alignstr)
top.resizable(width=True, height=True)  # 设置窗口是否可变长、宽，True：可变，False：不可变



######## Sqlite3 SQL 语句函数
##
## 数据库操作：执行SQL查询语句，返回执行状态和执行结果（数据列表）
def DEF_SQL_查询和返回(SQL_CMD):
    数据库连接对象 = sqlite3.connect('PWD.DB')     # 尝试打开数据库文件
    print("打开连接")
    try:
        游标对象 = 数据库连接对象.cursor()     # 创建一个游标
    except Exception as e:
        ERROR = '创建游标失败' + str(e)
        return(1, ERROR)
    else:
        print("创建游标")
        try:
            游标对象.execute(SQL_CMD)
        except Exception as e:
            ERROR = f'执行SQL语句 {SQL_CMD} 失败 {e}'
            游标对象.close()
            print("关闭游标")
            return(1, ERROR)
        else:
            全部记录 = 游标对象.fetchall()
            游标对象.close()
            print("关闭游标")
            return(0, 全部记录)

## 执行一条SQL语句
def DEF_SQL_执行(SQL_CMD):
    数据库连接对象 = sqlite3.connect('PWD.DB')     # 尝试打开数据库文件
    print("打开连接")
    try:
        游标对象 = 数据库连接对象.cursor()         # 创建一个游标
    except Exception as e:
        ERROR = '创建游标失败' + str(e)
        return(1, ERROR)
    else:
        print("创建游标")
        try:
            游标对象.execute(SQL_CMD)
        except Exception as e:
            游标对象.close()
            print("关闭游标")
            ERROR = str(e)
            return(1, ERROR)
        else:
            数据库连接对象.commit()           # 提交更改
            游标对象.close()
            print("关闭游标")
            数据库连接对象.close()
            print("关闭连接")
            return(0,)

## 执行SQL脚本
def DEF_SQL_执行脚本(SQL_SCRIPT):
    数据库连接对象 = sqlite3.connect('PWD.DB')     # 尝试打开数据库文件
    print("打开连接")
    try:
        游标对象 = 数据库连接对象.cursor()
    except Exception as e:
        ERROR = str(e)
        return(1, ERROR)
    else:
        print("创建游标")
        try:
            游标对象.executescript(SQL_SCRIPT)      # 执行SQL脚本
        except Exception as e:
            游标对象.close()
            print("关闭游标")
            ERROR = str(e)
            return(1, ERROR)
        else:
            数据库连接对象.commit()                 # 提交更改
            游标对象.close()
            print("关闭游标")
            数据库连接对象.close()
            print("关闭连接")
            return(0,)

## 打开刷新数据表，PWD表不存在则新建
def 打开数据库():
    ## 打开数据库
    ## 读取数据库内容
    SQL_CMD = 'SELECT * FROM PWD'
    R = DEF_SQL_查询和返回(SQL_CMD)
    if R[0] == 0:
        print("数据库表PWD读取成功")
        数据列表 = R[1]
        #print("数据列表", 数据列表)
        字段列表 = ['ID', 'PS', 'USER', 'PASS']
        字段和数据的存储和展示(字段列表, 数据列表)
    else:
        ## 创建表
        print("数据库表PWD读取失败，尝试创建据库表PWD")
        SQL_CMD = '''CREATE TABLE IF NOT EXISTS PWD(
        ID INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
        PS TEXT,
        USER TEXT,
        PASS TEXT);'''
        R = DEF_SQL_执行(SQL_CMD)
        if R[0] == 0:
            print("创建表PWD成功")
        else:
            ERROR = f'创建表失败:{R[1]}'
            tkinter.messagebox.showerror(title='ERROR', message=ERROR)
##
########


######## 新密钥对操作框
##


def 生成新密钥对():
    当前设置密钥长度 = IV_密钥长度.get()
    ## 生成新密钥对
    (公钥, 私钥) = rsa.newkeys(当前设置密钥长度)

    ## 保存新密钥对
    FILE_DATE = time.strftime('%Y%m%d_%H%M%S')
    新公钥文件名 = f'公钥_{当前设置密钥长度}_{FILE_DATE}.pem'
    with open(新公钥文件名, 'w') as f:
        f.write(公钥.save_pkcs1().decode())
    新私钥文件名 = f'私钥_{当前设置密钥长度}_{FILE_DATE}.pem'
    with open(新私钥文件名, 'w') as f:
        f.write(私钥.save_pkcs1().decode())
    INFO = '生成新密钥对完成，长度为：' + str(当前设置密钥长度)
    SV_新密钥对提示信息.set(INFO)
    ## 自动替换为新生成密钥对
    SV_选择公钥文件.set(新公钥文件名)
    Label_公钥提示信息['fg'] = 'green'
    SV_公钥提示信息.set('自动替换为新生成的公钥文件')
    SV_选择私钥文件.set(新私钥文件名)
    Label_私钥提示信息['fg'] = 'green'
    SV_私钥提示信息.set('自动替换为新生成的私钥文件')


新密钥对操作框 = LabelFrame(top, text='新密钥对操作框')
IV_密钥长度 = IntVar()
IV_密钥长度.set(1024)               # 设置默认值 1024
SV_新密钥对提示信息 = StringVar()
SV_新密钥对提示信息.set('生成密钥需要等待数秒时间')

Label(新密钥对操作框, text='设置新密钥长度').grid(row=0, column=0, sticky='NW')
#Entry(新密钥对操作框, textvariable=IV_密钥长度, width=5).grid(row=0, column=1)
Combobox_密钥长度 = ttk.Combobox(新密钥对操作框, width=5)
Combobox_密钥长度['value'] = (1024, 2048, 3072, 4096)
Combobox_密钥长度.current(0)                            # 默认值中的内容为索引，从0开始
Combobox_密钥长度.grid(row=0, column=1, sticky='E')
def 选择后执行函数(event):
    设置新密钥长度 = Combobox_密钥长度.get()
    IV_密钥长度.set(设置新密钥长度)
    print("设置新密钥长度", 设置新密钥长度)
Combobox_密钥长度.bind('<>', 选择后执行函数)
Button(新密钥对操作框, text='生成新密钥对', command=生成新密钥对).grid(row=0, column=2, sticky='NW')
Label_新密钥对提示信息 = Label(新密钥对操作框, textvariable=SV_新密钥对提示信息)
Label_新密钥对提示信息['fg'] = '#FF6600'
Label_新密钥对提示信息.grid(row=0, column=3)


新密钥对操作框.grid(row=0, column=0, sticky='NW')
##
########


######## 公钥文件框
##
SV_选择公钥文件 = StringVar()       ## TK全局变量:可以实时更新显示
SV_公钥提示信息 = StringVar()       ## 显示公钥文件的情况

def DEF_按钮_选择公钥文件():
    选择文件 = filedialog.askopenfilename()
    SV_选择公钥文件.set(选择文件)
    print("SV_选择公钥文件", SV_选择公钥文件)
    ## 选择文件后更新一下提示信息
    Label_公钥提示信息['fg'] = 'green'
    SV_公钥提示信息.set('已手动选择公钥文件')

公钥操作框 = LabelFrame(top, text='公钥')
Button(公钥操作框, text='选择公钥文件', command=DEF_按钮_选择公钥文件).grid(row=0, column=0, sticky='NW')
Entry(公钥操作框, textvariable=SV_选择公钥文件, width=55).grid(row=0, column=1)
Label_公钥提示信息 = Label(公钥操作框, textvariable=SV_公钥提示信息)
Label_公钥提示信息.grid(row=0, column=2)

默认公钥文件 = '公钥.pem'
if os.path.isfile(默认公钥文件):
    SV_选择公钥文件.set(默认公钥文件)           ## 设置公钥默认存放位置为程序同目录下，方便使用
    Label_公钥提示信息['fg'] = 'green'
    SV_公钥提示信息.set('自动选择默认公钥文件')
else:
    Label_公钥提示信息['fg'] = '#FF6600'
    SV_公钥提示信息.set('加密需要先选择公钥')

公钥操作框.grid(row=1, column=0, sticky='NW')
##
########


######## 私钥文件框
##
SV_选择私钥文件 = StringVar()
SV_私钥提示信息 = StringVar()

def DEF_按钮_选择私钥文件():
    选择文件 = filedialog.askopenfilename()
    SV_选择私钥文件.set(选择文件)              # 实时更新显示
    print("SV_选择私钥文件", SV_选择私钥文件)
    Label_私钥提示信息['fg'] = 'green'
    SV_私钥提示信息.set('已手动选择私钥文件')

私钥操作框 = LabelFrame(top, text='私钥')
Button(私钥操作框, text='选择私钥文件', command=DEF_按钮_选择私钥文件).grid(row=0, column=0, sticky='NW')
Entry(私钥操作框, textvariable=SV_选择私钥文件, width=55).grid(row=0, column=1)
Label_私钥提示信息 = Label(私钥操作框, textvariable=SV_私钥提示信息)
Label_私钥提示信息.grid(row=0, column=2)

默认私钥文件 = '私钥.pem'
if os.path.isfile(默认私钥文件):
    SV_选择私钥文件.set(默认私钥文件)           ## 设置私钥默认存放位置为程序同目录下，方便使用（不安全，私钥加密后可以提高安全性）
    Label_私钥提示信息['fg'] = 'green'
    SV_私钥提示信息.set('自动选择默认私钥文件')
else:
    Label_私钥提示信息['fg'] = '#FF6600'
    SV_私钥提示信息.set('提示:解密需要先选择私钥')

私钥操作框.grid(row=2, column=0, sticky='NW')
##
########



######## 存储操作框
##
def 明文存入():
    print("明文存入")
    备注 = Entry_备注.get().strip()
    帐号 = Entry_帐号.get().strip()
    密码 = Entry_密码.get().strip()
    if 备注 == '' or 帐号 == '' or 密码 == '':
        ERROR = '备注/帐号/密码 中有空内容'
        tkinter.messagebox.showerror(title='ERROR', message=ERROR)
    else:
        #print(备注,帐号,密码)
        ## 存入数据库
        SQL_插入数据 = f'INSERT INTO PWD (PS, USER, PASS) VALUES ("{备注}", "{帐号}", "{密码}");'
        R_INSERT = DEF_SQL_执行(SQL_插入数据)
        if R_INSERT[0] == 0:
            print("插入数据成功")
            Entry_备注.delete(0, END)         # 界面：清空输入框
            Entry_帐号.delete(0, END)         # 界面：清空输入框
            Entry_密码.delete(0, END)         # 界面：清空输入框
            打开数据库()
        else:
            #print("插入数据失败", R_INSERT[1])
            ERROR = f'插入数据失败:{R_INSERT[1]}'
            tkinter.messagebox.showerror(title='ERROR', message=ERROR)

def 密文存入():
    print("密文存入")
    备注 = Entry_备注.get().strip()
    帐号 = Entry_帐号.get().strip()
    密码 = Entry_密码.get().strip()
    if 备注 == '' or 帐号 == '' or 密码 == '':
        ERROR = '备注/帐号/密码 中有空内容'
        tkinter.messagebox.showerror(title='ERROR', message=ERROR)
    else:
        #print(备注,帐号,密码)
        ## 明文密码加密
        公钥文件 = SV_选择公钥文件.get()
        if 公钥文件.rstrip() == '':
            ERROR = '没有选择公钥文件'
            tkinter.messagebox.showerror(title='ERROR', message=ERROR)
        else:
            try:
                f = open(公钥文件,'r')
            except Exception as E:
                print("打开公钥文件失败", E)
                ERROR = f'打开公钥文件失败:{E}'
                tkinter.messagebox.showerror(title='ERROR', message=ERROR)
            else:
                print("打开公钥文件成功")
                try:
                    pubkey = rsa.PublicKey.load_pkcs1(f.read().encode())
                except Exception as E:
                    print("读取公钥失败", E)
                    f.close()
                    ERROR = f'读取公钥失败:{E}'
                    tkinter.messagebox.showerror(title='ERROR', message=ERROR)
                else:
                    print("读取公钥成功")
                    f.close()
                    密码_B = str(密码).encode('UTF8')                                       # 转成UTF8编码的字节
                    #print("文本密码转字节密码", 密码_B, type(密码_B))
                    ## 公钥加密
                    公钥加密后密文 = rsa.encrypt(密码_B, pubkey)
                    #print("公钥加密后密文", 公钥加密后密文)
                    
                    ## 字节类型转成16进制字符串存储到数据库
                    STR_HEX = Bytes2HEX_STR(公钥加密后密文)
                    #print("公钥加密后密文 转 STR_HEX", type(STR_HEX))
                    #print(STR_HEX)

                    pubkey = ''         # 每次用完清空
                    
                    ## 存入数据库
                    SQL_插入数据 = f'INSERT INTO PWD (PS, USER, PASS) VALUES ("{备注}", "{帐号}", "{STR_HEX}");'
                    R_INSERT = DEF_SQL_执行(SQL_插入数据)
                    if R_INSERT[0] == 0:
                        print("插入数据成功")
                        Entry_备注.delete(0, END)         # 界面：清空输入框
                        Entry_帐号.delete(0, END)         # 界面：清空输入框
                        Entry_密码.delete(0, END)         # 界面：清空输入框
                        打开数据库()                      # 更新数据库显示框
                    else:
                        ERROR = f'插入数据失败:{R_INSERT[1]}'
                        tkinter.messagebox.showerror(title='ERROR', message=ERROR)

def 帐号密码加密存入():
    print("帐号和密码都加密存储")
    备注 = Entry_备注.get().strip()
    帐号 = Entry_帐号.get().strip()
    密码 = Entry_密码.get().strip()
    if 备注 == '' or 帐号 == '' or 密码 == '':
        ERROR = '备注/帐号/密码 中有空内容'
        tkinter.messagebox.showerror(title='ERROR', message=ERROR)
    else:
        #print(备注,帐号,密码)
        ## 明文密码加密
        公钥文件 = SV_选择公钥文件.get()
        if 公钥文件.rstrip() == '':
            ERROR = '没有选择公钥文件'
            tkinter.messagebox.showerror(title='ERROR', message=ERROR)
        else:
            try:
                f = open(公钥文件,'r')
            except Exception as E:
                print("打开公钥文件失败", E)
                ERROR = f'打开公钥文件失败:{E}'
                tkinter.messagebox.showerror(title='ERROR', message=ERROR)
            else:
                print("打开公钥文件成功")
                try:
                    pubkey = rsa.PublicKey.load_pkcs1(f.read().encode())
                except Exception as E:
                    print("读取公钥失败", E)
                    f.close()
                    ERROR = f'读取公钥失败:{E}'
                    tkinter.messagebox.showerror(title='ERROR', message=ERROR)
                else:
                    print("读取公钥成功")
                    f.close()
                    
                    ## 公钥加密密码
                    密码_B = str(密码).encode('UTF8')                       # 转成UTF8编码的字节
                    密码公钥加密后密文 = rsa.encrypt(密码_B, pubkey)
                    STR_HEX_密码 = Bytes2HEX_STR(密码公钥加密后密文)        ## 字节类型转成16进制字符串
                    
                    ## 公钥加密帐号
                    帐号_B = str(帐号).encode('UTF8')
                    帐号公钥加密后密文 = rsa.encrypt(帐号_B, pubkey)
                    STR_HEX_帐号 = Bytes2HEX_STR(帐号公钥加密后密文)

                    pubkey = ''         # 每次用完清空
                    
                    ## 存入数据库
                    SQL_插入数据 = f'INSERT INTO PWD (PS, USER, PASS) VALUES ("{备注}", "{STR_HEX_帐号}", "{STR_HEX_密码}");'
                    R_INSERT = DEF_SQL_执行(SQL_插入数据)
                    if R_INSERT[0] == 0:
                        print("插入数据成功")
                        Entry_备注.delete(0, END)         # 界面：清空输入框
                        Entry_帐号.delete(0, END)         # 界面：清空输入框
                        Entry_密码.delete(0, END)         # 界面：清空输入框
                        打开数据库()                      # 更新数据库显示框
                    else:
                        ERROR = f'插入数据失败:{R_INSERT[1]}'
                        tkinter.messagebox.showerror(title='ERROR', message=ERROR)

def 搜索备注信息():
    print("搜索备注信息")
    备注 = Entry_备注.get().strip()
    if 备注 == '':
        ERROR = '备注空内容'
        tkinter.messagebox.showerror(title='ERROR', message=ERROR)
    else:
        print("搜索备注", 备注)
        SQL_CMD = f'SELECT * FROM PWD WHERE PS LIKE "%{备注}%"'
        print("SQL_CMD", SQL_CMD)
        R = DEF_SQL_查询和返回(SQL_CMD)
        if R[0] == 0:
            print("执行搜索语句成功")
            数据列表 = R[1]
            #print("数据列表", 数据列表)
            字段列表 = ['ID', 'PS', 'USER', 'PASS']
            字段和数据的存储和展示(字段列表, 数据列表)
        else:
            ERROR = f'执行搜索语句失败:{R[1]}'
            tkinter.messagebox.showerror(title='ERROR', message=ERROR)

存储操作框 = LabelFrame(top, text='存储操作框')
存储操作框.grid(row=3, column=0, sticky='NW')        ## top 3-1

备注框 = Frame(存储操作框)
备注框.grid(row=1, column=0, sticky='NW')                        ## 存储操作框 1-0
Label(备注框, text='备注').grid(row=0, column=0)                                   ## 存储操作框 备注框 0-0
Entry_备注 = Entry(备注框, width=20)
Entry_备注.grid(row=1, column=0)                                                   ## 存储操作框 备注框 1-0
Button(备注框, text='搜索备注信息', command=搜索备注信息).grid(row=2, column=0)    ## 存储操作框 备注框 2-0

帐号框 = Frame(存储操作框)
帐号框.grid(row=1, column=1, sticky='NW')                        ## 存储操作框 1-1
Label(帐号框, text='帐号').grid(row=0, column=0)                                   ## 存储操作框 帐号框 0-0
Entry_帐号 = Entry(帐号框, width=20)
Entry_帐号.grid(row=1, column=0)                                                   ## 存储操作框 帐号框 1-0

密码框 = Frame(存储操作框)
密码框.grid(row=1, column=2, sticky='NW')                        ## 存储操作框 1-2
Label(密码框, text='密码').grid(row=0, column=0)                                   ## 存储操作框 密码框 0-0
Entry_密码 = Entry(密码框, width=30)
Entry_密码.grid(row=1, column=0)                                                   ## 存储操作框 密码框 1-0

数据库写入框 = Frame(存储操作框)
数据库写入框.grid(row=1, column=3, sticky='ESWN')                ## 存储操作框 1-3
Label(数据库写入框, text='密码存入数据库方式').grid(row=0, column=0, columnspan=3)                                ## 存储操作框 数据库写入框 0-0
Button(数据库写入框, text='  明文存入  ', command=明文存入).grid(row=1, column=0, sticky='NW')                    ## 存储操作框 数据库写入框 1-0
Button(数据库写入框, text='  密文存入  ', command=密文存入).grid(row=1, column=1, sticky='NW')                    ## 存储操作框 数据库写入框 1-1
Button(数据库写入框, text='  帐号和密码都加密  ', command=帐号密码加密存入).grid(row=1, column=2, sticky='NW')    ## 存储操作框 数据库写入框 1-2

SV_剪贴板提示信息 = StringVar()
Label_剪贴板提示信息 = Label(存储操作框, textvariable=SV_剪贴板提示信息)
Label_剪贴板提示信息['fg'] = '#FF6600'
Label_剪贴板提示信息.grid(row=2, column=0, columnspan=3, sticky='ESWN')        ## 存储操作框 2-0
##
########


######## 密码操作框
##
def 生成随机密码():
    密码长度 = IV_密码位数.get()
    数字字符列表 = ['0','1','2','3','4','5','6','7','8','9']
    大写字母列表 = ['A','B','C','D','E','F','G','H','J','K','M','N','P','Q','R','S','T','U','V','W','X','Y','Z']
    小写字母列表 = ['a','b','c','d','e','f','g','h','j','k','m','n','p','q','r','s','t','u','v','w','x','y','z']
    符号字符列表 = ['`','~','!','@','#','$','%','^','&','*','(',')','-','_','=','+','[','{',']','}','|',';',':','<','.','>','/','?']
    组合列表 = 数字字符列表 + 大写字母列表 + 小写字母列表 + 符号字符列表
    if 密码长度 > 84:
        ERROR = '过长，请设置长度 <= 84'
        tkinter.messagebox.showerror(title='ERROR', message=ERROR)
    else:
        random.shuffle(组合列表)
        随机密码 = ''
        for i in range(0, 密码长度):
            随机密码 += 组合列表[i]
        #print(随机密码)
        Entry_密码.delete(0, END)         # 界面：清空输入框
        Entry_密码.insert(END, 随机密码)

## 字节码转16进制格式的字符串
def Bytes2HEX_STR(Bytes):
    STR_HEX = ''
    for i in Bytes:
        STR_HEX += hex(i)[2:].zfill(2)      ## '0x50' 取 '50' 部分，如果不足2个字符，填充0
    return(STR_HEX)

IV_密码位数 = IntVar()
IV_密码位数.set(20)         ## 设置默认密码位数
密码操作框 = LabelFrame(存储操作框, text='')
Label(密码操作框, text='设置密码长度').grid(row=0, column=0, sticky='NW')
Entry(密码操作框, textvariable=IV_密码位数, width=5).grid(row=0, column=1)
Button(密码操作框, text='生成随机密码', command=生成随机密码).grid(row=0, column=2, sticky='NW')
Button(密码操作框, text='刷新数据库', bg='#00FFFF', command=打开数据库).grid(row=0, column=3, sticky='NW')
密码操作框.grid(row=0, column=0, sticky='NW', columnspan=8)
##
########



######## 数据库显示/操作框
##
字典_查询字段_坐标_初值 = {}  # KEY=控件坐标 || VAULE=初始值   || {(控件行号,控件列号):初始值}   || { (0,0):123 }
字典_查询结果_坐标_初值 = {}  # KEY=控件坐标 || VAULE=初始值   || {(控件行号,控件列号):初始值}   || { (0,0):123 }

数据框_定位行 = IntVar()
数据框_定位列 = IntVar()

## 信息复制到剪贴板
def DEF_解密后复制到剪贴板(): 
    控件行号 = 数据框_定位行.get()
    控件列号 = 数据框_定位列.get()
    print("控件行号", 控件行号, "控件列号", 控件列号)
    选中单元格内容 = 字典_查询结果_坐标_初值[(控件行号,控件列号)]
    print("选中单元格内容", 选中单元格内容)
    ## 解密密文
    私钥文件 = SV_选择私钥文件.get()
    if 私钥文件.rstrip() == '':
        ERROR = '没有选择私钥文件'
        tkinter.messagebox.showerror(title='ERROR', message=ERROR)
    else:
        try:
            f = open(私钥文件,'r')
        except Exception as E:
            ERROR = f'打开私钥文件失败:{E}'
            tkinter.messagebox.showerror(title='ERROR', message=ERROR)
        else:
            print("打开私钥文件成功")
            try:
                privkey = rsa.PrivateKey.load_pkcs1(f.read().encode())
            except Exception as E:
                print("读取私钥失败", E)
                f.close()
                ERROR = f'读取私钥失败:{E}'
                tkinter.messagebox.showerror(title='ERROR', message=ERROR)
            else:
                print("读取私钥成功")
                f.close()
                ## 读取字符串并还原字节类型
                try:
                    还原字节码 = bytes.fromhex(选中单元格内容)
                except Exception as E:
                    #print("还原字节码失败，格式有误(非16进制字符串形式", E)
                    ERROR = f'还原字节码失败，格式有误(非16进制字符串形式:{E}'
                    tkinter.messagebox.showerror(title='ERROR', message=ERROR)
                else:
                    #print("还原字节码", type(还原字节码))
                    #print(还原字节码)
                    ## 私钥解密
                    try:
                        B_私钥解密后明文 = rsa.decrypt(还原字节码, privkey)
                    except Exception as E:
                        #print("私钥解密失败", E)
                        ERROR = f'私钥解密失败:{E}'
                        tkinter.messagebox.showerror(title='ERROR', message=ERROR)
                    else:
                        print("私钥解密成功")
                        #print("B_私钥解密后明文(字节码)", type(B_私钥解密后明文))
                        S_私钥解密后明文 = B_私钥解密后明文.decode()
                        #print("S_私钥解密后明文(字符串)", S_私钥解密后明文)
                        privkey = ''         # 每次用完清空
                        top.clipboard_clear()
                        top.clipboard_append(S_私钥解密后明文)
                        
                        ## 提示哪个数据被复制到剪贴板
                        选中行ID = 字典_查询结果_坐标_初值[(控件行号,0)]
                        选中行列名 = 字典_查询字段_坐标_初值[(0,控件列号)]
                        INFO = f'ID【{选中行ID}】的【{选中行列名}】【解密后内容】 已经复制到剪贴板'
                        #tkinter.messagebox.showinfo(title='INFO', message=INFO)
                        SV_剪贴板提示信息.set(INFO)

def DEF_保留原值复制到剪贴板(): 
    控件行号 = 数据框_定位行.get()
    控件列号 = 数据框_定位列.get()
    print("控件行号", 控件行号, "控件列号", 控件列号)
    选中单元格内容 = 字典_查询结果_坐标_初值[(控件行号,控件列号)]
    print("选中单元格内容", 选中单元格内容)
    top.clipboard_clear()
    top.clipboard_append(选中单元格内容)
    
    ## 提示哪个数据被复制到剪贴板
    选中行ID = 字典_查询结果_坐标_初值[(控件行号,0)]
    选中行列名 = 字典_查询字段_坐标_初值[(0,控件列号)]
    INFO = f'ID【{选中行ID}】的【{选中行列名}】【原值】 已经复制到剪贴板'
    #tkinter.messagebox.showinfo(title='INFO', message=INFO)
    SV_剪贴板提示信息.set(INFO)



## 菜单按钮函数：删除整行（提取控件行号信息）
def DEL_ROW():
    控件行号 = 数据框_定位行.get()
    DEF_删除记录(控件行号)
    ## 删除成功后的行列号和当前行列号有差别，立刻设置为无效行列号，防止后面误删
    数据框_定位行.set(-1)
    数据框_定位列.set(-1)

## 菜单按钮函数：删除整行（根据控件行号删除）
def DEF_删除记录(控件行号):
    ID = 字典_查询结果_坐标_初值[(控件行号, 0)]
    print("DELETE ID", ID)
    SQL_CMD = f'DELETE FROM PWD WHERE ID = "{ID}"'
    print("SQL_CMD", SQL_CMD)
    ## 删除记录
    R = DEF_SQL_执行(SQL_CMD)
    if R[0] == 0:
        打开数据库()
    else:
        ERROR = f'删除记录失败:{R[1]}'
        tkinter.messagebox.showerror(title='ERROR', message=ERROR)

## 事件函数：右键菜单
def DEF_弹出_数据框_右键菜单(event):
    # 取值控制坐标
    选中控件 = event.widget
    行 = 选中控件.grid_info()['row']
    列 = 选中控件.grid_info()['column']
    # 赋值控制坐标变量
    数据框_定位行.set(行)
    数据框_定位列.set(列)
    ## 弹出菜单
    光标X轴 = event.x_root
    光标Y轴 = event.y_root
    数据框_右键菜单.post(光标X轴, 光标Y轴)    # 光标位置显示菜单

## 创建数据框右键菜单
数据框_右键菜单 = Menu()
数据框_右键菜单.add_command(label='解密 到 剪贴板', command=DEF_解密后复制到剪贴板)
数据框_右键菜单.add_separator()                                                        # 分隔线
数据框_右键菜单.add_separator()
数据框_右键菜单.add_command(label='原值 到 剪贴板', command=DEF_保留原值复制到剪贴板)
数据框_右键菜单.add_separator()
数据框_右键菜单.add_separator()
数据框_右键菜单.add_command(label='删除此行', command=DEL_ROW)

## 清空框内控件
def FRAME_CLEAR(FRAME_NAME):
    for X in FRAME_NAME.winfo_children():
        X.destroy()

## 在显编框展示结果，保存结果到全局变量，可以进行修改操作
def 字段和数据的存储和展示(L, LL):
    行数 = len(LL)
    
    FRAME_CLEAR(LabelFrame_显编框)                    # 清空框内控件
    ## 创建画布
    画布 = Canvas(LabelFrame_显编框, bg='#00CED1')    # 创建画布
    画布.grid(row=0,column=0)                         # 显示画布
    ## 在画布里创建 Frame
    画布Frame框 = Frame(画布)
    字段框 = Frame(画布Frame框)
    字段框.grid(row=0,column=0,sticky='NW')
    数据框 = Frame(画布Frame框)
    数据框.grid(row=1,column=0,sticky='NW')
    
    ## 动态设置画布窗口宽高：根据主主窗口的参数设置限宽限高
    主窗口大小和位置 = top.geometry()
    主窗口宽, 主窗口高, 主窗口X, 主窗口Y = re.findall('[0-9]+', 主窗口大小和位置)
    画布限宽 = int(主窗口宽)
    print("画布限宽", 画布限宽)
    if 画布限宽 < 589:
        画布限宽 = 589                  # 保障最小宽度
    画布限高 = int(主窗口高) -300       # 减去显示框上边的内容
    print("画布限高", 画布限高)
    if 画布限高 < 250:
        画布限高 = 250                  # 保障最小高度
    
    ## 设置画布参数
    总行数 = 行数 + 1
    
    ## 画布可滚动显示的最大宽和高（要刚好能放下画布里的Frame里的全部控件）
    画布滚动最右边 = 786          ## Enter默认宽20==140像素（7像素/每宽） ID 10 PS 30 USER20 PASS50
    画布滚动最下边 = 21*总行数    ## 20*行数 + 行数*1
    
    ## 动态设置显示画布固定显示宽和高（要和主显示框的大小匹配）
    if 画布限宽 > 画布滚动最右边:
        画布['width'] = 画布滚动最右边
    else:
        画布['width'] = 画布限宽 - 30
    
    if 画布限高 > 画布滚动最下边:
        画布['height'] = 画布滚动最下边
    else:
        画布['height'] = 画布限高
    
    画布['scrollregion'] = (0,0,画布滚动最右边,画布滚动最下边)   # 一个元组 tuple (w, n, e, s) ，定义了画布可滚动的最大区域，w 为左边，n 为头部，e 为右边，s 为底部
    
    # 竖滚动条
    Scrollbar_画布_竖 = Scrollbar(LabelFrame_显编框, command=画布.yview)
    Scrollbar_画布_竖.grid(row=0,column=1,sticky=S+W+E+N)
    
    # 横滚动条
    Scrollbar_画布_横 = Scrollbar(LabelFrame_显编框, command=画布.xview, orient=HORIZONTAL)
    Scrollbar_画布_横.grid(row=1,column=0,sticky=S+W+E+N)

    画布.config(xscrollcommand=Scrollbar_画布_横.set, yscrollcommand=Scrollbar_画布_竖.set) # 自动设置滚动幅度
    画布.create_window((0,0), window=画布Frame框, anchor='nw')

    ## 在 画布里的Frame里创建控件
    # 清除全局字典的内容
    字典_查询字段_坐标_初值.clear()
    字典_查询结果_坐标_初值.clear()
    
    ## 字段名
    ## 固定行：0
    ## 固定列：ID PS USER PASS
    ## ID
    初始值 = str(L[0])                  # 转成字符串
    字典_查询字段_坐标_初值[(0,0)] = 初始值 # 保存初始值
    输入框对象 = Entry(字段框, width=10, bg='#00BFFF')
    输入框对象.insert(0, 初始值)
    输入框对象.grid(row=0,column=0,sticky='W')
    
    ## PS
    初始值 = str(L[1])                  # 转成字符串
    字典_查询字段_坐标_初值[(0,1)] = 初始值 # 保存初始值
    输入框对象 = Entry(字段框, width=30, bg='#00BFFF')
    输入框对象.insert(0, 初始值)
    输入框对象.grid(row=0,column=1,sticky='W')
    
    ## USER
    初始值 = str(L[2])                  # 转成字符串
    字典_查询字段_坐标_初值[(0,2)] = 初始值 # 保存初始值
    输入框对象 = Entry(字段框, width=20, bg='#00BFFF')
    输入框对象.insert(0, 初始值)
    输入框对象.grid(row=0,column=2,sticky='W')
    
    ## PASS
    初始值 = str(L[3])                  # 转成字符串
    字典_查询字段_坐标_初值[(0,3)] = 初始值 # 保存初始值
    输入框对象 = Entry(字段框, width=50, bg='#00BFFF')
    输入框对象.insert(0, 初始值)
    输入框对象.grid(row=0,column=3,sticky='W')
    
    ## 数据值
    for 行 in range(0, 行数):
        ## 固定列：ID PS USER PASS
        ## ID
        初始值 = str(LL[行][0])                  # 转成字符串
        字典_查询结果_坐标_初值[(行,0)] = 初始值 # 保存初始值
        输入框对象 = Entry(数据框, width=10)
        输入框对象.insert(0, 初始值)
        输入框对象.grid(row=行,column=0,sticky='W')
        输入框对象.bind("", DEF_弹出_数据框_右键菜单) # 每个控件对象都绑定右键菜单事件
        
        ## PS
        初始值 = str(LL[行][1])                  # 转成字符串
        字典_查询结果_坐标_初值[(行,1)] = 初始值 # 保存初始值
        输入框对象 = Entry(数据框, width=30)
        输入框对象.insert(0, 初始值)
        输入框对象.grid(row=行,column=1,sticky='W')
        输入框对象.bind("", DEF_弹出_数据框_右键菜单) # 每个控件对象都绑定右键菜单事件
        
        ## USER
        初始值 = str(LL[行][2])                  # 转成字符串
        字典_查询结果_坐标_初值[(行,2)] = 初始值 # 保存初始值
        输入框对象 = Entry(数据框, width=20)
        输入框对象.insert(0, 初始值)
        输入框对象.grid(row=行,column=2,sticky='W')
        输入框对象.bind("", DEF_弹出_数据框_右键菜单) # 每个控件对象都绑定右键菜单事件
        
        ## PASS
        初始值 = str(LL[行][3])                  # 转成字符串
        字典_查询结果_坐标_初值[(行,3)] = 初始值 # 保存初始值
        输入框对象 = Entry(数据框, width=50)
        输入框对象.insert(0, 初始值)
        输入框对象.grid(row=行,column=3,sticky='W')
        输入框对象.bind("", DEF_弹出_数据框_右键菜单) # 每个控件对象都绑定右键菜单事件

LabelFrame_显编框 = LabelFrame(top, text='显示/编辑框', bg='#FFD700')
LabelFrame_显编框.grid(row=4,column=0,sticky='NW')
##
########



######## SQL命令框
##
## 执行用户输入的SQL语句
def DEF_按钮_执行SQL语句():
    SQL_CMD = 文本框_命令行.get(1.0, END).rstrip('\n')     # 获取编写的SQL语句，去掉后面的回车符号
    if SQL_CMD.strip() != '':
        R = DEF_SQL_执行(SQL_CMD)                      # 调用非查询语句函数
        if R[0] == 0:
            INFO = f'数据库执行SQL语句 {SQL_CMD} 成功'
            打开数据库()     ## 更新一下数据库显示
            tkinter.messagebox.showinfo(title='成功', message=INFO)
        else:
            ERROR = f'数据库执行SQL语句 {SQL_CMD} 失败 {R[1]}'
            tkinter.messagebox.showerror(title='失败', message=ERROR)
    else:
        ERROR = '没有输入SQL语句'
        tkinter.messagebox.showerror(title='错误', message=ERROR)

## 执行用户输入的SQL脚本
def DEF_按钮_执行SQL脚本():
    SQL_CMD = 文本框_命令行.get(1.0, END).rstrip('\n')     # 获取编写的SQL语句，去掉后面的回车符号
    if SQL_CMD.strip() != '':
        R = DEF_SQL_执行脚本(SQL_CMD)                      # 调用非查询语句函数
        if R[0] == 0:
            INFO = f'数据库执行SQL脚本 {SQL_CMD} 成功'
            打开数据库()     ## 更新一下数据库显示
            tkinter.messagebox.showinfo(title='成功', message=INFO)
        else:
            ERROR = f'数据库执行SQL脚本 {SQL_CMD} 失败 {R[1]}'
            tkinter.messagebox.showerror(title='失败', message=ERROR)
    else:
        ERROR = 'SQL脚本无内容'
        tkinter.messagebox.showerror(title='错误', message=ERROR)

## 清除命令框里的内容
def DEF_按钮_清屏():
    文本框_命令行.delete(0.0, END)
    文本框_命令行.focus_set()


命令框 = LabelFrame(top, text='SQL语句/SQL脚本')
命令框.grid(row=5,column=0,sticky='NW')

命令行_按钮框 = Text(命令框)
命令行_按钮框.grid(row=1,column=0)
Button(命令行_按钮框, text='执行SQL语句', command=DEF_按钮_执行SQL语句).grid(row=0, column=0)
Button(命令行_按钮框, text='执行SQL脚本', command=DEF_按钮_执行SQL脚本).grid(row=0, column=1)
Button(命令行_按钮框, text='清屏', command=DEF_按钮_清屏).grid(row=0, column=2)

文本框_命令行 = Text(命令框, height=3, wrap='none')
文本框_命令行.grid(row=2,column=0,sticky='NESW')
Scrollbar_命令框_竖 = Scrollbar(命令框) 
Scrollbar_命令框_竖['command'] = 文本框_命令行.yview
Scrollbar_命令框_横 = Scrollbar(命令框) 
Scrollbar_命令框_横['command'] = 文本框_命令行.xview
Scrollbar_命令框_横['orient'] = HORIZONTAL
Scrollbar_命令框_竖.grid(row=2, column=1, sticky=S+W+E+N)
Scrollbar_命令框_横.grid(row=3, column=0, sticky=S+W+E+N)
文本框_命令行.config(xscrollcommand=Scrollbar_命令框_横.set, yscrollcommand=Scrollbar_命令框_竖.set)  # 自动设置滚动条滑动幅度




## 开软件后先初始化数据库
## 如果PWD表不存在则创建表
SQL_CMD = '''CREATE TABLE IF NOT EXISTS PWD(
ID INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
PS TEXT,
USER TEXT,
PASS TEXT);'''
R = DEF_SQL_执行(SQL_CMD)
if R[0] == 0:
    print("创建表PWD成功")
else:
    ERROR = f'创建表失败:{R[1]}'
    tkinter.messagebox.showerror(title='ERROR', message=ERROR)

## 再打开数据库
打开数据库()

# 进入消息循环
top.mainloop()