Struct request_response::message::RequestMessage

pub struct RequestMessage<R: Request, K: SignatureKey> {
    pub public_key: K,
    pub signature: K::PureAssembledSignatureType,
    pub timestamp_unix_seconds: u64,
    pub request: R,
}

A request message, which includes the requester’s public key, the request’s signature, a timestamp, and the request itself

Fields

public_key: K

The requester’s public key

signature: K::PureAssembledSignatureType

The requester’s signature over the [the actual request content + timestamp]

timestamp_unix_seconds: u64

The timestamp of when the request was sent (in seconds since the Unix epoch). We use this to ensure that the request is not old, which is useful for preventing replay attacks.

request: R

The actual request data. This is from the application

Implementations

impl<R: Request, K: SignatureKey> RequestMessage<R, K>

pub fn new_signed( public_key: &K, private_key: &K::PrivateKey, request: &R, ) -> Result<Self>

where <K as SignatureKey>::SignError: 'static,

Create a new signed request message from a request

Errors

• If the request’s content cannot be serialized
• If the request cannot be signed

Panics

• If time is not monotonic

pub async fn validate(&self, incoming_request_ttl: Duration) -> Result<()>

Validate the RequestMessage, checking the signature and the timestamp and calling the request’s application-specific validation function

Errors

• If the request’s signature is invalid
• If the request is too old

Panics

• If time is not monotonic

Trait Implementations

impl<R: Clone + Request, K: Clone + SignatureKey> Clone for RequestMessage<R, K>

where K::PureAssembledSignatureType: Clone,

fn clone(&self) -> RequestMessage<R, K>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<R: Debug + Request, K: Debug + SignatureKey> Debug for RequestMessage<R, K>

where K::PureAssembledSignatureType: Debug,

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<R: Request, K: SignatureKey> Serializable for RequestMessage<R, K>

fn to_bytes(&self) -> Result<Vec<u8>>

Serialize the type to a byte array. If this is for a Request and your Request type is represented as an enum, please make sure that you serialize it with a unique type ID. Otherwise, you may end up with collisions as the request hash is used as a unique identifier

fn from_bytes(bytes: &[u8]) -> Result<Self>

Deserialize the type from a byte array