论迷惑度娘的可行性

hoebec · 发表于 2022-3-8 21:40:21

马上注册，结交更多好友，享用更多功能，让你轻松玩转社区。

您需要登录才可以下载或查看，没有账号？注册

x

本帖最后由 hoebec 于 2022-3-8 21:50 编辑

度娘出的在线解压功能太过强大,号几乎都被封完了,所以尝试迷惑下度娘

据对rar文件加密的了解,如果加密的压缩包切掉前面的几十个字节,后面的数据就应该解压不出来了.只有几十个字节也很容易用其他路径来传递.

下面是一个自动切割/合并的bat脚本,双击运行,拖放文件/文件夹,ENTER
输入的是文件路径就进入切割模式,下一步是输入切割的文件头长度,默认是32.再下一步是输入另外一个切割长度(剩余文件的分卷大小,默认50M,留空则不分卷),运行后生成目标文件夹
输入的是文件夹路径就进入合并模式,把文件夹内所有文件按文件名排序进行合并(数字的排序要注意补零),运行后生成目标文件

' 2>nul&cls&@echo off
' 2>nul&title Binary-Split
' 2>nul&Setlocal Enabledelayedexpansion
' 2>nul&Set /p "Input=Input File/Folder:"
' 2>nul&Start "" Wscript.exe %0 %Input% //Nologo //e:vbs &exit
Set objFSO = CreateObject("scripting.filesystemobject")
Set ADO = CreateObject("Adodb.Stream")
Input = Wscript.Arguments(0)
ADO.Type = 1
ADO.Mode = 3
If objFSO.FileExists(Input) Then
Splpresize=InputBox("Split Presize",,"32")
If IsEmpty(Splpresize) Then Wscript.quit
Splsufsize=InputBox("Split Sufsize",,"50,000,000")
If IsEmpty(Splsufsize) Then Wscript.quit
Splpresize=Int(Splpresize)
If Splsufsize=Empty Then Splsufsize=0
Splsufsize=Int(Splsufsize)
OutputFolder=objFSO.GetParentFolderName(Input)&"\"&objFSO.GetBaseName(Input)&"-Split"
If not objFSO.FolderExists(OutputFolder) Then objFSO.createFolder(OutputFolder)
BinarySplitLoop Input,Splpresize,Splsufsize,OutputFolder
End If
If objFSO.FolderExists(Input) Then
For Each i in objFSO.GetFolder(Input).files
Output=Input&"-Combine."&objFSO.GetExtensionName(i)
Exit For
Next
For Each i in objFSO.GetFolder(Input).files
n=n+1
ADO.Open
ADO.LoadFromFile i
CombineStr=ADO.Read
ADO.Close
ADO.Open
If n=1 Then
ADO.Write CombineStr
ADO.SaveToFile Output,2
Else
ADO.LoadFromFile Output
ADO.position=ADO.size
ADO.Write CombineStr
ADO.SaveToFile Output,2
End If
ADO.Close
CombineStr=Empty
Next
End If
Wscript.Echo "done"
Function BinarySplit(ImpFile,PreSize,ExpPreFile,ExpSufFile)
ADO.Open
ADO.LoadFromFile ImpFile
Splitprestr=ADO.Read(PreSize)
Splitsuflen=ADO.size-PreSize
ADO.position=PreSize
Splitsufstr=ADO.Read(Splitsuflen)
ADO.Close
ADO.Open
ADO.Write Splitprestr
ADO.SaveToFile ExpPreFile,2
ADO.Close
ADO.Open
ADO.Write Splitsufstr
ADO.SaveToFile ExpSufFile,2
ADO.Close
End Function
Function BinarySplitLoop(ImpFile,PreSize,SufSize,ExpFolder)
Outputnum=0
Outputpre=ExpFolder&"\part"&Outputnum&"."&objFSO.GetExtensionName(ImpFile)
Outputnum=Outputnum+1
Outputsuf=ExpFolder&"\part"&Outputnum&"."&objFSO.GetExtensionName(ImpFile)
Call BinarySplit(ImpFile,PreSize,Outputpre,Outputsuf)
If SufSize>0 Then
Splitsufsize=objFSO.GetFile(ImpFile).size-PreSize
Do while Splitsufsize>SufSize
Splitsufsize=Splitsufsize-SufSize
Outputpre=Outputsuf
Outputnum=Outputnum+1
Outputsuf=ExpFolder&"\part"&Outputnum&"."&objFSO.GetExtensionName(ImpFile)
Call BinarySplit(Outputpre,SufSize,Outputpre,Outputsuf)
Loop
End If
End Function

