20231427田泽航实验4-1

20231427田泽航_实验4

部署运行你感兴趣的模型镜像一键部署
密码模块的应用
实践要求（40分）
****1 .完成电子公文交换系统，系统功能，（15分）

mindmap
root((电子公文系统))
发文
公文起草
公文查看
发文审核（审核员）
公文发送
公文查询
收文
公文签收
公文查看
公文处理
公文查询
系统管理
组织单位
用户管理
操作员（科员）
审核员（科⻓，处⻓）：至少有一级审核功能
系统管理员：至少管理用户账号，组织单位功能
安全保密管理员：至少有权限管理功能，密钥管理功能
安全审计员：至少有日志查看功能
权限设置（安全保密管理员）
系统日志
数据字典（选做）

总体要求
项目类型必须是B/S或C/S架构
项目程序设计语言可以是C，Python，Rust等
三员制度是指将系统管理员、安全保密管理员和安全审计员三个⻆色分离，分别负责系统运行、安全保密和安全管理，相互制约，共同保障信息系统安全。三员职责
系统管理员
负责信息系统的日常维护、故障处理和升级更新。
确保系统正常运行，对系统资源进行合理分配。
负责用户账号的创建、修改和删除。
定期备份重要数据，确保数据安全。

安全保密管理员
负责制定和实施安全保密策略，确保信息系统安全。
对用户进行安全意识培训，提高用户安全防范能力。
监控网络安全状况，发现异常情况及时处理。
负责信息系统安全事件的应急响应和处理。

安全审计员
负责对信息系统进行安全审计，评估安全⻛险。
监督系统管理员和安全保密管理员的工作，确保其履行职责。
对信息系统安全事件进行调查，提出整改建议。
3. ⻩金法则（5分）
身份鉴别：口令不能存，数据库要保存加盐的SM3Hash值
访问控制：操作员，审核员，安全三员的权限设置
安全审计：至少完成日志查询功能
4. 密码（15分）
算法：SM2，SM3，SM4，推荐使用 Key
密钥管理：所有私钥，对称算法密钥等不能明存
5. 系统量化评估（5分）
按照商用密码应用安全性评估量化评估规则,计算自己系统的得分，只计算应用和数据安全

****二、系统测试及实现过程
操作规程
运行代码
该项目是在python中Django环境下实现的，首先运行代码需要在终端下实行以下操作：

C:\Users\dell\AppData\Local\Programs\Python\Python311\python.exe C:\Users\dell\Desktop\docsys-master\完整项目\doc-trans-sys\system-master\manage.py

Type 'manage.py help ' for help on a specific subcommand.

Available subcommands:

[auth]
changepassword
createsuperuser

[contenttypes]
remove_stale_contenttypes

[django]
check
compilemessages
createcachetable
dbshell
diffsettings
dumpdata
flush
inspectdb
loaddata
makemessages
makemigrations
migrate
optimizemigration
sendtestemail
shell
showmigrations
sqlflush
sqlmigrate
sqlsequencereset
squashmigrations
startapp
startproject
test
testserver

[django_extensions]
admin_generator
clean_pyc
clear_cache
compile_pyc
create_command
create_jobs
create_template_tags
delete_squashed_migrations
describe_form
drop_test_database
dumpscript
export_emails
find_template
generate_password
generate_secret_key
graph_models
list_model_info
list_signals
mail_debug
managestate
merge_model_instances
notes
pipchecker
print_settings
print_user_for_session
raise_test_exception
reset_db
reset_schema
runjob
runjobs
runprofileserver
runscript
runserver_plus
set_default_site
set_fake_emails
set_fake_passwords
shell_plus
show_template_tags
show_urls
sqlcreate
sqldiff
sqldsn
sync_s3
syncdata
unreferenced_files
update_permissions
validate_templates

[sessions]
clearsessions

[sslserver]
runsslserver

[staticfiles]
collectstatic
findstatic
runserver

