无穷博弈模型：教师（1名），学生（i=0,1,...,N-1共N名）进行无穷博弈：
角色：Alice代表教师，Bob代表任意一名学生
博弈选项描述：
作业选项包括算法和数据结构;
备选作业包括操作系统作业（操作系统作业名称：问题反馈系统，针对学生算法数据结构课程中屡见不鲜的“学渣”现象设置的option）；
在截止日期内，以上两种作业都无法完成的学生，重复出现这种情况1次（即一学期出现两次“两种作业都没完成”情况的）学生，自动进入强制要求完成期末大作业“拖deadline模块”（即物理模式的生命抢救课程作业）；
无穷博弈过程和有穷博弈子过程描述：
1.教师布置-学生接收算法数据结构作业：教师先手，学生N后手
1a：教师布置算法数据结构作业(assignHomework)
1b：学生确定是否接受作业布置：i)接受并开始做作业；ii)作为attacker攻击教师服务器
1aii：学生选择1bii后，教师挂起学生占用的进程号，采取如下策略：A)抵御学生/来自盗用学生进程的Mallory的攻击；B)确认学生进程不再有攻击后恢复学生对应进程的学生使用权限（如学生进程被盗用，学生返回后确认进程不再有新的安全威胁则为被盗号学生恢复进程）；
1aiiA：教师跟学生进程（Mallory）进行信息安全博弈；
1aiiB：教师根据学生表现选择是否原谅学生并重新开放权限允许学生继续上课i）开放权限；ii）不开放权限反映给教师所在技术团队和执法团队；
2.学生选择-教师布置备选作业(assignAlteredHomework)（针对算法数据结构作业完不成、不会做、需要补充知识情形）：学生i(0<i<N共N名)同步或异步的先手，教师后手（布置作业，如果没有学生发起请求，教师有理由不布置备选作业）
2b：学生选择是否i)完成算法数据结构作业；ii)不完成算法数据结构作业
2bii：学生确定未完成算法数据结构作业并且接受下一轮选择:是否完成补充作业：i)接受;ii)拒绝
2end：截止时间到，学生作业提交（不管完成完不成），多次既未完成算法数据结构作业，又未完成操作系统作业的学生记一次（TODO尚未完成相关逻辑设计）
3a：教师批改作业并下发结果
3b：学生选择i)订正作业并提交结果；ii)不订正作业（包含既不订正又不提交，不订正但是正常提交）
4a：教师开启针对“不订正不提交订正内容”学生的公开点名批评、要求反复修改直至成功的作业订正-测试通过-提交的学习监督；
4b：学生在反复博弈中：i）向老师妥协（同意订正作业并提交订正后的结果）；ii）反复被老师点名批评；
以上是业务逻辑。
思维导图：
业务平台涉及的知识点：
数据结构
算法
操作系统：进程互锁；读者写者问题；进程池（逻辑）；锁
#Person.py
class StoryBoard:
""" a simple Server for User = {teacher, students} """
def __init__(self, teacher, students, pool=None):
# 存放每次布置的操作系统作业索引：每次学生获取对应区块内容，教师布置新备选作业则应获取成功失败则
self.alteredHomework = []
self.initialHomework = []
self.pool = pool
self.teacher = teacher
self.students = students
#put/get函数需要添加访问控制（学生不能布置新作业，学生可以提交完成的新作业）
def putHomework(self, teacher, buffer=[], alt=False):
# 教师布置新算法和数据结构作业接口
pass
def getHomework(self, user, alt=False):
# 教师/学生收取布置的新算法和数据结构作业
if alt:
if len(self.alteredHomework) < len(self.initialHomework): #有学生索要新备选作业而教师还没布置
self.teacher.assignHomework(self.storyBoard, alt=True) # 教师对全局发布新的操作系统作业
return self.alteredHomework[-1]
return self.initialHomework[-1]
def putDoneHomework(self, student):
# 学生提交新完成的作业
pass
def getDoneHomework(self, user):
# 教师/学生收取新完成的作业
pass
def putGradedHomework(self, teacher):
# 教师提交打分后的作业
pass
def putCorrectedHomework(self, student):
# 学生提交订正后的作业
pass
def getCorrectedHomework(self, teacher):
# 教师获取学生订正后的作业
pass
def saveUncorrectedStudent(self, teacher, student):
# 对于deadline后没有按时交纠正稿的学生，进行记录
pass
def checkAssignment(self, user):
"""
check server's PC env and storyboard
由用户端发起检查作业布置情况的请求，服务器完成检查并向教师和学生反映结果
"""
return user #把控制权重新交给user
class CryptoPerson:
""" a simple User of Server """
def __init__(self, name, pid):
self.name = name
self.pid = pid
# 逻辑管道
self.src = [] #用于从文本文件流中读取数据
self.dir = [] #用于存储从输入流取出后编辑好的数据
@classmethod
def equal(cls, cp1, cp2):
if cp1.name == cp2.name and cp1.pid == cp2.pid:
return True
return False
def readinFile(self, type=""):
""" read in file to self.src as data source """
try:
name = raw_input("new %s_r homework name:" % type)
with open(name) as f:
self.src.append(f.readlines())
return True
except Exception as e:
print(str(e))
finally:
return False
def writeoutFile(self, buffer, type=""):
try:
name = raw_input("new %s_w homework name:" % type)
with open(name) as f:
f.writelines(buffer)
return True
except Exception as e:
print(str(e))
finally:
return False
def print(self):
print("{%s %d}" % (self.name, self.pid), end="")
def closeThread(self, tid):
#关闭进程接口封装
pass
def openThread(self, tid):
#遇到不合作的学生改邪归正，恢复进程使用权
pass
# def correctHomework(self):
# pass
class Homework:
def __init__(self):
self.name = []
self.description = []
self.lastUpdateTime = None
self.student = None
self.teacher = None
#需要将教师注册到故事板
class Teacher(CryptoPerson):
def assignHomework(self, storyBoard, alt=False):
""" read in file and put into storyboard"""
if self.readinFile():
if alt:
storyBoard.alteredHomework.append(self.src[-1])
else:
storyBoard.initialHomework.append(self.src[-1])
return True
return False
def correctHomework(self, storyboard):
#TODO 访问学生作业并保存在本地，跑通后提交学生作业并批注
try:
for student in storyboard.students:
self.writeoutFile(student.dir)
except Exception as e:
print(str(e))
return False
finally:
return True
def assignAlteredHomework(self, storyBoard, Homework):
#对全局发布新的操作系统作业
pass
def fetchSubmision(self):
#获取学生提交的作业，
pass
def forgiveStudent(self):
#原谅不合作者
pass
def assignmentDefend(self, exception):
#针对作业发布过程中/作业发布之后有可能面临的攻击进行防御
pass
def systemDefend(self, helper, attacked_student, log=True):
""" 面对使用业务逻辑攻击教师和学生的学生/第三方/盗用学生账号的Eve和Mallory，使用援助helper，疏散学生attacked_student，并做好事件记录日志"""
pass
class Student(CryptoPerson):
def bigHomework(self, teacher, deadlineAbuser=True):
#针对屡次提交作业拖过deadline而且未完成的学生，强制要求提交学渣系统拖deadline模块作业，并且交由专门的老师辅导
pass
def fetchHomework(self, storyBoard, alt=False):
""" fetch new homework from storyboard"""
try:
self.src = storyBoard.getHomework(self, alt)
except Exception as e:
print((str(e)))
return False
finally:
return True
def doDSHomework(self):
# 读者写者逻辑：老师学生合作修改
try:
self.dir = self.readinFile("ds")
except Exception as e:
print(str(e))
return False
finally:
return True
def doAlgosHomework(self):
# 读者写者逻辑：老师学生合作修改
try:
self.dir = self.readinFile("algos")
except Exception as e:
print(str(e))
return False
finally:
return True
def doOSHomework(self):
#读者写者逻辑：老师学生合作修改
try:
self.dir = self.readinFile("os")
except Exception as e:
print(str(e))
return False
finally:
return True
def doHomework(self, alt=False):
#crypto-dsalgo-graphics/dsalgo-OS
""" doHomework占用一个进程：学生在截止时间前一直出于做作业状态，检测到新系统作业发布，学生可以选择是（Y）或否（n）"""
self.doDSHomework()
self.doAlgosHomework()
if alt:#冗余逻辑：while三个条件下来还会问一次但是缺乏如下文所述文字提示
choice = raw_input("New assignment of OS accept? (Y/n): ")
if choice == "Y": # 2b学生选择
self.doOSHomework()
def doCryptanalysisHomework(self):
pass
def doAlteredHomework(self):
self.doOSHomework()
def haltCurrentHomework(self):
#学生可以在教师补充发布OS作业（作为学生不做算法数据结构作业的妥协）后挂起当前算法数据结构作业，开始做操作系统书面作业
pass
def submitHomework(self, storyboard):
# TODO 检查storyboard上的strudents[]里面对应项是否是已存有数据的
if self.storyboard.students.find(self).dir == self.dir:
return True
return False
def correctHomework(self, storyboard):
#TODO 访问学生作业并保存在本地，跑通后提交学生作业并批注
try:
#老师批改后的作业在storyboard里
for student in storyboard.students:
if CryptoPerson.equal(student, self):
self.writeoutFile(student.dir)
while raw_input("Please upload corrected edition:(Y/n)") == 'Y':
#TODO 还未检查正确性
student.doHomework()
student.doAlteredHomework()
return student.submitHomework(self.storyBoard) # TODO 提交失败的案例先跳过
except Exception as e:
print(str(e))
return False
finally:
return True
#Game.py
import os
from multiprocessing import Process
import datetime
import numpy as np
from Person import CryptoPerson, Student, Teacher
from Person import StoryBoard
class CryptoGame():
def __init__(self, alice, bob=None):
""" alice and bob are thread id """
if type(alice) != CryptoPerson:
raise TypeError("Alice should be a CryptoPerson but", type(alice))
if bob != None and type(bob) != CryptoPerson: # Bob should be None or CryptoPerson
raise TypeError("Bob should be a CryptoPerson but", type(bob))
self.alice = alice
self.bob = bob
def runInfiniteGame(self):
solved = False
while not solved:
#alice play
#bob play
continue
class BystanderEffectGame(CryptoGame):
N = 0xffffffff
def __init__(self, alice, bystanders=[]):
super().__init__(alice)
for ele in bystanders:
if type(ele) != CryptoPerson:
raise TypeError("bystanders should be a Cryptoperson but", type(ele))
self.bystanders = bystanders
def appendBystander(self, cp):
if CryptoPerson.equal(self.alice, cp):
return False
for i in range(len(self.bystanders)):
if CryptoPerson.equal(cp, self.bystanders[i]): # already inside bystanders
return False
self.bystanders.append(cp)
return True
def printAll(self):
print("Alice:", end="")
print(" ", end="")
self.alice.print()
print()
print("bystanders: ", end="")
for ele in self.bystanders:
print(" ", end="")
ele.print()
print()
def gameResult(self):
# N = 5
# alice = "sudo thread"
# eves = np.zeros(5)
a = np.append([self.alice], self.bystanders) #需要修改为内部的赋值
a.shape = (1, a.shape[0])
# print(a)
b = a.reshape((a.shape[1], a.shape[0]))
# print(b)
A = np.dot(b, a)
# print(A)
return A
class TeacherStudentGame(BystanderEffectGame):
def __init__(self, server):
super().__init__(server.teacher, server.students)
self.storyBoard = server
def assignHomeworkGame(self):
"""
按照神经反射建模，学生进程在教师发布作业之后有可能发起攻击直接针对教师/对同学发起攻击，
使得教师疲于应付学生/诱导学生攻击教师以达到攻击教师和隐藏犯罪行为的目的。
1.教师布置算法和数据结构作业，并在1biB/1biiB情况下（学生发起密码学攻击），启动防御机制抵御密码学攻击：
1a.教师先手：发布算法和数据结构作业并开始计时（time）；
1bi/1bii
A.学生不发起攻击；
B.学生使用进程发起攻击：
I.向老师的计算机直接发起攻击
II.向其他同学的计算机发起攻击
III.诱导其他学生对老师发起攻击
Ia), IIa), IIIa)老师开启主动御策略：挂起学生进程，开始防御
i).防御成功，由教师决定是否重新开启被挂起的学生进程ID
A).重新开启
B).延续挂起
ii).防御失败，运行系统防御函数（选择求援外界、疏散学生）
1b. 学生后手：决定是否接受算法和数据结构作业
i. 学生接受作业：
A.学生不发起攻击；
B.学生使用进程发起攻击：
I.向老师的计算机直接发起攻击
II.向其他同学的计算机发起攻击
III.诱导其他学生对老师发起攻击
Ib), IIb), IIIb)学生后手：进程被挂起
i).学生继续进攻
ii).学生停止进攻
ii. 学生不接受作业：
A.学生不发起攻击；
B.学生使用进程发起攻击：
I.向老师的计算机直接发起攻击
II.向其他同学的计算机发起攻击
III.诱导其他学生对老师发起攻击
Ib), IIb), IIIb)学生后手：进程被挂起
i).学生继续进攻
ii).学生停止进攻
"""
while not self.storyBoard.teacher.assignHomework(self.storyBoard): # 1a.教师（服务器端）发布任务失败
try:
self.storyBoard.teacher.checkAssignment() #教师端检查配置直至作业发布成功
except SystemError as se:
self.storyBoard.teacher.closeThread() # 教师获取学生进程锁：采用应对策略（如暂时挂起进程）
self.storyBoard.teacher.assignmentDefend(se)
self.storyBoard.teacher.openThread()
except Exception as e:
print(str(e))
# 1a教师成功将新作业发送至公告板->1b所有学生从公告板上获取新作业
for student in self.storyBoard.students:
while not student.fetchHomework(self.storyBoard):
try:
self.storyBoard.student.checkAssignment() # 学生端检查配置直至作业收取成功
except Exception as e:
print(str(e))
def alterHomeworkGame(self, deadline):
"""
2. 未到截止时间:
学生选择是否换操作系统作业（例如学生接受算法和数据结构作业，但是做下来发现无法在规定时间内完成，
于是要求教师另外布置简单点的作业）
密码学意义先后手：学生先手（在本无穷博弈组合中依然是Bob），教师后手（在本无穷博弈组合中依然是Alice）：
b. 学生先手：
i. 学生完成算法和数据结构作业
ii. 学生不完成算法和数据结构作业：
i）先手选择备选作业，教师后手（分支1a2a）选项教师布置操作系统作业到全班（读者写者模型）
i)学生获取作业并完成提交；
ii)学生获取/未获取作业，未完成提交；
ii）不做选择，拖过deadline
a. 教师后手：发布备选作业（如操作系统作业）
"""
alteredAssignment = False
altered = False
finish = False
for student in self.storyBoard.students:
# TODO for循环应当是服务器上一条进程一直等待学生，如果不提交则选项一直存在
# 仔细分析提交逻辑（包括game2）：不再是一个人而是轮询有人不提交则阻塞：待修改
# 目前的代码会因为IO甚至是手动控制的读者写者跑的很慢
# TODO 这样的轮询是一遍遍历所有学生，无法回头重复选择（全部轮询一遍，中间如果有人一直没有提交会弄得其他人提交不了）
while not student.submitHomework(self.storyBoard): #Storyboard端检测到学生未提交作业
# 未到截止时间、学生没有做算法数据结构作业、学生没有做备选作业
while (datetime.datetime.now() < deadline) and\
(not student.doHomework()) and\
(not student.doAlteredHomework()):
# 2b：学生先手决定是否接受备选作业内容
if student.fetchHomework(self.storyBoard, alt=True):
print("Altered homework fetched!")
# if not finish:
return student.submitHomework(self.storyBoard) # 截止时间到，没有提交的学生进程自动提交作业；已提交学生不用重复提交
def correctHomeworkGame(self):
# 3a.本轮作业博弈结束：老师批改作业，学生纠正作业
if self.alice.correctHomework(self.storyBoard): # 第一次布置作业不需要批改
for student in self.storyBoard.students: # 3b学生选择i)订正作业ii)不订正作业
student.correctHomework(self.storyBoard) # 第一次布置作业不需要批改
else:
raise RuntimeError("Teacher correctness return False")
def homeworkGame(self):
now = datetime.datetime.now()
deadline = now + datetime.timedelta(days=14)
self.assignHomeworkGame() # game1
self.alterHomeworkGame(deadline) # game2
self.correctHomeworkGame() # game 3
def cryptoAnalysisGame(self, cryptographer, cryptanalysts):
while 1:
# 决定是否在本轮对数据进行加密/解密，选项A：不加密/不解密退出，选项B：加密/解密继续
pass
if __name__ == '__main__':
"""逻辑：创建Alice存储当前函数进程，创建子进程并保存pid和名称"""
# 1.创建进程Alice和其他用户实例，分配角色（教师、学生）
alice = CryptoPerson("Alice", os.getpid())
students = [CryptoPerson(name, os.getpid()) for name in ["Bob", "Carol", "Dave"]]
storyBoard = StoryBoard(alice, students)
beGame = TeacherStudentGame(storyBoard)
# 2.打印所有角色信息
beGame.printAll()
扫一扫
2868
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
