tls_codec/
tls_vec.rs

1//! A vector with a length field for TLS serialisation.
2//! Use this for any vector that is serialised.
3
4// TODO: #2 share code between the different implementations. There's too much
5//       duplicate code in here.
6
7use alloc::vec::Vec;
8use core::ops::Drop;
9
10#[cfg(feature = "serde")]
11use serde::ser::SerializeStruct;
12#[cfg(feature = "std")]
13use std::io::{Read, Write};
14use zeroize::Zeroize;
15
16use crate::{Deserialize, DeserializeBytes, Error, Serialize, SerializeBytes, Size, U24};
17
18macro_rules! impl_size {
19    ($self:ident, $size:ty, $name:ident, $len_len:literal) => {
20        /// The serialized len
21        #[inline(always)]
22        fn tls_serialized_length(&$self) -> usize {
23            $self.as_slice()
24                .iter()
25                .fold($len_len, |acc, e| acc + e.tls_serialized_len())
26        }
27    }
28}
29
30macro_rules! impl_byte_size {
31    ($self:ident, $size:ty, $name:ident, $len_len:literal) => {
32        /// The serialized len
33        #[inline(always)]
34        fn tls_serialized_byte_length(&$self) -> usize {
35            $self.as_slice().len() + $len_len
36        }
37    }
38}
39
40macro_rules! impl_byte_deserialize {
41    ($self:ident, $size:ty, $name:ident, $len_len:literal) => {
42        #[cfg(feature = "std")]
43        #[inline(always)]
44        fn deserialize_bytes<R: Read>(bytes: &mut R) -> Result<Self, Error> {
45            let len = <$size>::tls_deserialize(bytes)?.try_into().unwrap();
46            // When fuzzing we limit the maximum size to allocate.
47            // XXX: We should think about a configurable limit for the allocation
48            //      here.
49            if cfg!(fuzzing) && len > u16::MAX as usize {
50                return Err(Error::DecodingError(format!(
51                    "Trying to allocate {} bytes. Only {} allowed.",
52                    len,
53                    u16::MAX
54                )));
55            }
56            let mut result = Self {
57                vec: vec![0u8; len],
58            };
59            bytes.read_exact(result.vec.as_mut_slice())?;
60            Ok(result)
61        }
62
63        #[inline(always)]
64        fn deserialize_bytes_bytes(bytes: &[u8]) -> Result<(Self, &[u8]), Error> {
65            let (type_len, remainder) = <$size>::tls_deserialize_bytes(bytes)?;
66            let len = type_len.try_into().unwrap();
67            // When fuzzing we limit the maximum size to allocate.
68            // XXX: We should think about a configurable limit for the allocation
69            //      here.
70            if cfg!(fuzzing) && len > u16::MAX as usize {
71                return Err(Error::DecodingError(alloc::format!(
72                    "Trying to allocate {} bytes. Only {} allowed.",
73                    len,
74                    u16::MAX
75                )));
76            }
77            let vec = bytes
78                .get($len_len..len + $len_len)
79                .ok_or(Error::EndOfStream)?;
80            let result = Self { vec: vec.to_vec() };
81            Ok((result, &remainder.get(len..).ok_or(Error::EndOfStream)?))
82        }
83    };
84}
85
86macro_rules! impl_deserialize {
87    ($self:ident, $size:ty, $name:ident, $len_len:literal) => {
88        #[cfg(feature = "std")]
89        #[inline(always)]
90        fn deserialize<R: Read>(bytes: &mut R) -> Result<Self, Error> {
91            let mut result = Self { vec: Vec::new() };
92            let len = <$size>::tls_deserialize(bytes)?;
93            let mut read = len.tls_serialized_len();
94            let len_len = read;
95            while (read - len_len) < len.try_into().unwrap() {
96                let element = T::tls_deserialize(bytes)?;
97                read += element.tls_serialized_len();
98                result.push(element);
99            }
100            Ok(result)
101        }
102    };
103}
104
105macro_rules! impl_deserialize_bytes {
106    ($self:ident, $size:ty, $name:ident, $len_len:literal) => {
107        #[inline(always)]
108        fn deserialize_bytes(bytes: &[u8]) -> Result<(Self, &[u8]), Error> {
109            let mut result = Self { vec: Vec::new() };
110            let (len, mut remainder) = <$size>::tls_deserialize_bytes(bytes)?;
111            let mut read = len.tls_serialized_len();
112            let len_len = read;
113            while (read - len_len) < len.try_into().unwrap() {
114                let (element, next_remainder) = T::tls_deserialize_bytes(remainder)?;
115                remainder = next_remainder;
116                read += element.tls_serialized_len();
117                result.push(element);
118            }
119            Ok((result, remainder))
120        }
121    };
122}
123
124macro_rules! impl_serialize {
125    ($self:ident, $size:ty, $name:ident, $len_len:literal) => {
126        #[cfg(feature = "std")]
127        #[inline(always)]
128        fn serialize<W: Write>(&$self, writer: &mut W) -> Result<usize, Error> {
129            // Get the byte length of the content, make sure it's not too
130            // large and write it out.
131            let (tls_serialized_len, byte_length) = $self.get_content_lengths()?;
132
133            let mut written = <$size as Serialize>::tls_serialize(&<$size>::try_from(byte_length).unwrap(), writer)?;
134
135            // Now serialize the elements
136            for e in $self.as_slice().iter() {
137                written += e.tls_serialize(writer)?;
138            }
139
140            $self.assert_written_bytes(tls_serialized_len, written)?;
141            Ok(written)
142        }
143    };
144}
145
146macro_rules! impl_byte_serialize {
147    ($self:ident, $size:ty, $name:ident, $len_len:literal) => {
148        #[cfg(feature = "std")]
149        #[inline(always)]
150        fn serialize_bytes<W: Write>(&$self, writer: &mut W) -> Result<usize, Error> {
151            // Get the byte length of the content, make sure it's not too
152            // large and write it out.
153            let (tls_serialized_len, byte_length) = $self.get_content_lengths()?;
154
155            let mut written = <$size as Serialize>::tls_serialize(&<$size>::try_from(byte_length).unwrap(), writer)?;
156
157            // Now serialize the elements
158            written += writer.write($self.as_slice())?;
159
160            $self.assert_written_bytes(tls_serialized_len, written)?;
161            Ok(written)
162        }
163    };
164}
165
166macro_rules! impl_serialize_common {
167    ($self:ident, $size:ty, $name:ident, $len_len:literal $(,#[$std_enabled:meta])?) => {
168        $(#[$std_enabled])?
169        fn get_content_lengths(&$self) -> Result<(usize, usize), Error> {
170            let tls_serialized_len = $self.tls_serialized_len();
171            let byte_length = tls_serialized_len - $len_len;
172
173            let max_len = <$size>::MAX.try_into().unwrap();
174            debug_assert!(
175                byte_length <= max_len,
176                "Vector length can't be encoded in the vector length a {} >= {}",
177                byte_length,
178                max_len
179            );
180            if byte_length > max_len {
181                return Err(Error::InvalidVectorLength);
182            }
183            Ok((tls_serialized_len, byte_length))
184        }
185
186        $(#[$std_enabled])?
187        fn assert_written_bytes(&$self, tls_serialized_len: usize, written: usize) -> Result<(), Error> {
188            debug_assert_eq!(
189                written, tls_serialized_len,
190                "{} bytes should have been serialized but {} were written",
191                tls_serialized_len, written
192            );
193            if written != tls_serialized_len {
194                return Err(Error::EncodingError(format!(
195                    "{} bytes should have been serialized but {} were written",
196                    tls_serialized_len, written
197                )));
198            }
199            Ok(())
200        }
201    };
202}
203
204macro_rules! impl_serialize_bytes_bytes {
205    ($self:ident, $size:ty, $name:ident, $len_len:literal) => {
206        fn serialize_bytes_bytes(&$self) -> Result<Vec<u8>, Error> {
207            let (tls_serialized_len, byte_length) = $self.get_content_lengths()?;
208
209            let mut vec = Vec::<u8>::with_capacity(tls_serialized_len);
210            let length_vec = <$size as SerializeBytes>::tls_serialize(&byte_length.try_into().unwrap())?;
211            let mut written = length_vec.len();
212            vec.extend_from_slice(&length_vec);
213
214            let bytes = $self.as_slice();
215            vec.extend_from_slice(bytes);
216            written += bytes.len();
217
218            $self.assert_written_bytes(tls_serialized_len, written)?;
219
220            Ok(vec)
221        }
222    };
223}
224
225macro_rules! impl_tls_vec_codec_generic {
226    ($size:ty, $name:ident, $len_len: literal $(, $bounds:ident)*) => {
227        impl<T: $($bounds + )* Serialize> Serialize for $name<T> {
228            #[cfg(feature = "std")]
229            fn tls_serialize<W: Write>(&self, writer: &mut W) -> Result<usize, Error> {
230                self.serialize(writer)
231            }
232        }
233
234        impl<T: $($bounds + )* Size> Size for $name<T> {
235            #[inline]
236            fn tls_serialized_len(&self) -> usize {
237                self.tls_serialized_length()
238            }
239        }
240
241        impl<T: $($bounds + )* Serialize> Serialize for &$name<T> {
242            #[cfg(feature = "std")]
243            fn tls_serialize<W: Write>(&self, writer: &mut W) -> Result<usize, Error> {
244                self.serialize(writer)
245            }
246        }
247
248        impl<T: $($bounds + )* Size> Size for &$name<T> {
249            #[inline]
250            fn tls_serialized_len(&self) -> usize {
251                self.tls_serialized_length()
252            }
253        }
254
255        impl<T: $($bounds + )* Deserialize> Deserialize for $name<T> {
256            #[cfg(feature = "std")]
257            fn tls_deserialize<R: Read>(bytes: &mut R) -> Result<Self, Error> {
258                Self::deserialize(bytes)
259            }
260        }
261
262        impl<T: $($bounds + )* DeserializeBytes> DeserializeBytes for $name<T> {
263            fn tls_deserialize_bytes(bytes: &[u8]) -> Result<(Self, &[u8]), Error> {
264                Self::deserialize_bytes(bytes)
265            }
266        }
267    };
268}
269
270macro_rules! impl_tls_vec_codec_bytes {
271    ($size:ty, $name:ident, $len_len: literal) => {
272        impl Serialize for $name {
273            #[cfg(feature = "std")]
274            fn tls_serialize<W: Write>(&self, writer: &mut W) -> Result<usize, Error> {
275                self.serialize_bytes(writer)
276            }
277        }
278
279        impl Size for $name {
280            #[inline]
281            fn tls_serialized_len(&self) -> usize {
282                self.tls_serialized_byte_length()
283            }
284        }
285
286        impl Serialize for &$name {
287            #[cfg(feature = "std")]
288            fn tls_serialize<W: Write>(&self, writer: &mut W) -> Result<usize, Error> {
289                self.serialize_bytes(writer)
290            }
291        }
292
293        impl Size for &$name {
294            #[inline]
295            fn tls_serialized_len(&self) -> usize {
296                self.tls_serialized_byte_length()
297            }
298        }
299
300        impl Deserialize for $name {
301            #[cfg(feature = "std")]
302            fn tls_deserialize<R: Read>(bytes: &mut R) -> Result<Self, Error> {
303                Self::deserialize_bytes(bytes)
304            }
305        }
306
307        impl DeserializeBytes for $name {
308            fn tls_deserialize_bytes(bytes: &[u8]) -> Result<(Self, &[u8]), Error> {
309                Self::deserialize_bytes_bytes(bytes)
310            }
311        }
312
313        impl SerializeBytes for $name {
314            fn tls_serialize(&self) -> Result<Vec<u8>, Error> {
315                self.serialize_bytes_bytes()
316            }
317        }
318    };
319}
320
321macro_rules! impl_vec_members {
322    ($element_type:ident, $len_len:literal) => {
323        /// Create a new `TlsVec` from a Rust Vec.
324        #[inline]
325        pub fn new(vec: Vec<$element_type>) -> Self {
326            Self { vec }
327        }
328
329        /// Create a new `TlsVec` from a slice.
330        #[inline]
331        pub fn from_slice(slice: &[$element_type]) -> Self
332        where
333            $element_type: Clone,
334        {
335            Self {
336                vec: slice.to_vec(),
337            }
338        }
339
340        /// Get the length of the vector.
341        #[inline]
342        pub fn len(&self) -> usize {
343            self.vec.len()
344        }
345
346        /// Get a slice to the raw vector.
347        #[inline]
348        pub fn as_slice(&self) -> &[$element_type] {
349            &self.vec
350        }
351
352        /// Check if the vector is empty.
353        #[inline]
354        pub fn is_empty(&self) -> bool {
355            self.vec.is_empty()
356        }
357
358        /// Get the underlying vector and consume this.
359        #[inline]
360        pub fn into_vec(mut self) -> Vec<$element_type> {
361            core::mem::take(&mut self.vec)
362        }
363
364        /// Add an element to this.
365        #[inline]
366        pub fn push(&mut self, value: $element_type) {
367            self.vec.push(value);
368        }
369
370        /// Remove the last element.
371        #[inline]
372        pub fn pop(&mut self) -> Option<$element_type> {
373            self.vec.pop()
374        }
375
376        /// Remove the element at `index`.
377        #[inline]
378        pub fn remove(&mut self, index: usize) -> $element_type {
379            self.vec.remove(index)
380        }
381
382        /// Returns a reference to an element or subslice depending on the type of index.
383        /// XXX: implement SliceIndex instead
384        #[inline]
385        pub fn get(&self, index: usize) -> Option<&$element_type> {
386            self.vec.get(index)
387        }
388
389        /// Returns an iterator over the slice.
390        #[inline]
391        pub fn iter(&self) -> core::slice::Iter<'_, $element_type> {
392            self.vec.iter()
393        }
394
395        /// Retains only the elements specified by the predicate.
396        #[inline]
397        pub fn retain<F>(&mut self, f: F)
398        where
399            F: FnMut(&$element_type) -> bool,
400        {
401            self.vec.retain(f)
402        }
403
404        /// Get the number of bytes used for the length encoding.
405        #[inline(always)]
406        pub fn len_len() -> usize {
407            $len_len
408        }
409    };
410}
411
412macro_rules! impl_tls_vec_generic {
413    ($size:ty, $name:ident, $len_len: literal $(, $bounds:ident)*) => {
414        #[derive(Eq, Debug)]
415        pub struct $name<T: $($bounds + )*> {
416            vec: Vec<T>,
417        }
418
419        impl<T: $($bounds + )* Clone> Clone for $name<T> {
420            fn clone(&self) -> Self {
421                Self::new(self.vec.clone())
422            }
423        }
424
425        impl<T: $($bounds + )*> $name<T> {
426            impl_vec_members!(T, $len_len);
427        }
428
429        impl<T: $($bounds + )* core::hash::Hash> core::hash::Hash for $name<T> {
430            #[inline]
431            fn hash<H: core::hash::Hasher>(&self, state: &mut H) {
432                self.vec.hash(state)
433            }
434        }
435
436        impl<T: $($bounds + )*> core::ops::Index<usize> for $name<T> {
437            type Output = T;
438
439            #[inline]
440            fn index(&self, i: usize) -> &T {
441                self.vec.index(i)
442            }
443        }
444
445        impl<T: $($bounds + )* core::cmp::PartialEq> core::cmp::PartialEq for $name<T> {
446            fn eq(&self, other: &Self) -> bool {
447                self.vec.eq(&other.vec)
448            }
449        }
450
451        impl<T: $($bounds + )*> core::ops::IndexMut<usize> for $name<T> {
452            #[inline]
453            fn index_mut(&mut self, i: usize) -> &mut Self::Output {
454                self.vec.index_mut(i)
455            }
456        }
457
458        impl<T: $($bounds + )*> core::borrow::Borrow<[T]> for $name<T> {
459            #[inline]
460            fn borrow(&self) -> &[T] {
461                &self.vec
462            }
463        }
464
465        impl<T: $($bounds + )*> core::iter::FromIterator<T> for $name<T> {
466            #[inline]
467            fn from_iter<I>(iter: I) -> Self
468            where
469                I: IntoIterator<Item = T>,
470            {
471                let vec = Vec::<T>::from_iter(iter);
472                Self { vec }
473            }
474        }
475
476        impl<T: $($bounds + )*> From<Vec<T>> for $name<T> {
477            #[inline]
478            fn from(v: Vec<T>) -> Self {
479                Self::new(v)
480            }
481        }
482
483        impl<T: $($bounds + )* Clone> From<&[T]> for $name<T> {
484            #[inline]
485            fn from(v: &[T]) -> Self {
486                Self::from_slice(v)
487            }
488        }
489
490        impl<T: $($bounds + )*> From<$name<T>> for Vec<T> {
491            #[inline]
492            fn from(mut v: $name<T>) -> Self {
493                core::mem::take(&mut v.vec)
494            }
495        }
496
497        impl<T: $($bounds + )*> Default for $name<T> {
498            #[inline]
499            fn default() -> Self {
500                Self { vec: Vec::new() }
501            }
502        }
503
504        #[cfg(feature = "serde")]
505        impl<T> serde::Serialize for $name<T>
506        where
507            T: $($bounds + )* serde::Serialize,
508        {
509            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
510            where
511                S: serde::Serializer,
512            {
513                let mut state = serializer.serialize_struct(stringify!($name), 1)?;
514                state.serialize_field("vec", &self.vec)?;
515                state.end()
516            }
517        }
518
519        #[cfg(feature = "serde")]
520        impl<'de, T> serde::de::Deserialize<'de> for $name<T>
521        where
522            T: $($bounds + )* serde::de::Deserialize<'de>,
523        {
524            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
525            where
526                D: serde::de::Deserializer<'de>,
527            {
528                enum Field {
529                    Vec,
530                }
531
532                impl<'de> serde::de::Deserialize<'de> for Field {
533                    fn deserialize<D>(deserializer: D) -> Result<Field, D::Error>
534                    where
535                        D: serde::de::Deserializer<'de>,
536                    {
537                        struct FieldVisitor;
538
539                        impl<'de> serde::de::Visitor<'de> for FieldVisitor {
540                            type Value = Field;
541
542                            fn expecting(
543                                &self,
544                                formatter: &mut core::fmt::Formatter<'_>,
545                            ) -> core::fmt::Result {
546                                formatter.write_str("`vec`")
547                            }
548
549                            fn visit_str<E>(self, value: &str) -> Result<Field, E>
550                            where
551                                E: serde::de::Error,
552                            {
553                                match value {
554                                    "vec" => Ok(Field::Vec),
555                                    _ => Err(serde::de::Error::unknown_field(value, &["vec"])),
556                                }
557                            }
558                        }
559
560                        deserializer.deserialize_identifier(FieldVisitor)
561                    }
562                }
563
564                struct TlsVecVisitor<T> {
565                    data: core::marker::PhantomData<T>,
566                }
567
568                impl<'de, T> serde::de::Visitor<'de> for TlsVecVisitor<T>
569                where
570                    T: $($bounds + )* serde::de::Deserialize<'de>,
571                {
572                    type Value = $name<T>;
573                    fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
574                        formatter.write_fmt(format_args!("struct {}<T>", stringify!($name)))
575                    }
576                    fn visit_seq<V>(self, mut seq: V) -> Result<$name<T>, V::Error>
577                    where
578                        V: serde::de::SeqAccess<'de>,
579                    {
580                        let vec = seq
581                            .next_element()?
582                            .ok_or_else(|| serde::de::Error::invalid_length(0, &self))?;
583                        Ok($name::<T>::new(vec))
584                    }
585                    fn visit_map<V>(self, mut map: V) -> Result<$name<T>, V::Error>
586                    where
587                        V: serde::de::MapAccess<'de>,
588                    {
589                        let mut vec = None;
590                        while let Some(key) = map.next_key()? {
591                            match key {
592                                Field::Vec => {
593                                    if vec.is_some() {
594                                        return Err(serde::de::Error::duplicate_field("vec"));
595                                    }
596                                    vec = Some(map.next_value()?);
597                                }
598                            }
599                        }
600                        let vec = vec.ok_or_else(|| serde::de::Error::missing_field("vec"))?;
601                        Ok($name::<T>::new(vec))
602                    }
603                }
604                deserializer.deserialize_struct(
605                    stringify!($name),
606                    &["vec"],
607                    TlsVecVisitor {
608                        data: core::marker::PhantomData,
609                    },
610                )
611            }
612        }
613    };
614}
615
616macro_rules! impl_tls_vec {
617    ($name:ident, $len_len:literal) => {
618        #[derive(Eq, Clone, Debug)]
619        pub struct $name {
620            vec: Vec<u8>,
621        }
622
623        impl $name {
624            impl_vec_members!(u8, $len_len);
625        }
626
627        impl core::hash::Hash for $name {
628            #[inline]
629            fn hash<H: core::hash::Hasher>(&self, state: &mut H) {
630                self.vec.hash(state)
631            }
632        }
633
634        impl core::ops::Index<usize> for $name {
635            type Output = u8;
636
637            #[inline]
638            fn index(&self, i: usize) -> &u8 {
639                self.vec.index(i)
640            }
641        }
642
643        impl core::cmp::PartialEq for $name {
644            fn eq(&self, other: &Self) -> bool {
645                self.vec.eq(&other.vec)
646            }
647        }
648
649        impl core::ops::IndexMut<usize> for $name {
650            #[inline]
651            fn index_mut(&mut self, i: usize) -> &mut Self::Output {
652                self.vec.index_mut(i)
653            }
654        }
655
656        impl core::borrow::Borrow<[u8]> for $name {
657            #[inline]
658            fn borrow(&self) -> &[u8] {
659                &self.vec
660            }
661        }
662
663        impl core::iter::FromIterator<u8> for $name {
664            #[inline]
665            fn from_iter<I>(iter: I) -> Self
666            where
667                I: IntoIterator<Item = u8>,
668            {
669                let vec = Vec::<u8>::from_iter(iter);
670                Self { vec }
671            }
672        }
673
674        impl From<Vec<u8>> for $name {
675            #[inline]
676            fn from(v: Vec<u8>) -> Self {
677                Self::new(v)
678            }
679        }
680
681        impl From<&[u8]> for $name {
682            #[inline]
683            fn from(v: &[u8]) -> Self {
684                Self::from_slice(v)
685            }
686        }
687
688        impl From<$name> for Vec<u8> {
689            #[inline]
690            fn from(mut v: $name) -> Self {
691                core::mem::take(&mut v.vec)
692            }
693        }
694
695        impl Default for $name {
696            #[inline]
697            fn default() -> Self {
698                Self { vec: Vec::new() }
699            }
700        }
701
702        #[cfg(feature = "serde")]
703        impl serde::Serialize for $name {
704            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
705            where
706                S: serde::Serializer,
707            {
708                let mut state = serializer.serialize_struct(stringify!($name), 1)?;
709                state.serialize_field("vec", &self.vec)?;
710                state.end()
711            }
712        }
713
714        #[cfg(feature = "serde")]
715        impl<'de> serde::de::Deserialize<'de> for $name {
716            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
717            where
718                D: serde::de::Deserializer<'de>,
719            {
720                enum Field {
721                    Vec,
722                }
723
724                impl<'de> serde::de::Deserialize<'de> for Field {
725                    fn deserialize<D>(deserializer: D) -> Result<Field, D::Error>
726                    where
727                        D: serde::de::Deserializer<'de>,
728                    {
729                        struct FieldVisitor;
730
731                        impl<'de> serde::de::Visitor<'de> for FieldVisitor {
732                            type Value = Field;
733
734                            fn expecting(
735                                &self,
736                                formatter: &mut core::fmt::Formatter<'_>,
737                            ) -> core::fmt::Result {
738                                formatter.write_str("`vec`")
739                            }
740
741                            fn visit_str<E>(self, value: &str) -> Result<Field, E>
742                            where
743                                E: serde::de::Error,
744                            {
745                                match value {
746                                    "vec" => Ok(Field::Vec),
747                                    _ => Err(serde::de::Error::unknown_field(value, &["vec"])),
748                                }
749                            }
750                        }
751
752                        deserializer.deserialize_identifier(FieldVisitor)
753                    }
754                }
755
756                struct TlsVecVisitor {
757                    data: core::marker::PhantomData<u8>,
758                }
759
760                impl<'de> serde::de::Visitor<'de> for TlsVecVisitor {
761                    type Value = $name;
762                    fn expecting(
763                        &self,
764                        formatter: &mut core::fmt::Formatter<'_>,
765                    ) -> core::fmt::Result {
766                        formatter.write_fmt(format_args!("struct {}", stringify!($name)))
767                    }
768                    fn visit_seq<V>(self, mut seq: V) -> Result<$name, V::Error>
769                    where
770                        V: serde::de::SeqAccess<'de>,
771                    {
772                        let vec = seq
773                            .next_element()?
774                            .ok_or_else(|| serde::de::Error::invalid_length(0, &self))?;
775                        Ok($name::new(vec))
776                    }
777                    fn visit_map<V>(self, mut map: V) -> Result<$name, V::Error>
778                    where
779                        V: serde::de::MapAccess<'de>,
780                    {
781                        let mut vec = None;
782                        while let Some(key) = map.next_key()? {
783                            match key {
784                                Field::Vec => {
785                                    if vec.is_some() {
786                                        return Err(serde::de::Error::duplicate_field("vec"));
787                                    }
788                                    vec = Some(map.next_value()?);
789                                }
790                            }
791                        }
792                        let vec = vec.ok_or_else(|| serde::de::Error::missing_field("vec"))?;
793                        Ok($name::new(vec))
794                    }
795                }
796                deserializer.deserialize_struct(
797                    stringify!($name),
798                    &["vec"],
799                    TlsVecVisitor {
800                        data: core::marker::PhantomData,
801                    },
802                )
803            }
804        }
805    };
806}
807
808macro_rules! impl_secret_tls_vec {
809    ($size:ty, $name:ident, $len_len: literal) => {
810        impl_tls_vec_generic!($size, $name, $len_len, Zeroize);
811        impl_tls_vec_codec_generic!($size, $name, $len_len, Zeroize);
812
813        impl<T: Serialize + Zeroize> $name<T> {
814            impl_serialize_common!(self, $size, $name, $len_len, #[cfg(feature = "std")]);
815            impl_serialize!(self, $size, $name, $len_len);
816        }
817
818        impl<T: Size + Zeroize> $name<T> {
819            impl_size!(self, $size, $name, $len_len);
820        }
821
822        impl<T: Deserialize + Zeroize> $name<T> {
823            impl_deserialize!(self, $size, $name, $len_len);
824        }
825
826        impl<T: DeserializeBytes + Zeroize> $name<T> {
827            impl_deserialize_bytes!(self, $size, $name, $len_len);
828        }
829
830        impl<T: Zeroize> Zeroize for $name<T> {
831            fn zeroize(&mut self) {
832                self.vec.zeroize()
833            }
834        }
835
836        impl<T: Zeroize> Drop for $name<T> {
837            fn drop(&mut self) {
838                self.zeroize()
839            }
840        }
841    };
842}
843
844macro_rules! impl_public_tls_vec {
845    ($size:ty, $name:ident, $len_len: literal) => {
846        impl_tls_vec_generic!($size, $name, $len_len);
847
848        impl_tls_vec_codec_generic!($size, $name, $len_len);
849
850        impl<T: Serialize> $name<T> {
851            impl_serialize_common!(self, $size, $name, $len_len, #[cfg(feature = "std")]);
852            impl_serialize!(self, $size, $name, $len_len);
853        }
854
855        impl<T: Size> $name<T> {
856            impl_size!(self, $size, $name, $len_len);
857        }
858
859        impl<T: Deserialize> $name<T> {
860            impl_deserialize!(self, $size, $name, $len_len);
861        }
862
863        impl<T: DeserializeBytes> $name<T> {
864            impl_deserialize_bytes!(self, $size, $name, $len_len);
865        }
866    };
867}
868
869macro_rules! impl_tls_byte_vec {
870    ($size:ty, $name:ident, $len_len: literal) => {
871        impl_tls_vec!($name, $len_len);
872
873        impl $name {
874            // This implements serialize and size for all versions
875            impl_serialize_common!(self, $size, $name, $len_len);
876            impl_byte_serialize!(self, $size, $name, $len_len);
877            impl_serialize_bytes_bytes!(self, $size, $name, $len_len);
878            impl_byte_size!(self, $size, $name, $len_len);
879            impl_byte_deserialize!(self, $size, $name, $len_len);
880        }
881
882        impl_tls_vec_codec_bytes!($size, $name, $len_len);
883    };
884}
885
886impl_public_tls_vec!(u8, TlsVecU8, 1);
887impl_public_tls_vec!(u16, TlsVecU16, 2);
888impl_public_tls_vec!(U24, TlsVecU24, 3);
889impl_public_tls_vec!(u32, TlsVecU32, 4);
890
891impl_tls_byte_vec!(u8, TlsByteVecU8, 1);
892impl_tls_byte_vec!(u16, TlsByteVecU16, 2);
893impl_tls_byte_vec!(U24, TlsByteVecU24, 3);
894impl_tls_byte_vec!(u32, TlsByteVecU32, 4);
895
896// Secrets should be put into these Secret tls vectors as they implement zeroize.
897impl_secret_tls_vec!(u8, SecretTlsVecU8, 1);
898impl_secret_tls_vec!(u16, SecretTlsVecU16, 2);
899impl_secret_tls_vec!(U24, SecretTlsVecU24, 3);
900impl_secret_tls_vec!(u32, SecretTlsVecU32, 4);
901
902// We also implement shallow serialization for slices
903
904macro_rules! impl_tls_byte_slice {
905    ($size:ty, $name:ident, $len_len:literal) => {
906        pub struct $name<'a>(pub &'a [u8]);
907
908        impl<'a> $name<'a> {
909            /// Get the raw slice.
910            #[inline(always)]
911            pub fn as_slice(&self) -> &[u8] {
912                self.0
913            }
914        }
915
916        impl<'a> $name<'a> {
917            impl_serialize_common!(self, $size, $name, $len_len, #[cfg(feature = "std")]);
918            impl_byte_serialize!(self, $size, $name, $len_len);
919            impl_byte_size!(self, $size, $name, $len_len);
920        }
921
922        impl<'a> Serialize for &$name<'a> {
923            #[cfg(feature = "std")]
924            fn tls_serialize<W: Write>(&self, writer: &mut W) -> Result<usize, Error> {
925                self.serialize_bytes(writer)
926            }
927        }
928
929        impl<'a> Serialize for $name<'a> {
930            #[cfg(feature = "std")]
931            fn tls_serialize<W: Write>(&self, writer: &mut W) -> Result<usize, Error> {
932                self.serialize_bytes(writer)
933            }
934        }
935
936        impl<'a> Size for &$name<'a> {
937            #[inline]
938            fn tls_serialized_len(&self) -> usize {
939                self.tls_serialized_byte_length()
940            }
941        }
942
943        impl<'a> Size for $name<'a> {
944            #[inline]
945            fn tls_serialized_len(&self) -> usize {
946                self.tls_serialized_byte_length()
947            }
948        }
949    };
950}
951
952impl_tls_byte_slice!(u8, TlsByteSliceU8, 1);
953impl_tls_byte_slice!(u16, TlsByteSliceU16, 2);
954impl_tls_byte_slice!(U24, TlsByteSliceU24, 3);
955impl_tls_byte_slice!(u32, TlsByteSliceU32, 4);
956
957macro_rules! impl_tls_slice {
958    ($size:ty, $name:ident, $len_len: literal) => {
959        pub struct $name<'a, T>(pub &'a [T]);
960
961        impl<'a, T> $name<'a, T> {
962            /// Get the raw slice.
963            #[inline(always)]
964            pub fn as_slice(&self) -> &[T] {
965                self.0
966            }
967        }
968
969        impl<'a, T: Size> $name<'a, T> {
970            impl_size!(self, $size, $name, $len_len);
971        }
972
973        impl<'a, T: Serialize> $name<'a, T> {
974            impl_serialize_common!(self, $size, $name, $len_len, #[cfg(feature = "std")]);
975            impl_serialize!(self, $size, $name, $len_len);
976        }
977
978        impl<'a, T: Serialize> Serialize for &$name<'a, T> {
979            #[cfg(feature = "std")]
980            fn tls_serialize<W: Write>(&self, writer: &mut W) -> Result<usize, Error> {
981                self.serialize(writer)
982            }
983        }
984
985        impl<'a, T: Serialize> Serialize for $name<'a, T> {
986            #[cfg(feature = "std")]
987            fn tls_serialize<W: Write>(&self, writer: &mut W) -> Result<usize, Error> {
988                self.serialize(writer)
989            }
990        }
991
992        impl<'a, T: Size> Size for &$name<'a, T> {
993            #[inline]
994            fn tls_serialized_len(&self) -> usize {
995                self.tls_serialized_length()
996            }
997        }
998
999        impl<'a, T: Size> Size for $name<'a, T> {
1000            #[inline]
1001            fn tls_serialized_len(&self) -> usize {
1002                self.tls_serialized_length()
1003            }
1004        }
1005    };
1006}
1007
1008impl_tls_slice!(u8, TlsSliceU8, 1);
1009impl_tls_slice!(u16, TlsSliceU16, 2);
1010impl_tls_slice!(U24, TlsSliceU24, 3);
1011impl_tls_slice!(u32, TlsSliceU32, 4);
1012
1013impl From<core::num::TryFromIntError> for Error {
1014    fn from(_e: core::num::TryFromIntError) -> Self {
1015        Self::InvalidVectorLength
1016    }
1017}
1018
1019impl From<core::convert::Infallible> for Error {
1020    fn from(_e: core::convert::Infallible) -> Self {
1021        Self::InvalidVectorLength
1022    }
1023}
tls_codec/tls_vec.rs

tls_codec/
tls_vec.rs