进程已结束,退出代码0

配置mysql
参考链接教程：
2024 年 MySQL 8.0 安装 配置 教程 最简易（保姆级）
注意要在代码文件的“settings.py”中对配置的sql数据库信息进行更改

配置虚拟环境

安装 virtualenv

pip install virtualenv
AI写代码
1
然后，创建虚拟环境：

virtualenv venv
AI写代码
1
激活虚拟环境

.\venv\Scripts\activate.bat
AI写代码
1
然后就进入了虚拟环境中

4. 进行应用迁移
   在虚拟环境中运行：

python manage.py migrate
AI写代码
1
启动开发服务器
准备工作完成，即可启动Django 开发服务器：
python manage.py runserver 7788
AI写代码
1
（7788为自定义端口号）

启动成功，可以运行http://127.0.0.1:7788/网址了

部分重要代码
实现加密过程的代码

-- coding: UTF-8 --

! /usr/bin/env python

import base64
from Crypto.Cipher import PKCS1_v1_5 as PKCS1_v1_5_cipper
from Crypto.Signature import PKCS1_v1_5
from Crypto.PublicKey import RSA
from Crypto.Hash import SHA
import rsa
from Cryptodome import Random
from Cryptodome.PublicKey import RSA
from Cryptodome.Cipher import PKCS1_v1_5 as Cipher_pkcs1_v1_5
from Cryptodome.Signature import PKCS1_v1_5 as Signature_pkcs1_v1_5
import Crypto

使用 rsa库进行RSA签名和加解密

伪随机数生成器

random_generator = Random.new().read

with open('random.txt', 'w') as f:

f.write(str(random_generator))

# rsa算法生成实例

rsa = RSA.generate(1024, random_generator)

private_pem = str(rsa.exportKey(), encoding="utf-8")

with open("client-private.pem", "w") as f:

f.write(private_pem)

public_pem = str(rsa.publickey().exportKey(), encoding="utf-8")

with open("client-public.pem", "w") as f:

f.write(public_pem)

class RsaUtil(object):
PUBLIC_KEY_PATH = 'client-public.pem' # 公钥
PRIVATE_KEY_PATH = 'client-private.pem' # 私钥

# 初始化key
def __init__(self,
             company_pub_file=PUBLIC_KEY_PATH,
             company_pri_file=PRIVATE_KEY_PATH):

    if company_pub_file:
        self.company_public_key = RSA.importKey(open(company_pub_file).read())
    if company_pri_file:
        self.company_private_key = RSA.importKey(open(company_pri_file).read())

def get_max_length(self, rsa_key, encrypt=True):
    """加密内容过长时 需要分段加密 换算每一段的长度.
        :param rsa_key: 钥匙.
        :param encrypt: 是否是加密.
    """
    blocksize = Crypto.Util.number.size(rsa_key.n) / 8
    reserve_size = 11  # 预留位为11
    if not encrypt:  # 解密时不需要考虑预留位
        reserve_size = 0
    maxlength = blocksize - reserve_size
    return maxlength

# 加密 支付方公钥
def encrypt_by_public_key(self, encrypt_message):
    """使用公钥加密.
        :param encrypt_message: 需要加密的内容.
        加密之后需要对接过进行base64转码
    """
    encrypt_result = b''
    max_length = int(self.get_max_length(self.company_public_key))
    cipher = PKCS1_v1_5_cipper.new(self.company_public_key)
    while encrypt_message:
        input_data = encrypt_message[:max_length]
        encrypt_message = encrypt_message[max_length:]
        out_data = cipher.encrypt(input_data)
        encrypt_result += out_data
    encrypt_result = base64.b64encode(encrypt_result)
    return encrypt_result

