Struct ShadowsocksAeadStream 

pub struct ShadowsocksAeadStream<S> { /* private fields */ }

Bidirectional AEAD stream adapter for Shadowsocks TCP.

Wraps an AsyncRead + AsyncWrite stream and encrypts/decrypts all data using standard Shadowsocks AEAD chunk framing (SIP003).

In SIP003, each direction uses its own salt and subkey:

• The SENDER prepends a random salt to the first packet, derives a subkey from it, and encrypts all subsequent packets with that subkey.
• The RECEIVER reads the salt from the first packet, derives the same subkey, and uses it for decryption.

This means:

• For the client: subkey is the write subkey (for encrypting to server), and the read subkey is derived from the server’s first response salt.
• For the server: subkey is the read subkey (for decrypting from client), and the write subkey is sent as the first bytes of the response.

Implementations

impl<S: AsyncRead + AsyncWrite + Unpin> ShadowsocksAeadStream<S>

pub fn new( inner: S, method: CipherMethod, subkey: Vec<u8>, ) -> Result<Self, ShadowsocksError>

Create a new AEAD stream (same subkey for both directions — for internal use).

pub fn new_client( inner: S, method: CipherMethod, write_subkey: Vec<u8>, password: &str, ) -> Result<Self, ShadowsocksError>

Create a client-side AEAD stream.

• write_subkey: derived from the client’s salt (for encrypting to server).
• On first read, the peer’s salt is read and read_subkey is derived.

pub fn new_server( inner: S, method: CipherMethod, read_subkey: Vec<u8>, send_write_salt: bool, password: &str, ) -> Result<Self, ShadowsocksError>

Create a server-side AEAD stream.

• read_subkey: derived from the client’s salt (for decrypting from client).
• send_write_salt: must be true so the server can send a fresh salt before its first data chunk (as required by standard implementations).

pub fn new_with_nonces( inner: S, method: CipherMethod, subkey: Vec<u8>, write_start: u64, read_start: u64, ) -> Result<Self, ShadowsocksError>

Create a new AEAD stream with explicit starting nonces (legacy/internal).

pub fn into_inner(self) -> S

Trait Implementations

impl<S: AsyncRead + AsyncWrite + Unpin> AsyncRead for ShadowsocksAeadStream<S>

fn poll_read( self: Pin<&mut Self>, cx: &mut Context<'_>, buf: &mut ReadBuf<'_>, ) -> Poll<Result<()>>

Attempts to read from the AsyncRead into buf.

impl<S: AsyncRead + AsyncWrite + Unpin> AsyncWrite for ShadowsocksAeadStream<S>

fn poll_write( self: Pin<&mut Self>, cx: &mut Context<'_>, buf: &[u8], ) -> Poll<Result<usize>>

Attempt to write bytes from buf into the object.

fn poll_flush(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<()>>

Attempts to flush the object, ensuring that any buffered data reach their destination.

fn poll_shutdown(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<()>>

Initiates or attempts to shut down this writer, returning success when the I/O connection has completely shut down.

fn poll_write_vectored( self: Pin<&mut Self>, cx: &mut Context<'_>, bufs: &[IoSlice<'_>], ) -> Poll<Result<usize, Error>>

Like poll_write, except that it writes from a slice of buffers.

fn is_write_vectored(&self) -> bool

Determines if this writer has an efficient poll_write_vectored implementation.