mtls
only.Expand description
The SEQUENCE
object is an ordered list of heteregeneous types.
Sequences can usually be of 2 types:
- a list of different objects (
SEQUENCE
, usually parsed as astruct
) - a list of similar objects (
SEQUENCE OF
, usually parsed as aVec<T>
)
The current object covers the former. For the latter, see the SequenceOf
documentation.
The Sequence
object contains the (unparsed) encoded representation of its content. It provides
methods to parse and iterate contained objects, or convert the sequence to other types.
Building a Sequence
To build a DER sequence:
- if the sequence is composed of objects of the same type, the
Sequence::from_iter_to_der
method can be used - otherwise, the
ToDer
trait can be used to create content incrementally
use asn1_rs::{Integer, Sequence, SerializeResult, ToDer};
fn build_seq<'a>() -> SerializeResult<Sequence<'a>> {
let mut v = Vec::new();
// add an Integer object (construct type):
let i = Integer::from_u32(4);
let _ = i.write_der(&mut v)?;
// some primitive objects also implement `ToDer`. A string will be mapped as `Utf8String`:
let _ = "abcd".write_der(&mut v)?;
// return the sequence built from the DER content
Ok(Sequence::new(v.into()))
}
let seq = build_seq().unwrap();
Examples
use asn1_rs::Sequence;
// build sequence
let it = [2, 3, 4].iter();
let seq = Sequence::from_iter_to_der(it).unwrap();
// `seq` now contains the serialized DER representation of the array
// iterate objects
let mut sum = 0;
for item in seq.der_iter::<u32>() {
// item has type `Result<u32>`, since parsing the serialized bytes could fail
sum += item.expect("parsing list item failed");
}
assert_eq!(sum, 9);
Note: the above example encodes a SEQUENCE OF INTEGER
object, the SequenceOf
object could
be used to provide a simpler API.
Fields
content: Cow<'a, [u8]>
Serialized DER representation of the sequence content
Implementations
impl<'a> Sequence<'a>
impl<'a> Sequence<'a>
pub const fn new(content: Cow<'a, [u8]>) -> Sequence<'a>
pub const fn new(content: Cow<'a, [u8]>) -> Sequence<'a>
Build a sequence, given the provided content
pub fn into_content(self) -> Cow<'a, [u8]>
pub fn into_content(self) -> Cow<'a, [u8]>
Consume the sequence and return the content
pub fn and_then<U, F>(self, op: F) -> Result<(&'a [u8], U), Err<Error>> where
F: FnOnce(Cow<'a, [u8]>) -> Result<(&'a [u8], U), Err<Error>>,
pub fn and_then<U, F>(self, op: F) -> Result<(&'a [u8], U), Err<Error>> where
F: FnOnce(Cow<'a, [u8]>) -> Result<(&'a [u8], U), Err<Error>>,
Apply the parsing function to the sequence content, consuming the sequence
Note: this function expects the caller to take ownership of content. In some cases, handling the lifetime of objects is not easy (when keeping only references on data). Other methods are provided (depending on the use case):
Sequence::parse
takes a reference on the sequence data, but does not consume it,Sequence::from_der_and_then
does the parsing of the sequence and applying the function in one step, ensuring there are only references (and dropping the temporary sequence).
pub fn from_ber_and_then<U, F>(
bytes: &'a [u8],
op: F
) -> Result<(&'a [u8], U), Err<Error>> where
F: FnOnce(&'a [u8]) -> Result<(&'a [u8], U), Err<Error>>,
pub fn from_ber_and_then<U, F>(
bytes: &'a [u8],
op: F
) -> Result<(&'a [u8], U), Err<Error>> where
F: FnOnce(&'a [u8]) -> Result<(&'a [u8], U), Err<Error>>,
Same as Sequence::from_der_and_then
, but using BER encoding (no constraints).
pub fn from_der_and_then<U, F>(
bytes: &'a [u8],
op: F
) -> Result<(&'a [u8], U), Err<Error>> where
F: FnOnce(&'a [u8]) -> Result<(&'a [u8], U), Err<Error>>,
pub fn from_der_and_then<U, F>(
bytes: &'a [u8],
op: F
) -> Result<(&'a [u8], U), Err<Error>> where
F: FnOnce(&'a [u8]) -> Result<(&'a [u8], U), Err<Error>>,
Parse a DER sequence and apply the provided parsing function to content
After parsing, the sequence object and header are discarded.
use asn1_rs::{FromDer, ParseResult, Sequence};
// Parse a SEQUENCE {
// a INTEGER (0..255),
// b INTEGER (0..4294967296)
// }
// and return only `(a,b)
fn parser(i: &[u8]) -> ParseResult<(u8, u32)> {
Sequence::from_der_and_then(i, |i| {
let (i, a) = u8::from_der(i)?;
let (i, b) = u32::from_der(i)?;
Ok((i, (a, b)))
}
)
}
pub fn parse<F, T>(&'a self, f: F) -> Result<(&'a [u8], T), Err<Error>> where
F: FnMut(&'a [u8]) -> Result<(&'a [u8], T), Err<Error>>,
pub fn parse<F, T>(&'a self, f: F) -> Result<(&'a [u8], T), Err<Error>> where
F: FnMut(&'a [u8]) -> Result<(&'a [u8], T), Err<Error>>,
Apply the parsing function to the sequence content (non-consuming version)
pub fn parse_into<F, T>(self, f: F) -> Result<(&'a [u8], T), Err<Error>> where
F: FnMut(&'a [u8]) -> Result<(&'a [u8], T), Err<Error>>,
pub fn parse_into<F, T>(self, f: F) -> Result<(&'a [u8], T), Err<Error>> where
F: FnMut(&'a [u8]) -> Result<(&'a [u8], T), Err<Error>>,
Apply the parsing function to the sequence content (consuming version)
Note: to parse and apply a parsing function in one step, use the
Sequence::from_der_and_then
method.
Limitations
This function fails if the sequence contains Owned
data, because the parsing function
takes a reference on data (which is dropped).
pub fn ber_iter<T>(&'a self) -> SequenceIterator<'a, T, BerParser> where
T: FromBer<'a>,
pub fn ber_iter<T>(&'a self) -> SequenceIterator<'a, T, BerParser> where
T: FromBer<'a>,
Return an iterator over the sequence content, attempting to decode objects as BER
This method can be used when all objects from the sequence have the same type.
pub fn der_iter<T>(&'a self) -> SequenceIterator<'a, T, DerParser> where
T: FromDer<'a>,
pub fn der_iter<T>(&'a self) -> SequenceIterator<'a, T, DerParser> where
T: FromDer<'a>,
Return an iterator over the sequence content, attempting to decode objects as DER
This method can be used when all objects from the sequence have the same type.
pub fn ber_sequence_of<T>(&'a self) -> Result<Vec<T, Global>, Error> where
T: FromBer<'a>,
pub fn ber_sequence_of<T>(&'a self) -> Result<Vec<T, Global>, Error> where
T: FromBer<'a>,
Attempt to parse the sequence as a SEQUENCE OF
items (BER), and return the parsed items as a Vec
.
pub fn der_sequence_of<T>(&'a self) -> Result<Vec<T, Global>, Error> where
T: FromDer<'a>,
pub fn der_sequence_of<T>(&'a self) -> Result<Vec<T, Global>, Error> where
T: FromDer<'a>,
Attempt to parse the sequence as a SEQUENCE OF
items (DER), and return the parsed items as a Vec
.
pub fn into_ber_sequence_of<T, U>(self) -> Result<Vec<T, Global>, Error> where
T: for<'b> FromBer<'b> + ToStatic<Owned = T>,
pub fn into_ber_sequence_of<T, U>(self) -> Result<Vec<T, Global>, Error> where
T: for<'b> FromBer<'b> + ToStatic<Owned = T>,
Attempt to parse the sequence as a SEQUENCE OF
items (BER) (consuming input),
and return the parsed items as a Vec
.
Note: if Self
is an Owned
object, the data will be duplicated (causing allocations) into separate objects.
pub fn into_der_sequence_of<T, U>(self) -> Result<Vec<T, Global>, Error> where
T: for<'b> FromDer<'b> + ToStatic<Owned = T>,
pub fn into_der_sequence_of<T, U>(self) -> Result<Vec<T, Global>, Error> where
T: for<'b> FromDer<'b> + ToStatic<Owned = T>,
Attempt to parse the sequence as a SEQUENCE OF
items (DER) (consuming input),
and return the parsed items as a Vec
.
Note: if Self
is an Owned
object, the data will be duplicated (causing allocations) into separate objects.
impl<'a> Sequence<'a>
impl<'a> Sequence<'a>
pub fn from_iter_to_der<T, IT>(it: IT) -> Result<Sequence<'a>, SerializeError> where
IT: Iterator<Item = T>,
T: ToDer + Tagged,
pub fn from_iter_to_der<T, IT>(it: IT) -> Result<Sequence<'a>, SerializeError> where
IT: Iterator<Item = T>,
T: ToDer + Tagged,
Attempt to create a Sequence
from an iterator over serializable objects (to DER)
Examples
use asn1_rs::Sequence;
// build sequence
let it = [2, 3, 4].iter();
let seq = Sequence::from_iter_to_der(it).unwrap();
Trait Implementations
impl<'a> CheckDerConstraints for Sequence<'a>
impl<'a> CheckDerConstraints for Sequence<'a>
fn check_constraints(_any: &Any<'_>) -> Result<(), Error>
impl<'_> ToDer for Sequence<'_>
impl<'_> ToDer for Sequence<'_>
fn to_der_len(&self) -> Result<usize, Error>
fn to_der_len(&self) -> Result<usize, Error>
Get the length of the object, when encoded Read more
fn write_der_header(
&self,
writer: &mut dyn Write
) -> Result<usize, SerializeError>
fn write_der_header(
&self,
writer: &mut dyn Write
) -> Result<usize, SerializeError>
Attempt to write the DER header to this writer.
fn write_der_content(
&self,
writer: &mut dyn Write
) -> Result<usize, SerializeError>
fn write_der_content(
&self,
writer: &mut dyn Write
) -> Result<usize, SerializeError>
Attempt to write the DER content (all except header) to this writer.
fn to_der_vec(&self) -> Result<Vec<u8, Global>, SerializeError>
fn to_der_vec(&self) -> Result<Vec<u8, Global>, SerializeError>
Write the DER encoded representation to a newly allocated Vec<u8>
.
fn to_der_vec_raw(&self) -> Result<Vec<u8, Global>, SerializeError>
fn to_der_vec_raw(&self) -> Result<Vec<u8, Global>, SerializeError>
Similar to using to_vec
, but uses provided values without changes.
This can generate an invalid encoding for a DER object. Read more
fn write_der(&self, writer: &mut dyn Write) -> Result<usize, SerializeError>
fn write_der(&self, writer: &mut dyn Write) -> Result<usize, SerializeError>
Attempt to write the DER encoded representation (header and content) into this writer. Read more
fn write_der_raw(&self, writer: &mut dyn Write) -> Result<usize, SerializeError>
fn write_der_raw(&self, writer: &mut dyn Write) -> Result<usize, SerializeError>
Similar to using to_der
, but uses provided values without changes.
This can generate an invalid encoding for a DER object. Read more
impl<'a> Eq for Sequence<'a>
impl<'a> StructuralEq for Sequence<'a>
impl<'a> StructuralPartialEq for Sequence<'a>
Auto Trait Implementations
impl<'a> RefUnwindSafe for Sequence<'a>
impl<'a> Send for Sequence<'a>
impl<'a> Sync for Sequence<'a>
impl<'a> Unpin for Sequence<'a>
impl<'a> UnwindSafe for Sequence<'a>
Blanket Implementations
impl<'a, T> AsTaggedExplicit<'a> for T where
T: 'a,
impl<'a, T> AsTaggedExplicit<'a> for T where
T: 'a,
fn explicit(self, class: Class, tag: u32) -> TaggedParser<'a, Explicit, Self>
impl<'a, T> AsTaggedImplicit<'a> for T where
T: 'a,
impl<'a, T> AsTaggedImplicit<'a> for T where
T: 'a,
sourceimpl<T> BorrowMut<T> for T where
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
const: unstable · sourcefn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
impl<T> Choice for T where
T: Tagged,
impl<T> Choice for T where
T: Tagged,
fn can_decode(tag: Tag) -> bool
fn can_decode(tag: Tag) -> bool
Is the provided Tag
decodable as a variant of this CHOICE
?
sourceimpl<Q, K> Equivalent<K> for Q where
Q: Eq + ?Sized,
K: Borrow<Q> + ?Sized,
impl<Q, K> Equivalent<K> for Q where
Q: Eq + ?Sized,
K: Borrow<Q> + ?Sized,
sourcefn equivalent(&self, key: &K) -> bool
fn equivalent(&self, key: &K) -> bool
Compare self to key
and return true
if they are equal.
impl<'a, T> FromDer<'a> for T where
T: TryFrom<Any<'a>, Error = Error> + CheckDerConstraints,
impl<'a, T> FromDer<'a> for T where
T: TryFrom<Any<'a>, Error = Error> + CheckDerConstraints,
sourceimpl<T> Instrument for T
impl<T> Instrument for T
sourcefn instrument(self, span: Span) -> Instrumented<Self>
fn instrument(self, span: Span) -> Instrumented<Self>
sourcefn in_current_span(self) -> Instrumented<Self>
fn in_current_span(self) -> Instrumented<Self>
sourceimpl<T> IntoCollection<T> for T
impl<T> IntoCollection<T> for T
sourcefn into_collection<A>(self) -> SmallVec<A> where
A: Array<Item = T>,
fn into_collection<A>(self) -> SmallVec<A> where
A: Array<Item = T>,
Converts self
into a collection.
fn mapped<U, F, A>(self, f: F) -> SmallVec<A> where
F: FnMut(T) -> U,
A: Array<Item = U>,
sourceimpl<T> ToOwned for T where
T: Clone,
impl<T> ToOwned for T where
T: Clone,
type Owned = T
type Owned = T
The resulting type after obtaining ownership.
sourcefn clone_into(&self, target: &mut T)
fn clone_into(&self, target: &mut T)
toowned_clone_into
)Uses borrowed data to replace owned data, usually by cloning. Read more
impl<V, T> VZip<V> for T where
V: MultiLane<T>,
impl<V, T> VZip<V> for T where
V: MultiLane<T>,
fn vzip(self) -> V
sourceimpl<T> WithSubscriber for T
impl<T> WithSubscriber for T
sourcefn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self> where
S: Into<Dispatch>,
fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self> where
S: Into<Dispatch>,
Attaches the provided Subscriber
to this type, returning a
WithDispatch
wrapper. Read more
sourcefn with_current_subscriber(self) -> WithDispatch<Self>
fn with_current_subscriber(self) -> WithDispatch<Self>
Attaches the current default Subscriber
to this type, returning a
WithDispatch
wrapper. Read more