# 加密 支付方私钥
def encrypt_by_private_key(self, encrypt_message):
    """使用私钥加密.
        :param encrypt_message: 需要加密的内容.
        加密之后需要对接过进行base64转码
    """
    encrypt_result = b""
    max_length = int(self.get_max_length(self.company_private_key))
    cipher = PKCS1_v1_5_cipper.new(self.company_public_key)
    while encrypt_message:
        input_data = encrypt_message[:max_length]
        encrypt_message = encrypt_message[max_length:]
        out_data = cipher.encrypt(input_data.encode(encoding='utf-8').strip() + b"\n")
        encrypt_result += out_data
    encrypt_result = base64.b64encode(encrypt_result)
    return encrypt_result

def decrypt_by_public_key(self, decrypt_message):
    """使用公钥解密.
        :param decrypt_message: 需要解密的内容.
        解密之后的内容直接是字符串，不需要在进行转义
    """
    decrypt_result = b""
    max_length = self.get_max_length(self.company_public_key, False)
    decrypt_message = base64.b64decode(decrypt_message)
    cipher = PKCS1_v1_5_cipper.new(self.company_public_key)
    while decrypt_message:
        input_data = decrypt_message[:max_length]
        decrypt_message = decrypt_message[max_length:]
        out_data = cipher.decrypt(input_data.encode(encoding='utf-8'), '')
        decrypt_result += out_data
    return decrypt_result

def decrypt_by_private_key(self, decrypt_message):
    """使用私钥解密.
        :param decrypt_message: 需要解密的内容.
        解密之后的内容直接是字符串，不需要在进行转义
    """
    decrypt_result = b""
    max_length = int(self.get_max_length(self.company_private_key, False))
    decrypt_message = base64.b64decode(decrypt_message)
    cipher = PKCS1_v1_5_cipper.new(self.company_private_key)
    while decrypt_message:
        input_data = decrypt_message[:max_length]
        decrypt_message = decrypt_message[max_length:]
        out_data = cipher.decrypt(input_data, '')
        decrypt_result += out_data.strip() + b"\n"
        #decrypt_result += str(out_data).encode(encoding='utf-8').strip() + b"\n"
    return decrypt_result

# 签名 商户私钥 base64转码
def sign_by_private_key(self, message):
    """私钥签名.
        :param message: 需要签名的内容.
        签名之后，需要转义后输出
    """
    cipher = PKCS1_v1_5.new(self.company_private_key)  # 用公钥签名，会报错 raise TypeError("No private key") 如下
    # if not self.has_private():
    #   raise TypeError("No private key")
    hs = SHA.new(message)
    signature = cipher.sign(hs)
    return base64.b64encode(signature)

def verify_by_public_key(self, message, signature):
    """公钥验签.
        :param message: 验签的内容.
        :param signature: 对验签内容签名的值（签名之后，会进行b64encode转码，所以验签前也需转码）.
    """
    signature = base64.b64decode(signature)
    cipher = PKCS1_v1_5.new(self.company_public_key)
    hs = SHA.new(message)

    # digest = hashlib.sha1(message).digest()  # 内容摘要的生成方法有很多种，只要签名和解签用的是一样的就可以

    return cipher.verify(hs, signature)

with open(r'C:\Users\misaka\Desktop\1.docx', 'rb') as f:
message = f.read()
rsaUtil = RsaUtil()
encrypy_result = rsaUtil.encrypt_by_public_key(message)
with open(r'C:\Users\misaka\Desktop\cryed.docx',"wb") as w:
w.write(encrypy_result)

这段代码用于使用RSA算法对文件内容进行加密。

导入库：代码开始部分导入了必要的库，包括base64用于编码，Crypto及其子模块用于加密操作。

RsaUtil类：定义了一个名为RsaUtil的类，用于封装RSA加密、解密、签名和验证的方法。

初始化密钥：__init__方法用于从文件中加载公钥和私钥。

计算最大长度：get_max_length方法用于计算在加密时每段数据的最大长度，以适应RSA加密块的大小。

加密方法：

