pushers 1.5.0

A Rust client for interacting with the Pusher HTTP API
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
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
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161

use crate::{Token, util};
use sonic_rs::Value;

/// Authentication data for socket connections
#[derive(Debug, serde::Serialize)]
pub struct SocketAuth {
    pub auth: String,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub channel_data: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub shared_secret: Option<String>,
}

/// User authentication data
#[derive(Debug, serde::Serialize)]
pub struct UserAuth {
    pub auth: String,
    pub user_data: String,
}

/// Gets socket signature for channel authorization
pub fn get_socket_signature(
    pusher: &crate::Pusher,
    token: &Token,
    channel: &str,
    socket_id: &str,
    data: Option<&Value>,
) -> crate::Result<SocketAuth> {
    let mut signature_data = vec![socket_id.to_string(), channel.to_string()];
    let mut channel_data = None;

    if let Some(data) = data {
        let serialized = sonic_rs::to_string(data)?;
        signature_data.push(serialized.clone());
        channel_data = Some(serialized);
    }

    let auth_string = signature_data.join(":");
    let signature = token.sign(&auth_string);
    let auth = format!("{}:{}", token.key, signature);

    let mut result = SocketAuth {
        auth,
        channel_data,
        shared_secret: None,
    };

    // Handle encrypted channels
    if util::is_encrypted_channel(channel) {
        #[cfg(feature = "encryption")]
        {
            if pusher.config().encryption_master_key().is_none() {
                return Err(crate::PusherError::Encryption {
                    message: "Cannot generate shared_secret because encryptionMasterKey is not set"
                        .to_string(),
                });
            }

            let shared_secret = pusher.channel_shared_secret(channel)?;
            result.shared_secret = Some(base64::Engine::encode(
                &base64::engine::general_purpose::STANDARD,
                &shared_secret,
            ));
        }

        #[cfg(not(feature = "encryption"))]
        {
            return Err(crate::PusherError::Encryption {
                message: "Encryption support is not enabled. Enable the 'encryption' feature to use encrypted channels.".to_string(),
            });
        }
    }

    Ok(result)
}

/// Gets socket signature for user authentication
pub fn get_socket_signature_for_user(
    token: &Token,
    socket_id: &str,
    user_data: &Value,
) -> crate::Result<UserAuth> {
    let serialized_user_data = sonic_rs::to_string(user_data)?;
    let signature_string = format!("{}::user::{}", socket_id, serialized_user_data);
    let signature = token.sign(&signature_string);

    Ok(UserAuth {
        auth: format!("{}:{}", token.key, signature),
        user_data: serialized_user_data,
    })
}

#[cfg(test)]
mod tests {
    use super::*;
    use sonic_rs::json;

    #[test]
    fn test_get_socket_signature_for_user() {
        let token = Token::new("test_key", "test_secret");
        let user_data = json!({"id": "123", "name": "Test User"});

        let result = get_socket_signature_for_user(&token, "123.456", &user_data).unwrap();

        assert!(result.auth.starts_with("test_key:"));
        assert!(result.user_data.contains("123"));
    }

    #[cfg(feature = "encryption")]
    #[test]
    fn test_encrypted_channel_auth_with_encryption() {
        use crate::{Config, Pusher};

        // This test only runs when encryption is enabled
        let config = Config::builder()
            .app_id("test")
            .key("test_key")
            .secret("test_secret")
            .encryption_master_key_base64("MDEyMzQ1Njc4OWFiY2RlZjAxMjM0NTY3ODlhYmNkZWY=")
            .unwrap()
            .build()
            .unwrap();

        let pusher = Pusher::new(config).unwrap();
        let token = Token::new("test_key", "test_secret");

        let result =
            get_socket_signature(&pusher, &token, "private-encrypted-test", "123.456", None)
                .unwrap();

        assert!(result.shared_secret.is_some());
    }

    #[cfg(not(feature = "encryption"))]
    #[test]
    fn test_encrypted_channel_auth_without_encryption() {
        use crate::{Config, Pusher};

        // This test only runs when encryption is disabled
        let config = Config::builder()
            .app_id("test")
            .key("test_key")
            .secret("test_secret")
            .build()
            .unwrap();

        let pusher = Pusher::new(config).unwrap();
        let token = Token::new("test_key", "test_secret");

        let result =
            get_socket_signature(&pusher, &token, "private-encrypted-test", "123.456", None);

        // Should fail with appropriate error message
        assert!(result.is_err());
        if let Err(crate::PusherError::Encryption { message }) = result {
            assert!(message.contains("Encryption support is not enabled"));
        } else {
            panic!("Expected encryption error");
        }
    }
}