复制代码

切割后的文件头可以使用base64方式转换,直接在帖子上发,下面的bat脚本用来做base64转换/反转
双击运行,输入文件路径或base64编码,ENTER
输入txt文件或base64编码,就会在"我的文档"下生成base64_decode-part0.rar.有些base64编码不能直接通过命令行运行,要先保存到txt文件(不能使用utf-8或unicode)
输入的是非txt文件,就会在文件的同一目录生成base64的txt

' 2>nul&cls&@echo off
' 2>nul&title Base64-Transfer
' 2>nul&Setlocal Enabledelayedexpansion
' 2>nul&Set /p "Input=Input File/Base64Code:"
' 2>nul&Start "" Wscript.exe %0 %Input% //Nologo //e:vbs &exit
Set objFSO = CreateObject("scripting.filesystemobject")
Set WshShell = CreateObject("Wscript.Shell")
Set ADO = CreateObject("Adodb.Stream")
Set oXml = CreateObject("MSXML2.DOMDocument")
Set oNode = oXml.CreateElement("tmpNode")
Set RE = CreateObject("vbscript.RegExp")
Input = Wscript.Arguments(0)
If objFSO.FileExists(Input) Then
If Lcase(objFSO.GetExtensionName(Input))="txt" Then
Base64Text=objFSO.OpenTextFile(Input,1).ReadAll
CodeType=1
Else
CodeType=2
End If
Else
Base64Text=Input
CodeType=1
End If
If CodeType=1 Then
BinaryFile=WshShell.SpecialFolders("MyDocuments")&"\base64_decode-part0.rar"
oNode.dataType = "bin.base64"
oNode.Text = Base64Text
ADO.Type = 1
ADO.Open
ADO.Position = 0
ADO.Write(oNode.NodeTypedValue)
ADO.SaveToFile BinaryFile,2
ADO.Close
End If
If CodeType=2 Then
Base64TextFile=objFSO.GetParentFolderName(Input)&"\"&objFSO.GetBaseName(Input)&"-base64.txt"
oNode.dataType = "bin.base64"
ADO.CharSet = "ascii"
ADO.Type = 2
ADO.Open
ADO.LoadFromFile(Input)
ADO.Position = 0
ADO.Type = 1
oNode.nodeTypedValue = ADO.Read(-1)
ADO.Close
RE.Global = True
RE.MultiLine = True
RE.IgnoreCase = True
RE.Pattern = vbLf
OutputBase64Text=oNode.Text
OutputBase64Text = RE.Replace(OutputBase64Text,"")
Set bt=objFSO.OpenTextFile(Base64TextFile,2,1)
bt.Write OutputBase64Text
bt.close
End If
Wscript.Echo "done"

复制代码

理论上说,把文件头去掉,度娘无论如何也猜不出里面有什么东西了,也许能提高某些文件的防聚爆能力
一个自动给文件名数字补零的脚本:http://ritdon.com/forum.php?mod=viewthread&tid=8679

实例:
http://ritdon.com/forum.php?mod=viewthread&tid=9509
http://ritdon.com/forum.php?mod=viewthread&tid=9514

LONGDONG · 发表于 2022-3-8 22:46:57

精神可嘉，祝你成功。

hinjo16 · 发表于 2022-3-8 23:08:49

這個完全看不懂...可以簡單一些

香露露 · 发表于 2022-3-9 00:02:47

能不能试试这一招：
把图片和经过加密的压缩包进行二进制合并，再上传到度娘呢？
压缩包可以进行二次加密，甚至第三方二次加密（比如简单的异或加密，将密码进行编码后转二进制，对加密过的压缩包直接进行一次加密）
比起合并，我认为这样做的可行性更高。
而且，可以直接用油猴脚本进行解压，操作比bat方便多了。

香露露 · 发表于 2022-3-9 00:05:05

补充说明：图片和压缩包的二进制合并，是很久以前的图种的做法。
只要后缀名是图片，又能读出图片本身，图片后附加的信息或许就会被度娘忽略。

此外，如果是图种的话，也可能通过图床进行传播。
如果图床不会清除额外的二进制信息的话。

香露露 · 发表于 2022-3-9 00:28:59