encrypt_by_public_key：使用公钥加密消息。
encrypt_by_private_key：使用私钥加密消息（虽然这个功能不常用，因为通常使用公钥进行加密）。
签名和验证：

sign_by_private_key：使用私钥对消息进行签名。
verify_by_public_key：使用公钥验证签名。
文件加密：

代码读取指定路径下的文件（C:\Users\misaka\Desktop\1.docx）。
创建RsaUtil类的实例。
使用公钥对文件内容进行加密。
将加密后的内容写入新文件（C:\Users\misaka\Desktop\cryed.docx）。
实现解密过程的代码

-- coding: UTF-8 --

! /usr/bin/env python

import base64
from Crypto.Cipher import PKCS1_v1_5 as PKCS1_v1_5_cipper
from Crypto.Signature import PKCS1_v1_5
from Crypto.PublicKey import RSA
from Crypto.Hash import SHA
import rsa
from Cryptodome import Random
from Cryptodome.PublicKey import RSA
from Cryptodome.Cipher import PKCS1_v1_5 as Cipher_pkcs1_v1_5
from Cryptodome.Signature import PKCS1_v1_5 as Signature_pkcs1_v1_5
import Crypto

'''

使用 rsa库进行RSA签名和加解密

伪随机数生成器

random_generator = Random.new().read
with open('random.txt', 'w') as f:
f.write(str(random_generator))

rsa算法生成实例

rsa = RSA.generate(1024, random_generator)
private_pem = str(rsa.exportKey(), encoding="utf-8")
with open("client-private.pem", "w") as f:
f.write(private_pem)

public_pem = str(rsa.publickey().exportKey(), encoding="utf-8")
with open("client-public.pem", "w") as f:
f.write(public_pem)
'''
class RsaUtil(object):
PUBLIC_KEY_PATH = 'client-public.pem' # 公钥
PRIVATE_KEY_PATH = 'client-private.pem' # 私钥

# 初始化key
def __init__(self,
             company_pub_file=PUBLIC_KEY_PATH,
             company_pri_file=PRIVATE_KEY_PATH):

    if company_pub_file:
        self.company_public_key = RSA.importKey(open(company_pub_file).read())
    if company_pri_file:
        self.company_private_key = RSA.importKey(open(company_pri_file).read())

def get_max_length(self, rsa_key, encrypt=True):
    """加密内容过长时 需要分段加密 换算每一段的长度.
        :param rsa_key: 钥匙.
        :param encrypt: 是否是加密.
    """
    blocksize = Crypto.Util.number.size(rsa_key.n) / 8
    reserve_size = 11  # 预留位为11
    if not encrypt:  # 解密时不需要考虑预留位
        reserve_size = 0
    maxlength = blocksize - reserve_size
    return maxlength

# 加密 支付方公钥
def encrypt_by_public_key(self, encrypt_message):
    """使用公钥加密.
        :param encrypt_message: 需要加密的内容.
        加密之后需要对接过进行base64转码
    """
    encrypt_result = b''
    max_length = int(self.get_max_length(self.company_public_key))
    cipher = PKCS1_v1_5_cipper.new(self.company_public_key)
    while encrypt_message:
        input_data = encrypt_message[:max_length]
        encrypt_message = encrypt_message[max_length:]
        out_data = cipher.encrypt(input_data)
        encrypt_result += out_data
    encrypt_result = base64.b64encode(encrypt_result)
    return encrypt_result

# 加密 支付方私钥
def encrypt_by_private_key(self, encrypt_message):
    """使用私钥加密.
        :param encrypt_message: 需要加密的内容.
        加密之后需要对接过进行base64转码
    """
    encrypt_result = b""
    max_length = int(self.get_max_length(self.company_private_key))
    cipher = PKCS1_v1_5_cipper.new(self.company_public_key)
    while encrypt_message:
        input_data = encrypt_message[:max_length]
        encrypt_message = encrypt_message[max_length:]
        out_data = cipher.encrypt(input_data.encode(encoding='utf-8').strip() + b"\n")
        encrypt_result += out_data
    encrypt_result = base64.b64encode(encrypt_result)
    return encrypt_result

