synta 0.1.11

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
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80

# 1. `decode_integer.rs` — Decode ASN.1 INTEGER values

[← Example index](index.md) · [decode_integer.rs on Codeberg](https://codeberg.org/abbra/synta/src/branch/main/examples/decode_integer.rs)

Decode DER-encoded INTEGER values using `Decoder` and the `Integer` type.
Covers positive and negative integers, big-integer handling, and the
`Encoding` trait.

## Source

```rust,ignore
//! 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::{Decoder, Encoding, Integer};

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 mut encoder = synta::Encoder::new(Encoding::Der);
    let integer = Integer::from(value);
    encoder.encode(&integer).unwrap();
    let encoded = encoder.finish().unwrap();

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

    // Verify by decoding
    let mut decoder = Decoder::new(&encoded, Encoding::Der);
    let decoded: Integer = decoder.decode().unwrap();
    println!("Decoded back: {}", decoded.as_i64().unwrap());
}

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

    let mut decoder = Decoder::new(data, Encoding::Der);
    match decoder.decode::<Integer>() {
        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!();
}
```