如果是 Windows 上的话可以考虑用 COM 作为接口，就没这么多费事儿的了

打开文件资源管理器之后用 breadcrumb 导航，点地址栏第一个向右的三角形，然后在列表中选择“回收站”。

@dangyuluo #53 安全的密钥交换算法在所有通讯都被记录的情况下仍然保持安全。

@niubee1 #54 零知识共享是什么？

任何可以用的操作系统都有这种问题。

https://geelaw.blog/entries/red-envelope/

这个问题其实很无聊 - - 从我两个小时就能排版完毕就能看出来。

您似乎没有弄明白 RSA 和 DH 的关系。

您链接文章里似乎暗示 Z_p^* 里 decisional Diffie-Hellman 成立——这是不对的，在 Z_p^* 里 DDH 不成立，用整数取模计算的时候应该选择安全质数 p=2q+1，并使用 Z_p^* 的 q 阶子群（因此使用 23、5 作为例子也是误导性的）。以及对困难性的理解也不太对，因为计算 a、b 没有什么用，攻击者需要考虑的是如何计算 g^(ab)——这并不非要计算 a、b。

另外您也没有公布您使用的是什么（对称）加密算法，通常来说这样默认安全性是 0。

Chrome 把 Windows 的亮暗主题色 translate 成了 CSS media query。

我觉得尝试用第三方工具解析 Word 都是很诡异的思路，不考虑兼容性问题，也是直接用 Word COM 更简单。想要用 VBA、C++、Python 还是 PowerShell 都可以。

最直接的思路是区间动态规划，自然需要的时间是 n^3，空间是 n^2。
稍微思考可以只考虑开头的区间，时间是 nlogn，额外空间是 1。

具体做法留作习题。

@xml123 #9 startendend 会拿到太长的结果。

@ipwx #11 对于我来说零宽断言不够“纯粹”。

而且重点是方法很简单（结果确实很复杂），所谓“理论帮助思考”，是指思考的很大一部分负担由理论内部所消化——类似于使用方程比算术方法简单，“条件表达为方程”（建立一个 (G)NFA ）以及“解方程”（把 (G)NFA 转换为正则表达式）中，前者是比直接想出反向的算式简单的，后者是机械的。

至于为什么直接写一个正则表达式更加困难，是因为正则表达式中对补集、交集的表达力比较弱（纯粹的正则表达式根本没有这些功能，比如计算一个正则表达式识别的语言补的正则表达式，是没有什么很直接的办法的），而 (G)NFA 表达这些很容易。

#18 见 https://gist.github.com/GeeLaw/be3aec94a6ba7c3817ef2e16d261f616

@noqwerty #10 startendstartend 会只能拿到第二个匹配。

呃，上面那个似乎有错误，正确的结果应该是：

start((e(ne|e)*(ns|s)|s)(t(a(r(e(ne|e)*(ns|s)|s)|e(ne|e)*(ns|s)|s)|e(ne|e)*(ns|s)|s)|e(ne|e)*(ns|s)|s)*(t(a(r(e(ne|e)*(n[^sed]|[^sen])|[^set])|e(ne|e)*(n[^sed]|[^sen])|[^ser])|e(ne|e)*(n[^sed]|[^sen])|[^sea])|e(ne|e)*(n[^sed]|[^sen])|[^set])|e(ne|e)*(n[^sed]|[^sen])|[^se])*((e(ne|e)*(ns|s)|s)(t(a(r(e(ne|e)*(ns|s)|s)|e(ne|e)*(ns|s)|s)|e(ne|e)*(ns|s)|s)|e(ne|e)*(ns|s)|s)*(t(a(re(ne|e)*nd|e(ne|e)*nd)|e(ne|e)*nd)|e(ne|e)*nd)|e(ne|e)*nd)

用理论帮助思考，考虑一个 NFA，它的状态是
x/s/st/sta/star/start/starts/startst/startsta/startstar/startstart/starte/starten/startend
你希望这个机器接受 start 开头 end 结尾且中间没有 start 或者 end 的字符串，初始状态是 x。

用 q+r = q' 表示 q 之后看到 r 就进入 q'，只有 startend 是接受状态

读入最开始的 start：
x+s = s
s+t = st
st+a = sta
sta+r = star
star+t = start

中间可能出现 start：
start/starts/startst/startsta/startstar/starte/starten+s = starts
starts+t = startst
startst+a = startsta
startsta+r = startstar
startstar+t = startstart

中间可能出现 end：
start/starts/startst/startsta/startstar/starte/starten+e = starte
starte+n=starten
starten+d=startend

任何其他字符：
start+[^se] = start
starts+[^set] = start
startst+[^sea] = start
startsta+[^ser] = start
startstar+[^set] = start
starte+[^sen] = start
starten+[^sed] = start

通过 NFA 转换为正则表达式的算法得出一个写法是这样的