def decrypt_by_public_key(self, decrypt_message):
    """使用公钥解密.
        :param decrypt_message: 需要解密的内容.
        解密之后的内容直接是字符串，不需要在进行转义
    """
    decrypt_result = b""
    max_length = self.get_max_length(self.company_public_key, False)
    decrypt_message = base64.b64decode(decrypt_message)
    cipher = PKCS1_v1_5_cipper.new(self.company_public_key)
    while decrypt_message:
        input_data = decrypt_message[:max_length]
        decrypt_message = decrypt_message[max_length:]
        out_data = cipher.decrypt(input_data.encode(encoding='utf-8'), '')
        decrypt_result += out_data
    return decrypt_result

def decrypt_by_private_key(self, decrypt_message):
    """使用私钥解密.
        :param decrypt_message: 需要解密的内容.
        解密之后的内容直接是字符串，不需要在进行转义
    """
    decrypt_result = b""
    max_length = int(self.get_max_length(self.company_private_key, False))
    decrypt_message = base64.b64decode(decrypt_message)
    cipher = PKCS1_v1_5_cipper.new(self.company_private_key)
    while decrypt_message:
        input_data = decrypt_message[:max_length]
        decrypt_message = decrypt_message[max_length:]
        out_data = cipher.decrypt(input_data, '')
        decrypt_result += out_data.strip() + b"\n"
        #decrypt_result += str(out_data).encode(encoding='utf-8').strip() + b"\n"
    return decrypt_result

# 签名 商户私钥 base64转码
def sign_by_private_key(self, message):
    """私钥签名.
        :param message: 需要签名的内容.
        签名之后，需要转义后输出
    """
    cipher = PKCS1_v1_5.new(self.company_private_key)  # 用公钥签名，会报错 raise TypeError("No private key") 如下
    # if not self.has_private():
    #   raise TypeError("No private key")
    hs = SHA.new(message)
    signature = cipher.sign(hs)
    return base64.b64encode(signature)

def verify_by_public_key(self, message, signature):
    """公钥验签.
        :param message: 验签的内容.
        :param signature: 对验签内容签名的值（签名之后，会进行b64encode转码，所以验签前也需转码）.
    """
    signature = base64.b64decode(signature)
    cipher = PKCS1_v1_5.new(self.company_public_key)
    hs = SHA.new(message)

    # digest = hashlib.sha1(message).digest()  # 内容摘要的生成方法有很多种，只要签名和解签用的是一样的就可以

    return cipher.verify(hs, signature)

rsaUtil = RsaUtil()
'''encrypy_result = rsaUtil.encrypt_by_public_key(message)
with open(r'D:\document\study\RocEDU\dzgw\test4\cryed.txt',"wb") as w:
w.write(encrypy_result)
'''
with open(r'C:\Users\misaka\Desktop\cryed.docx','rb') as r:
encrypy_result = r.read()
decrypt_result = rsaUtil.decrypt_by_private_key(encrypy_result)

code =decrypt_result.decode(errors='ignore').encode('utf-8')
with open(r'C:\Users\misaka\Desktop\decry.docx', "wb") as w:
w.write(code)

with open(r'C:\Users\misaka\Desktop\1.docx', 'rb') as f:
message = f.read()
sign = rsaUtil.sign_by_private_key(bytearray(message))
print("验签结果：>>> ")
print(rsaUtil.verify_by_public_key(bytearray(message), sign))

这段代码用于实现RSA算法的签名和加解密操作。它使用了pycryptodome库，这是pycrypto的一个分支，用于处理加密算法。

导入库：代码开始部分导入了必要的库，包括base64用于编码，Crypto用于加密操作，RSA用于生成和管理RSA密钥对。

