1
00:00:00,000 --> 00:00:28,480
好,然后我们来讲一下这个Codex Lulers体系构建与代码可控性治理。那这个的话其实也是一套这个细节的一个规范啊。这个就更加的这个细利度了。前面那个我们说的这个规范的话,主要还是指的是整个项目的一些大的一些规范啊。比如说目录啊,结构啊,是吧。它就相当于一个代码地图。

2
00:00:28,480 --> 00:00:32,000
那这个Lurus的这个规范的话

3
00:00:32,000 --> 00:00:33,880
它就更加的细了

4
00:00:33,880 --> 00:00:36,300
这个是用来去控制

5
00:00:36,300 --> 00:00:39,820
哪些命令可以在沙箱外去做一个执行

6
00:00:39,820 --> 00:00:41,900
这个就偏执行类的

7
00:00:41,900 --> 00:00:44,940
也就是说比如说我们在这个

8
00:00:44,940 --> 00:00:47,180
跑一些代码的时候

9
00:00:47,180 --> 00:00:48,180
跑一些case的时候

10
00:00:48,180 --> 00:00:49,860
做一些自动化测试的时候

11
00:00:49,860 --> 00:00:52,320
那自动化测试的话

12
00:00:52,320 --> 00:00:54,220
可能涉及到命令就比较多了

13
00:00:54,220 --> 00:00:55,960
有可能会删除文件

14
00:00:55,960 --> 00:00:57,760
有可能需要调用工具

15
00:00:57,760 --> 00:00:59,000
等等的啊

16
00:00:59,000 --> 00:01:00,400
就个人关系的权限都会有

17
00:01:00,400 --> 00:01:03,380
所以Codex专门设计了一套

18
00:01:03,380 --> 00:01:05,520
叫Lulis的一套组件啊

19
00:01:05,520 --> 00:01:07,460
专门就是用来干这个事情的

20
00:01:07,460 --> 00:01:09,620
那这个里面的话啊

21
00:01:09,620 --> 00:01:11,400
很好理解就是什么呢

22
00:01:11,400 --> 00:01:12,640
那在这个里面

23
00:01:12,640 --> 00:01:15,180
你可以建一些这个Lulis啊

24
00:01:15,180 --> 00:01:18,380
比如说我们就直接在这个

25
00:01:18,380 --> 00:01:19,840
这个里面啊

26
00:01:19,840 --> 00:01:21,720
我们就找个项目吧

27
00:01:21,720 --> 00:01:23,060
嗯

28
00:01:23,060 --> 00:01:29,300
看一下啊

29
00:01:29,300 --> 00:01:32,760
这个里面的话

30
00:01:32,760 --> 00:01:34,900
相当于

31
00:01:34,900 --> 00:01:37,040
我们要可以加一个规则

32
00:01:37,040 --> 00:01:38,200
做一个什么呢

33
00:01:38,200 --> 00:01:39,900
就是杀向外运行的话

34
00:01:39,900 --> 00:01:41,460
需要先提示用户确认

35
00:01:41,460 --> 00:01:44,940
也就是说我们可能要执行一个

36
00:01:44,940 --> 00:01:47,980
GHPR的一个命令

37
00:01:47,980 --> 00:01:49,160
然后这个命令的话

38
00:01:49,160 --> 00:01:50,540
可能要去干嘛呢

39
00:01:50,540 --> 00:01:53,520
要去分析一些仓库是吧

40
00:01:53,520 --> 00:01:55,180
获取一些这个信息

41
00:01:55,180 --> 00:01:56,920
所以这个里面的话

42
00:01:56,920 --> 00:01:59,720
当他执行这种命令的时候

43
00:01:59,720 --> 00:02:03,100
我们需要有用户去做一个确认

44
00:02:03,100 --> 00:02:05,020
所以这个里面

45
00:02:05,020 --> 00:02:06,100
事实上

46
00:02:06,100 --> 00:02:08,380
他就是要做一个什么呢

47
00:02:08,380 --> 00:02:09,540
授权的一个管理

48
00:02:09,540 --> 00:02:12,660
那比如说我们现在就是在这个里面去建一下

49
00:02:12,660 --> 00:02:16,800
然后我们在这个里面

50
00:02:16,800 --> 00:02:18,000
比如说这个项目下面

51
00:02:18,000 --> 00:02:20,740
先建文件啊

52
00:02:20,740 --> 00:02:22,160
比如说我就建一个点lulus

53
00:02:22,160 --> 00:02:25,240
然后把下面这一堆翻过来啊

54
00:02:25,240 --> 00:02:26,800
翻过来啊

55
00:02:26,800 --> 00:02:28,300
然后在这个里面的话

56
00:02:28,300 --> 00:02:31,840
我们可以看一下

57
00:02:31,840 --> 00:02:35,440
首先我们进入到洛伊的这个目楼里去

58
00:02:35,440 --> 00:02:39,240
进入到洛伊

59
00:02:48,000 --> 00:02:50,900
好到这个里面然后进入到codex

60
00:02:50,900 --> 00:02:52,300
然后你就直接问他

61
00:02:52,300 --> 00:02:56,100
当前项目有哪些

