update

Hunter0x7c7

2022-08-11 b8230139fb40edea387617b6accd8371e37eda58

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
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
package crypto_test 
 
import ( 
    "bytes" 
    "crypto/aes" 
    "crypto/cipher" 
    "crypto/rand" 
    "io" 
    "testing" 
 
    "github.com/google/go-cmp/cmp" 
 
    "github.com/v2fly/v2ray-core/v5/common" 
    "github.com/v2fly/v2ray-core/v5/common/buf" 
    . "github.com/v2fly/v2ray-core/v5/common/crypto" 
    "github.com/v2fly/v2ray-core/v5/common/protocol" 
) 
 
func TestAuthenticationReaderWriter(t *testing.T) { 
    key := make([]byte, 16) 
    rand.Read(key) 
    block, err := aes.NewCipher(key) 
    common.Must(err) 
 
    aead, err := cipher.NewGCM(block) 
    common.Must(err) 
 
    const payloadSize = 1024 * 80 
    rawPayload := make([]byte, payloadSize) 
    rand.Read(rawPayload) 
 
    payload := buf.MergeBytes(nil, rawPayload) 
 
    cache := bytes.NewBuffer(nil) 
    iv := make([]byte, 12) 
    rand.Read(iv) 
 
    writer := NewAuthenticationWriter(&AEADAuthenticator{ 
        AEAD:                    aead, 
        NonceGenerator:          GenerateStaticBytes(iv), 
        AdditionalDataGenerator: GenerateEmptyBytes(), 
    }, PlainChunkSizeParser{}, cache, protocol.TransferTypeStream, nil) 
 
    common.Must(writer.WriteMultiBuffer(payload)) 
    if cache.Len() <= 1024*80 { 
        t.Error("cache len: ", cache.Len()) 
    } 
    common.Must(writer.WriteMultiBuffer(buf.MultiBuffer{})) 
 
    reader := NewAuthenticationReader(&AEADAuthenticator{ 
        AEAD:                    aead, 
        NonceGenerator:          GenerateStaticBytes(iv), 
        AdditionalDataGenerator: GenerateEmptyBytes(), 
    }, PlainChunkSizeParser{}, cache, protocol.TransferTypeStream, nil) 
 
    var mb buf.MultiBuffer 
 
    for mb.Len() < payloadSize { 
        mb2, err := reader.ReadMultiBuffer() 
        common.Must(err) 
 
        mb, _ = buf.MergeMulti(mb, mb2) 
    } 
 
    if mb.Len() != payloadSize { 
        t.Error("mb len: ", mb.Len()) 
    } 
 
    mbContent := make([]byte, payloadSize) 
    buf.SplitBytes(mb, mbContent) 
    if r := cmp.Diff(mbContent, rawPayload); r != "" { 
        t.Error(r) 
    } 
 
    _, err = reader.ReadMultiBuffer() 
    if err != io.EOF { 
        t.Error("error: ", err) 
    } 
} 
 
func TestAuthenticationReaderWriterPacket(t *testing.T) { 
    key := make([]byte, 16) 
    common.Must2(rand.Read(key)) 
    block, err := aes.NewCipher(key) 
    common.Must(err) 
 
    aead, err := cipher.NewGCM(block) 
    common.Must(err) 
 
    cache := buf.New() 
    iv := make([]byte, 12) 
    rand.Read(iv) 
 
    writer := NewAuthenticationWriter(&AEADAuthenticator{ 
        AEAD:                    aead, 
        NonceGenerator:          GenerateStaticBytes(iv), 
        AdditionalDataGenerator: GenerateEmptyBytes(), 
    }, PlainChunkSizeParser{}, cache, protocol.TransferTypePacket, nil) 
 
    var payload buf.MultiBuffer 
    pb1 := buf.New() 
    pb1.Write([]byte("abcd")) 
    payload = append(payload, pb1) 
 
    pb2 := buf.New() 
    pb2.Write([]byte("efgh")) 
    payload = append(payload, pb2) 
 
    common.Must(writer.WriteMultiBuffer(payload)) 
    if cache.Len() == 0 { 
        t.Error("cache len: ", cache.Len()) 
    } 
 
    common.Must(writer.WriteMultiBuffer(buf.MultiBuffer{})) 
 
    reader := NewAuthenticationReader(&AEADAuthenticator{ 
        AEAD:                    aead, 
        NonceGenerator:          GenerateStaticBytes(iv), 
        AdditionalDataGenerator: GenerateEmptyBytes(), 
    }, PlainChunkSizeParser{}, cache, protocol.TransferTypePacket, nil) 
 
    mb, err := reader.ReadMultiBuffer() 
    common.Must(err) 
 
    mb, b1 := buf.SplitFirst(mb) 
    if b1.String() != "abcd" { 
        t.Error("b1: ", b1.String()) 
    } 
 
    mb, b2 := buf.SplitFirst(mb) 
    if b2.String() != "efgh" { 
        t.Error("b2: ", b2.String()) 
    } 
 
    if !mb.IsEmpty() { 
        t.Error("not empty") 
    } 
 
    _, err = reader.ReadMultiBuffer() 
    if err != io.EOF { 
        t.Error("error: ", err) 
    } 
}