RsaUtil类：定义了一个名为RsaUtil的类，用于封装RSA加密和解密、签名和验证的方法。

初始化密钥：__init__方法用于从文件中加载公钥和私钥。

计算最大长度：get_max_length方法用于计算在加密时每段数据的最大长度，以适应RSA加密块的大小。

解密方法：

decrypt_by_public_key：使用公钥解密消息。
decrypt_by_private_key：使用私钥解密消息。
签名和验证：

sign_by_private_key：使用私钥对消息进行签名。
verify_by_public_key：使用公钥验证签名。
文件操作：代码中包含了读取加密文件、解密内容并保存到新文件的操作，以及对文件内容进行签名和验证的操作。

系统运行测试
系统运行代码

!/usr/bin/env python

"""Django's command-line utility for administrative tasks."""
import os
import sys

def main():
"""Run administrative tasks."""
os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'system.settings')
try:
from django.core.management import execute_from_command_line
except ImportError as exc:
raise ImportError(
"Couldn't import Django. Are you sure it's installed and "
"available on your PYTHONPATH environment variable? Did you "
"forget to activate a virtual environment?"
) from exc
execute_from_command_line(sys.argv)

if name == 'main':
main()

系统欢迎界面
测试图片

登录页面
测试图片

注册页面
测试图片

点击“了解我们”或“制作过程”，即可进入云班课中的作业要求

公文起草发送

发送的公文标题设为test，选择密级（分为普密，机密，绝密）

接受公文并查看

同时刚发送公文文件的用户20231427tzh也会在“我的文件”中查看到该公文文件”test"

日志查看
源代码：

logging_ubits.py
import logging

配置日志级别和日志格式

logging.basicConfig(level=logging.INFO,
format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
datefmt='%Y-%m-%d %H:%M:%S')

创建一个logger对象

logger = logging.getLogger(name)

def view_function(doc_id):
try:
# 记录用户请求的doc_id
logger.info(f"View accessed with doc_id: {doc_id}")

    # 调用模型函数
    result = model_function(doc_id)

    # 记录查询结果
    logger.info(f"View received result: {result}")

    return result
except Exception as e:
    # 记录异常信息
    logger.error(f"Error in view_function: {e}")
    raise

def model_function(doc_id):
try:
# 记录检索文档的doc_id
logger.info(f"Retrieving document with doc_id: {doc_id}")

    # 模拟数据库查询
    # 假设这里是数据库查询代码
    query_result = "query result"

    # 记录查询结果
    logger.debug(f"Query result: {query_result}")

    return query_result
except Exception as e:
    # 记录异常信息
    logger.error(f"Error retrieving document: {e}")
    raise

测试代码

if name == "main":
doc_id = "12345"
result = view_function(doc_id)
print(result)

在modules.py中添加安全审计员进行日志查看

class Role(models.Model):
name = models.CharField(max_length=255)
permissions = models.ManyToManyField('Permission', blank=True)

class Permission(models.Model):
name = models.CharField(max_length=255)
description = models.TextField(blank=True)

管理员模式（修改用户和删除用户）
我们先注册一个测试用户用户名为ceshi

进入管理员模式
具有修改用户和删除用户的功能
点击修改用户，即可进行对用户查询并修改密码的功能

修改刚刚注册的测试用户密码更改为“12345”

点击删除用户，即可进行用户的查询并删除功能

文件审核功能

对公文的审核具有批准和拒绝的操作

最后点击退出，回到主页面

三、 系统量化评估
按照商用密码应用安全性评估量化评估规则,计算自己系统的得分，只计算应用和数据安全。

身份鉴别：1
访问控制信息完整性：0.5
重要信息资源安全标记完整性：1
重要数据传输机密性：1
重要数据存储机密性：0.7
重要数据传输完整性：0.5
重要数据存储完整性：0.7
不可否认性：1