62
00:02:56,100 --> 00:03:01,100
glueless

63
00:03:01,100 --> 00:03:06,600
你就直接问他有哪些具体的这个规则是吧

64
00:03:06,600 --> 00:03:19,460
然后他会自动的去分析啊

65
00:03:19,460 --> 00:03:22,760
他会去找

66
00:03:22,760 --> 00:03:26,020
所以他优先级的话

67
00:03:26,020 --> 00:03:29,480
他会去扫Lulis的这个目录吧

68
00:03:29,480 --> 00:03:30,780
这里还不行

69
00:03:30,780 --> 00:03:34,520
我们建了这个点Lulis的这个目录文件以外

70
00:03:34,520 --> 00:03:35,020
我看一下

71
00:03:35,020 --> 00:03:38,860
还要建一个.lulus的目录

72
00:03:38,860 --> 00:03:40,520
不然的话加载是有问题的

73
00:03:41,540 --> 00:03:44,980
所以这个里面我们得加一个

74
00:03:44,980 --> 00:03:48,520
还得建个目录

75
00:03:48,520 --> 00:03:51,100
建个文件夹

76
00:03:51,100 --> 00:03:54,900
然后把这个.lulus给它拖进去

77
00:03:54,900 --> 00:03:59,680
然后再重启一下

78
00:04:03,280 --> 00:04:04,340
然后再去问它

79
00:04:04,340 --> 00:04:25,040
然后这个里面

80
00:04:25,040 --> 00:04:27,180
他会去加载这个Lulis

81
00:04:27,180 --> 00:04:34,000
你看他把agency.md的内容

82
00:04:34,000 --> 00:04:34,840
也输出出来了

83
00:04:34,840 --> 00:04:37,240
看一下lulis

84
00:04:37,240 --> 00:04:39,680
嗯

85
00:04:39,680 --> 00:04:43,360
哎他这个这里个规范没有输出来

86
00:04:43,360 --> 00:04:46,040
项目生效的lulis

87
00:04:46,040 --> 00:04:47,480
dd驱动

88
00:04:47,480 --> 00:04:52,560
他他把这个lulis理解成

89
00:04:52,560 --> 00:04:53,920
agents.md了

90
00:04:53,920 --> 00:04:57,080
看一下有没有办法给他调整一下

91
00:04:57,080 --> 00:04:59,140
嗯

92
00:04:59,140 --> 00:05:03,980
这里要去激活一下啊

93
00:05:04,000 --> 00:05:10,100
lulus

94
00:05:10,100 --> 00:05:15,700
看一下这个目录

95
00:05:15,700 --> 00:05:17,840
lulus 下面有一个点

96
00:05:17,840 --> 00:05:18,360
lulus

97
00:05:18,360 --> 00:05:27,440
然后我们

98
00:05:27,440 --> 00:05:31,200
执行一下这个命令看一下

99
00:05:34,000 --> 00:05:41,800
ghprvu

100
00:05:41,800 --> 00:05:54,700
原因是当前仓库的gitremote没有指向github助期

101
00:05:54,700 --> 00:05:58,200
那其实我们可以换一个项目

102
00:05:58,200 --> 00:06:00,700
prodx

103
00:06:04,000 --> 00:06:10,840
我们找到那个项目

104
00:06:10,840 --> 00:06:13,240
用这个开源项目来测试一下

105
00:06:19,000 --> 00:06:21,000
把这个项目导下来啊

106
00:06:21,000 --> 00:06:34,120
git clone

107
00:06:34,120 --> 00:06:40,940
首先我把这个项目拉下来

108
00:06:40,940 --> 00:06:48,100
因为这个里面要用github的项目

109
00:06:48,100 --> 00:06:50,180
我上面那个是gitty的一个项目

110
00:06:51,000 --> 00:06:53,400
所以我首先要把它给它导进来

111
00:06:53,400 --> 00:06:58,680
看这个项目有点大啊

112
00:06:58,680 --> 00:07:01,740
反正这个规则的意思就是

113
00:07:01,740 --> 00:07:04,640
大家在执行一些命令的时候

114
00:07:04,640 --> 00:07:08,740
就是你可以去指定哪一些各个命令

115
00:07:08,740 --> 00:07:10,720
是需要用户授权的

116
00:07:10,720 --> 00:07:13,620
因为我们默认的话

117
00:07:13,620 --> 00:07:15,820
其实有一些命令啊

118
00:07:15,820 --> 00:07:17,120
它需要授权

119
00:07:17,120 --> 00:07:18,660
有些是不需要授权的

120
00:07:18,660 --> 00:07:20,360
那么大家可以去配一下

121
00:07:20,360 --> 00:07:21,740
就是在某些命令下

122
00:07:21,740 --> 00:07:23,400
需要去触发授权

123
00:07:23,400 --> 00:07:25,280
也就是大家可以针对

124
00:07:25,280 --> 00:07:27,280
我们当前执行的一个命令的话

125
00:07:27,280 --> 00:07:29,860
做一些细地图的权限管控

126
00:07:29,860 --> 00:07:31,120
就加一个规则

