mirror of
https://github.com/nadoo/glider.git
synced 2026-11-19 07:09:42 +08:00
ss: use internal pkg instead
This commit is contained in:
1 parent
32990ebf77
commit
dad45afb17
19 files changed
+1012
-155
No files matched your search
+75
-84
@@ -1,136 +1,127 @@
|
||||
// protocol:
|
||||
// format: [data length] [data]
|
||||
// sizes: 2 bytes, n bytes
|
||||
// max(n): 2^14 bytes
|
||||
// [data]: [encrypted payload] + [Overhead]
|
||||
|
||||
package vmess
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"crypto/cipher"
|
||||
"encoding/binary"
|
||||
"io"
|
||||
"net"
|
||||
|
||||
"github.com/nadoo/glider/pool"
|
||||
)
|
||||
|
||||
type aeadWriter struct {
|
||||
io.Writer
|
||||
cipher.AEAD
|
||||
nonce []byte
|
||||
buf []byte
|
||||
nonce [32]byte
|
||||
count uint16
|
||||
iv []byte
|
||||
}
|
||||
|
||||
// AEADWriter returns a aead writer.
|
||||
func AEADWriter(w io.Writer, aead cipher.AEAD, iv []byte) io.Writer {
|
||||
return &aeadWriter{
|
||||
Writer: w,
|
||||
AEAD: aead,
|
||||
buf: make([]byte, lenSize+chunkSize),
|
||||
nonce: make([]byte, aead.NonceSize()),
|
||||
count: 0,
|
||||
iv: iv,
|
||||
}
|
||||
aw := &aeadWriter{Writer: w, AEAD: aead}
|
||||
copy(aw.nonce[2:], iv[2:12])
|
||||
return aw
|
||||
}
|
||||
|
||||
func (w *aeadWriter) Write(b []byte) (int, error) {
|
||||
n, err := w.ReadFrom(bytes.NewBuffer(b))
|
||||
return int(n), err
|
||||
}
|
||||
func (w *aeadWriter) Write(b []byte) (n int, err error) {
|
||||
buf := pool.GetBuffer(chunkSize)
|
||||
defer pool.PutBuffer(buf)
|
||||
|
||||
func (w *aeadWriter) ReadFrom(r io.Reader) (n int64, err error) {
|
||||
for {
|
||||
buf := w.buf
|
||||
payloadBuf := buf[lenSize : lenSize+chunkSize-w.Overhead()]
|
||||
var lenBuf [lenSize]byte
|
||||
var writeLen, dataLen int
|
||||
|
||||
nr, er := r.Read(payloadBuf)
|
||||
if nr > 0 {
|
||||
n += int64(nr)
|
||||
buf = buf[:lenSize+nr+w.Overhead()]
|
||||
payloadBuf = payloadBuf[:nr]
|
||||
binary.BigEndian.PutUint16(buf[:lenSize], uint16(nr+w.Overhead()))
|
||||
|
||||
binary.BigEndian.PutUint16(w.nonce[:2], w.count)
|
||||
copy(w.nonce[2:], w.iv[2:12])
|
||||
|
||||
w.Seal(payloadBuf[:0], w.nonce, payloadBuf, nil)
|
||||
w.count++
|
||||
|
||||
_, ew := w.Writer.Write(buf)
|
||||
if ew != nil {
|
||||
err = ew
|
||||
break
|
||||
}
|
||||
nonce := w.nonce[:w.NonceSize()]
|
||||
for left := len(b); left != 0; {
|
||||
writeLen = left + w.Overhead()
|
||||
if writeLen > chunkSize {
|
||||
writeLen = chunkSize
|
||||
}
|
||||
dataLen = writeLen - w.Overhead()
|
||||
|
||||
if er != nil {
|
||||
if er != io.EOF { // ignore EOF as per io.ReaderFrom contract
|
||||
err = er
|
||||
}
|
||||
binary.BigEndian.PutUint16(lenBuf[:], uint16(writeLen))
|
||||
binary.BigEndian.PutUint16(nonce[:2], w.count)
|
||||
|
||||
w.Seal(buf[:0], nonce, b[n:n+dataLen], nil)
|
||||
w.count++
|
||||
|
||||
if _, err = (&net.Buffers{lenBuf[:], buf[:writeLen]}).WriteTo(w.Writer); err != nil {
|
||||
break
|
||||
}
|
||||
|
||||
n += dataLen
|
||||
left -= dataLen
|
||||
}
|
||||
|
||||
return n, err
|
||||
return
|
||||
}
|
||||
|
||||
type aeadReader struct {
|
||||
io.Reader
|
||||
cipher.AEAD
|
||||
nonce []byte
|
||||
buf []byte
|
||||
leftover []byte
|
||||
count uint16
|
||||
iv []byte
|
||||
nonce [32]byte
|
||||
count uint16
|
||||
buf []byte
|
||||
offset int
|
||||
}
|
||||
|
||||
// AEADReader returns a aead reader.
|
||||
func AEADReader(r io.Reader, aead cipher.AEAD, iv []byte) io.Reader {
|
||||
return &aeadReader{
|
||||
Reader: r,
|
||||
AEAD: aead,
|
||||
buf: make([]byte, lenSize+chunkSize),
|
||||
nonce: make([]byte, aead.NonceSize()),
|
||||
count: 0,
|
||||
iv: iv,
|
||||
}
|
||||
ar := &aeadReader{Reader: r, AEAD: aead}
|
||||
copy(ar.nonce[2:], iv[2:12])
|
||||
return ar
|
||||
}
|
||||
|
||||
func (r *aeadReader) Read(b []byte) (int, error) {
|
||||
if len(r.leftover) > 0 {
|
||||
n := copy(b, r.leftover)
|
||||
r.leftover = r.leftover[n:]
|
||||
return n, nil
|
||||
}
|
||||
|
||||
// get length
|
||||
_, err := io.ReadFull(r.Reader, r.buf[:lenSize])
|
||||
if err != nil {
|
||||
func (r *aeadReader) read(p []byte) (int, error) {
|
||||
if _, err := io.ReadFull(r.Reader, p[:lenSize]); err != nil {
|
||||
return 0, err
|
||||
}
|
||||
|
||||
// if length == 0, then this is the end
|
||||
l := binary.BigEndian.Uint16(r.buf[:lenSize])
|
||||
if l == 0 {
|
||||
return 0, nil
|
||||
}
|
||||
|
||||
// get payload
|
||||
buf := r.buf[:l]
|
||||
_, err = io.ReadFull(r.Reader, buf)
|
||||
if err != nil {
|
||||
size := int(binary.BigEndian.Uint16(p[:lenSize]))
|
||||
p = p[:size]
|
||||
if _, err := io.ReadFull(r.Reader, p); err != nil {
|
||||
return 0, err
|
||||
}
|
||||
|
||||
binary.BigEndian.PutUint16(r.nonce[:2], r.count)
|
||||
copy(r.nonce[2:], r.iv[2:12])
|
||||
|
||||
_, err = r.Open(buf[:0], r.nonce, buf, nil)
|
||||
_, err := r.Open(p[:0], r.nonce[:r.NonceSize()], p, nil)
|
||||
r.count++
|
||||
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
|
||||
dataLen := int(l) - r.Overhead()
|
||||
m := copy(b, r.buf[:dataLen])
|
||||
if m < int(dataLen) {
|
||||
r.leftover = r.buf[m:dataLen]
|
||||
return size - r.Overhead(), nil
|
||||
}
|
||||
|
||||
func (r *aeadReader) Read(p []byte) (int, error) {
|
||||
if r.buf == nil {
|
||||
if len(p) >= chunkSize {
|
||||
return r.read(p)
|
||||
}
|
||||
|
||||
buf := pool.GetBuffer(chunkSize)
|
||||
n, err := r.read(buf)
|
||||
if err != nil || n == 0 {
|
||||
pool.PutBuffer(buf)
|
||||
return 0, err
|
||||
}
|
||||
|
||||
r.buf = buf[:n]
|
||||
r.offset = 0
|
||||
}
|
||||
|
||||
return m, err
|
||||
n := copy(p, r.buf[r.offset:])
|
||||
r.offset += n
|
||||
if r.offset == len(r.buf) {
|
||||
pool.PutBuffer(r.buf)
|
||||
r.buf = nil
|
||||
}
|
||||
|
||||
return n, nil
|
||||
}
|
||||
Reference in new issue
Block a user