やりたくないこともやる

controller是什么

简单来说，controller就是监听kubernetes的配置/状态变化，自动对资源进行调节。比如kubernetes内置的controller有Deployment、StatefulSet、DaemonSet。

实现controller

这里我们实现一个简单的loadbalancer controller，使用kubernetes的client-go。

先创建一个新的Serivce,并且指定Type为LoadBalancer。

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

apiVersion: v1
kind: Service
metadata:
  name: my-service
spec:
  selector:
    app.kubernetes.io/name: MyApp
  ports:
    - protocol: TCP
      port: 80
      targetPort: 80
  clusterIP: 10.0.171.239
  type: LoadBalancer

这时Service的状态还是pending,因为还没有controller为其分配IP地址。

创建新的client

目前我只会记录最近看了个，有些看的比较早的就不记录了，记忆也比较模糊。

自定义神剧（个人主观决定）

• CLANNAD
• Kanon
• リトルバスターズ!
• Air
• Angel Beats! -1st beat-
• かぎなど
• true tears
• 花咲くいろは
• TARI TARI

1
2
3
4
5
6

+----------------+       +-----------------+
|  kubelet       |       |   CRI shim      |
| +-----------+  |       |  +-----------+  |      +-----------+
| |grpc client|<-|-------|->|grpc server|  |<---->| container |
| +-----------+  |       |  +-----------+  |      |  runtime  |
+----------------+       +-----------------+      +-----------+

CRI shim

• cri-o
• cri-containerd
• rkt
• frakti
• docker (cri-dockerd)

container runtime

• gvisor
• kata containers

NAT Mapping

描述NAT在映射网络内主机地址的行为

1

computer(192.168.100.2:30086) -> NAT -> 1.1.1.1:2345

Endpoint-Independent Mapping

网络内主机在通过同一监听udp地址向不同地址和不同端口发包时, NAT使用同一映射地址向外发包

1
2
3
4
5
6
7
8
9
10
11

如 网络内一主机监听了一udp地址 192.168.100.2:30086

此时主机向 1.0.0.1:53 发送udp包,
             NAT使用 1.1.1.1:2345 向 1.0.0.1:53 发包
主机又向   1.0.0.1:63 发送udp包,
             NAT也使用 1.1.1.1:2345 向 1.0.0.1:63 发包
主机又向   8.8.8.8:53 发送udp包,
             NAT也使用 1.1.1.1:2345 向 8.8.8.8:53 发包

这种无论目标地址和端口是什么都使用同一地址进行发包的NAT行为就是 Endpoint-Independent Mapping,
跟没有NAT一样

Address-Dependent Mapping

网络内主机在通过同一监听udp地址向同一地址和不同端口发包时, NAT使用同一映射地址向外发包

1
2
3
4
5
6
7
8
9
10

如 网络内一主机监听了一udp地址 192.168.100.2:30086

此时主机向 1.0.0.1:53 发送udp包,
             NAT使用 1.1.1.1:2345 向 1.0.0.1:53 发包
主机又向   1.0.0.1:63 发送udp包,
             NAT也将使用 1.1.1.1:2345 向 1.0.0.1:63 发包
主机又向   8.8.8.8:53 发送udp包,
             此时NAT将使用一新映射地址 1.1.1.1:5678 向 8.8.8.8:53 发包

这种依赖目标地址但不依赖端口的NAT映射行为就是 Address-Dependent Mapping

the sensors not show fan and voltage
it’s a kernel bug now Hardware monitoring sensor nct6798d doesn’t work unless acpi_enforce_resources=lax is enabled
need wait add the motherboard name to linux kernel code list linux/drivers/hwmon/nct6775-platform.c

temporary measure

add

1

acpi_enforce_resources=lax

to linux boot parameter

load nct6775 kernel module

1

modprobe -v nct6775

run sensors-detect --auto.

finally, you will see nct6798-isa-* in sensors.

拉格朗日插值法