127
00:07:31,120 --> 00:07:33,880
因为涉及到一些危险动作的时候

128
00:07:33,880 --> 00:07:36,640
就需要用户来确认

129
00:07:36,640 --> 00:07:38,580
确认完之后再去做处理

130
00:07:38,580 --> 00:07:41,020
所以我们在这个点

131
00:07:41,020 --> 00:07:43,680
Codex里面去加这个规则的话

132
00:07:43,680 --> 00:07:45,460
就意味着什么呢

133
00:07:45,460 --> 00:07:48,400
我们可以去做一些权限的一些细节管控

134
00:07:48,400 --> 00:07:50,320
就是做一个这种审批

135
00:07:50,320 --> 00:07:53,120
就相当于大家在这做这个

136
00:07:53,120 --> 00:07:54,840
整个的一个

137
00:07:54,840 --> 00:07:57,540
各种各样的命令管理的时候

138
00:07:57,540 --> 00:07:59,780
你可以下一些细流的一些管控

139
00:07:59,780 --> 00:08:01,000
有一些

140
00:08:01,000 --> 00:08:03,180
这个命令的话

141
00:08:18,690 --> 00:08:20,090
给他加一下

142
00:08:20,090 --> 00:08:20,610
是吧

143
00:08:20,610 --> 00:08:22,530
加一些权限控制

144
00:08:22,530 --> 00:08:24,430
然后这个里面啊

145
00:08:24,430 --> 00:08:25,850
我们可以配置哪些东西呢

146
00:08:25,850 --> 00:08:27,490
比如说啊

147
00:08:27,490 --> 00:08:29,390
它是有一套规范

148
00:08:29,390 --> 00:08:30,870
比如说这个partner

149
00:08:30,870 --> 00:08:31,790
匹配规则

150
00:08:31,790 --> 00:08:32,530
比如说pr

151
00:08:32,530 --> 00:08:34,690
就是你有pr的一些命令

152
00:08:34,690 --> 00:08:36,430
然后这个decision

153
00:08:36,430 --> 00:08:38,230
这个是做一些具体的命

154
00:08:38,230 --> 00:08:39,310
动作的一个执行

155
00:08:39,310 --> 00:08:40,650
比如说允许

156
00:08:40,650 --> 00:08:41,650
或者拒绝

157
00:08:41,650 --> 00:08:42,390
或者怎么样

158
00:08:42,390 --> 00:08:44,230
一个是不提示

159
00:08:44,230 --> 00:08:46,610
直接在沙厢环境下面去执行

160
00:08:46,610 --> 00:08:47,930
然后是提示

161
00:08:47,930 --> 00:08:50,090
就每次命中都要确认请求

162
00:08:50,090 --> 00:08:53,870
然后这个forbidden是直接拒绝了

163
00:08:53,870 --> 00:08:56,130
就这种命令就不允许执行了

164
00:08:56,130 --> 00:08:59,630
比如说RM跟RF这种删除文件的

165
00:08:59,630 --> 00:09:01,490
我们就不管它了

166
00:09:01,490 --> 00:09:02,430
这个完了

167
00:09:02,430 --> 00:09:05,530
然后我们现在去切换到这个

168
00:09:05,530 --> 00:09:07,530
看一下

169
00:09:07,530 --> 00:09:10,870
切换到codex

170
00:09:10,870 --> 00:09:12,470
这个项目里面去

171
00:09:12,470 --> 00:09:15,170
然后在这个项目下面的话

172
00:09:15,170 --> 00:09:16,210
我们建一个

173
00:09:16,210 --> 00:09:17,870
把那个移动过去

174
00:09:17,870 --> 00:09:19,870
刚刚有一个lulus

175
00:09:23,270 --> 00:09:24,870
把这个移到这个下面去

176
00:09:34,370 --> 00:09:35,510
好现在已经移过来

177
00:09:35,510 --> 00:09:36,130
移过来之后

178
00:09:36,130 --> 00:09:37,670
我们再切进去看一下

179
00:09:39,070 --> 00:09:39,970
codex

180
00:09:43,210 --> 00:09:43,870
好这里面

181
00:09:43,870 --> 00:09:46,670
然后我们再去执行刚刚的一个指令

182
00:09:47,870 --> 00:09:54,070
比如说我们来分析一下

183
00:09:54,070 --> 00:09:59,770
当前项目的

184
00:09:59,770 --> 00:10:03,590
Loss有哪些

185
00:10:17,870 --> 00:10:27,910
他默认读的也是这个agents.md

186
00:10:27,910 --> 00:10:35,470
他不能夹载内容

187
00:10:35,470 --> 00:10:39,570
这就这么来就问他

188
00:10:39,570 --> 00:10:42,650
当前项目的

189
00:10:42,650 --> 00:10:46,530
有哪些内容

190
00:10:46,530 --> 00:10:53,810
我看这样来问行不行啊

191
00:10:53,810 --> 00:10:57,530
他会去找这个文件啊

192
00:10:57,530 --> 00:11:04,610
他是有一个匹配规则的

193
00:11:04,610 --> 00:11:08,590
就比如说Codex想在沙箱里面去运行