start((e(ne|e)*(ns|s)|s)(t(a(r(t(e(ne|e)*(ns|s)|s)|e(ne|e)*(ns|s)|s)|e(ne|e)*(ns|s)|s)|e(ne|e)*(ns|s)|s)|e(ne|e)*(ns|s)|s)*(t(a(r(te(ne|e)*(n[^sed]|[^sen])|e(ne|e)*(n[^sed]|[^sen])|[^set])|e(ne|e)*(n[^sed]|[^sen])|[^ser])|e(ne|e)*(n[^sed]|[^sen])|[^sea])|e(ne|e)*(n[^sed]|[^sen])|[^set])|e(ne|e)*(n[^sed]|[^sen])|[^se])*((e(ne|e)*(ns|s)|s)(t(a(r(t(e(ne|e)*(ns|s)|s)|e(ne|e)*(ns|s)|s)|e(ne|e)*(ns|s)|s)|e(ne|e)*(ns|s)|s)|e(ne|e)*(ns|s)|s)*(t(a(r(te(ne|e)*nd|e(ne|e)*nd)|e(ne|e)*nd)|e(ne|e)*nd)|e(ne|e)*nd)|e(ne|e)*nd)((.(e(ne|e)*(ns|s)|s)(t(a(r(t(e(ne|e)*(ns|s)|s)|e(ne|e)*(ns|s)|s)|e(ne|e)*(ns|s)|s)|e(ne|e)*(ns|s)|s)|e(ne|e)*(ns|s)|s)*(t(a(r(te(ne|e)*(n[^sed]|[^sen])|e(ne|e)*(n[^sed]|[^sen])|[^set])|e(ne|e)*(n[^sed]|[^sen])|[^ser])|e(ne|e)*(n[^sed]|[^sen])|[^sea])|e(ne|e)*(n[^sed]|[^sen])|[^set])|.e(ne|e)*(n[^sed]|[^sen]))((e(ne|e)*(ns|s)|s)(t(a(r(t(e(ne|e)*(ns|s)|s)|e(ne|e)*(ns|s)|s)|e(ne|e)*(ns|s)|s)|e(ne|e)*(ns|s)|s)|e(ne|e)*(ns|s)|s)*(t(a(r(te(ne|e)*(n[^sed]|[^sen])|e(ne|e)*(n[^sed]|[^sen])|[^set])|e(ne|e)*(n[^sed]|[^sen])|[^ser])|e(ne|e)*(n[^sed]|[^sen])|[^sea])|e(ne|e)*(n[^sed]|[^sen])|[^set])|e(ne|e)*(n[^sed]|[^sen])|[^se])*((e(ne|e)*(ns|s)|s)(t(a(r(t(e(ne|e)*(ns|s)|s)|e(ne|e)*(ns|s)|s)|e(ne|e)*(ns|s)|s)|e(ne|e)*(ns|s)|s)|e(ne|e)*(ns|s)|s)*(t(a(r(te(ne|e)*nd|e(ne|e)*nd)|e(ne|e)*nd)|e(ne|e)*nd)|e(ne|e)*nd)|e(ne|e)*nd)|.(e(ne|e)*(ns|s)|s)(t(a(r(t(e(ne|e)*(ns|s)|s)|e(ne|e)*(ns|s)|s)|e(ne|e)*(ns|s)|s)|e(ne|e)*(ns|s)|s)|e(ne|e)*(ns|s)|s)*(t(a(r(te(ne|e)*nd|e(ne|e)*nd)|e(ne|e)*nd)|e(ne|e)*nd)|e(ne|e)*nd)|.e(ne|e)*nd)*

因为增加文件同步功能不符合去耦合原则。

第一个原因是资本主义的原因，第二个原因是共产主义的原因。

@Raymon111111 #4 楼主的错误还没发展到这么高级的阶段，他的错误在于选择一个非主流的 **算法**，而不是选择一个非主流的 **实现**。

@claymore94 #27 评论是否安全不需要知道怎么做才安全。

此外，证明一个东西不安全是一件非常容易的事情。
具体到楼主的方案，你可以参考任何一个本科生密码学课程的前两节课的内容。
一个简单的提示是这样的：QQ 号码是多位数字，因此可以把位移量缩小到一个非常小的范围内，接下来再结合其他用户名的有意义性就差不多可以算出位移量，因此可以从楼主的密文中还原出所有的密码。
这是一个惟密文攻击下不安全的方案——现代安全工具通常使用的是选择密文攻击下安全的方案。

@claymore94 #48 加密算法的安全性不应当依赖于明文（这里就是你需要加密的密码）的随机性，任何选择明文攻击下安全的加密方案，加密 1111111111111 和 s$Kf5%i&e?gfu 之后都是无法辨别的。
至于密码本身是弱密码容易被攻破，那并不是通过你的密码管理器攻破的，和你的密码管理器没有关系。

@claymore94 #63 我没有用过任何密码管理器，但我相信几乎所有的密码管理器的算法都是公开的，云端存储并不会包括密钥，加上加密算法的安全性，可以相信厂商并没有解密的能力。

@libook #64 并不需要是密码学博士，需要的是密码学知识，以及能够在久经考验的假设下形式化证明安全性。

最后回复附言：
> 我自己用吧，用自己的作品还是很开心的。

我在 1 楼的建议也适用于楼主本人。或许用自己写的密码管理器很开心，但是这个密码管理器非常不安全。当然本身的不安全性也不是什么巨大的实际威胁，只要你愿意相信 Tencent 不会偷看你的内容；真正的威胁是虚假的安全感。

@geelaw *离安全差十万八千里

我强烈建议任何觉得自己的账户应该保密的人不要用这个软件。

这个加密方法里安全差十万八千里。

@alphatoad #4 贵的是 130 块钱的额外费用，类似于花了 5 块钱买的东西运费要 10 块钱的运费。

这是一个非常简单的 DPDA，用一个带有左右孩子和亲代节点指针的结构，从一个单独的根开始。
遇到数字：设置当前节点的值。
遇到左括号：建立并进入左子树。
遇到逗点：回到亲代，如果左子树没有值则删除之，建立并进入右子树。
遇到右括号：回到亲代，如果右子树没有值则删除之。