ss: use internal pkg instead

This commit is contained in:
nadoo committed 2020-10-26 21:43:56 +08:00
1 parent 32990ebf77
commit dad45afb17
19 files changed
+1012 -155

No files matched your search

+75 -84
View File
@@ -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
}
+16 -22
View File
@@ -3,17 +3,17 @@ package vmess
import (
"encoding/binary"
"io"
"github.com/nadoo/glider/pool"
"net"
)
const (
lenSize = 2
chunkSize = 1 << 14 // 16384
chunkSize = 16 << 10
)
type chunkedWriter struct {
io.Writer
buf [lenSize]byte
}
// ChunkedWriter returns a chunked writer.
@@ -21,28 +21,22 @@ func ChunkedWriter(w io.Writer) io.Writer {
return &chunkedWriter{Writer: w}
}
func (w *chunkedWriter) Write(b []byte) (n int, err error) {
buf := pool.GetBuffer(lenSize + chunkSize)
defer pool.PutBuffer(buf)
for left := len(b); left != 0; {
writeLen := left
if writeLen > chunkSize {
writeLen = chunkSize
func (w *chunkedWriter) Write(p []byte) (n int, err error) {
var dataLen int
for left := len(p); left != 0; {
dataLen = left
if dataLen > chunkSize {
dataLen = chunkSize
}
copy(buf[lenSize:], b[n:n+writeLen])
binary.BigEndian.PutUint16(buf[:lenSize], uint16(writeLen))
_, err = w.Writer.Write(buf[:lenSize+writeLen])
if err != nil {
binary.BigEndian.PutUint16(w.buf[:], uint16(dataLen))
if _, err = (&net.Buffers{w.buf[:], p[n : n+dataLen]}).WriteTo(w.Writer); err != nil {
break
}
n += writeLen
left -= writeLen
n += dataLen
left -= dataLen
}
return
}
@@ -57,7 +51,7 @@ func ChunkedReader(r io.Reader) io.Reader {
return &chunkedReader{Reader: r}
}
func (r *chunkedReader) Read(b []byte) (int, error) {
func (r *chunkedReader) Read(p []byte) (int, error) {
if r.left == 0 {
// get length
_, err := io.ReadFull(r.Reader, r.buf[:lenSize])
@@ -72,12 +66,12 @@ func (r *chunkedReader) Read(b []byte) (int, error) {
}
}
readLen := len(b)
readLen := len(p)
if readLen > r.left {
readLen = r.left
}
n, err := r.Reader.Read(b[:readLen])
n, err := r.Reader.Read(p[:readLen])
if err != nil {
return 0, err
}