NJUPT SAST

C语言急救车

2021-12-24T00:00:00+00:00

PPT下载：https://www.aliyundrive.com/s/AvVpC1tMbgW

用一节公开课的时间带领大家将考试的常见知识点和考察方式复习一遍，做到听进一道题就能多得一分，快速高效复习。

本次公开课无需报名需自带纸笔

不预留座位前排座位先到先得

活动信息：

主讲人：黄霄
时间： 2021/12/24 18:30 UTC +08:00
活动形式：教四-202 线下授课
同步直播地址：http://live.bilibili.com/14980641

SFINAE 的发展史

2021-12-14T00:00:00+00:00

说到 C++ 的模板技术，有一个术语不得不提：SFINAE (读作 Sfee-nay，Substitution Failure is Not An Error )。这个技术使得 C++ 这样的静态语言在一定程度上可以实现类似反射的功能 (可以根据类型的特征，表现出不同的行为)。在 C++20 标准概念库发布之后，许多运用到 SFINAE 技术的场景都可以被概念取代，这一古老的技术也许也将退出历史舞台。

当然，这不是一件值得悲伤的事情，这说明标准委员会在积极地寻求摆脱历史的包袱的途径。

这篇文章旨在向想要了解 SFINAE 的读者介绍这一技术的发展历史。

什么是 SFINAE?

任何人，看到那样一长串的英文解释，或许都会懵逼。替换失败不是一个错误？什么鬼？

更加具体地说，这句话的意思是，在模板实例化的过程中，替换失败不是一个错误。

C++98 的做法

下面我将以判断一个类是否拥有 size_t size() 方法为例，来深入 SFINAE。

我们希望，假如这个类拥有 size 方法，那么就调用这个方法，否则使用另外一个泛化版本的方法。

traits

我们定义一个结构体 hasSize 作为类的特征，假如这个类拥有 size 方法，那么 hasSize::value 将会是 true (或1)，否则为 false。

template <typename T>
struct hasSize
{
    // Compile-time Boolean
    typedef char yes;
    typedef int  no;
};

Q: 你一定注意到了上面的 typedef，并且对此有些不解。它是做什么的？

A: 它是用来做编译期的对错判断的。

Q: 为什么要这么写？直接用函数返回 true 或 false 难道不好吗？

A: 确实好，但是 C++98 的函数返回值只能在运行时获得。直到 C++11 引入 constexpr 之后，这一问题才得到改善。

Q: 那为什么这么写就能达成我们的目的？

A: 我们应该还记得 C 里的一个运算符，它长得有点像函数，但与它有关的求值却全都发生在编译期。那就是 sizeof。

const int a = sizeof(int);
const bool b = sizeof(int) == sizeof(char);

上面的两个赋值语句，其赋值号右边的值均可以在编译期求得。而看到第二个语句，你一定已经恍然大悟。

下面就是我们的 SFINAE 登场的时候了。

我们在结构体内加入另外一个脚手架结构体 reallyHas：

template <typename U, U u> struct reallyHas;

我们在参数 U 中可以给出函数指针的类型，在参数 u 中给出成员函数的具体名字。

然后给出两个函数 test 的重载版本：

template <typename U,
          typename = reallyHas<size_t(U::*)() const, &U::size>>
static yes test(U) { }

// Fallback:
static no test(...) { }

第一个版本返回 yes，接受 U 类型的变量为参数，模板参数列表里第一个是 U，第二个参数是我们之前的脚手架 reallyHas。

第二个版本接受可变长参数。

匹配 test 版本的过程中，会发生这样的事：

test 从参数中推导出 U 的具体类型，代入模板的第一个参数，然后把所有的 U 替换成这个类型。
替换 (Substitution) 完毕，接着编译器会去查找实例化后 test 中和替换后 U 有关的部分（本例中就是 size_t(U::*)() const 类型的 &U::size），假如它们不存在，那么这次替换就宣告失败 (Failure)。但替换失败不是一个错误 (Error)，编译器会接着匹配，直到所有候选名单 (candidates) 的成员都不匹配，才会报错。
随着第一个匹配失败，模板去匹配可变长参数版本的 test。这个版本无论如何一定能匹配成功，而它的返回值类型是 no。

然后我们使用一个枚举常量 value 来接受结果：（C++11 之后便被 constexpr 取代）

enum
{
    value = sizeof(test(T())) == sizeof(yes)
};

这一过程，我们并不需要函数具体的返回值，而只是对返回值的类型作操作。这冥冥之中也印证了一句话：C++的模板是编译期的多态，是类型的多态（或者也可以说，类型和值本身可以等价）。

当然上面的并不是最终版本，假如我们的 size 有两种可能的版本：

size_t(U::*)() const
size_t(U::*)()

那么我们就无法简单使用上面的做法了。

下面提供一种更加简洁的做法：

template <typename T>
struct hasSize
{
    typedef char yes;
    typedef int  no;

    template <typename U, U u> struct reallyHas;

    template <typename U> static yes test(reallyHas<size_t(U::*)(), &U::size> *) { }
    template <typename U> static yes test(reallyHas<size_t(U::*)() const, &U::size> *) { }
    template <typename> static no test(...) { }

    enum
    {
        value = sizeof(test<T>(int())) == sizeof(yes)
    };
};

由于 C++ 整形可以隐式转化为指针，我们仍然会先匹配 yes 版本的 test。

enable_if

下面我们使用之前的 hasSize 来帮助我们实现目的。我们来引入另外一个工具人：enable_if。

template <bool, typename T>
struct enable_if
{
    typedef T type;
};

template <typename T>
struct enable_if<false, T>
{ };

看起来有点懵？不知道它要干嘛？我们继续实现我们的 getSize 函数：

template <typename T>
  typename enable_if<hasSize<T>::value, size_t>::type
getSize(const T &obj)
{
    std::cout << "obj has size" << std::endl;
    return obj.size();
}

template <typename T>
/* disable if: */
  typename enable_if<!hasSize<T>::value, size_t>::type
getSize(const T &obj)
{
    std::cout << "obj has no size" << std::endl;
    return sizeof(obj);
}

两处都得写上 enable_if，否则会产生二义性。（如果其中一个 enable_if 的参数1为 true，那么返回值是 size_t，那么另外一个 enable_if 必然没有返回值，所以它会被排除在候选名单之外，假如另外一个函数拥有返回值，那么这个时候编译器将会不清楚应该调用哪个版本的函数，从而产生 error）

下面来试验一下：

std::vector<int> v = {4, 5, 6, 7};
char c = 'c';
std::cout << getSize(v) << std::endl;
std::cout << getSize(c) << std::endl;

输出结果：

obj has size
4
obj has no size
1

时间来到 C++11

我们在讲述 C++98 的解决方法的时候，已经说过：许多东西到了 C++11 会有更好的解决办法。

现在我们终于可以介绍 C++11 了。

其实本来并没有 C++11，它最早的名字叫做 C++0x，因为人们坚信在二十一世纪的前十年 C++11 的标准就能够实现，然而实际上直到2011年，C++11 才正式发布。

C++11 为模板编程带来了许多的便利。

首先是编译期表达式类型推导 decltype。
接着是 std::declval，这是一个模板函数，它允许我们构造一个类型 T 的临时量，而无需我们提供参数对其构造。
还有我们之前说过的 constexpr，也是千呼万唤始出来。
std::enable_if，它进标准了。
当然还有新的标准库头文件，type_traits，它为我们提供了许许多多方便的 traits，我们不需要再自己手动实现了。

在 C++11 中，我们将使用另外一个例子——判断一个类是否是可以比较大小的。(这里以小于号为例)

我们写一个类模板 isComparable：

template <typename T>
struct isComparable
{
    template <typename U>
    static constexpr bool test(decltype(std::declval<U>() < std::declval<U>()) *)
    { return true; }

    template <typename>
    static constexpr bool test(...) { return false; }
	// C++11 initializer list
    static constexpr bool value { test<T>(int()) };
};

在 test 的参数中用到了 decltype 和 std::declval。用 declval 来查询是否两个 U 类型的变量重载了（或者本身就拥有）operator<，如果拥有，则匹配成功，否则匹配失败，将会匹配可变长参数版本的 test。

C++11 版本下我们的许多操作变得更加符合直觉，实现也更加简洁明了。

试验：

class Test1
{
public:
    bool operator<(Test1);
};

class Test2
{ };

std::cout << isComparable<Test1>::value << std::endl; // 1
std::cout << isComparable<Test2>::value << std::endl; // 0

除此之外还有另一种方法：

template <typename T,
          typename = bool>
struct isComparable: std::false_type // 继承而来的 value 成员为 false，下面类似。
{ };

template <typename T>
struct isComparable<T, decltype(std::declval<T>() < std::declval<T>())>: std::true_type
{ };

第一个版本的 isComparable 默认参数一定要设为 bool，也就是 operator< 返回值的类型，原因是：