194
00:11:08,590 --> 00:11:10,250
GHVU开头的命令

195
00:11:10,250 --> 00:11:11,950
但是需要后续的批准

196
00:11:11,950 --> 00:11:14,250
精准匹配啊才可以

197
00:11:14,250 --> 00:11:17,790
所以说不匹配

198
00:11:17,790 --> 00:11:22,490
比如说我们现在来整这个看一下

199
00:11:22,490 --> 00:11:37,710
你看现在是不是需要用户来确认是吧

200
00:11:37,710 --> 00:11:40,950
这个是不是我们那个规则生效了

201
00:11:40,950 --> 00:11:44,010
这里面是不是就需要用户来确认

202
00:11:44,010 --> 00:11:44,910
是吧

203
00:11:44,910 --> 00:11:46,810
来确认一下

204
00:11:46,810 --> 00:12:02,290
你看这个是以执行

205
00:12:02,290 --> 00:12:05,310
然后我们再来执行这个看一下

206
00:12:14,010 --> 00:12:15,690
你看用这种命令

207
00:12:15,690 --> 00:12:16,950
一旦匹配上了

208
00:12:16,950 --> 00:12:17,670
他就要确认

209
00:12:17,670 --> 00:12:19,550
然后不匹配的

210
00:12:19,550 --> 00:12:20,890
我们来也来确认一下

211
00:12:20,890 --> 00:12:24,010
看一下这个是不是就不会授权了

212
00:12:24,010 --> 00:12:31,370
这个还是要确认

213
00:12:31,370 --> 00:12:33,250
这个也是要确认

214
00:12:33,250 --> 00:12:35,090
只是说这里面

215
00:12:35,090 --> 00:12:38,690
就是相当于一些一个逻辑

216
00:12:38,690 --> 00:12:41,430
要做一些处理

217
00:12:41,430 --> 00:12:46,070
但是我们看一下这个上面那个规则

218
00:12:46,070 --> 00:12:55,650
因为他网络访问

219
00:12:55,650 --> 00:12:56,990
所以还是需要授权

220
00:12:56,990 --> 00:12:59,110
其实这个不匹配的话

221
00:12:59,110 --> 00:13:02,030
不匹配的话就必须

222
00:13:02,030 --> 00:13:03,410
然后再分析一下

223
00:13:03,410 --> 00:13:05,150
看一下刚刚那个规则是什么

224
00:13:11,430 --> 00:13:17,930
呃

225
00:13:17,930 --> 00:13:21,370
GHPRVU会匹配

226
00:13:21,370 --> 00:13:22,730
GonRepo不会匹配

227
00:13:22,730 --> 00:13:25,430
因为他不是以精准的GHPRVU

228
00:13:27,130 --> 00:13:28,330
不匹配会怎么样

229
00:13:41,430 --> 00:13:46,310
怎么样

230
00:13:46,310 --> 00:13:48,770
我们就看一下

231
00:13:48,770 --> 00:13:50,570
他这个规则到底是怎么样的

232
00:13:50,570 --> 00:13:52,990
他说是不会命中

233
00:13:52,990 --> 00:13:54,550
点Lulis这个规则

234
00:13:54,550 --> 00:13:58,770
但是我们实际还是看到那个是吧

235
00:13:58,770 --> 00:14:00,490
看一下他这个细节

236
00:14:00,490 --> 00:14:02,950
他说的是不会命中

237
00:14:07,750 --> 00:14:10,590
但是因为还是会涉及到一些网络权限

238
00:14:10,590 --> 00:14:12,550
还是会有一些提示的

239
00:14:12,550 --> 00:14:15,390
你看啊

240
00:14:15,390 --> 00:14:17,590
因为这个命令需要访问GitHub网络

241
00:14:17,590 --> 00:14:19,190
所以在当年黄金下

242
00:14:19,190 --> 00:14:21,350
还是会要求额外授权之行

243
00:14:21,350 --> 00:14:22,430
所以正常来说

244
00:14:22,430 --> 00:14:25,310
按理说他没有匹配就不需要做授权

245
00:14:25,310 --> 00:14:27,370
因为你要访问网络啊

246
00:14:27,370 --> 00:14:31,730
所以这个就还是要做授权的

247
00:14:31,730 --> 00:14:35,610
那我们最近这个依旧需要授权

248
00:14:40,590 --> 00:14:42,450
你看这里面需要确认一下

249
00:14:42,450 --> 00:14:45,510
还是需要收取

250
00:14:45,510 --> 00:14:49,410
也要涉及到访问网络啊

251
00:14:49,410 --> 00:14:53,070
所以这个规则这个里面的逻辑就是

252
00:14:53,070 --> 00:14:55,190
啊我们整个

253
00:14:55,190 --> 00:14:58,570
他不一定就说严格按照这个来啊

254
00:14:58,570 --> 00:15:00,470
他还要根据当前的环境来决定

255
00:15:00,470 --> 00:15:06,090
这个里面到底有没有其他的一些权限需要去申请啊

256
00:15:06,090 --> 00:15:08,870
所以说你写在这里的话

