ades-rs 0.1.0

AdES digital signatures (CAdES, PAdES, XAdES, JAdES) for the eIDAS 2.0 ecosystem
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
98
99
100
101
102
103
104
105
106
107

use crate::{error::AdesError, levels, signer::Signer, tsp::TspClient};

/// Produces a CAdES B-T signature: B-B + a signature timestamp from a TSA.
///
/// The `TimeStampToken` is embedded as the unsigned attribute
/// `id-aa-signatureTimeStampToken` (over the `SignatureValue`).
///
/// # Errors
///
/// Returns [`AdesError`] if signing, the TSA request, or CMS re-encoding fails.
///
/// # Example
///
/// ```no_run
/// use ades::{cades, signer::SoftSigner, tsp::TspClient};
///
/// let signer = SoftSigner::generate(2048).unwrap();
/// let tsa = TspClient::new("https://freetsa.org/tsr");
/// let signed = cades::sign_t(b"hello world", &signer, &tsa).unwrap();
/// ```
#[cfg(all(feature = "cades", feature = "tsp"))]
pub fn sign_t<S>(data: &[u8], signer: &S, tsa: &TspClient) -> Result<Vec<u8>, AdesError>
where
    S: Signer,
    S::Error: std::error::Error + Send + Sync + 'static,
{
    // 1. Produce B-B signature
    let bb = crate::cades::sign(data, signer)?;

    // 2. Extract SignatureValue bytes to timestamp.
    //    Per ETSI EN 319 122-1 §5.2.7, the TST covers the signature value octets.
    let sig_value = extract_signature_value(&bb)?;

    // 3. Request TST from TSA
    let digest_algo = signer.digest_algorithm();
    let hash = digest_algo.hash(&sig_value);
    let tst = tsa.timestamp(&hash, digest_algo)?;

    // 4. Embed TST as unsigned attribute
    levels::add_signature_timestamp(&bb, &tst)
}

/// Produces a CAdES B-LT signature: B-T + embedded revocation data (OCSP).
///
/// # Errors
///
/// Returns [`AdesError`] if any step fails.
///
/// # Example
///
/// ```no_run
/// use ades::{cades, signer::SoftSigner, tsp::TspClient, ocsp::OcspClient};
///
/// let signer = SoftSigner::generate(2048).unwrap();
/// let tsa = TspClient::new("https://freetsa.org/tsr");
/// let ocsp = OcspClient::new();
/// let signed = cades::sign_lt(b"hello world", &signer, &tsa, &ocsp).unwrap();
/// ```
#[cfg(all(feature = "cades", feature = "tsp", feature = "ocsp"))]
pub fn sign_lt<S>(
    data: &[u8],
    signer: &S,
    tsa: &TspClient,
    ocsp: &crate::ocsp::OcspClient,
) -> Result<Vec<u8>, AdesError>
where
    S: Signer,
    S::Error: std::error::Error + Send + Sync + 'static,
{
    // 1. B-T
    let bt = sign_t(data, signer, tsa)?;

    // 2. Check revocation status and get raw OCSP response bytes.
    //    For self-signed certs (no AIA), we skip revocation embedding.
    //    Production certs with AIA will trigger a real OCSP request.
    let cert = signer.certificate();
    let ocsp_resp = match ocsp.raw_response(cert, cert) {
        Ok(resp) => resp,
        Err(AdesError::Ocsp(_)) => {
            // No AIA or OCSP unavailable — still return B-T (acceptable for test certs)
            return Ok(bt);
        }
        Err(e) => return Err(e),
    };

    // 3. Embed revocation data
    levels::add_revocation_values(&bt, &ocsp_resp)
}

/// Extracts the raw `SignatureValue` bytes from a CMS `ContentInfo`.
///
/// Per RFC 5652 §5.3, `SignatureValue` is an OCTET STRING inside `SignerInfo`.
fn extract_signature_value(cms_der: &[u8]) -> Result<Vec<u8>, AdesError> {
    use cms::{content_info::ContentInfo, signed_data::SignedData};
    use der::{Decode, Encode};

    let ci = ContentInfo::from_der(cms_der)?;
    let sd = SignedData::from_der(&ci.content.to_der()?)?;
    let si = sd
        .signer_infos
        .0
        .as_ref()
        .first()
        .ok_or(AdesError::NotImplemented("CMS has no signer infos"))?;

    Ok(si.signature.as_bytes().to_vec())
}