当类模板有默认参数的时候，编译器会更加偏袒那个有默认参数的模板；
当带有默认参数的模板与另外一个偏特化模板参数一致的时候，则会优先选择那个偏特化的版本。

于是当 [T = Test1]，偏特化版本模板的第二个参数也是 bool，于是选择了第二个偏特化版本的模板。

当 [T = Test2]，SFINAE 的规则让我们不得不选择第一个版本的模板。

C++14 泛型 `lambda`

C++14 让我们的匿名函数支持 auto 类型的参数。它的本质其实就是带有模板括号运算符的仿函数。

auto f = [] (auto x) { return x; };

// equivalent to:
struct Unnamed
{
    template <typename T>
    auto operator()(T x) { return x; }
} functor;

因此 SFINAE 的技术也能够适用于它。

我们可以用泛型 lambda 来实现袖珍版的 traits。

先上效果：

class A { };

class B
{
public:
    bool operator<(B const &) const { }
};

auto hasLess = is_valid([] (auto &&x) -> decltype(x < x) { });
std::cout << std::boolalpha;
std::cout << hasLess(43)  << std::endl;
std::cout << hasLess(A()) << std::endl;
std::cout << hasLess(B()) << std::endl;

auto comparableWith = is_valid([] (auto &&x, auto &&y) -> decltype(x < y) { });
std::cout << comparableWith(43, "Abc"s) << std::endl;
std::cout << comparableWith(43, 72.2)   << std::endl;
std::cout << comparableWith(B(), B())   << std::endl;
std::cout << comparableWith(A(), B())   << std::endl;

输出结果：

true
false
true
false
true
true
false

这个 is_valid 是个啥，好神奇。下面我们就来详细解释一下：

首先，它是一个工厂函数。产生 is_valid_impl 类型的对象。

template <typename F>
struct is_valid_impl
{
private:
    F _f;

    template <typename... Ts>
    static constexpr auto test(Ts&&... ts) -> decltype(_f(ts...), true)
    { return true; }

    // fallback
    static constexpr bool test(...)
    { return false; }

public:
    constexpr explicit is_valid_impl(F &&f): _f(f) { }

    template <typename... Us>
    constexpr auto operator()(Us&&... us)
    { return test(us...); }
};

template <typename F>
is_valid_impl<F> is_valid(F &&f)
{ return is_valid_impl<F>(std::forward<F>(f)); }

is_valid_impl 的工作原理：

依靠 is_valid_impl 构造函数把仿函数对象 _f 初始化。
operator() 从调用时的实参列表推导出来 Us... 将运算委任给 test 函数。
首先匹配第一个版本的 test，这个过程有 SFINAE 的参与：decltype 时，将形参代入 _f，而我们的 _f 形如：[] (auto &&x, auto &&y) -> decltype(x < y) { }，如果参数无法进行某些指定操作，或者参数长度不匹配，那么第一个版本的 test 被 SFINAE out。否则匹配成功，返回 true。
匹配失败，这个时候就进入第二个版本的 test，其无论如何都会返回 false。

由于 C++14 参数推导还不够智能，所以我们这里不得不使用一个工厂函数来帮助我们推导 F 的类型，而在后续标准，我们可以不再需要这个工厂函数，而直接使用构造函数了。

C++17 void_t

C++17 引入了一个类模板std::void_t，它可以干啥呢？接受一长串的类型，但自己永远是 void。它其实就是一个别名模板，长成这样：

template <typename...>
using void_t = void;

现在可以方便地使用 decltype + 逗号表达式，来完成一长串的判断，而无需判断返回值类型了（有的时候返回值类型是难以判断的，比如返回值类型带有模板参数）。

下面给出一个终极版 isComparable：

template <typename T,
          typename = void>
struct isComparable: std::false_type
{ };

template <typename T>
struct isComparable<T, std::void_t<decltype(std::declval<T>() < std::declval<T>(),
                                            std::declval<T>() > std::declval<T>(),
                                            std::declval<T>() >= std::declval<T>(),
                                            std::declval<T>() <= std::declval<T>(),
                                            std::declval<T>() == std::declval<T>(),
                                            std::declval<T>() != std::declval<T>())>>: std::true_type
{ };

C++20 concepts

如前言所说，C++20 概念库或给 SFINAE 的时代画上一个句号。那么我们也用概念重写的 isComparable 为本文画上一个句号。

template <typename T>
concept is_bool = std::is_convertible_v<T, bool>;

template <typename T>
concept isComparable =
  requires (T t)
{                            
    {t >  t} -> is_bool; {t <  t} -> is_bool;
    {t >= t} -> is_bool; {t <= t} -> is_bool;
    {t == t} -> is_bool; {t != t} -> is_bool;
};

template <typename T>
concept isNotComparable = !isComparable<T>;

我们可以这么使用：

// 使用不同的概念我们可以提供不同的重载函数版本（即便参数列表相同）
void foo(isComparable auto&&)
{
    std::cout << "is comparable" << std::endl;
}

void foo(isNotComparable auto&&)
{
    std::cout << "is not comparable" << std::endl;
}

class Test { };

foo(1);
foo(Test());

结果：

is comparable
is not comparable

当然我们可以把 concepts 和上面的那些类模板结合起来，用来做空基类优化，不过那就不是本文要讨论的内容了。

后记

尽管我曾在前言说过，我们毋须为 SFINAE 技术的退出而悲伤，但我认为 SFINAE 技术是老一代 C++ 工程师智慧的结晶。二十多年过去，C++ 标准从跛脚逐步开始走向完善，使用 C++ 抽象的方法日趋成熟，我想这其中不无他们的功劳。在模板技术发展的过程中，许多东西都事出偶然，然而如果没有前人的不懈尝试，这些偶然又怎会成为已经发生的必然？

当然，SFINAE 作为 C++ 本身的一个语言规则，它仍然会在底层发挥作用。不得不直接倚赖底层的东西去解决上层的问题，这是 C++ 过去的缺陷。

人们始终不停地在探索这个语言的极限，我想这才是 C++ 吸引人的地方。

如果这篇文章能给读者带来一丝启发，那就再好不过了。

参考

