synta 0.2.2

ASN.1 parser, decoder, and encoder library with DER/BER support and C FFI
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

//! Example: Decoding ASN.1 integers
//!
//! This example demonstrates how to decode ASN.1 INTEGER values from DER-encoded data.
//!
//! Run with: cargo run --example decode_integer

use synta::{FromDer, Integer, ToDer};

fn main() {
    println!("=== ASN.1 Integer Decoding Example ===\n");

    // Example 1: Small positive integer (42)
    let data1 = vec![0x02, 0x01, 0x2A]; // INTEGER 42
    decode_and_display("Small positive (42)", &data1);

    // Example 2: Larger positive integer (1000)
    let data2 = vec![0x02, 0x02, 0x03, 0xE8]; // INTEGER 1000
    decode_and_display("Larger positive (1000)", &data2);

    // Example 3: Negative integer (-1)
    let data3 = vec![0x02, 0x01, 0xFF]; // INTEGER -1
    decode_and_display("Negative (-1)", &data3);

    // Example 4: Large integer (i64::MAX)
    let data4 = vec![0x02, 0x08, 0x7F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF];
    decode_and_display("Large (i64::MAX)", &data4);

    // Example 5: Zero
    let data5 = vec![0x02, 0x01, 0x00]; // INTEGER 0
    decode_and_display("Zero", &data5);

    println!("\n=== Encoding Example ===\n");

    // Encode an integer
    let value = 12345;
    println!("Encoding integer: {}", value);

    let integer = Integer::from(value);
    let encoded = integer.to_der().unwrap();

    println!("Encoded bytes: {:02X?}", encoded);
    println!("Length: {} bytes", encoded.len());

    // Verify by decoding
    let decoded = Integer::from_der(&encoded).unwrap();
    println!("Decoded back: {}", decoded.as_i64().unwrap());
}

fn decode_and_display(label: &str, data: &[u8]) {
    println!("{}:", label);
    println!("  Raw bytes: {:02X?}", data);

    match Integer::from_der(data) {
        Ok(integer) => {
            match integer.as_i64() {
                Ok(value) => println!("  Decoded value: {}", value),
                Err(_) => println!("  Value too large for i64"),
            }
            println!("  Raw bytes: {:02X?}", integer.as_bytes());
        }
        Err(e) => println!("  Error: {:?}", e),
    }
    println!();
}