kdb_codec 1.1.0

Kdb+ IPC codec library for handling kdb+ wire protocol data with Rust.
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

//! Security Tests: Message Size Vulnerabilities
//!
//! Tests for potential DoS attacks via oversized message declarations

use bytes::BytesMut;
use kdb_codec::codec::{CompressionMode, KdbCodec, ValidationMode};
use tokio_util::codec::Decoder;

#[test]
fn test_reject_oversized_message_header() {
    // Test that decoder rejects messages claiming unreasonable sizes
    let mut codec = KdbCodec::builder()
        .is_local(false)
        .compression_mode(CompressionMode::Never)
        .validation_mode(ValidationMode::Strict)
        .max_message_size(1024)
        .build();
    let mut buffer = BytesMut::new();

    // Create header with 4GB size (0xFFFFFFFF)
    buffer.extend_from_slice(&[
        0x01, // encoding: little endian
        0x01, // message_type: sync
        0x00, // compressed: no
        0x00, // reserved
        0xFF, 0xFF, 0xFF, 0xFF, // length: 4,294,967,295 bytes (4GB)
    ]);

    let result = codec.decode(&mut buffer);
    assert!(result.is_err(), "should reject oversized message header");
}

#[test]
fn test_reject_message_size_2gb() {
    let mut codec = KdbCodec::builder()
        .is_local(false)
        .compression_mode(CompressionMode::Never)
        .validation_mode(ValidationMode::Strict)
        .max_message_size(1024)
        .build();
    let mut buffer = BytesMut::new();

    // Create header with 2GB size (0x80000000)
    buffer.extend_from_slice(&[
        0x01, // encoding: little endian
        0x01, // message_type: sync
        0x00, // compressed: no
        0x00, // reserved
        0x00, 0x00, 0x00, 0x80, // length: 2,147,483,648 bytes (2GB)
    ]);

    let result = codec.decode(&mut buffer);
    assert!(result.is_err(), "should reject oversized message header");
}

#[test]
fn test_reject_message_size_below_header_size() {
    let mut codec = KdbCodec::builder()
        .is_local(false)
        .compression_mode(CompressionMode::Never)
        .validation_mode(ValidationMode::Strict)
        .max_message_size(1024)
        .build();
    let mut buffer = BytesMut::new();

    // Create header with size less than header itself (invalid)
    buffer.extend_from_slice(&[
        0x01, // encoding: little endian
        0x01, // message_type: sync
        0x00, // compressed: no
        0x00, // reserved
        0x04, 0x00, 0x00, 0x00, // length: 4 bytes (less than 8-byte header!)
    ]);

    let result = codec.decode(&mut buffer);
    assert!(result.is_err(), "should reject message smaller than header");
}

#[test]
fn test_accept_reasonable_message_size() {
    let mut codec = KdbCodec::builder()
        .is_local(false)
        .compression_mode(CompressionMode::Never)
        .validation_mode(ValidationMode::Strict)
        .max_message_size(1024)
        .build();
    let mut buffer = BytesMut::new();

    // Create header with reasonable size (1KB) to avoid large allocations in tests
    let message_size = 1024;
    buffer.extend_from_slice(&[
        0x01, // encoding: little endian
        0x01, // message_type: sync
        0x00, // compressed: no
        0x00, // reserved
    ]);
    buffer.extend_from_slice(&(message_size as u32).to_le_bytes());

    let result = codec.decode(&mut buffer);

    // Should return Ok(None) because we don't have the full message yet
    assert!(result.is_ok());
    assert!(result.unwrap().is_none());
}

#[test]
fn test_maximum_message_size_boundary() {
    let mut codec = KdbCodec::builder()
        .is_local(false)
        .compression_mode(CompressionMode::Never)
        .validation_mode(ValidationMode::Strict)
        .max_message_size(1024)
        .build();
    let mut buffer = BytesMut::new();

    // Test at exactly the configured maximum (1KB)
    let max_size = 1024;
    buffer.extend_from_slice(&[
        0x01, // encoding: little endian
        0x01, // message_type: sync
        0x00, // compressed: no
        0x00, // reserved
    ]);
    buffer.extend_from_slice(&(max_size as u32).to_le_bytes());

    let result = codec.decode(&mut buffer);
    assert!(result.is_ok(), "should accept at boundary");
}

#[test]
fn test_zero_message_size() {
    let mut codec = KdbCodec::builder()
        .is_local(false)
        .compression_mode(CompressionMode::Never)
        .validation_mode(ValidationMode::Strict)
        .max_message_size(1024)
        .build();
    let mut buffer = BytesMut::new();

    // Create header with zero size
    buffer.extend_from_slice(&[
        0x01, // encoding: little endian
        0x01, // message_type: sync
        0x00, // compressed: no
        0x00, // reserved
        0x00, 0x00, 0x00, 0x00, // length: 0 bytes
    ]);

    let result = codec.decode(&mut buffer);
    assert!(result.is_err(), "should reject zero-length message");
}