再补充说明：
关于压缩包加密，度娘大概率是会用常用密码去碰瓷解压。此外，也有可能有人不听话进行在线解压。
所以，只要使用第三方加密，而不是压缩包加密，就能基本避开度娘在线解压的功能。

除了网络上的加密算法以外，楼主也可以自己开发加密算法。毕竟目标只是混淆度娘的自动程序，以及避免不听话的人进行在线解压，所以加密算法本身不需要搞得太过复杂。
我个人自己整过一些，只要有心人想破解就会轻易破解，但并非现成算法所以不知道算法的一般人大概率就没法破解的加密算法。这里贴出来给楼主参考

算法1：语言C#，利用一个整形数做密码的算法。这是加密算法的核心来着，算法设计思路是用离散算法扩张初始的整型数，形成一个二进制序列，用二进制序列对原数据进行异或加密，并且并入原数据的内容形成更复杂的异或密码。

public abstract class Int32Encryptor
{
/// <summary>
/// 基础值
/// </summary>
protected int baseNumber;
static byte nc(byte xu, byte xv)
{
int u = xu;
int v = xv;
v = (u * (u + 1) * (u + 2)) ^ (21401 * (int)Math.Pow(v, 2) + 2531011);
v ^= ((v >> 16) & 56544866);
v ^= ((v >> 8) & 226800473);
v = Math.Abs(v);
v %= 256;
return (byte)v;
}
/// <summary>
/// 获取基于基础值扩展得来的扩展密钥组
/// </summary>
/// <param name="rank"></param>
/// <param name="baseNumber"></param>
/// <returns></returns>
protected static List<byte[]> GetExtendKey(int rank, int baseNumber)
{
uint tm =(uint) baseNumber ;
var p = new byte[] { 0, 0, 0, 0 };
p[0] = (byte)((tm & 0xFF000000) >> 24);
p[1] = (byte)((tm & 0xFF0000) >> 16);
p[2] = (byte)((tm & 0xFF00) >> 8);
p[3] = (byte)(tm & 0xFF);
var ks = new List<byte[]>();
var mx = 6 + 2 * rank;
for (var i = 0; i < mx; i++)
{
byte[] b;
if (i == 0) b = p;
else b = ks[i - 1];
var len = b.Length;
var a = new byte[b.Length + 1];
for (var k = 0; k < len; k++)
{
byte u = 1;
if (k > 0) u = a[k - 1];
else if (i > 0) u = b[b.Length - 1];
var v = (byte)(b[k] % 256);
v = nc(u, v);
a[k] = v;
}
var ax = 0;
for (var l = 0; l < len; l++)
{
var ay = (int)Math.Pow((a[l] + 773) >> 2, 2);
ay = ay ^ ((ay >> 4) & 9752438);
ax += ay % 16777216;
}
a[len] = nc(a[0], (byte)(ax % 256));
ks.Add(a.ToArray());
}
ks.RemoveRange(0, ks.Count - rank);
return ks;
}
/// <summary>
/// 解密算法
/// </summary>
/// <param name="Input"></param>
/// <param name="ks"></param>
/// <returns></returns>
protected static byte[] Decrypt(byte[] Input, List<byte[]> ks)
{
var resault = Input.ToArray();
var l = resault.Length;
bool mod2 = l % 2 == 0, mod3 = l % 3 == 0;
bool tcut = !mod2 && !mod3;
for (var k = ks.Count - 1; k >= 0; k--)
{
//还原交换混淆法。
if (l > 3)
{
if (k % 4 == 0 && mod3)
{
for (var z = 0; z < l; z += 3)
{
var t = resault[z];
resault[z] = resault[z + 1];
resault[z + 1] = resault[z + 2];
resault[z + 2] = t;
}
}
if (k % 4 == 1 && mod2)
{
for (var z = 0; z < l; z += 2)
{
var t = resault[z];
resault[z] = resault[z + 1];
resault[z + 1] = t;
}
}
if (k % 4 == 2 && !mod2)
{
{//将前三条记录进行交换
var t = resault[0];
resault[0] = resault[1];
resault[1] = resault[2];
resault[2] = t;
}
for (var z = 3; z < l; z += 2)
{
var t = resault[z];
resault[z] = resault[z + 1];
resault[z + 1] = t;
}
}
if (k % 4 == 3 && tcut)
{
for (var z = 0; z < l - 3; z += 2)
{
var t = resault[z];
resault[z] = resault[z + 1];
resault[z + 1] = t;
}
{//将后三条记录进行交换
var t = resault[l - 3];
resault[l - 3] = resault[l - 2];
resault[l - 2] = resault[l - 1];
resault[l - 1] = t;
}
}
}
var key = ks[k];
var kl = key.Length;
for (var c = 0; c < l; c++)
{
resault[c] = (byte)(resault[c] ^ key[c % kl]);
}
}
return resault;
}
/// <summary>
/// 加密算法
/// </summary>
/// <param name="source">待加密的数据</param>
/// <param name="ks">加密所用的密钥组</param>
/// <returns></returns>
protected static byte[] Encrypt(byte[] source, List<byte[]> ks)
{
var resault = source.ToArray();
var l = resault.Length;
bool mod2 = l % 2 == 0, mod3 = l % 3 == 0;
bool tcut = !mod2 && !mod3;
for (var k = 0; k < ks.Count; k++)
{
var key = ks[k];
var kl = key.Length;
for (var c = 0; c < l; c++)
{
resault[c] = (byte)(resault[c] ^ key[c % kl]);
}
//使用交换混淆法。
if (l > 3)
{
if (k % 4 == 0 && mod3)
{
for (var z = 0; z < l; z += 3)
{
var t = resault[z];
resault[z] = resault[z + 2];
resault[z + 2] = resault[z + 1];
resault[z + 1] = t;
}
}
if (k % 4 == 1 && mod2)
{
for (var z = 0; z < l; z += 2)
{
var t = resault[z];
resault[z] = resault[z + 1];
resault[z + 1] = t;
}
}
if (k % 4 == 2 && !mod2)
{
{//将前三条记录进行交换
var t = resault[0];
resault[0] = resault[2];
resault[2] = resault[1];
resault[1] = t;
}
for (var z = 3; z < l; z += 2)
{
var t = resault[z];
resault[z] = resault[z + 1];
resault[z + 1] = t;
}
}
if (k % 4 == 3 && tcut)
{
for (var z = 0; z < l - 3; z += 2)
{
var t = resault[z];
resault[z] = resault[z + 1];
resault[z + 1] = t;
}
{//将后三条记录进行交换
var t = resault[l - 3];
resault[l - 3] = resault[l - 1];
resault[l - 1] = resault[l - 2];
resault[l - 2] = t;
}
}
}
}
return resault;
}
}