257
00:15:08,870 --> 00:15:11,090
如果说这个里面啊

258
00:15:11,090 --> 00:15:13,770
并不需要额外再去申请其他权限的话

259
00:15:13,770 --> 00:15:15,670
这个命令执行就执行成功了

260
00:15:15,670 --> 00:15:18,430
他不会弹出那个还需要你确认的那个过程

261
00:15:18,430 --> 00:15:21,590
所以具体得看一些场景啊

262
00:15:21,590 --> 00:15:24,250
这个大家回头也可以去试一下

263
00:15:24,250 --> 00:15:27,170
如果他但凡没有涉及到网络访问的话

264
00:15:27,170 --> 00:15:29,870
这个我们其实是OK的啊

265
00:15:29,870 --> 00:15:33,130
所以整个Codex

266
00:15:33,130 --> 00:15:35,170
他的一个处理逻辑的话就是

267
00:15:35,170 --> 00:15:39,770
他会先去加载我们整个Lulis的一个目录

268
00:15:39,770 --> 00:15:40,130
是吧

269
00:15:40,130 --> 00:15:42,230
那加载完之后的话

270
00:15:42,230 --> 00:15:46,770
他会读取到里面的这个点Lulis的一些文件内容

271
00:15:46,770 --> 00:15:47,790
然后的话

272
00:15:47,790 --> 00:15:50,270
这个里面他也分全局的

273
00:15:50,270 --> 00:15:51,630
还有这个项目的

274
00:15:51,630 --> 00:15:53,690
就有用户级别的

275
00:15:53,690 --> 00:15:54,910
整个全局的

276
00:15:54,910 --> 00:15:56,890
也有按照项目来分的

277
00:15:56,890 --> 00:15:58,670
在某个项目下面去点Lulis

278
00:15:58,670 --> 00:16:01,730
这个都是OK的

279
00:16:01,730 --> 00:16:03,890
跟我们前面讲的那个

280
00:16:03,890 --> 00:16:04,484
嗯

281
00:16:19,484 --> 00:16:20,884
就是一个匹配

282
00:16:20,884 --> 00:16:22,884
在这个里面

283
00:16:22,884 --> 00:16:25,184
比如说我们可以匹配pr命令是吧

284
00:16:25,184 --> 00:16:26,684
然后decision

285
00:16:26,684 --> 00:16:28,484
就我们前面讲的不提示

286
00:16:28,484 --> 00:16:30,184
然后提示

287
00:16:30,184 --> 00:16:32,684
然后或者是直接阻止了

288
00:16:33,884 --> 00:16:34,784
那比如说大家

289
00:16:34,784 --> 00:16:36,684
其实你可以在这个里面去改

290
00:16:36,684 --> 00:16:38,184
比如说现在是提示吗

291
00:16:38,184 --> 00:16:40,684
你直接改成forbidden

292
00:16:40,684 --> 00:16:42,984
然后你再去执行看一下

293
00:16:42,984 --> 00:16:43,784
比如说在这个里面

294
00:16:43,784 --> 00:16:45,384
我们先退出去

295
00:16:45,384 --> 00:16:46,884
再执行codex

296
00:16:46,884 --> 00:16:49,084
然后再直接执行这个

297
00:16:49,484 --> 00:16:50,204
命令

298
00:16:50,204 --> 00:16:51,344
看一下他会怎么样

299
00:16:51,344 --> 00:16:56,824
你看

300
00:16:56,824 --> 00:16:58,344
当前

301
00:16:58,344 --> 00:17:01,484
看一下会不会被拒绝啊

302
00:17:01,484 --> 00:17:03,084
啊

303
00:17:03,084 --> 00:17:05,384
因为这个是网络访问啊

304
00:17:05,384 --> 00:17:06,944
这个是另外一个权限申请啊

305
00:17:06,944 --> 00:17:08,124
跟刚刚那个还不一样

306
00:17:08,124 --> 00:17:17,144
看一下他最终会不会被拒绝啊

307
00:17:17,144 --> 00:17:19,044
你看现在已经在加载那个

308
00:17:19,044 --> 00:17:19,964
点录了死了

309
00:17:19,964 --> 00:17:23,264
看一下他最终会不会被拒绝掉

310
00:17:23,264 --> 00:17:37,984
还是有这个结果

311
00:17:37,984 --> 00:17:41,444
这个是前面咱们做了授权

312
00:17:41,444 --> 00:17:43,304
一次性给他加进去了吗

313
00:17:43,304 --> 00:17:46,704
正常来说应该是给他拒绝了

314
00:17:46,704 --> 00:17:49,704
我现在已经有一个forbidden了

315
00:17:49,704 --> 00:17:51,104
我再退出去啊

316
00:17:51,104 --> 00:17:51,704
再看一下

317
00:17:51,704 --> 00:18:02,704
看我切换这个premission看一下

318
00:18:02,704 --> 00:18:05,704
然后测试review

319
00:18:05,704 --> 00:18:07,704
我切换这种模式看一下

320
00:18:07,704 --> 00:18:10,704
然后再置信

321
00:18:10,704 --> 00:18:13,704
看一下他需不需要确认

