crypto

type AEADAlgorithm ¶ added in v0.7.0

type AEADAlgorithm string

type AEADStreamOptions ¶ added in v0.7.0

type AEADStreamOptions struct {
	Algorithm      AEADAlgorithm
	Key            []byte
	MaxPayloadSize int
}

AEADStreamOptions configures the framed AEAD stream reader and writer. Key must be a raw 32-byte AEAD key. Callers are responsible for deriving it from application secrets before constructing the stream.

The AEAD stream authenticates each frame and its order, but it does not authenticate end-of-stream. A clean EOF on a frame boundary is treated as normal stream termination. Protocols that need object/file truncation detection must authenticate a total length or final record at a higher layer.

For AES-256-GCM, this package enforces a per-stream limit of 2^32 frames. This is a local limit only; callers that reuse a key across multiple streams or directions must enforce the global per-key limit themselves or derive independent keys.

type AEADStreamReader ¶ added in v0.7.0

type AEADStreamReader struct {
	// contains filtered or unexported fields
}

AEADStreamReader decrypts the framed AEAD stream produced by AEADStreamWriter.

It authenticates each frame and its order using the stream nonce, frame header, and incrementing frame nonce. Truncation inside a frame is returned as an error from the underlying reader, but EOF at a frame boundary is treated as normal stream termination and does not authenticate end-of-stream. AEADStreamReader is not safe for concurrent use by multiple goroutines.

func NewAEADStreamReader(r io.Reader, opts AEADStreamOptions) (*AEADStreamReader, error)

func (r *AEADStreamReader) Read(p []byte) (nRet int, errRet error)

type AEADStreamWriter ¶ added in v0.7.0

type AEADStreamWriter struct {
	// contains filtered or unexported fields
}

AEADStreamWriter encrypts plaintext into a framed AEAD stream.

The wire format is:

stream nonce || repeated frame

Each frame is:

uint32 ciphertext length || AEAD ciphertext and tag

The stream nonce is sent in cleartext and seeds the first frame nonce. Each subsequent frame increments that nonce by one. Each frame authenticates the stream nonce and frame length header as AAD, which binds frame order to the stream. AEADStreamWriter is not safe for concurrent use by multiple goroutines. Once Write returns an error, the writer remembers it and returns the same error from subsequent Write calls.

func NewAEADStreamWriter(w io.Writer, opts AEADStreamOptions) (*AEADStreamWriter, error)

func (w *AEADStreamWriter) Write(p []byte) (nRet int, errRet error)

type Reader ¶

type Reader struct {
	// contains filtered or unexported fields
}

Reader is an io.Reader that can read encrypted bytes. Now it only supports aes-128-cfb.

func NewReader(r io.Reader, key []byte) *Reader

func (r *Reader) Read(p []byte) (nRet int, errRet error)

type Writer ¶

type Writer struct {
	// contains filtered or unexported fields
}

Writer is an io.Writer that can write encrypted bytes. Now it only support aes-128-cfb.

func NewWriter(w io.Writer, key []byte) (*Writer, error)

func (w *Writer) Write(p []byte) (nRet int, errRet error)