okid 0.23.0

A library for generating double clickable ids
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

#![cfg(target_arch = "wasm32")]
use worker::{
    crypto::{DigestStream, DigestStreamAlgorithm},
    worker_sys::web_sys,
    Error as WorkerError, Result as WorkerResult,
};

use crate::{BinaryType, Digest, OkId};

/// Internal helper that maps an `OkId` digest type to the corresponding Cloudflare
/// `DigestStreamAlgorithm`, returning the algorithm and the raw digest bytes.
fn worker_digest_info(okid: &OkId) -> WorkerResult<(DigestStreamAlgorithm, &[u8])> {
    match &okid.digest {
        #[cfg(feature = "sha2")]
        Digest::Sha256(d) => Ok((DigestStreamAlgorithm::Sha256, &d.0[..])),
        _ => Err(WorkerError::RustError(format!(
            "OkId type '{}' is not supported by Cloudflare DigestStream",
            okid.hash_type
        ))),
    }
}

/// Convert the provided raw digest bytes into an `OkId`, using the supplied algorithm.
fn okid_from_worker_digest_bytes(
    bytes: &[u8],
    algorithm: DigestStreamAlgorithm,
) -> WorkerResult<OkId> {
    match algorithm {
        #[cfg(feature = "sha2")]
        DigestStreamAlgorithm::Sha256 => {
            if bytes.len() != 32 {
                return Err(WorkerError::RustError(format!(
                    "SHA-256 digest must be 32 bytes, got {}",
                    bytes.len()
                )));
            }
            let mut buf = [0u8; 32];
            buf.copy_from_slice(bytes);
            Ok(OkId {
                hash_type: BinaryType::Sha256,
                digest: Digest::Sha256(crate::sha2::Sha256(buf)),
            })
        }
        _ => Err(WorkerError::RustError(format!(
            "DigestStreamAlgorithm '{:?}' is not supported by Cloudflare OkId",
            algorithm
        ))),
    }
}

#[cfg(feature = "worker")]
impl OkId {
    /// Construct an `OkId` by hashing the provided readable stream inside a Cloudflare Worker.
    ///
    /// This uses the Worker runtime `crypto.DigestStream` API and supports the same
    /// algorithms that OkId exposes for Cloudflare (`SHA-1` and `SHA-256`).
    pub async fn from_worker_stream(
        stream: &web_sys::ReadableStream,
        algorithm: DigestStreamAlgorithm,
    ) -> WorkerResult<Self> {
        let digest_stream = DigestStream::new(algorithm);
        let _ = stream.pipe_to(digest_stream.raw());
        let digest = digest_stream.digest().await?.to_vec();
        okid_from_worker_digest_bytes(&digest, algorithm)
    }

    /// Verify that the readable stream's digest matches the current `OkId`.
    ///
    /// ```rust,no_run
    /// use worker::{
    ///     crypto::{DigestStream, DigestStreamAlgorithm},
    ///     worker_sys::web_sys,
    /// };
    ///
    /// # async fn example(
    /// #     stream: &web_sys::ReadableStream,
    /// #     expected: okid::OkId,
    /// # ) -> worker::Result<bool> {
    /// let matches = expected.verify_worker_stream(stream).await?;
    /// # Ok(matches)
    /// # }
    /// ```
    pub async fn verify_worker_stream(
        &self,
        stream: &web_sys::ReadableStream,
    ) -> WorkerResult<bool> {
        let (algorithm, expected) = worker_digest_info(self)?;
        let digest_stream = DigestStream::new(algorithm);
        let _ = stream.pipe_to(digest_stream.raw());
        let digest = digest_stream.digest().await?.to_vec();
        Ok(digest.as_slice() == expected)
    }
}