322
00:18:16,704 --> 00:18:24,764
他说GH因为网络杀箱受限

323
00:18:24,764 --> 00:18:27,324
他会按照他这里提升的权限

324
00:18:27,324 --> 00:18:29,724
他那个杀箱是没权限的

325
00:18:29,724 --> 00:18:31,624
是直接给他锯掉的

326
00:18:31,624 --> 00:18:34,864
但是的话他要重新做一个提权

327
00:18:34,864 --> 00:18:37,704
所以这里面他最终还是可以的

328
00:18:37,704 --> 00:18:40,424
你看他这个只是查询

329
00:18:40,424 --> 00:18:42,364
他没有涉及到修改的风险

330
00:18:42,364 --> 00:18:44,824
所以这里面默认给他放行的

331
00:18:44,824 --> 00:18:46,984
看一下

332
00:18:46,984 --> 00:18:53,684
在这里大家去改的话

333
00:18:53,684 --> 00:18:55,464
你其实看不到什么效果

334
00:18:55,464 --> 00:18:58,524
他其实杀箱给他阻止了

335
00:18:58,524 --> 00:18:59,984
但是的话就是

336
00:18:59,984 --> 00:19:03,344
我们还是可以有一个提权的过程

337
00:19:03,344 --> 00:19:05,564
这个是他设计的

338
00:19:05,564 --> 00:19:06,844
就是这个样子

339
00:19:14,824 --> 00:19:22,184
你看他这个是网络网络权限啊

340
00:19:25,024 --> 00:19:27,184
然后不要告诉我之前

341
00:19:27,184 --> 00:19:29,664
告诉Codex

342
00:19:29,664 --> 00:19:35,004
他其实内部是已经拒绝

343
00:19:35,004 --> 00:19:36,784
但是这里会有个提权的操作

344
00:19:36,784 --> 00:19:39,844
所以大家得看距离的一个情况

345
00:19:39,844 --> 00:19:43,904
然后我们还可以加一些不同的一些参数是吧

346
00:19:43,904 --> 00:19:45,444
然后去做一些匹配啊等等

347
00:19:45,444 --> 00:19:48,504
那这个里面的话就是

348
00:19:48,504 --> 00:19:51,364
我们基于这个Codex

349
00:19:51,364 --> 00:19:53,204
可以去做一些这个

350
00:19:53,204 --> 00:19:55,784
评估一条代运行的命令的时候

351
00:19:55,784 --> 00:19:57,284
他会把命令

352
00:19:57,284 --> 00:19:58,384
他的一个参数

353
00:19:58,384 --> 00:20:00,784
做一个比较啊

354
00:20:00,784 --> 00:20:01,624
那在内部的话

355
00:20:01,624 --> 00:20:02,884
Codex会把命令

356
00:20:02,884 --> 00:20:04,724
看作一个参数列表

357
00:20:04,724 --> 00:20:06,304
比如说一些这个

358
00:20:06,304 --> 00:20:09,424
不同的这个参数是吧

359
00:20:09,424 --> 00:20:10,064
比如说这个

360
00:20:10,064 --> 00:20:13,484
EKCVP这种参数的方式

361
00:20:13,484 --> 00:20:15,684
然后去做一个这个接收

362
00:20:15,684 --> 00:20:19,144
就是他会有这么一个机制

363
00:20:19,144 --> 00:20:20,584
好

364
00:20:20,584 --> 00:20:22,224
然后是sharewrapple

365
00:20:22,224 --> 00:20:23,544
与复合的一些命令

366
00:20:23,544 --> 00:20:25,524
这个是用来干嘛的呢

367
00:20:25,524 --> 00:20:27,464
这个就是我们还可以包装一下

368
00:20:27,464 --> 00:20:29,524
就是我们在lulis里面

369
00:20:29,524 --> 00:20:32,704
我们可以把整个命令做一个包装

370
00:20:32,704 --> 00:20:34,524
什么意思呢

371
00:20:34,524 --> 00:20:36,584
就是你现在要执行多个命令是吧

372
00:20:36,584 --> 00:20:39,544
那我现在想把这个做给打包

373
00:20:39,544 --> 00:20:41,864
比如说提交文件删除

374
00:20:41,864 --> 00:20:43,344
整个做一个打包

375
00:20:43,344 --> 00:20:46,044
那么在这里面的话

376
00:20:46,044 --> 00:20:46,804
就相当于

377
00:20:46,804 --> 00:20:49,444
它单次操作的话

378
00:20:49,444 --> 00:20:51,424
相当于把整个mini做一个执行

379
00:20:51,424 --> 00:20:53,144
就这里面我们可以做一个封装

380
00:20:53,144 --> 00:20:55,664
然后Codex的话

381
00:20:55,664 --> 00:20:59,644
它什么时候可以去拆分一些脚本

382
00:20:59,644 --> 00:21:01,004
比如说

383
00:21:01,004 --> 00:21:02,584
这个里面

384
00:21:02,584 --> 00:21:05,904
一些纯字面量的一些单词

385
00:21:05,904 --> 00:21:08,204
不包含变量展开的这种情况

386
00:21:08,204 --> 00:21:10,244
或者是一些