Jean Guegant: An introduction to C++’s SFINAE concept: compile-time introspection of a class member [https://jguegant.github.io/blogs/tech/sfinae-introduction.html] （我的 SFINAE 启蒙读物）

二十年以来对RSA密码系统攻击综述

2021-12-14T00:00:00+00:00

这篇文章翻译自Dan Boneh的Twenty Years of Attacks on the RSA Cryptosystem，其中部分译文参考了二十年以来对 RSA 密码系统攻击综述 (seebug.org)~~（但是这个译文机翻有点重，而且公式也没有了）~~。希望通过这篇文章，对目前常见的RSA攻击进行一个总结以及较为深入的了解。

1.分解大整数(Factoring Large Integers)

我们将模分解称为对RSA的暴力攻击。尽管因数分解算法一直在改进，但在正确使用RSA时，目前的技术水平，还远远没有对RSA的安全性构成威胁。虽然大整数的因式分解是计算数学中最美丽的问题之一，但它不是本文的主题。

目前最快的分解算法是General Number Field Sieve(普通数域筛选法)，其时间复杂度为
\(e^{((\sqrt[3]{\frac{64}{9}}+o(1))(\ln{n})^{\frac{1}{3}}(\ln{\ln n})^{\frac{2}{3}}}\)
学长在服务器上操作下来情况是这样的：16核32线程分解400bits的n，需要4000s；分解505bits的n，需要67小时。

开放性问题1：给定整数n和e，满足gcd(e, phi(n))=1。定义函数\(f_{e,n}:Z^*_n\to Z^*_n,\ f_{e,n}(x)=x^{\frac{1}{e}}\pmod n\)，是否存在一个多项式时间的算法A，对于给定n，可以计算n的分解同时能访问一些e的oracle \(f_{e,n}(x)\)。

有学者指出，上述开放性问题，对于一个较小的e来说，答案是否定的。

下面我们将证明知道公开私钥 d 和分解 N 是等效的。因此，对于知道 d 的任何一方隐藏 N 的因式分解是没有意义的。

分解n显然可以很容易计算得到d。
若给定d，我们有\(k=e*d-1\)，通过定义我们可以知道，k是\(\phi (n)\)的倍数，我们知道\(\phi(n)\)是偶数，同时有\(k=2^t*r\)，（\(r\)是奇数）。对于\(g\in Z^*_n\)，有\(g^k\equiv1\pmod n\)，并且\(g^{\frac{k}{2}}\)是模n的平方根，由中国剩余定理我们知道，对于n=p*q，这样的数有4个。其中，有两个是正负一，还有两个是\(\pm x\)，其中\(x\equiv1\pmod p,x\equiv-1\pmod q\)。使用后两者，我们就可以通过计算gcd(x-1, n)得到n的分解。有简单的论证表明，如果g是在\(Z^*_n\)中随机取，那么序列\(g^{\frac{k}{2}},g^{\frac{k}{4}},\dots,g^{\frac{k}{2^t}}\pmod n\)的其中一个是平方根且能分解n的概率至少为1/2。序列中的所有元素都可以在\(O(\log_2{n})^3)\)的时间内有效计算。

2.两种简单攻击

2.1共模攻击

共模攻击是一种只需要知道多组公钥对，就可以推出明文的攻击，在上一篇中已经介绍，这里就不再赘述。

2.2Blinding——盲签名（攻击）

令<n,d>为私钥，<n,e>为公钥。我们想让Bob对m签名，Bob肯定会拒绝。于是我们选择一个随机数\(r\in Z_n^*\)，并且令\(M'=r^em\)，明文改变了，Bob可能愿意在看上去没什么问题的M’上签名。但是此时，我们就可以很简单的得到原本的签名\(S'\equiv(M')^d\pmod n,\ S\equiv S'/r\pmod n\)。
\(S^e\equiv(S')^e/r^e\equiv(M')^{ed}/r^e\equiv M'/r^e\equiv M\pmod n\)
不过由于大多数签名方案在签名之前对消息应用”单向散列”算法，这种攻击并不是一个严重的问题。况且，正如标题中攻击在括号里一样，这种盲签名在区块链中应用更广。

3.低解密指数攻击

为了减少解密时间（或签名时间），人们希望使用一个较小的d，而不是随机的d。而这种操作就会导致下面的一些攻击。

定理(M. Wiener)：令\(n=pq\)，且\(q<p<2q，d<\frac{1}{3}n^{\frac{1}{4}}\)，如果给定公钥，我们可以有效恢复解密指数d。
证明：我们有等式\(ed-k\phi(n)=1\)，于是
\(\lvert \frac{e}{\phi(n)}-\frac{k}{d} \rvert=\frac{1}{d\phi(n)}\)
此时，\(\frac{k}{d}\)是\(\frac{e}{\phi(n)}\)的近似值。尽管我们不知道\(\phi(n)\)，但是我们可以用n近似它。
\(\phi(n)=n-p-q+1\\\)
同时，由p、q的不等关系容易得到\(p+q-1<3\sqrt n\)，于是
\(\lvert n-\phi(n) \rvert<3\sqrt n\)
我们用上面的不等式代换原有的等式
\(\lvert \frac{e}{n}-\frac{k}{d} \rvert=\lvert \frac{ed-k\phi(n)-kn+k\phi(n)}{nd} \rvert\\=\lvert \frac{1-k(n-\phi(n))}{nd} \rvert\\\leq\lvert \frac{3k\sqrt{n}}{nd} \rvert\\ =\frac{3k}{d\sqrt n}\)

由于等式\(k\phi(n)=ed-1<ed\)，因为\(e<\phi(n)\)，根据不等式原则可以知道\(k<d<\frac{1}{3}n^{\frac{1}{4}}\)。于是，上面的不等式可以进一步得到
\(\lvert \frac{e}{n}-\frac{k}{d} \rvert\leq\frac{3k}{d\sqrt n}<\frac{1}{d\sqrt[4]n}<\frac{1}{2d^2}\)
这是一个经典的逼近关系，分数 \(\frac{k}{d}\) 且 \(k<n\) 在约束\(\log_2n\)内非常逼近 \(\frac{e}{n}\) 。实际上，所有类似这样的分数都是的连分数展开的收敛。因此我们首要做的便是计算的连分数 \(\frac{e}{n}\) 的收敛，其中一个连分数就等于 \(\frac{k}{d}\) 。由于\(ed − kϕ(N)=1\)，所以\(gcd(k,d)=1\)，因此\(\frac{k}{d}\)是一个最简分数。这就是一个可以算出密钥d的线性时间算法。

Wiener attack后来被 Boneh and Durfee两人改进，把d的界扩大到了\(d<n^{0.292}\)，这样的结果表明Wiener的界限并不固定。正确的界限可能是\(d<n^{0.5}\)。不过截至到这篇paper发表的时间，这还是一个尚未解决的问题。

开放性问题2：令\(n=pq，d<n^{0.5}\)，如果给定满足RSA的e、d，是否可以有效的恢复d？

4.低加密指数

为了减少加密或签名验证时间，通常会使用一个小的公钥指数。e的最小可能值为3，但为防止某些攻击，一般推荐使用\(e=2^{16}+1=65537\)。当使用e=65537时，签名验证需要17次乘法运算，而使用随机的e时则需要大约1000次乘法运算。与上一节的攻击不同，当使用一个小e时，应用的攻击不仅仅是得到明文而已。

4.1 Coppersmith’s Theorem

针对RSA低公钥指数最有力的攻击是基于Copper-smith的一个定理，Coppersmith定理有很多应用，这里我们只讨论其中的一些应用，具体如下。

定理(Coppersmith)：令n为一个整数，\(f\in Z[x]\)是d次的一元多项式，设\(X=N^{\frac{1}{d}-\epsilon}\)其中\(\epsilon\geq0\)，在给定\(<n,f>\)之后Marvin能够有效找到所有满足\(\lvert x_0 \rvert<X\)的整数，运行时间由在维数为\(O(w)\)且\(w=min(1/\epsilon,\log_2N)\)的格上运行的LLL算法所需时间决定。

该定理为有效地求模\(N\)的所有小于\(X=N^{1/d}\)的根提供了一种算法，当X越小，算法的运行时间越短。这个定理的强大之处在于它能够找到多项式的小根。当模数为素数时，就目前而言，找不到比使用Coppersmith定理更好的求根算法。

我们概述了Coppersmith定理证明背后的主要思想，我们采用由Howgrave-Graham提出的简化方法。给定多项式\(h(x)=\Sigma a_ix^i\in Z[x]\)，并定义\(\lVert h \rVert^2=\Sigma\lvert a_i \rvert^2\)。证明需要下面的引理。

引理：令\(h(x)\in Z[x]\)是d次多项式，同时令X为正整数。假设\(\lVert h(xX) \rVert<N/\sqrt d\)，如果存在\(\lvert x_0 \rvert<X\)满足\(h(x_0)=0\pmod N\)，那么\(h(x_0)=0\)对整数成立。
证明：从Schwarz不等式观察到：
\(\lvert h(x_0) \rvert=\lvert \Sigma a_ix_0^i \rvert\\ =\lvert \Sigma a_iX^i(\frac{x_0}{X})^i \rvert\\ \leq\Sigma\lvert a_iX^i(\frac{x_0}{X})^i \rvert\\ \leq\Sigma\lvert a_iX^i \rvert\\ \leq\sqrt d\lVert h(xX) \rVert<N\)

因为\(h(x_0)=0\pmod N\)，所以我们可以得到结论。

引理指出，如果\(h\)是一个低范数多项式，则\(h\pmod N\)的所有小根也是\(h\)在整数上的根。引理表明，要找到\(f(x)\pmod N\)的一个小根\(x_0\)，我们需要寻找另一个和\(f\pmod N\)有相同根的低范数多项式\(h\in Z[x]\)，这样就能容易找到在\(h\)整数上的根\(x_0\)。为此，我们可以寻找一个多项式\(g\in Z[x]\)，使得\(h=gf\)具有低范数，即范数小于\(N\)。这相当于寻找具有低范数多项式的整数线性组合\(f,xf,x^2f,\dots,x^rf\)。不过，大多数情况下，并不存在具有足够小的范数的非平凡线性组合。

Coppersmith找到了解决这个问题的方法：如果\(f(x_0)\equiv 0\pmod N\)成立，那么对于任意\(k\)则有\(f(x_0)^k\equiv 0\pmod {N^k}\)。更一般地，定义以下多项式：

对于给定m，有
\(g_{u,v}(x)=N^{m-v}x^uf(x)^v\)
对任意\(u\geq0,0\leq v\leq m\)，则\(x_0\)是\(g_{u,v}(x)\pmod {N^m}\)的一个根。

要使用引理4，我们必须找到多项式\(g_{u,v}(x)\)的一个整数线性组合\(h(x)\)，使得\(h(xX)\)的范数小于 \(N^m\)(回想一下\(X\)是满足\(X\leq N^{1/d}\)的\(x_0\)的上界)。由于范数（是\(N\)而不是\(N^m\)）的松弛上界，我们可以证明，对于足够大的\(m\)，总是存在一个线性组合\(h(x)\)满足所要求的界。一旦\(h(x)\)被找到，引理4就说明它有整数根\(x_0\)，于是，\(x_0\)就可以很容易地找到。

如何有效地找到\(h(x)\)还有待证明，要做到这一点，我们必须先陈述一些关于格的基本事实。设是\(u_1,\dots,u_w\in Z^w\)线性独立的向量。由\(<u_1,\dots,u_w>\)构成的(满秩)格是\(u_1,\dots,u_w\)的所有整数线性组合的集合。\(L\)的行列式定义为w×w方阵的行列式，其行向量是\(u_1,\dots,u_w\)。

在我们的例子中，我们把多项式\(g_{u,v}(xX)\)看作向量，并研究了它们所构成的格L。设\(v=0,\dots,m\)，\(u=0,\dots,d-1\)，则格的维数为\(w=d(m+1)\)。例如，当\(f\)是二次一元多项式且\(m=3\)时，得到以下的格：

\(*\)元素对应我们忽略的其值的多项式的系数，所有空元素为零。由于矩阵是三角阵，其行列式就是对角线元素乘积。我们需要在这个格中找到短向量。

Hermite的一个经典结论表明：任意维数为\(w\)的格\(L\)包含一个非零向量\(v\in L\)，它的范数满足\(\lVert v \rVert\leq \gamma_w\det(L)^{1/w}\)，其中\(\gamma_w\)是只依赖于\(w\)的常数。Hermite的界可以用来证明，对于足够大的\(m\)，我们的格包含小于的范数\(N^m\)向量。问题是我们能否有效地在中构造长度小于Hermite界的短向量，而LLL算法恰好是一种有效的算法。

Fact（LLL）：若格\(L\)有一组基\(<u_1,\dots,u_w>\)，通过LLL算法，可以得到一个向量\(v\in L\)满足：
\(\lVert v \rVert\leq2^{w/4}\det(L)^{1/w}\)
算法的运行时间是输入长度的四分之一

通过LLL算法，我们就可以完成Coppersmith定理的证明。为了保证LLL算法产生的向量满足引理4的界，我们需要满足：
\(2^{w/4}\det(L)^{1/w}<N^m/\sqrt w\)
其中\(w=d(m+1)\)是\(L\)的维度。常规计算表明，对于足够大的\(m\)，也能满足约束条件。实际上，当时\(X=N^{\frac{1}{d}-\epsilon}\)，取\(m=O(k/d)\)和\(k=\min(\frac{1}{\epsilon},\log N)\)就足够了。因此，运行时间主要由在维数为\(O(k)\)的格上运行LLL算法所决定。

一个自然而然的问题，Coppersmith定理能否应用于二元和多元多项式。如果\(f(x,y)\in Z_N[x,y]\)有根\((x_0,y_0)\)且\(\lvert x_0y_0 \rvert\)有适当的界，我们能有效地找到\((x_0,y_0)\)吗？尽管相同的技术似乎仍然适用于某些二元多项式，但它目前还是一个有待证明的开放性问题。随着越来越多的结果依赖于Coppersmith定理的二元扩展，严密的算法将会非常有用。

开放性问题3：找出可以将 Coppersmith 定理推广到二元多项式的一般条件。

4.2 Hastad广播攻击

其简化版本就是国内常说的低加密指数广播攻击，直接CRT然后开三次方就可以得到明文。一般来说，需要收集k组密文，\(k\geq e\)。

Hastad提出了一种更强的攻击方法。为了抵御上述的攻击，发送方会做一些简单的防御。Bob在加密之前”填充”消息，而不是直接广播加密后的\(M\)。例如，如果\(M\)是m位长的，Bob可以将\(M_i=i2^m+M\)发送给party \(P_i\)。由于我们获得了不同消息的加密，就无法发起上述攻击。然而，Hastad证明了这种线性填充是不安全的，事实上，他证明了在加密之前对消息应用任何固定多项式都不能阻止攻击。

假设对于每个参与者\(P_1,\dots,P_k\)，Bob有一个固定的公用多项式\(f_i\in Z_{N_i}[x]\)。为了广播消息\(M\)，Bob将\(f_i(M)\)的加密发送给party \(P_i\)。我们通过窃听知道了\(C_i\equiv f_i(M)^{e_i}\pmod N_i\)，其中\(i=1,\dots,k\)。Hastad证明，如果有足够的参与方，我们就可以从所有的密文中恢复出明文。以下定理是Hastad原始结论的一个更强的版本。

定理6（Hastad）：令\(N_1,\dots,N_k\)是两两互质的整数，并设\(N_{\min}=\min_i(N_i)\)。设\(g_i\in Z_{N_i}\)是\(k\)个\(d\)次多项式。假设存在唯一的\(M<N_{\min}\)满足
\(g_i(M)\equiv0\pmod {N_i}\ \ \ i=1,\dots,k\)
假设\(k>d\)，给定\(<N_i,g_i>_{i=1}^k\)，我们就可以很容易恢复\(M\)。

这个定理表明，当提供了足够多的方程，我们就可以有效地求解以两两互素的整数为模的单变量方程组。令\(g_i\equiv f_i^{e_i}-C_i\pmod {N_i}\)，当有至少\(d\)组数据时，我们就可以恢复\(M\)了。特别的，如果所有的e都一样并且Bob发送线性相关的消息，那么我们只要\(k(k>e)\)组数据，就可以算出明文。

Hastad的原始定理比上述定理更弱。与\(d\)次多项式不同，Hastad定理需要\(d(d+1)/2\)次多项式。Hastad定理的证明类似于上一节中提到的Coppersmith定理证明。然而，Hastad 格中没有使用\(g\)的幂，因此得到了一个较弱的界。

总结这一部分，我们注意到，要正确地防御上述广播攻击，必须使用随机填充方法，而不是使用固定填充方法。

4.3 Franklin-Reiter相关消息攻击

当Bob用相同的模数发送与Alice相关的加密消息时，Franklin和Reiter发现了一种巧妙的攻击。\(<N,e>\)是Alice的公钥，假设\(M_1,M_2\in Z_N^*\)是两个不同的消息，但存在一个已知的多项式\(f\in Z_N[x]\)，满足\(M_1=f(M_2)\)。为了将\(M_1,M_2\)发送给Alice，Bob可能会简单地对消息进行加密，并发送得到的密文\(C_1,C_2\)。通过证明可以知道，在给定\(C_1,C_2\)的情况下，我们可以很容易地计算出\(M_1,M_2\)。虽然攻击对任意小\(e\)都有效，但为了简化证明，我们给出了\(e=3\)时的引理。

引理（FR）：令\(e=3\)，\(<N,e>\)是RSA的公钥，且对于\(M_1\ne M_2\in Z_N^*\)，存在一个线性多项式\(f=ax+b\in Z_N[x]\ \ (b\ne0)\)满足\(M_1=f(M_2)\pmod N\)。于是，给定\(<N,e,C_1,C_2,f>\)，我们就可以在\((\log N)^2\)的时间内恢复\(M_1,M_2\)。
证明：为了保证这部分证明的一般性，我们使用任意的\(e\)来表示它（而不是局限在\(e=3\)）。由于\(C_1\equiv M_1^e\pmod N\)，我们可以知道\(M_2\)是多项式\(g_1(x)=f(x)^e-C_1\in Z_N[x]\)的一个根。同样的，\(M_2\)也是\(g_2(x)=x^e-C_2\in Z_N[x]\)的一个根。这两个多项式都有同一个线性因子\(x-M_2\)，因此我们就可以计算\(\gcd(g_1,g_2)\)，如果结果是线性的，那么我们就找到了\(M_2\)。

我们证明了当\(e=3\)时，GCD的结果一定是线性的。多项式因子\(x^3-C_2\)将\(p,q\)都模成一个线性因子和一个不可约二次因子(因为\(\gcd(e,\phi(N))=1\)，所以\(x^3-C_2\)在\(Z_N\)中只有一个根)。因为\(g_2\)不能整除\(g_1\)，所以GCD一定是线性的。对于\(e>3\)的情况，GCD几乎总是线性的。然而，对于一些罕见的\(M_1,M_2\)和\(f\)，有可能得到一个非线性的GCD，在这种情况下攻击会失败。

对于\(e>3\)情况，攻击所需时间是\(e\)的平方。因此，只有在使用小的公钥指数\(e\)时才能应用这种攻击。对于大\(e\)，计算GCD的工作令人望而却步。为任意\(e\)设计这样的攻击是一个有趣的问题（尽管可能很困难）。特别是，上面\(g1\)和\(g2\)的GCD能否在\(\log e\)的多项式时间内找到吗？

4.4 Coppersmith短填充攻击

Franklin-Reiter的攻击可能看起来有点人为。毕竟，为什么Bob要给Alice发送相关消息的加密呢？Coppersmith加强了攻击，并证明了一个关于填充攻击的重要的结论。

一个简单的随机填充算法可能会通过将几个随机位附加到一个末端来填充一个明文 \(M\)，但是以下攻击指出了这种简单填充的危险。假设Bob向Alice发送了正确填充的加密\(M\)。攻击者Marvin拦截密文并阻止其到达目的地。Bob注意到Alice没有回复他的消息，并决定将重新发送给Alice。他随机填充并传输生成的密文\(M\)。Marvin现在有两个密文，对应于使用两种不同随机填充对同一消息的两次加密。以下定理表明，虽然他不知道使用的填充算法，但Marvin仍能够算出明文。

定理8：令\(<N,e>\)是RSA的公钥，N长为\(n\)-bits。令\(m=[n/e^2]\)，设\(M\in Z_N^*\)是长最多为\(n-m\)-bits的消息。定义\(M_1=2^mM+r_1,M_2=2^mM+r_2\)，其中\(r_1,r_2\)是不同的整数，且\(0\leq r_1,r_2\leq 2^m\)。如果给定\(<N,e>\)和密文\(C_1,C_2\)，那么就可以有效恢复\(M\)。
证明：定义\(g_1(x,y)=x^e-C_1,g_2(x,y)=(x+y)^e-C_2\)。我们知道，当\(y=r_2-r_1\)时，两个多项式有共同的根\(M_1\)。也就是说，\(\Delta=r_2-r_1\)是结果\(h(y)=res_x(g_1,g_2)\in Z_N[y]\)的根。\(h\)的次数最多为\(e^2\)。此外，有\(\lvert \Delta \rvert<2^m<N^{1/e^2}\)，因此\(\Delta\)是\(h\pmod N\)的一个小根，所以我们就可以通过Coppersmith定理计算它。一旦\(\Delta\)求出来，Franklin-Reiter攻击就可以用来计算\(M_2\)，最终算出\(M\)。

当 e = 3 时，只要填充长度小于消息长度的 1/9，就可以发起攻击。这是一个重要的结论。但是需要注意，对于 e = 65537 这一推荐值，对于标准的模数大小来说，这种攻击就无效了。

4.5 部分密钥泄露攻击

设\(<N,d>\)为RSA私钥，假设Marvin通过某种方式知道了\(d\)的一部分，比如说\(d\)的四分之一比特。他能得到\(d\)剩下的部分吗？当相应的公钥指数很小时，答案是肯定的。最近，Boneh，Durfee和Frankel证明了只要\(e<\sqrt N\)，就有可能从它的一小部分位算出的所有部分。这个结论说明了保护整个RSA私钥的重要性。

定理9(BDF)：令\(<N,d>\)是RSA的私钥，其中\(N\)有n比特。当给定\([n/4]\)个最低有效位，Marvin可以在\(e\log_2e\)的线性时间内恢复所有d。
定理10(Coppersmith)：令\(N=pq\)是n比特的RSA模数，给定\(p\)的\(n/4\)个最低有效位或\(p\)的\(n/4\)个最高有效位，我们就可以有效分解\(N\)。

定理9很容易从定理10推出来，事实上，对于\(e,d\)有：
\(ed-k(N-p-q+1)=1\)
由于\(d<\phi(N)\)，可以知道\(0<k\leq e\)，对方程模\(2^{n/4}\)进行约化，令\(q=N/p\)，我们得到
\((ed)p-kp(N-p+1)+kN\equiv p\pmod{2^{n/4}}\)
由于我们知道\(d\)的低\(n/4\)的值，于是就有\(ed\pmod{2^{n/4}}\)的值。我们就可以得到一个关于k和p的等式，对于每一个e对应k的可能值，我们求解上面的方程，获得\(p\pmod{2^{n/4}}\)的候选值。对于这些候选值，应用定理10的算法分解N。而所有候选值的总数最多为\(e\log_2e\)，因此在遍历这些值后，N就被成功分解。

定理9被称为部分密钥泄露攻击，对于更大\(e\)的值，只要\(e<\sqrt N\)，也存在类似的攻击，不过，要实现此种攻击的技术有点复杂。有趣的是，基于离散对数的密码系统，如ELGamal公钥系统，似乎不容易受到部分密钥泄漏攻击的影响。事实上，如果给出\(g^x\pmod p\)和\(x\)位的常数分数，则没有已知的多项式时间算法来计算\(x\)的其余部分。

为了总结这一节，我们将证明当加密指数\(e\)很小时，RSA系统会泄漏相应私钥\(d\)一半的最高有效位。要了解这一点，再考虑一个方程\(ed-k(N-p-q+1)=1\)，其中\(0<k\leq e\)。给定\(k\)，Marvin可以很容易地计算出：
\(\hat{d}=[(kN+1)/e]\)
然后
\(\lvert \hat{d}-d \rvert\leq k(p+q)/e\leq3k\sqrt N/e<3\sqrt N\)
因此\(\hat{d}\)是\(d\)的很好的近似值。上面的界表明，对于大多数\(d\)，\(\hat{d}\)的一半高位和d中的相同。由于只有\(e\)个可能的\(k\)，因此Marvin可以构造一个大小为\(e\)的集合，使得该集合中的一个元素等于 d 的最高有效位的一半。\(e=3\)的情况特别有趣，在这种情况下，可以证明总是 k = 2，因此系统完全泄漏了 d 的一半最高有效位。

5. 执行攻击

我们将注意力转向完全不同的攻击类别。这些攻击不是攻击 RSA 函数的底层结构，而是侧重于 RSA 的实现。

待完善

这些攻击方式在CTF比赛中不容易实现，但是在现实生活中是完全可以存在的，由于本人时间有限，这篇文章也拖了很久，执行攻击这部分就先放一放，以后有时间再补上。

6. 总结

对RSA系统进行了20年的研究以来，产生了一些有见地的攻击，但还没有发现破坏性的攻击。到目前为止发现的攻击主要说明了在实现RSA时需要避免的陷阱，目前看来，可以信任正确的RSA密码系统实施来提供数字世界中的安全性。

我们将针对RSA的攻击分为四类：

(1)利用系统公然误用的基本攻击
(2)低私钥指数攻击，此种攻击非常严重，绝不能使用低私钥指数
(3)低公钥指数攻击
(4)对RSA系统执行时的攻击

这些持续不断的攻击说明，我们对基本数学结构的研究还是不够的。另外，Desmedt和Odlyzko、Joye和Quisquater以及DeJonge和Chaum还提出了一些额外的攻击。在整篇论文中，我们观察到通过在加密或签名之前正确填充消息可以防御许多攻击。

RSA 的前二十年催生了许多引人入胜的算法。我希望接下来的二十年同样令人兴奋。

Java 环境安装教程（自动配置环境变量）

2021-09-30T00:00:00+00:00

注意，本文包含 Java 开发与运行环境配置，请选择自己需要安装的环境。

Java 下载安装

目前主流的 Java 版本分为 4 种，如下表所示：

版本	Oracle Java	OpenJDK/OpenJRE	区别
开发环境	Oracle JDK	OpenJDK	带有编译器
运行环境	Oracle JRE	OpenJRE	无编译器
区别	闭源，可付费商用	依据 GPL 协议开源

Oracle JRE 8 下载安装

适用平台：Windows、macOS（Intel 芯片版 Mac）
演示环境：Windows 10 家庭中文版20H2
提示：Oracle JRE 只支持 Java 8 版本。如果程序要求 Java 11 或更高版本，请考虑安装 OpenJRE。

如果需要配置 Oracle Java 开发环境（Oracle JDK），请参考：https://www.oracle.com/java/technologies/downloads/
配置步骤：
1. 请务必使用 chrome浏览器 进入 Oracle Java 下载页面 https://www.java.com/zh-CN/ 点击“免费 Java 下载”，再点击跳转后页面的“同意并开始免费下载”按钮，等待安装包下载完成。
2. 右键以管理员身份运行安装包，在安装向导界面中点击“安装”并等待程序自动安装。
3. 安装完成，如图所示。

OpenJDK/OpenJRE 下载安装

OpenJDK 是 Oracle 根据 GPL 协议开源的 JDK 源码，其中去除了一部分 Oracle 专有代码，因此可能与部分软件存在兼容问题。
适用平台：Windows、macOS
演示环境：Windows 11
提示：Oracle 在网站上提供了 OpenJDK 的源码包，但是不提供安装包，所以需要~~自己动手编译~~下载安装第三方预编译版本。 Eclipse Adoptium（原 AdoptOpenJDK）是一个比较流行的 OpenJDK 预编译版本，且支持自动配置环境变量。本教程以该版本 OpenJDK 为例。
配置步骤：
1. 使用浏览器进入 Eclipse Adoptium OpenJDK 下载页面（https://adoptium.net/archive.html）选择需要下载的版本（如不确定需要下载哪个版本，推荐下载 OpenJDK 11）。
2. 根据自己的系统配置选择对应版本的安装包，若要安装运行环境，请选择 JRE，若要下载开发环境，请选择 JDK。
  
  若官网下载速度慢，可以使用清华大学提供的镜像
3. 运行安装包，在安装向导界面中点击“安装”并等待程序自动安装。
4. 使用默认设置完成安装，Windows 系统请确保 Add to PATH 和 Set JAVA_HOME variable 已勾选。
5. 请打开系统终端，执行 java --version 查看是否安装成功。
OpenJDK 官网：https://openjdk.java.net/
其他 OpenJDK 预编译包：
- Microsoft 编译版本：https://www.microsoft.com/openjdk
- RedHat 编译版本：https://developers.redhat.com/products/openjdk/download
- IBM 编译版本：https://developer.ibm.com/languages/java/semeru-runtimes/downloads

C语言急救车

2020-12-26T00:00:00+00:00

PPT下载地址：https://wwr.lanzoui.com//idSSqjq8huf

用一节公开课的时间带领大家将考试的常见知识点和考察方式复习一遍，做到听进一道题就能多得一分，快速高效复习。

本次公开课无需报名需自带纸笔

不预留座位前排座位先到先得

活动信息：

主讲人：张帅青
时间： 2020/12/26 18:30 UTC +08:00
活动形式：线下授课

C# 与 .NET 环境配置（2021 年修订）

2020-10-25T00:00:00+00:00

本文将介绍基于 Windows 平台和 .NET 5.0 的 C# 开发环境配置与简易使用方法

直接安装 .NET CLI（控制台程序）

访问 .NET 官网下载页，选择需要的版本（如 .NET 5.0），选择“Download .NET SDK x64”

运行安装向导，完成后在终端中输入 dotnet，将看到以下信息：

 > dotnet
    
 Usage: dotnet [options]
 Usage: dotnet [path-to-application]
    
 Options:
   -h|--help         Display help.
   --info            Display .NET information.
   --list-sdks       Display the installed SDKs.
   --list-runtimes   Display the installed runtimes.
    
 path-to-application:
   The path to an application .dll file to execute.

在想创建项目的文件夹运行终端，输入
```
 dotnet new console -o HelloWorldApp
```
等待命令执行完成，这将创建一个 HelloWorldApp 文件夹

用代码编辑器（建议使用 Visual Studio Code）打开 HelloWorldApp 文件夹，其中的 Program.cs 文件应如下所示：

 using System;

 namespace HelloWorldApp
 {
     class Program
     {
         static void Main(string[] args)
         {
             Console.WriteLine("Hello World!");
         }
     }
 }

在 HelloWorldApp 文件夹中，执行
```
 dotnet run
```
程序将运行并输出 Hello World!

通过 Visual Studio 安装（以 Visual Studio 2019 为例）

下载 Visual Studio 2019

确保电脑符合 Visual Studio 2019 安装系统要求

打开 Visual Studio 官网选择“下载 Visual Studio Community 2019”
安装 Visual Studio 2019

运行 Visual Studio 2019 安装程序，待其加载数据完成，在“选择工作负荷”界面勾选“.NET 桌面开发”，选择安装位置并点击安装
启动 Visual Studio 2019 并登录 Microsoft 账号

如果没有账号需在线免费注册。可点击 Visual Studio 官网右上角的头像图标注册。登录过程如遇白屏/加载失败可采用特殊手段联网
创建新项目
- 在启动窗口中选择“创建新项目”，选择“C# 控制台应用程序”，点击“下一步”
- 输入项目名称如“HelloWorldApp”，选择创建位置，点击“下一步”
- 目标框架选择“.NET 5.0”，点击“创建”

将自动打开 Program.cs 文件，代码如下：

 using System;
    
 namespace HelloWorldApp
 {
     class Program
     {
         static void Main(string[] args)
         {
             Console.WriteLine("Hello World!");
         }
     }
 }

按 F5 启动程序，程序将输出 Hello World! 与进程退出提示

学习资料推荐

书籍推荐：
- 《Visual C# 从入门到精通》
- 《C# 入门经典》
网站推荐
- 微软官方 C# 文档：https://docs.microsoft.com/zh-cn/dotnet/csharp/
- .NET API 浏览器：https://docs.microsoft.com/dotnet/api/
- 菜鸟教程：https://www.runoob.com/csharp/csharp-tutorial.html

Lisp 入门指北

2020-10-16T00:00:00+00:00

原子，列表和求值

在 Lisp 中，所有的以空格或是括号分隔的，都是一种叫做原子(atom)的元素(element)，当然，原子也是可被分类的，确切的说，原子可被分为符号和值，这两种东西在 Lisp 的解释器里是不同的。符号是一个词法上的概念，可以类比设想一门自然语言中的名词。而值则是确切存在的自然客属物。一个符号可以指代值，值也就被符号指代，这些我们将会在稍后详细讲解。

我们现在尝试着将原子进行组合，可以得到什么呢？设想我们已经学到过的组合，比如数组，哈希……同样的的，在 Lisp 中，原子的组合叫做列表，一个列表被一对闭合的大括号所包围。我们来写出一些列表：

(1 2 3)
(a 1 Kyoto_Animation)
((lisp is so) amazing)
(defun fac (x) (if (eql x 0) 1 (* x (fac (- x 1)))))
((())())

如你所见，空也是一个元素，空列表也是列表，列表嵌套列表也是合法的。和我们之前所讲过的基本 λ 计算一样，这给了我们强有力的求值工具。

那么列表有什么具体的作用呢？简单地说（在这里，我们忽略了少部分的特殊情况），列表是用于求值(evaluation)的。更严格的说，Lisp中的列表是一个 Program。我们来考虑计算语义上的辖域。辖域主要分为三个部分（一个计算系统）：定义式域，命令式域以及表达式域，我们可以说，大部分列表是属于表达式域的，最初的 Lisp 是一个纯表达式域的语言，并且是严格依照代数语义学的理论建构的。当然，现在的 Lisp 经过许多的演化，成为了一个语族。Lisp 拥有众多的方言，Scheme、Racket等等，我们学习的是 Common Lisp，是之后的 Lisp 社区综合了早期的各种 Lisp 方言而尝试制定的一个统一标准。

还有一个值得注意的问题是，我们发现，对于列表的嵌套深度，Lisp 是没有限度的，这带给了阅读程序的人很大的混淆，比如以下的表达式:

(+ (* 3 (+ (* 2 4) (+ 3 5))) (+ (- 10 7) 6))

实际上，在一般的Lisp编写时，遵循一种叫做美观打印的原则，即把多个运算对象垂直对齐的写法，因此，符合规范的写法应该是这样的

(+ (* 3
      (+ (* 2 4)
         (+ 3 5)))
   (+ (- 10 7)
      6))

我们继续来讲回求值的概念，现在给出一个列表，我们按照什么样的规则来得出它的值呢，这和我们接下来要介绍的代换模型有关。

如果按照一般的想法，我们计算 1 + 2 的时候，大脑里思考的是：辨识出这是一个加法运算，然后创造值1，创造值2，运算1与2的加法运算。还有一种思考方式是：创造一个值1，对1应用加法（动词），（宾语）是2，得出结果。

实际上在一般的语义学分析中采取的都是第一种做法，即关系指代型的语义关系，谓词是第一公民。比如 Bob loves Alice 应写成 Love(Bob,Alice)。

代换模型采用的是第一种做法，即我们将1和2应用于加法过程。我们定义：一个列表的第一个原子是运算符，其余所有的都是运算对象。代换模型所做的事情是：对运算符求值，得出一个过程，然后分别对运算对象求值，将其应用到运算符过程的形式参数位（回想一下β-规约）。同时，我们也知道， Lisp 出于效率的考虑，采用了急切求值的做法。

代换模型要求我们不得不采用一种叫做前缀表示法的记法来表示运算，如 (+ 1 2)，这和我们经常使用的中缀表示法是不同的。实际上，我们可以把前缀表示法抽象成一颗表达式树，来看看它在计算机中有什么优势。

特殊的列表，词法作用域

但是事情并不总是尽如人意的，我们会发现，拥有一些列表，它们即无法被代换模型合理的解释，也无法被认为是固化的求值顺序，这个时候，我们就会说代换模型失效了。

我们可以稍稍前进一些，发掘到 Lisp 中少数命令式的风格语句。第一个便是setq和let了。考虑以下的语法规则：

(setq a 47)
(setq a 50)
(defun dec (x)
    (let ((num 40))
         (setq num (- num
                      x))))
(dec 10)
(dec 10)

以上的代码会输出什么值呢？如果我们使用单纯的代换模型来解释以上的代码，我们可以说，setq是一个求值过程，他接受了 a 和47，返回了47，接受了 a 和50，返回了50，我们就会有理由的相信，setq 是一个接受两个参数并返回第二个参数的过程，但是我们在前两条语句后，如果调用 a 会发现什么呢？

我们会发现，a 的值被改变了。我们之前说过，函数式编程的核心是使用不变量来计算，一旦引入了setq和let这样特殊的列表，变量也就被引入了Lisp语言之中，这个时候，我们就要用一个更加通用的环境模型来解释列表的求值过程了。

当然现在也无需立刻介绍这个模型，只需要确知，拥有一个叫做setq的过程，它能够改变变量的值，至于let它仅仅是创建了更深的一层变量作用域而已。

实际说来，let只是lambda的一个语法糖而已，至于匿名函数，我们也会在稍后讲到。

另外两个特殊的列表是条件选择和反引号函数，分别叫做cond和quote。反引号的作用，实际上就是将意指转为符号。我们本来的 Lisp 语言，是将语法对象确定为一个指代，是有语法学之后的语义学含义的。而quote则可以将语法学对象仅仅限制在符号的范畴里，举例说，一旦(setq a (quote b))被求值，那么b的含义被仅仅被限制在了符号层面上，以后我们求值 a，就会仅仅是 b 这个符号。

至于条件选择的特殊之处，同样也在与它不会将列表里的每一个元素都求值，这样的选择性求值也和原本我们所说的代换模型的求值规则相悖。大家有兴趣的话，可以试着去写一个自己的条件选择函数，来看看能不能运行。

接下来让我们来讲讲作用域的事情。所谓的作用域，其实就是一个变量约束所能生效的范围。一般而言，第一个找到的定义了变量的过程是作用域的边界，我们来看下面的例子：

(defun fun (x)
    (let ((var 5))
         (let ((var 4))
              (+ x var))))

这一个过程会输出什么呢？实际上，我们可以说外层的var和内层的有着截然不同的词法含义。尽管他们的符号相同，但他们是被互相隔离的。或者说，内层的变量在参与运算的时候遮蔽了外层变量。这便是所谓的词法作用域，设想一个盒子里套另一个盒子的模型，你就很理解为什么这两个var会能够共存在一个过程中（实际上并不是一个）。我们作为住在最里面盒子的小人，一旦盒子里有了我们所需要的东西，自然也就不需要打破下一层障壁了。

符号，取值与匿名函数

Lisp 是一门符号语言，或者说，它是为了解决符号运算而被设计出来的。一个很著名的符号运算例子便是多项式求导，在之后，我们会试着制作出一个完备的多项式求导系统。

一个符号，是一个语义上的概念。所谓的符号都只是解释器所能够接受的名称。而一个值，则是确实地存储在内存中的地址上的二进制串。我们把一个符号指向一个值的过程，实际上就相当于创建了一个指向内存区域的指针。以后解释器碰到求值这个符号的时候，就会去调取指向的内存。

为了避免语义的二义性，一个符号往往在一个作用域内只能有一个值，同时，Lisp 还有与众不同的两个特点：其一是并不对符号的大小写加以区分，其二则是一个符号虽然不能同时具有两个值，但确实是能同时拥有一个值和一个过程名称的，这一点将会给我们更深的思考：到底 Lisp 中的过程是以怎样的形式存储和被使用的？

值得注意的是，Lisp 并不会持久化的存储值的内存，除非是一个全局的赋值，否则 Lisp 会在每次需要的时候重新分配内存来存储变量和值。这一点也往往被人诟病为非常低效，但实际上，一旦我们深入到解释器的细节层面，我们就可以做许多优化来避免运行过慢的局面。

有了之前的基础后，这边的介绍就简单的多了。事实上我们首先要明确的一点是，所有的过程都是没有名字的，或者说匿名的，我们使用以下的语法规则来创建它们：

(lambda (argument_list)
        (function_body))
(lambda (x y)
        (+ x y))
((lambda (a b c)
         (* a (+ b c))) 5 6 7)

一个匿名函数只有在能被求值，或者说，拥有实际参数的时候才合法，所以说，如果我们单单地对一个 lambda 表达式求值是错误的，因为这实际上只是一个指代，而没有被实例化。

当然，如之前所述，我们也可以给过程指定一个符号的名称，使用defun就可以完成这样的过程。

宏与多值函数

什么是宏？这需要我们进一步的去推广列表求值的概念，既然 Lisp 中一切都是符号，那一个列表当然也可以表示为一个符号，一个列表也有它本身的值。所以从这个层面上，我们可以先简单地将宏（Marco）和函数以这样的定义区分开来：

宏是一种语法结构，它接受参数，返回一个将参数绑定到形参的表。

我们可以来参看几个例子

(defmarco reverse (a b)
    `(cons ,b ,a))
(defmarco filter-remainder (list x)
    `(filter ,(lambda (p) (= (remainder p x) 0)) ,list))
(defmarco setq-literal (symbol literal)
    `(setq ,symbol ',literal))

这里首先出现了一种新的语法结构，即反引号（backquote）。反引号和引号一样，会抑制之后元素的求值过程，但是与引号不同的是，一旦遇到一个逗号，我们就可以要求解释器去求值逗号之后的一个元素。

简要说明上面三个例子的意思，reverse **宏接受了两个参数，并把它们按照第二个，第一个的方式组合成了序对，而filter-remainder接受了一个列表和一个除数，用于筛选出列表中能够整除除数的部分。而setq-literal则将一个符号的值绑定为另一个符号，我们可以看到由于引号的存在，第二个参数不会被setq求值。

Lisp 的宏是一个极为强大的语法结构，它给了我们扩展语言表达的能力，或者说，正是有了宏的概念，Lisp 所谓的求值与应用（Evaluation ＆ Application）循环才真正圆满。有了宏，我们可以轻松地用它来制作 Parser，模式匹配和其它语言的解释器，甚至，可以编写 Lisp 自己的解释器（这一点确实难以置信，但我会在之后说明）。

然后再介绍一个 Lisp 内置的函数marcoexpand，它接受一个宏（需要被引号抑制求值），可以将要用于求值的宏返回的列表打印出来，在你不知道一个宏究竟有什么效果的时候，这个功能非常有用。

多值是什么？多值即是一个非确定性的计算过程，形式化一点讲，多值就是一个一到多的映射。正常的说，Lisp 中的映射都是一个单射，由于 Curry 化的存在，Lisp 的函数都可以被转化为一个链式的高阶过程链，但是，这里存在着几个特殊的表结构，它们会返回多值。

其中有一个较为常用的是values过程，它返回所有参数求值后的结果，例如：

(values (+ 1 3) (/ 6 2))
-> 3
-> 4

你也可以通过宏来书写自己的多值函数。

招新试题资料

2020-10-10T00:00:00+00:00

图1

图2

图3

C/C++环境配置指南

2020-09-25T00:00:00+00:00

本文将介绍常见的C/C++环境配置方法。

Devcpp

适用平台：winxp/win7/win10
所需文件：Dev C++ 5.11(TDM-GCC 4.9.2)
配置步骤
1. 在安装包上单击右键选择以管理员身份运行,语言默认选择English,然后点击OK.
2. 点击 I Agree ,之后点击Next.
3. 选择安装路径(建议选择纯英文路径),之后点击Install.
4. 安装完成后点击Finish并打开Dev-C++.
5. 打开后选择语言为简体中文/Chinese,并点击Next.
6. 选择性配置皮肤等,完成配置.
7. 选择 文件->新建->源代码 或使用快捷键 Ctrl+N 新建一个文件,输入以下C语言代码:
```
#include <stdio.h>
int main()
{
	printf("Hello,SAST");
	return 0;
} 
```
8. 选择 文件->保存 或使用快捷键 Ctrl+S 进行保存,保存类型选择 C source files(*.c),按需选择名字与保存位置,点击 保存 即可.
9. 保存成功后选择 运行->编译运行 或使用快捷键 F11 将C语言文件编译并运行,输出Hello,SAST即可.
常见问题Q&A
1. 为什么我按笔记本键盘上的F11没有反应? 部分笔记本需要先按下键盘上的 Fn 键,然后再按 F11 才有效果;也有部分笔记本需要按住 Fn 键不放按 F11 才有效果.如果均无效,则可能是快捷键冲突,请使用 运行->编译运行 的方法编译运行程序.

VSCode(Visual Studio Code)

写在前面 Visual Studio Code（以下简称VSCode）是一个运行于Mac OS X、Windows和Linux之上的，针对于编写现代Web和云应用的跨平台源代码编辑器。

该编辑器集成了所有一款现代编辑器所应该具备的特性，包括语法高亮（syntax high lighting），可定制的热键绑定（customizable keyboard bindings），括号匹配（bracket matching）以及代码片段收集（snippets）。同时这款编辑器也拥有对Git的开箱即用的支持。
适用平台： win7/win10/Mac OS
所需文件：VSCode
安装步骤 - win10
1. 演示环境：Windows 10 专业版 64位（版本：2004） 官网下载镜像虚拟机
  同类优秀教程阅读：Visual Studio Code 配置 C/C++ 环境 | 0xfaner’s Blog
2. 下载 VSCode 安装包 VSCodeSetup-x64-1.49.2.exe ，可在校科协招新群文件内下载，也可去官网下载，请点击 System Installer 后的 64 bit （根据系统位数选择）下载安装包。
3. 以管理员身份运行安装包，选择安装位置时最好选择不含中文的路径，建议按照图片所示选择附加任务：
4. 点击左侧 Extensions 按钮或使用快捷键 Ctrl+Shift+X 打开扩展商店。
5. 搜索 Chinese 安装语言包 Chinese (Simplified) Language Pack for Visual Studio Code 以汉化 VSCode ；搜索 C++ 安装插件 C/C++ 和 C/C++ Compile Run ，以获得 C/C++ 编辑器环境和按下 F6 快速运行体验。（安装完语言包后右下角可能会提示重启，点击重启即可）
6. 下载 TDM-GCC ，可在校科协招新群群文件内下载，也可去官网下载，点击 tdm64-gcc-9.2.0.exe 下载。
7. 以管理员身份运行安装包，去掉 Check for updated files on the TDM-GCC server 前面的勾，点击 Create 按钮进入安装，选择安装位置时安装路径不能有英文，其他请一路 Next 即可。
8. 切回 VSCode 新建一个后缀名为 c 的文件，如 Paste.c 。（新建文件直接保存，文件类型**选择 C **）
并输入以下代码：
```
   #include <stdio.h>
   int main()
   {
       printf("Hello,SAST!");
       return 0;
   }
```
然后按下 F6 或 Ctrl+6 编译运行，如果能够得到下图结果，则表示环境配置成功！祝贺祝贺！(缩小窗口截图)
```
    #include <stdio.h>
    int main()
    {
        int a, b;
        scanf("%d%d", &a, &b);
        printf("%d", a + b);
        return 0;
    }
```
然后按下 F6 或 Ctrl+6 编译运行，并输入 1 2 ，如果能够得到下图结果，则表示环境配置成功！祝贺祝贺！
1. 进一步配置… 感觉字体太小了?还没法用 Ctrl+鼠标滚轮 放大缩小?代码空格太多了不想输入? 进行进一步配置非常重要！点击左下角的设置图标，选择 设置 或使用快捷键 Ctrl+, 打开设置界面。（也可以按Ctrl+Shift+P，键入Open Settings (JSON)，选择 首选项：打开设置(json) ，直接打开 settings.json文件）
  然后点右上角第一个按钮打开 settings.json 配置文件。
2. 如果想要使用鼠标滚轮缩放，在大括号内插入以下脚本：
```
 "editor.mouseWheelZoom": true,
```
  如果使用代码格式化，请插入以下脚本：
```
"editor.formatOnPaste": true,
"C_Cpp.clang_format_fallbackStyle": "{ BasedOnStyle: Microsoft, UseTab: Never, IndentWidth: 4, TabWidth: 4, AllowShortBlocksOnASingleLine: true, AllowShortIfStatementsOnASingleLine: true, AllowShortLoopsOnASingleLine: true, AllowShortCaseLabelsOnASingleLine: true, AllowShortFunctionsOnASingleLine: All, AllowShortLambdasOnASingleLine: All,  }",
"[cpp]": {
	"editor.defaultFormatter": "ms-vscode.cpptools"
},
"editor.formatOnSave": true,
"C_Cpp.clang_format_style": "{ BasedOnStyle: Microsoft, UseTab: Never, IndentWidth: 4, TabWidth: 4, AllowShortBlocksOnASingleLine: true, AllowShortIfStatementsOnASingleLine: true, AllowShortLoopsOnASingleLine: true, AllowShortCaseLabelsOnASingleLine: true, AllowShortFunctionsOnASingleLine: All, AllowShortLambdasOnASingleLine: All,  }",
```
  如果有对 C++ 版本的要求，请在大括号插入（以 C++11 为例）：
```
"C_Cpp.default.cppStandard": "c++11"
```
  改变配置后推荐重启VSCode，以便设置生效。
常见问题Q&A
1. 可以配置按 F5 调试运行?
  这个可以参考柏老板的配置教程：Visual Studio Code 配置 C/C++ 环境教程 | 0xfaner’s Blog
2. 为什么我按下 F6 无法成功运行？
  请检查TDM安装位置是否含有中文，中文符号也不行！另外，如果是笔记本的话，看一下是否 F6 默认是功能键，尝试使用 Fn+F6 ( 按住 Fn 键不放按 F6 ) 编译运行。另外也可以尝试使用 Ctrl+6 组合键来编译运行。

Python环境配置指南

2020-09-25T00:00:00+00:00

本文将介绍常见的Python 环境配置方法。

Python3本体安装

适用平台：win7/win10/Mac OS X
演示环境：Windows 10 专业版 64位（版本：2004）
配置步骤：
1. 在Python3.8.5官方下载页拉到最下方点击 Windows x86-64 executable installer 或在校科协新生群群文件下载安装包，右击以管理员身份运行此安装包，先在 Add Python 3.8 to PATH 前面的框打勾，然后点击 Customize installation 。
2. 之后再点击 Next 进入 Advanced Options 设置页，在 Install for all users 前打勾，可以选择修改路径名（建议不要修改，如果必须修改请使用英文路径），然后点击 Install
3. 安装完成后，点击 Disable path length limit ，以保证python的配置能够成功写入path，然后关闭即可。
4. 首先打开开始菜单Python文件夹下的 Python 3.8(64-bit)
  
  输入以下python脚本并回车：
```
print("Hello,SAST!")
```
  如果能够得到下图结果说明运行正常。
5. 在命令行写python脚本不便于调试，为了能够保存成.py脚本文件，打开开始菜单Python文件夹下的 IDLE ，点击菜单栏 File->New File 或使用快捷键 Ctrl+N 新建一个脚本文件，并写入以下脚本：
```
x = 'SAST'
if x == "SAST":
    print("Hello,SAST!")
else:
    print("Hello,World!")
```
  保存后按 F5 或点击菜单栏 Run->Run Module 即可运行脚本。
6. Python的强大得益于第三方库的支持，下面介绍如何安装第三方库：
  按下快捷键 Win+R 然后输入 cmd （或 powershell ）打开命令提示符，然后输入pip install xxx 即可安装名为 xxx 的第三方库。例如校科协爬虫公开课将会用到 requests 库，则输入：
```
pip install requests
```
  得到如下结果即为安装成功：
  
  （可能有些库的安装需要以管理员身份运行命令行才能成功安装，方法为在左下角开始菜单键上右击选择 Windows Powershell（管理员） ）
常见问题Q&A
1. 安装过程中提示没有文件夹读写权限? 请以管理员身份运行安装包
2. 校科协公开课需要安装哪些第三方库？需要安装 re 和 requests 库

VSCode配置

适用平台：win7/win10/Mac OS X
演示环境：Windows 10 家庭版 64位（版本：2004）
配置步骤
1. 需要前置安装Python3本体
2. 按照配置C语言环境VSCode的1~3步安装VSCode
3. 在第1步最后打开的插件管理器中：搜索 Chinese 安装语言包 Chinese (Simplified) Language Pack for Visual Studio Code 以汉化 VSCode ；搜索 Python 安装第一个插件以使VSCode支持python。
4. 安装好后打开之前的脚本或新建文件写入以下脚本：
```
x = 'SAST'
if x == "SAST":
    print("Hello,SAST!")
else:
    print("Hello,World!")
```
5. 按下 F5 选择第一项 Python File ，如果结果和下图一致则配置成功。
常见问题Q&A
1. …

PyCharm

适用平台：win7/win10/Mac OS X
演示环境：Windows 10 专业版 64位（版本：2004）
配置步骤：
1. 需要前置安装Python3本体
2. 在官方下载页面点击 Community 版本下面的 Download 按钮或在校科协新生群中下载，以管理员身份运行安装包，两次 Next 后如图打勾，之后继续安装即可。
3. 打开软件后按照自身需要选择即可，然后选择 New Project 。
4. 重新输入项目位置和项目名称，重新选择 Base interpreter 为上面Python的安装位置。
5. 环境配置需要下载库，可能需要等待一段时间。
6. 按 shift+F10 或点击菜单 Run->Run 'main' 运行，如果运行结果如下图所示，则环境配置成功。

NJUPT SAST

C语言急救车

SFINAE 的发展史

什么是 SFINAE?

C++98 的做法

traits

enable_if

时间来到 C++11

C++14 泛型 lambda

C++17 void_t

C++20 concepts

后记

参考

二十年以来对RSA密码系统攻击综述

1.分解大整数(Factoring Large Integers)

2.两种简单攻击

2.1共模攻击

2.2Blinding——盲签名（攻击）

3.低解密指数攻击

4.低加密指数

4.1 Coppersmith’s Theorem

4.2 Hastad广播攻击

4.3 Franklin-Reiter相关消息攻击

4.4 Coppersmith短填充攻击

4.5 部分密钥泄露攻击

5. 执行攻击

6. 总结

Java 环境安装教程（自动配置环境变量）

Java 下载安装

Oracle JRE 8 下载安装

OpenJDK/OpenJRE 下载安装

C语言急救车

C# 与 .NET 环境配置（2021 年修订）

直接安装 .NET CLI（控制台程序）

通过 Visual Studio 安装（以 Visual Studio 2019 为例）

学习资料推荐

Lisp 入门指北

原子，列表和求值

特殊的列表，词法作用域

符号，取值与匿名函数

宏与多值函数

招新试题资料

图1

图2

图3

C/C++环境配置指南

Devcpp

VSCode(Visual Studio Code)

Python环境配置指南

Python3本体安装

VSCode配置

PyCharm

C++14 泛型 `lambda`