对某个多项式函数，已知有给定的k + 1个取值点：(x0,y0)...(xk,yk)
假设任意两个不同的xj都互不相同，那么应用拉格朗日插值公式所得到的拉格朗日插值多项式为：

1
2
3

l0 = (((x-x1)(x-x2)...(x-xk))/((x0-x1)(x0-x2)...(x0-xk)))*y0
    ...
lk = ...

f(x) = l0+l1...+lk即可求出多项式

example

1
2
3
4
5
6
7

已知3个点(4,10)(5,5.25)(6,1)

l0 = (((x-5)(x-6))/((4-5)(4-6))) * 10
l1 = (((x-4)(x-6))/((5-4)(5-6))) * 5.25
l2 = (((x-4)(x-5))/((6-4)(6-5))) * 1

f(x) = l0+l1+l2 = 1/4(x^2-28x+136)

Shamir 秘密共享

生成

前置知识 欧拉, 欧拉定理, 模反元素(模逆元) 可参见: RSA加密

阶

由欧拉定理可知，若n,a为正整数，且n,a互素（即gcd(a,n)=1），则 a^phi(n) = 1 (mod n)。
因此满足同余式 a^m = 1 (mod n)的最小正整数m存在，这个m称作a模n的阶，记作delta(n,a)。

原根

若n,a为正整数，且n,a互质，如果 gcd(a,n)=1 且 delta(n,a) = phi(n), 则称a为模n的原根.
简单来说，使该式成立的d可能有很多个值，又由欧拉定理可知delta(n,a) = phi(n)一定是满足的，如果此时所有delta(n,a)的可能取值中phi(n)是最小的，那么就称a为模n的原根。

eg:

1
2
3
4
5
6
7

a=3, n=7
可知 3,7互质, 所以phi(n) = 7 - 1 = 6
可得 3^6 = 1 (mod 7)

计算3^1, 3^2, 3^3, 3^4, 3^5 (mod 7) 都不等于1, 所以 6为满足 a^x = 1 (mod n)的最小正整数

delta(7,3) = 6 = phi(7), 可得 3为模7的原根

性质

流密码

密码学中，流密码（英語：Stream cipher），又譯為串流加密、資料流加密，是一种对称加密算法，加密和解密双方使用相同伪随机加密数据流（pseudo-random stream）作为密钥，明文数据每次与密钥数据流顺次对应加密，得到密文数据流。实践中数据通常是一个位（bit）并用异或（xor）操作加密。

https://zh.wikipedia.org/wiki/流密码

• chacha20/salsa20
• rc4

块密码/分组密码

块密码只能对确定长度的数据块进行处理, 如aes每个块的大小必须为16, 如果不满16就需要进行padding

加密模式

ECB

最简单的加密模式即为电子密码本（Electronic codebook，ECB）模式。需要加密的消息按照块密码的块大小被分为数个块，并对每个块进行独立加密。

CBC

在CBC模式中，每个明文块先与前一个密文块进行异或后，再进行加密。在这种方法中，每个密文块都依赖于它前面的所有明文块。同时，为了保证每条消息的唯一性，在第一个块中需要使用初始化向量。

PCBC

填充密码块链接（PCBC，Propagating cipher-block chaining）或称为明文密码块链接（Plaintext cipher-block chaining），是一种可以使密文中的微小更改在解密时导致明文大部分错误的模式，并在加密的时候也具有同样的特性。

Golang Tun (gVisor)

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

import "gvisor.dev/gvisor/pkg/tcpip/stack" // gvisor

s := stack.New(stack.Options{
  NetworkProtocols:   []stack.NetworkProtocolFactory{ipv4.NewProtocol, ipv6.NewProtocol},
  TransportProtocols: []stack.TransportProtocolFactory{tcp.NewProtocol, udp.NewProtocol, icmp.NewProtocol4, icmp.NewProtocol6},
 })

