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
98
99
100
101
102

use std::sync::Arc;

use super::crypto::*;
use super::error::*;
use super::event::*;
use super::meta::*;
use super::signature::MetaSignature;
use super::transaction::*;
use crate::spec::TrustMode;

#[derive(Debug)]
pub enum ValidationResult {
    Deny,
    Allow,
    #[allow(dead_code)]
    Abstain,
}

pub trait EventValidator: Send + Sync {
    fn validate(
        &self,
        _header: &EventHeader,
        _conversation: Option<&Arc<ConversationSession>>,
    ) -> Result<ValidationResult, ValidationError> {
        Ok(ValidationResult::Abstain)
    }

    fn set_integrity_mode(&mut self, _mode: TrustMode) {}

    fn clone_validator(&self) -> Box<dyn EventValidator>;

    fn validator_name(&self) -> &str;
}

#[derive(Default, Clone)]
pub struct RubberStampValidator {}

impl EventValidator for RubberStampValidator {
    fn clone_validator(&self) -> Box<dyn EventValidator> {
        Box::new(self.clone())
    }

    #[allow(unused_variables)]
    fn validate(
        &self,
        _header: &EventHeader,
        _conversation: Option<&Arc<ConversationSession>>,
    ) -> Result<ValidationResult, ValidationError> {
        Ok(ValidationResult::Allow)
    }

    fn validator_name(&self) -> &str {
        "rubber-stamp-validator"
    }
}

#[derive(Debug, Clone)]
pub struct StaticSignatureValidator {
    #[allow(dead_code)]
    pk: PublicSignKey,
}

impl StaticSignatureValidator {
    #[allow(dead_code)]
    pub fn new(key: &PublicSignKey) -> StaticSignatureValidator {
        StaticSignatureValidator { pk: key.clone() }
    }
}

impl EventValidator for StaticSignatureValidator {
    fn clone_validator(&self) -> Box<dyn EventValidator> {
        Box::new(self.clone())
    }

    #[allow(unused_variables)]
    fn validate(
        &self,
        _header: &EventHeader,
        _conversation: Option<&Arc<ConversationSession>>,
    ) -> Result<ValidationResult, ValidationError> {
        Ok(ValidationResult::Allow)
    }

    fn validator_name(&self) -> &str {
        "static-signature-validator"
    }
}

impl Metadata {
    #[allow(dead_code)]
    pub fn add_signature(&mut self, _sig: MetaSignature) {}

    pub fn get_signature<'a>(&'a self) -> Option<&'a MetaSignature> {
        self.core
            .iter()
            .filter_map(|m| match m {
                CoreMetadata::Signature(k) => Some(k),
                _ => None,
            })
            .next()
    }
}