复制代码

算法2：语言js + c#，这是一个利用数据本身进行加密的算法，优点就是不需要密码，加密解密的速度都挺快的，缺点就是算法被别人知道=密码被别人知道。所以使用时一定要对js进行混淆加密。
算法的思路是：将一段数据的长度作为起始密码，进行离散计算得到一个加密序列，用这个加密序列进行异或加密。并且，可以按需要进行多轮加密，以获得更离散更难破解的序列。

js:
var Encrypt = function (inputBytes, rank) {
var il = inputBytes.length;
if (il == 0) {
return;
}
var key0 = il;
for (var j = 0; j < rank; j++) {
for (var i = 0; i < il; i++) {
key0 = (key0 * 16807) % 0x3FFFFFFF;
var key = key0 % 256;
inputBytes[i] = inputBytes[i] ^ key;
}
}
}

复制代码

c#:
public class WithRandomEncryptor : Int32Encryptor
{
public WithRandomEncryptor(int key)
{
baseNumber = key;
}
public byte[] Encrypt(int Rank, string input)
{
if (string.IsNullOrEmpty(input))
{
return new byte[0];
}
var ks = GetExtendKey(Rank);
var e = Encoding.UTF8;
var b = e.GetBytes(input);
return Encrypt(b, ks);
}
public string Encrypt(string input, int Rank)
{
if (string.IsNullOrEmpty(input))
{
return "";
}
var b = Encrypt(Rank, input);
return DataMethods.ConvertArrayTo16String(b);
}
public string Decrypt(int Rank, byte[] input)
{
if (input == null || input.Length <= 0)
{
return "";
}
var ks = GetExtendKey(Rank);
var b = Decrypt(input, ks);
if (DataMethods.IsUTF8Bytes(b, out bool unexp))
{
var e = Encoding.UTF8;
return e.GetString(b);
}
ks = GetExtendKey(Rank);
b = Decrypt(input, ks);
if (DataMethods.IsUTF8Bytes(b, out bool unexp2))
{
var e = Encoding.UTF8;
return e.GetString(b);
}
throw new Exception("解码错误！您没有获得正确的数据。");
}
public string Decrypt(int Rank, string input)
{
if (string.IsNullOrEmpty(input))
{
return "";
}
var bs = DataMethods.Convert16StringToArray(input);
return Decrypt(Rank, bs);
}
List<byte[]> GetExtendKey(int rank)
{
ResetKey();
List<byte[]> ks = new List<byte[]>();
for (int i = 0; i < rank; i++)
{
generator();
var c = extract_number(0) % (18 + rank) + 16;
var u = new byte[c];
for (int j = 0; j < c; j++)
{
u[j] = (byte)(extract_number(rank + 2 * j) % 256);
}
ks.Add(u);
}
return ks;
}
int[] MT = new int[624];
void ResetKey()
{
MT[0] = baseNumber;
// 遍历剩下的每个元素
for (int i = 1; i < 624; i++)
{
MT[i] = (int)(((long)1812433253 * (MT[i - 1] ^ (MT[i - 1] >> 30)) + i) & 0xffffffff);
}
}
void generator()
{
for (int i = 0; i < 624; i++)
{
int y = (int)(MT[i] & 0x80000000) ^ (MT[(i + 1) % 624] & 0x7fffffff);
MT[i] = MT[(i + 397) % 624] ^ (y >> 1);
if (y % 2 != 0)
{
MT[i] = (int)(MT[i] ^ (2567483615));
}
}
}
int extract_number(int index)
{
long y = MT[index];
y = y ^ (y >> 11);
y = y ^ ((y << 7) & (0x9d2c5680));
y = y ^ ((y << 15) & (0xefc60000));
y = y ^ (y >> 18);
int x = (int)(y & 0xffffffff);
return Math.Abs(x);
}
static void EncryptCliten(ref byte[] inputBytes, int rank)
{
var il = inputBytes.Length;
if (il == 0)
{
return;
}
var key0 = il;
for (var j = 0; j < rank; j++)
{
for (var i = 0; i < il; i++)
{
key0 = (int)((key0 * (long)16807) % 0x3FFFFFFF);
var key = key0 % 256;
inputBytes[i] = (byte)(inputBytes[i] ^ key);
}
}
}
/// <summary>
/// 将与客户端交互用的文本加密为16进制文本
/// </summary>
/// <param name="input">待加密的文本</param>
/// <param name="rank">加密层数</param>
/// <returns></returns>
static public string EncryptCliten_2Str(string input, int rank)
{
if (input == null || input.Length == 0)
{
return "";
}
var te = Encoding.UTF8;
var b = te.GetBytes(input);
EncryptCliten(ref b, rank);
return DataMethods.ConvertArrayTo16String(b);
}
/// <summary>
/// 将与客户端交互用的文本加密为字节数组
/// </summary>
/// <param name="rank">加密层数</param>
/// <param name="input">待加密的文本</param>
/// <returns></returns>
static public byte[] EncryptCliten_2Bytes( string input,int rank)
{
if (input == null || input.Length == 0)
{
return new byte[0];
}
var te = Encoding.UTF8;
var b = te.GetBytes(input);
EncryptCliten(ref b, rank);
return b;
}
/// <summary>
/// 将与客户端交互的16进制密文解密为文本
/// </summary>
/// <param name="input">16进制密文</param>
/// <param name="rank">加密层数</param>
/// <returns></returns>
static public string DecryptCliten(string input, int rank)
{
if (input == null || input.Length == 0)
{
return "";
}
var b = DataMethods.Convert16StringToArray(input);
EncryptCliten(ref b, rank);
var te = Encoding.UTF8;
return te.GetString(b);
}
/// <summary>
/// 将与客户端交互的字符数组解密为文本
/// </summary>
/// <param name="input">被加密的字节数组</param>
/// <param name="rank">加密层数</param>
/// <returns></returns>
static public string DecryptCliten(byte[] input, int rank)
{
if (input == null || input.Length == 0)
{
return "";
}
var b = input;
EncryptCliten(ref b, rank);
var te = Encoding.UTF8;
return te.GetString(b);
}
}