387
00:21:10,244 --> 00:21:13,124
只通过安全运算服务的一些

388
00:21:13,124 --> 00:21:13,784
这个场景

389
00:21:13,784 --> 00:21:15,544
或者是一些

390
00:21:15,544 --> 00:21:16,464
这个

391
00:21:16,464 --> 00:21:19,524
不同情况的

392
00:21:19,524 --> 00:21:20,644
比如说下面这个

393
00:21:20,644 --> 00:21:23,304
一些有规则的

394
00:21:23,304 --> 00:21:23,604
是吧

395
00:21:23,604 --> 00:21:25,544
就都是安全的这种场景

396
00:21:25,544 --> 00:21:27,064
这个时候的话

397
00:21:27,064 --> 00:21:28,164
他就可以去

398
00:21:28,164 --> 00:21:29,644
加一些这个

399
00:21:29,644 --> 00:21:30,904
一些

400
00:21:30,904 --> 00:21:33,244
做一些安全的一些拆分

401
00:21:33,244 --> 00:21:34,804
比如说把这些命令

402
00:21:34,804 --> 00:21:35,404
做一个拆分

403
00:21:35,404 --> 00:21:38,184
所以他会分别用你的LULUS

404
00:21:38,184 --> 00:21:39,524
去评估每一条命令

405
00:21:39,524 --> 00:21:41,424
并且以最严格的

406
00:21:41,424 --> 00:21:42,624
这个结果为准

407
00:21:42,624 --> 00:21:44,944
然后这里面的话

408
00:21:44,944 --> 00:21:47,744
即使你允许这个partner

409
00:21:47,744 --> 00:21:49,844
然后执行这个

410
00:21:49,844 --> 00:21:51,904
你写了这个东西的话

411
00:21:51,904 --> 00:21:53,544
那他也不会自动放弃

412
00:21:53,544 --> 00:21:56,244
因为这个RM和RF

413
00:21:56,244 --> 00:21:57,964
是一个非常危险的一个操作

414
00:21:57,964 --> 00:22:01,264
因为这个命令比较危险

415
00:22:01,264 --> 00:22:02,484
所以他会单独评估

416
00:22:02,484 --> 00:22:05,204
所以你写归你写

417
00:22:05,204 --> 00:22:07,484
但是Codex他自己也有一套

418
00:22:07,484 --> 00:22:08,764
内置的一套规范

419
00:22:08,764 --> 00:22:12,244
所以这种危险命令的话

420
00:22:12,244 --> 00:22:13,364
你混在一起的话

421
00:22:13,364 --> 00:22:16,544
就违背了他的一个安全指令的一个要求

422
00:22:16,544 --> 00:22:18,304
所以大家会发现

423
00:22:18,304 --> 00:22:19,824
你不是你写所有命令

424
00:22:19,824 --> 00:22:21,564
他都会给你放行的

425
00:22:21,564 --> 00:22:22,764
他也要去看情况

426
00:22:22,764 --> 00:22:25,304
这个是Codex

427
00:22:25,304 --> 00:22:27,744
他可以做一些安全脚本的一个拆分

428
00:22:27,744 --> 00:22:29,024
然后的话Codex

429
00:22:29,024 --> 00:22:31,284
他什么情况下不会去拆分脚本呢

430
00:22:31,284 --> 00:22:34,024
比如说我们已经加了一些重令像的一些东西了

431
00:22:34,024 --> 00:22:35,964
加了一些替换的表达式了

432
00:22:35,964 --> 00:22:37,904
或者做了一些环境变量的一些复制了

433
00:22:37,904 --> 00:22:39,844
或者加了一些通费符了

434
00:22:39,844 --> 00:22:41,964
那这个就不会尝试去解析他

435
00:22:41,964 --> 00:22:43,924
因为它本身就代表

436
00:22:43,924 --> 00:22:45,684
它的执行的一些关键点

437
00:22:45,684 --> 00:22:47,384
是一些规范

438
00:22:47,384 --> 00:22:50,264
所以它就不会去拆分

439
00:22:50,264 --> 00:22:51,784
然后同时的话

440
00:22:51,784 --> 00:22:52,984
它就直接把它用过来

441
00:22:52,984 --> 00:22:54,384
直接去运行的啊

442
00:22:54,384 --> 00:22:57,484
所以它也不是说你写了

443
00:22:57,484 --> 00:22:58,784
它就会帮你去拆分

444
00:22:58,784 --> 00:23:00,564
那它也要去看情况

445
00:23:00,564 --> 00:23:04,324
所以这种处理方式意味着

446
00:23:04,324 --> 00:23:07,184
你就是在可以安全拆分的时候

447
00:23:07,184 --> 00:23:08,924
Codex会按照单条命令

448
00:23:08,924 --> 00:23:10,144
逐项的去评估

449
00:23:10,144 --> 00:23:12,064
在不能安全拆分的时候

450
00:23:12,064 --> 00:23:12,844
就是按照

451
00:23:12,844 --> 00:23:14,884
更加保守的一个方案

452
00:23:14,884 --> 00:23:15,644
去做一个贫固

