samael 0.0.21

A SAML2 library for Rust
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
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132

//!
//! Central XmlSec1 Context
//!
use crate::crypto::xmlsec::wrapper::bindings;

use lazy_static::lazy_static;

use super::backend;
use super::error::XmlSecError;
use super::XmlSecResult;
use std::convert::TryInto;
use std::ptr::null;
use std::sync::Mutex;

lazy_static! {
    static ref XMLSEC: Mutex<Option<XmlSecContext>> = Mutex::new(None);
}

pub fn guarantee_xmlsec_init() -> XmlSecResult<()> {
    let mut inner = XMLSEC
        .lock()
        .expect("Unable to lock global wrapper initalization wrapper");

    if inner.is_none() {
        *inner = Some(XmlSecContext::new()?);
    }

    Ok(())
}

/// XmlSec Global Context
///
/// This object initializes the underlying wrapper global state and cleans it
/// up once gone out of scope. It is checked by all objects in the library that
/// require the context to be initialized. See [`globals`][globals].
///
/// [globals]: globals
pub struct XmlSecContext {}

impl XmlSecContext {
    /// Runs wrapper initialization and returns instance of itself.
    pub fn new() -> XmlSecResult<Self> {
        unsafe {
            libxml::bindings::xmlInitParser();
        }

        init_xmlsec()?;
        init_crypto_app()?;
        init_crypto()?;

        Ok(Self {})
    }
}

impl Drop for XmlSecContext {
    fn drop(&mut self) {
        cleanup_crypto();
        cleanup_crypto_app();
        cleanup_xmlsec();
    }
}

/// Init wrapper library
fn init_xmlsec() -> XmlSecResult<()> {
    let rc = unsafe {
        bindings::xmlSecCheckVersionExt(
            bindings::XMLSEC_VERSION_MAJOR.try_into().unwrap(),
            bindings::XMLSEC_VERSION_MINOR.try_into().unwrap(),
            bindings::XMLSEC_VERSION_SUBMINOR.try_into().unwrap(),
            bindings::xmlSecCheckVersionMode_xmlSecCheckVersionABICompatible,
        )
    };

    if rc < 0 {
        return Err(XmlSecError::XmlSecAbiMismatch);
    }

    let rc = unsafe { bindings::xmlSecInit() };

    if rc < 0 {
        Err(XmlSecError::XmlSecInitError)
    } else {
        Ok(())
    }
}

/// Load default crypto engine if we are supporting dynamic loading for
/// wrapper-crypto libraries. Use the crypto library name ("openssl",
/// "nss", etc.) to load corresponding wrapper-crypto library.
fn init_crypto_app() -> XmlSecResult<()> {
    #[cfg(xmlsec_dynamic)]
    {
        let rc = unsafe { backend::xmlSecCryptoDLLoadLibrary(null()) };
        if rc < 0 {
            return Err(XmlSecError::CryptoLoadLibraryError);
        }
    }

    let rc = unsafe { backend::xmlSecCryptoAppInit(null()) };

    if rc < 0 {
        Err(XmlSecError::CryptoInitOpenSSLAppError)
    } else {
        Ok(())
    }
}

/// Init wrapper-crypto library
fn init_crypto() -> XmlSecResult<()> {
    let rc = unsafe { backend::xmlSecCryptoInit() };

    if rc < 0 {
        Err(XmlSecError::CryptoInitOpenSSLError)
    } else {
        Ok(())
    }
}

/// Shutdown wrapper-crypto library
fn cleanup_crypto() {
    unsafe { backend::xmlSecCryptoShutdown() };
}

/// Shutdown crypto library
fn cleanup_crypto_app() {
    unsafe { backend::xmlSecCryptoAppShutdown() };
}

/// Shutdown wrapper library
fn cleanup_xmlsec() {
    unsafe { bindings::xmlSecShutdown() };
}