cipherstash-client 0.34.1-alpha.1

The official CipherStash SDK
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97

use std::{
    convert::Infallible,
    fmt::{Debug, Display},
};

use cipherstash_core::string::OrderiseStringError;
use hex::FromHexError;
use hmac::digest::InvalidLength;
use miette::Diagnostic;
use ore_rs::OreError;
use static_assertions::assert_impl_all;
use thiserror::Error;

use crate::{ejsonpath, zerokms};

use super::{compound_indexer::accumulator::AccumulatorError, plaintext::Plaintext};

#[derive(Debug, Error, Diagnostic)]
pub enum EncryptionError {
    #[error(transparent)]
    EncodingError(#[from] FromHexError),

    #[error(transparent)]
    SerDeError(#[from] serde_cbor::Error),

    #[error(transparent)]
    #[diagnostic(transparent)]
    ZeroKMS(#[from] zerokms::Error),

    #[error(transparent)]
    TypeParseError(#[from] TypeParseError),

    #[error("Unable to index value: `{0}`")]
    IndexingError(String),

    #[error("Unable to create index: `{0}`")]
    CreateIndexError(String),

    #[error(transparent)]
    InvalidUniqueKey(#[from] InvalidLength),

    #[error("ORE Error: {0}")]
    OreError(#[from] OreError),

    #[error("Orderise string error: {0}")]
    OrderiseStringError(#[from] OrderiseStringError),

    #[error("Too many arguments provided")]
    TooManyArguments,

    #[error("Too few arguments provided")]
    TooFewArguments,

    #[error("AccumulatorError: {0}")]
    AccumulatorError(#[from] AccumulatorError),

    #[error("Invalid value: {0}")]
    InvalidValue(String),

    #[error(transparent)]
    CllwOre(#[from] cllw_ore::Error),

    #[error(transparent)]
    SelectorParseError(#[from] ejsonpath::ParseError),

    /// Convenience to keep the compiler happy for when internal errors are not used
    #[error("Infallible")]
    Infallible,
}

impl From<Infallible> for EncryptionError {
    fn from(_: Infallible) -> Self {
        EncryptionError::Infallible
    }
}

// Make sure that encryption errors can be sent between threads so encryptions can be run on
// different threads
assert_impl_all!(EncryptionError: Send, Sync);

#[derive(Debug, Error)]
pub struct TypeParseError(pub String);

impl TypeParseError {
    pub(crate) fn make(value: &[u8], variant: u8) -> Self {
        let target = Plaintext::variant_name(variant);
        Self(format!(
            "Unable to parse value, {value:?} into type {target:?}"
        ))
    }
}

impl Display for TypeParseError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(&self.0)
    }
}