Jędrzej Stuczyński
143 lines
4.3 KiB
Rust
143 lines
4.3 KiB
Rust
// Copyright 2025 - Nym Technologies SA <contact@nymtech.net>
|
|
// SPDX-License-Identifier: Apache-2.0
|
|
|
|
use crate::packet::MalformedLpPacketError;
|
|
use crate::peer_config::LpReceiverIndex;
|
|
use crate::replay::ReplayError;
|
|
use crate::transport::LpTransportError;
|
|
use libcrux_psq::handshake::HandshakeError;
|
|
use libcrux_psq::handshake::builders::BuilderError;
|
|
use libcrux_psq::session::SessionError;
|
|
// use nym_crypto::asymmetric::ed25519::Ed25519RecoveryError;
|
|
use nym_kkt::error::KKTError;
|
|
use nym_kkt_ciphersuite::{HashFunction, KEM};
|
|
use thiserror::Error;
|
|
|
|
#[derive(Error, Debug)]
|
|
pub enum LpError {
|
|
#[error("IO Error: {0}")]
|
|
IoError(#[from] std::io::Error),
|
|
|
|
#[error("Replay detected: {0}")]
|
|
Replay(#[from] ReplayError),
|
|
|
|
#[error("Insufficient buffer size provided")]
|
|
InsufficientBufferSize,
|
|
|
|
#[error("Attempted operation on closed session")]
|
|
SessionClosed,
|
|
|
|
#[error("There already exists an LP session with receiver index {0}")]
|
|
DuplicateSessionId(LpReceiverIndex),
|
|
|
|
#[error("Internal error: {0}")]
|
|
Internal(String),
|
|
|
|
#[error("Invalid state transition: tried input {input:?} in state {state:?}")]
|
|
InvalidStateTransition { state: String, input: String },
|
|
|
|
#[error("Invalid payload size: expected {expected}, got {actual}")]
|
|
InvalidPayloadSize { expected: usize, actual: usize },
|
|
|
|
#[error("Deserialization error: {0}")]
|
|
DeserializationError(String),
|
|
|
|
#[error(transparent)]
|
|
InvalidBase58String(#[from] bs58::decode::Error),
|
|
|
|
/// Session ID from incoming packet does not match any known session.
|
|
#[error("Received packet with unknown session ID: {0}")]
|
|
UnknownSessionId(LpReceiverIndex),
|
|
|
|
/// Invalid state transition attempt in the state machine.
|
|
#[error("Invalid input '{input}' for current state '{state}'")]
|
|
InvalidStateTransitionAttempt { state: String, input: String },
|
|
|
|
/// Session is closed.
|
|
#[error("Session is closed")]
|
|
LpSessionClosed,
|
|
|
|
/// Session is processing an input event.
|
|
#[error("Session is processing an input event")]
|
|
LpSessionProcessing,
|
|
|
|
/// State machine not found.
|
|
#[error("State machine not found for lp_id: {0}")]
|
|
StateMachineNotFound(LpReceiverIndex),
|
|
|
|
#[error("attempted to create an LP responder without providing a valid KEM keys")]
|
|
ResponderWithMissingKEMKeys,
|
|
|
|
#[error("attempted to create an LP mutual initiator without providing a valid KEM key")]
|
|
PSQMutualInitiatorMissingKemKey,
|
|
|
|
#[error(
|
|
"there are no known digests for remote's KEM key with {kem} KEM and {hash_function} hash function"
|
|
)]
|
|
NoKnownKEMKeyDigests {
|
|
kem: KEM,
|
|
hash_function: HashFunction,
|
|
},
|
|
|
|
#[error("failed to complete KKT/PSQ handshake: {0}")]
|
|
KKTPSQHandshake(String),
|
|
|
|
#[error("failed to complete the KKT exchange: {source}")]
|
|
KKTFailure {
|
|
#[from]
|
|
source: KKTError,
|
|
},
|
|
|
|
#[error(transparent)]
|
|
MalformedPacket(#[from] MalformedLpPacketError),
|
|
|
|
#[error("version {version} is not supported")]
|
|
UnsupportedVersion { version: u8 },
|
|
|
|
#[error("failed to build PSQ responder: {inner:?}")]
|
|
PSQResponderBuilderFailure { inner: BuilderError },
|
|
|
|
#[error("failed to build PSQ initiator: {inner:?}")]
|
|
PSQInitiatorBuilderFailure { inner: BuilderError },
|
|
|
|
#[error("failed to complete the PSQ handshake: {inner:?}")]
|
|
PSQHandshakeFailure { inner: HandshakeError },
|
|
|
|
#[error("failed to run the PSQ session: {inner:?}")]
|
|
PSQSessionFailure { inner: SessionError },
|
|
|
|
#[error("failed to derive a transport channel: {inner:?}")]
|
|
TransportDerivationFailure { inner: SessionError },
|
|
|
|
#[error("the initiator authenticator is not available after ingesting PSQ msg1")]
|
|
MissingInitiatorAuthenticator,
|
|
|
|
#[error("transport failure: {0}")]
|
|
TransportFailure(#[from] LpTransportError),
|
|
|
|
#[error("the current session is not in transport state")]
|
|
NotInTransport,
|
|
}
|
|
|
|
impl LpError {
|
|
pub fn kkt_psq_handshake(msg: impl Into<String>) -> Self {
|
|
Self::KKTPSQHandshake(msg.into())
|
|
}
|
|
}
|
|
|
|
impl From<HandshakeError> for LpError {
|
|
fn from(handshake_error: HandshakeError) -> Self {
|
|
Self::PSQHandshakeFailure {
|
|
inner: handshake_error,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl From<SessionError> for LpError {
|
|
fn from(session_error: SessionError) -> Self {
|
|
Self::PSQSessionFailure {
|
|
inner: session_error,
|
|
}
|
|
}
|
|
}
|