复制代码

hoebec · 发表于 2022-3-9 00:40:31

香露露发表于 2022-3-9 00:02
能不能试试这一招：
把图片和经过加密的压缩包进行二进制合并，再上传到度娘呢？
压缩包可以进行二次加密， ...

之前是在找一些不可言说资源时发现,就算有几重加密,仍旧有可能被爆破.
所以研究后,想了一个方法,如果网盘上的东西是不完整的,打不开的,就让人没法聚爆
这个方法的确比插件麻烦,不过度娘要识别出来也一样麻烦,毕竟要假设网盘官方也是知道各种方法的
要是图片和压缩包合并,文件可能会很大?

hoebec · 发表于 2022-3-9 00:45:33

香露露发表于 2022-3-9 00:28
再补充说明：
关于压缩包加密，度娘大概率是会用常用密码去碰瓷解压。此外，也有可能有人不听话进行在线解 ...

这个太专业了!

香露露 · 发表于 2022-3-9 00:53:07

hoebec 发表于 2022-3-9 00:40
之前是在找一些不可言说资源时发现,就算有几重加密,仍旧有可能被爆破.
所以研究后,想了一个方法,如果网盘 ...

文件确实会增大没错。
但你也可以把类似封面这样的图片缩放到一个比较小的尺寸作为表图，这样就算文件稍微增大，也不是不能忍受。