ep := fdbased.New(&fdbased.Options{
   FDs:            []int{fd}, // fd: linux文件标识符, 如android中最后会获取到一个文件标识符
   MTU:            uint32(1500),
  })
 
 nicID := tcpip.NICID(s.UniqueID())
 if er := s.CreateNIC(nicID, ep); er != nil {
  ep.Attach(nil)
  return
 }

func isdns(opt *TunOpt, id stack.TransportEndpointID) bool {
 if id.LocalPort == 53 && (opt.DNSHijacking || id.LocalAddress.String() == opt.Gateway) {
  return true
 }
 return false
}

// TCP
 s.SetTransportProtocolHandler(tcp.ProtocolNumber, tcp.NewForwarder(s, defaultWndSize, maxConnAttempts,  func(r *tcp.ForwarderRequest) {
  wq := new(waiter.Queue)
  id := r.ID()

  ep, err := r.CreateEndpoint(wq)
  if err != nil {
   r.Complete(true)
   return
  }
  r.Complete(false)


  go func(local net.Conn, id stack.TransportEndpointID) {
   defer local.Close()

   if isdns(opt, id) { // 劫持一下dns
    /*
    * Handle DNS
    */
    return
   }

   target := net.JoinHostPort(id.LocalAddress.String(), id.LocalPort) // 远程目标地址
   nconn, er := net.Dial("tcp", target)
   if er != nil {
    return
   }
   defer conn.Close()
   utils.Relay(local, conn)
  }(gonet.NewTCPConn(wq, ep), id)
 }).HandlePacket)


// UDP
 s.SetTransportProtocolHandler(udp.ProtocolNumber, udp.NewForwarder(s, func(fr *udp.ForwarderRequest) {
    // handle udp, 和tcp差不多
 }).HandlePacket)

完整代码: tun

Android VPN Service

Android 的VPN Service只能处理Tun接口

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

class MyVpnService : VpnService() {
    override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
        Builder().apply {
            setMtu(1500)
            setSession("my vpn")

            addAddress("172.19.0.1", 24).addRoute("172.19.0.2", 32)
            addAddress("fdfe:dcba:9876::1", 126)
                .addRoute("2000::", 3) // https://issuetracker.google.com/issues/149636790
                .addRoute("fdfe:dcba:9876::2", 128)

            addDnsServer("172.19.0.2") // 记得在Tun中劫持172.19.0.2:53处理所有的DNS请求

            addDisallowedApplication("com.example") // Disallowed和Allowed不能同时调用
            // addAllowedApplication("com.example")

            const fd = establish()
/*
    fd 为 linux文件标识符
    如果是通过tun2socks这种命令行工具处理
    需要使用Linux socket将fd发送给子进程
           
    如果是调用so动态库则不需要
    
    通过unix文件socket发送sd
      private fun sendFd(path: String) {
            LocalSocket().use { localSocket ->
                localSocket.connect(
                    LocalSocketAddress(
                        path,
                        LocalSocketAddress.Namespace.FILESYSTEM
                    )
                )
                localSocket.setFileDescriptorsForSend(arrayOf(fd)) // <------
                localSocket.outputStream.write(42)
            }
    }
*/
        }
        return START_STICKY   
    }


}

完整代码: VpnService

质数

质数（Prime number），又称素数，指在大于1的自然数中，除了1和该数自身外，无法被其他自然数整除的数（也可定义为只有1与该数本身两个正因数的数）。

来自 https://zh.wikipedia.org/wiki/质数

互质

互质是公约数只有1的两个整数，也可记gcd(a,b)=1, 叫做互质整数。

欧拉

在数论中，对正整数n，欧拉函数phi(n)是小于等于n的正整数中与n互质的数的数目。此函数以其首名研究者欧拉命名，它又称为φ函数（由高斯所命名）或是欧拉总计函数（totient function，由西尔维斯特所命名）。

来自 https://zh.wikipedia.org/wiki/欧拉函数