Struct Interceptor 

pub struct Interceptor {
    pub key_store: Arc<RwLock<KeyStore>>,
    pub handshake_store: HandshakeStore,
    pub replay_store: Option<ConnectionManager>,
}

Actix-web middleware that transparently decrypts incoming request bodies and encrypts outgoing response bodies using the X25519 ECDH + AES-256-GCM + HMAC-SHA256 pipeline.

Usage

use alterion_encrypt::interceptor::Interceptor;
use alterion_encrypt::{init_key_store, init_handshake_store, start_rotation};

let store = init_key_store(3600);
let hs    = init_handshake_store();
start_rotation(store.clone(), 3600, hs.clone());
// App::new().wrap(Interceptor { key_store: store, handshake_store: hs, replay_store: None })

Request path (POST / PUT / PATCH):

1. Collect raw body bytes.
2. MessagePack-decode a Request and validate timestamp.
3. Perform X25519 ECDH using the server key identified by key_id and the client’s ephemeral public key from the packet.
4. Derive a wrap key via HKDF-SHA256 and use it to AES-GCM-unwrap the client’s enc_key.
5. AES-256-GCM-decrypt the payload using enc_key.
6. Inject DecryptedBody and RequestSessionKeys into request extensions.

Requests whose body is not a valid Request are passed through unchanged.

Response path (only when RequestSessionKeys was set): JSON → deflate compress → msgpack → AES-256-GCM (enc_key) → HMAC-SHA256 (mac key derived from enc_key) → Response → msgpack.

Fields

key_store: Arc<RwLock<KeyStore>>

handshake_store: HandshakeStore

replay_store: Option<ConnectionManager>

Trait Implementations

impl<S, B> Transform<S, ServiceRequest> for Interceptor

where S: Service<ServiceRequest, Response = ServiceResponse<B>, Error = Error> + 'static, B: MessageBody + 'static,

type Response = ServiceResponse<EitherBody<B>>

Responses produced by the service.

type Error = Error

Errors produced by the service.

type Transform = InterceptorService<S>

The TransformService value created by this factory

type InitError = ()

Errors produced while building a transform service.

type Future = Ready<Result<<Interceptor as Transform<S, ServiceRequest>>::Transform, <Interceptor as Transform<S, ServiceRequest>>::InitError>>

The future response value.

fn new_transform(&self, service: S) -> Self::Future

Creates and returns a new Transform component, asynchronously