另外，我刚刚想起来，度娘除了会解压外，还会根据文件名智能判断是否是违规文件。
所以，我个人建议，发度娘的时候，文件名本身也要进行混淆。
比如，所有文件名都改成：语文课件 2022.03.09 第一节课这种奇奇怪怪的名称，并且直到2次加密解密后，才能够看到真实文件名。

关于多重加密被爆破，我个人认为，被他人举报、无论加密几重都用了同一个密码而且还是123456这样的简单密码所以跟一重加密没差、以及直接在文件名上告诉度娘这是违规品（比如直接加上18+的标签），这些情况比起度娘破解多重加密来得合理。

香露露 · 发表于 2022-3-9 00:54:37

hoebec 发表于 2022-3-9 00:45
这个太专业了!

不，真正专业人士会用效率更高更复杂更难破解的算法。
我这是压根看不懂那些天书一般的算法（连原理都看不懂），才搞了这些简单算法的。

香露露 · 发表于 2022-3-9 01:01:47

hoebec 发表于 2022-3-9 00:45
这个太专业了!

关于这些算法的应用，如果要用的话，可以这样：
方法一：
如果发布的站点管理员允许你直接在帖子中添加js代码和html代码，可以直接做一个网页版解密器（这个真不难做，需要的话我可以帮忙，但缺点是部分站点中可能只能支持pc，让用户下载后来到解密器这里进行解密）。

方法一又二分之一：
就是如果实在找不到允许你直接贴js和html的站点，也可以花一点小钱或者找免费但有广告的地方建站，站点只放解密器，什么都别说，让人去解密。因为站点只需要一个静态网页，开销应该不会太大才对。

方法二：
制作油猴脚本，让用户安装油猴脚本后，能够自动识别在你在帖子中放置的标记，并改造生成解密器。

香露露 · 发表于 2022-3-9 01:10:23

说起来……还有一种理论上的伪装……
docx格式本身是一种zip压缩包。
你可以试着建一个docx文件，在里边随便放一些日记、摘抄、文本这些奇奇怪怪但绝对合法的内容，用压缩包软件打开它，把加密过的真正要发的东西（一定要混淆文件名）丢到docx里边。
这样，在不知道它是什么的情况下，度娘只能识别出一个包含错误、但可修复的docx文件。

dsfr43r · 发表于 2022-3-9 12:19:06

以前撥接時代就有一堆這種軟體

liangjianfeng · 发表于 2022-3-9 15:04:53

有一个软件 AliShareTool 压缩包伪装专治在线解压
具体用法可以自行搜索。

hklj8 · 发表于 2022-3-9 15:14:14

原来，，大家都在学编程,,还是p..

hfy · 发表于 2022-3-11 12:38:08

这就是大佬的世界吗？看不懂

Momus諾哪 · 发表于 2022-3-11 19:18:22

這就是神的領域嗎?路人甲還是路過好了

qaz4544 · 发表于 2022-3-11 23:12:47

只会刷机，别的代码都不会

		自动登录	找回密码
密码			注册

[闲聊] 论迷惑度娘的可行性

马上注册，结交更多好友，享用更多功能，让你轻松玩转社区。