453
00:23:15,644 --> 00:23:18,684
然后弄完之后的话

454
00:23:18,684 --> 00:23:20,744
我们也可以去做一些测试

455
00:23:20,744 --> 00:23:23,304
比如说我们把这个命令

456
00:23:23,304 --> 00:23:25,344
加到这里来可以看一下

457
00:23:27,330 --> 00:23:33,890
就是你可以去看一下這個規則到底有沒有生效。

458
00:23:33,890 --> 00:23:38,690
比如說我們這個規則,我們可以把它加進去。

459
00:23:38,690 --> 00:23:40,750
你看这个里面就找到了啊

460
00:23:40,750 --> 00:23:42,590
什么

461
00:23:42,590 --> 00:23:44,450
Codex

462
00:23:44,450 --> 00:23:45,330
Default

463
00:23:45,330 --> 00:23:47,150
Check

464
00:23:47,150 --> 00:23:49,890
当前的这个用户目标

465
00:23:49,890 --> 00:23:52,690
但是我们没有这个规则是吧

466
00:23:52,690 --> 00:23:55,830
这个当前用户目标没有建那个规则

467
00:23:55,830 --> 00:23:59,350
所以这个里面我们得改一下啊

468
00:23:59,350 --> 00:24:02,250
这个就是当前目录的

469
00:24:02,250 --> 00:24:03,330
Lulis

470
00:24:03,330 --> 00:24:05,330
点Lulis

471
00:24:05,330 --> 00:24:08,690
这里我们就指定当前步

472
00:24:08,690 --> 00:24:11,650
然后来评估一下它的一些变化

473
00:24:11,650 --> 00:24:13,270
来看一下

474
00:24:29,910 --> 00:24:32,410
PowerShell可以复制执行的一个命令

475
00:24:32,410 --> 00:24:35,670
你看他帮我们把命令做了一个优化

476
00:24:35,670 --> 00:24:39,010
来我们退出去执行一下

477
00:24:39,010 --> 00:24:45,790
这个里面有一个问题

478
00:24:45,790 --> 00:24:47,090
Codex

479
00:25:02,410 --> 00:25:05,910
你看这个是他匹配的一个规则是吧

480
00:25:05,910 --> 00:25:08,250
匹配的规则就是我们可以看得出来

481
00:25:08,250 --> 00:25:10,810
这个里面的话就相当于不被允许啊

482
00:25:10,810 --> 00:25:13,070
这就是他要有这个结论

483
00:25:13,070 --> 00:25:14,670
他可以分析出来

484
00:25:14,670 --> 00:25:16,750
我们去执行这个命令的时候

485
00:25:16,750 --> 00:25:19,090
他给的这个决定就是拒绝了啊

486
00:25:19,090 --> 00:25:20,970
这就是测试规则文件

487
00:25:20,970 --> 00:25:22,450
到底有没有写的有没有问题

488
00:25:22,450 --> 00:25:25,070
他默认的话会帮你输出一个

489
00:25:25,070 --> 00:25:27,610
JSON格式的这么一个规则出来啊

490
00:25:27,610 --> 00:25:31,230
所以这个是我们做测试用的

491
00:25:31,230 --> 00:25:36,350
然后包括一些这些规则的一些语言啊

492
00:25:36,350 --> 00:25:36,690
是吧

493
00:25:36,690 --> 00:25:37,610
比如说

494
00:25:37,610 --> 00:25:39,590
大家可以去看一下

495
00:25:39,590 --> 00:25:42,110
专门有一套语法啊

496
00:25:42,110 --> 00:25:45,270
叫这个Specific的这么一个语法

497
00:25:45,270 --> 00:25:49,790
你看这个是专门的有一套规范啊

498
00:25:49,790 --> 00:25:50,870
大家可以去看一下

499
00:25:50,870 --> 00:25:54,070
怎么来写这个东西

500
00:25:54,070 --> 00:25:54,770
是吧

501
00:25:54,770 --> 00:25:56,830
大家可以去看一下

502
00:25:56,830 --> 00:25:58,990
他是专门有一套规则语法的

503
00:25:58,990 --> 00:26:00,610
他是采用了这种方式

504
00:26:00,610 --> 00:26:02,210
去写规则的

505
00:26:02,210 --> 00:26:04,490
大家可以去参考一下

506
00:26:04,490 --> 00:26:05,890
这是它的一个使用说明

507
00:26:05,890 --> 00:26:08,890
它的语法看起来有点像Python

508
00:26:08,890 --> 00:26:10,890
但是设计目标的话是安全执行

509
00:26:10,890 --> 00:26:12,650
所以Lulis的一个引擎

510
00:26:12,650 --> 00:26:14,830
可以在不产生副作用的前例下

511
00:26:14,830 --> 00:26:16,170
去运行它

512
00:26:16,170 --> 00:26:19,110
比如说它不会去触碰文件系统的一些逻辑

513
00:26:19,110 --> 00:26:20,630
所以这个里面

514
00:26:20,630 --> 00:26:23,830
大家可以去看一下它的一个细节点

515
00:26:23,830 --> 00:26:25,690
这个我们可以去