rust ݼ#rustc 1.98.1 (48a229cea 2026-09-01)RL.SAwjL-df1bddb45adbe94b<%Z>64V`-2d2ab9fb0fe1def5input 'a  is_empty  read_all as_slice_less_safe  into_valueno_panic getsubslice reader$$$$Reader((($,$.. .at_end.peek. read_byte. read_bytes.read_bytes_to_end. read_partial666.skip: . skip_to_endread_all_optionalBBBBGGJLLOQQbytesTVVY$ EndOfInput[ $$^$$a$c$$fN88888 8 8888X888!8"8#8,8-8-8-818283848586868:8<8_8b8b8b8d8g8g8B8GGIEzǚ'   gGGIEzǚ'8    QQSUo    g((*$+$&8[[\ w #   g     JGTQ][LGVQ^[OGYQ`[G,(a[GGc[e[f[U g (N#(GGIEzǚ'] gpz܀t Q@ G   Hj$  , QQSUo<r,  3  G i2TTU!i }!i "i] DD!!Diw T$,,c w ,T- ;;"[,,,Fu LX,I ( 4 T  #  2 # ((*$+$&$ %η Uȷ  4  T    |  r r    5   ^f՚  ÜĜŜƜǜȜ_w        [E u# ڻ    {  t{       H  m o  t 4   ,   * Ԝ    y /DKR~0Pd`i!  $  G1D[ ". `ֻ$mÜĜŜƜǜȜ_wd,|$xm[}OD^"- f G /    5ֻ*](incomplete_read<readE#     T\G#D, ?T{$ ܚ7 Qt G Se04Jm$,u Gz$, (X#(4 >GQ7 Q$, ,7 Q }{]T3j]3j / 3j4 j 4&j ř   4j3jY%4j řǙșəʙ˙G*R{9 .y 4jLЗiw 42jn MΘi.\+, .S26T Q^     _j`6j`4j-aj    }j  j &j  .j   j t aj `T'[@\@4'(A&HE untrusted.rs: Safe, fast, zero-panic, zero-crashing, zero-allocation(% parsing of untrusted inputs in Rust.B? git clone https://github.com/briansmith/untrustedEB untrusted.rs goes beyond Rust's normal safety guarantees by also<9 guaranteeing that parsing will be panic-free, as long asKH `untrusted::Input::as_slice_less_safe()` is not used. It avoids copying KH data and heap allocation and strives to prevent common pitfalls such as KH accidentally parsing input bytes multiple times. In order to meet these OL goals, untrusted.rs is limited in functionality such that it works best for NK input languages with a small fixed amount of lookahead such as ASN.1, TLS, LI TCP/IP, and many other networking, IPC, and related protocols. Languages LI that require more lookahead and/or backtracking require some significant OL contortions to parse using this framework. It would not be realistic to use :7 it for parsing programming language code, for example.  2/ The overall pattern for using untrusted.rs is:OL 1. Write a recursive-descent-style parser for the input language, where theJG input data is given as a `&mut untrusted::Reader` parameter to eachNK function. Each function should have a return type of `Result` forOL some value type `V` and some error type `E`, either or both of which mayJG be `()`. Functions for parsing the lowest-level language constructsNK should be defined. Those lowest-level functions will parse their inputsFC using `::read_byte()`, `Reader::peek()`, and similar functions.FC Higher-level language constructs are then parsed by calling the)& lower-level functions in sequence.FC 2. Wrap the top-most functions of your recursive-descent parser inIF functions that take their input data as an `untrusted::Input`. TheKH wrapper functions should call the `Input`'s `read_all` (or a variantNK thereof) method. The wrapper functions are the only ones that should be+( exposed outside the parser's module.PM 3. After receiving the input data to parse, wrap it in an `untrusted::Input`FC using `untrusted::Input::from()` as early as possible. Pass theOL `untrusted::Input` to the wrapper functions when they need to be parsed.PM In general parsers built using `untrusted::Reader` do not need to explicitlyOL check for end-of-input unless they are parsing optional constructs, becauseHE `Reader::read_byte()` will return `Err(EndOfInput)` on end-of-input.NK Similarly, parsers using `untrusted::Reader` generally don't need to checkOL for extra junk at the end of the input as long as the parser's API uses theOL pattern described above, as `read_all` and its variants automatically checkNK for trailing junk. `Reader::skip_to_end()` must be used when any remaining?< unread input should be ignored without triggering an error.IF untrusted.rs works best when all processing of the input data is doneDA through the `untrusted::Input` and `untrusted::Reader` types. InJG particular, avoid trying to parse input data using functions that takeMJ byte slices. However, when you need to access a part of the input data asDA a slice to use a function that isn't written using untrusted.rs,.+ `Input::as_slice_less_safe()` can be used.  HE It is recommend to use `use untrusted;` and then `untrusted::Input`, NK `untrusted::Reader`, etc., instead of using `use untrusted::*`. Qualifying!MJ the names with `untrusted` helps remind the reader of the code that it is!# dealing with *untrusted* input."t" # Examples""KH [*ring*](https://github.com/briansmith/ring)'s parser for the subset of"%" ASN.1 DER it needs to understand,#NK [`ring::der`](https://github.com/briansmith/ring/blob/main/src/io/der.rs),#OL is built on top of untrusted.rs. *ring* also uses untrusted.rs to parse ECC$KH public keys, RSA PKCS#1 1.5 padding, and for all other parsing it does.%%LI All of [webpki](https://github.com/briansmith/webpki)'s parsing of X.509%=: certificates (also ASN.1 DER) is done using untrusted.rs.&:https://briansmith.org/rustdoc/l&$BG>[@+\@(AhknL&,&GD4(A,(* #GD The value is intentionally omitted from the output to avoid leakingd secrets.8ii g D jkl j kggg cgcثq1ȡlB  8$      * 85 Construct a new `Input` for the given input `bytes`.$  B  =: Returns `true` if the input is empty and false otherwise.Dm m B   $ԅ&# Returns the length of the `Input`.n n B   $IF Calls `read` with the given input as a `Reader`, ensuring that `read`KH consumed the entire input. If `read` does not consume the entire input," `incomplete_read` is returned.Dp p "B      o# o((*$+$&'o#"d $$$#,HE Access the input as a slice so it can be processed by functions that52 are not written using the Input/Reader framework.q q B   $5T B  %  $ B a0 +$ B d&D&Q !"#) B *s s řǙșəʙ˙G*R{9  s B  $BDt t 7řǙșəʙ˙G*R{9  B  $*<    8Du u B  !$v v B  "$,w w B  #$T&4&([\D$&,G$'>,(* A> A read-only, forward-only cursor into the data in an `Input`.KH Using `Reader` to parse input helps to ensure that no byte of the inputDA will be accidentally processed more than once. Using `Reader` inLI conjunction with `read_all` and `read_all_optional` helps ensure that noOL byte of the input is accidentally left unprocessed. The methods of `Reader` IF never panic, so `Reader` also assists the writing of panic-free code.  LI Intentionally avoids implementing `PartialEq` and `Eq` to avoid implicit " non-constant-time comparisons.4 ))&*+  , $(( D  $(( $ JG Avoids writing the value or position to avoid creating a side channel, @= though `Reader` can't avoid leaking the position via timing.8xx -g- D yz{ y zggg cgcثq1ȡ{B, , -8$   //0123456:< $ A> Construct a new Reader for the given input. Use `read_all` orC@ `read_all_optional` instead of `Reader::new` whenever possible. B.. 0HE Returns `true` if the reader is at the end of the input, and `false`t otherwise.4| |B. . 1$!KH Returns `true` if there is at least one more byte in the input and that.+ byte is equal to `b`, and false otherwise.$} } B. . 2$"5 Reads the next input byte.JG Returns `Ok(b)` where `b` is the next input byte, or `Err(EndOfInput)`/, if the `Reader` is at the end of the input.L~ ~JB. . 3$OEB Skips `num_bytes` of the input, returning the skipped input as and `Input`.IF Returns `Ok(i)` if there are at least `num_bytes` of input remaining,$! and `Err(EndOfInput)` otherwise.T ÜĜŜƜǜȜ_w  B. . 4$d}/0IF Skips the reader to the end of the input, returning the skipped input as an `Input`.  B. . 5$LI Calls `read()` with the given input as a `Reader`. On success, returns aKH pair `(bytes_read, r)` where `bytes_read` is what `read()` consumed and# `r` is `read()`'s return value.d ÜĜŜƜǜȜ_w B.789879 .   #  '#"d  6$ $:uwz|#B"# Skips `num_bytes` of the input.""I#$$# }B. #. :$#d\8$:;;;;:~%$-* Skips the reader to the end of the input.\% 8B. %. <$%'d',',,,,('I(EB consumed the entire input. When `input` is `None`, `read` will be( called with `None`.(řǙșəʙ˙G*R{9  "BCDEFDFEC ) ) )#řǙșəʙ˙G*R{9  )/#"d* B0$0$0)FC A wrapper around `&'a [u8]` that helps in writing panic-free code.*' No methods of `Input` will ever panic.L",HH Ezǚ'IԾ,GG KK XZMM NNh h BLL N PP ,RR UoS|,QQ UU XZWW XXr r BVV X ZZ '%OL The error type used to indicate the end of the input was reached before the&! operation could be completed.T' w #\'[[ >">'> J> __e>h>  B^&^ _> & > bgb>>  ggg cgcثq1ȡBa &a bG?N?= dd>> >!>  8Bc 'c dh>3> E> gga>d>   Bf 'f g> >        z        z ,    C         0     R  |     @ s   * .:https://github.com/briansmith/ring/blob/main/src/io/der.rswebpkiring$https://github.com/briansmith/webpki"https://github.com/briansmith/ring ring::derƄфڄфƄڄ  ####!!!PQPPQ EndOfInput ՆvA;3măF,Xnd q >BgOS^xs'䣚x(q֔cwmqS6y: E~RDuϸch~RVj1fF7#G-Z}#7Էu!:~PrԑZuexRBNd1fV'XzM_D@5HI =Vr r+'%AW.r;4;a`(LŎ:Cc^>H~$#ڐ -SMټ:+,6*/7r#U碴uW,7F`\t4ГJ<E}?@`F;Nڮ}nldO?^E٠=A_2ʡ[%_3 B|W,=P|>иHaeg@Hn=JklU(°P,)9 Zo''pgzU6W%FLĥ6?ρ߂˷NɁ嶿B46** )k6T xsfNWb =%2 U<gBEҜu!n|ѧva |G86oY7 >Mې,Rq(8f-y^ W8s I}x#G\Z#9&izm_Nak][Wf:P+\VKG6;Ee=-2<zn|R4 - Y{2iPnk$lڟ!T~1:̰su|o ǒ{ujڞcetOz(x=lX"B` ?A@\m0{,?Ws/!˯{jǹfjsB6O*ll,L'| GU+BjnJ0|q-gKߖZs!vDWZr"H50}}AqeuEx:إt vC> X XnY{n#ʊhHCD^_iGK__J_L_P_W__``Gaagbdeee9feffff*ggxhhigiiiii illlminn{o9p$q:rstvwwnxrxyx|xxxz{{{|n||||"}L}}}~~~0B] $^_fi_`ePfflm n{{ |||};}}m~~~>P    (^__aa)bScHee f}fffBggh*iiilllmOoopqCsbtuQw/x yd{{1|||c}L~~~tXӀK ___F_J_N_R__```Caaabsddddeeee4fZf`fffff%ggthhibiiiiiillllmennnwo4pq5rstvvvvwwjxnxuxyxxxuz{zzzz{{{{{||i||||||}}E}I}}}}m~~~~+?Z!#*07>DJQW]ciou{ǁ́Ӂف߁ __L_P__`aab;cuddd0eeee^feffff*gghigiiiillllmn7oopq+sJt{uvvv9wxrx|xxyyz}zzz`{{{{||||||}G}L}}H~o~~]A '-4;AGNTZ`flrx~āʁЁց܁_q``,aaLbc}dddkeeefLfffggXhhhMiilllmIn|nbopq rst;vvvvywwUxyzzzw{{{|U||||}7}}}S~~~~:L}_e``$aa@bqcwddd_eeef;fffggLhhhAiilllm=nknZopprs|tvvvvmwwIxvyzzzf{{{{H|r|||}&}z}}M~~~~4F p_u``2aaPbKdoeee#fNfffgg\hhhQiilllmMn~nfo#pq$rstv}wwYxMzy{{{|Y||||}9}}}U~~~~!<N _aa*bTcIeef~ffCggh+iilmPoopqDsctuRw0x!ye{2||d}M~~~uY_aa+bXcJeefffDggh,iimQoopqEsdtuSw1x%y3|e}~uYԀ_aab?c4eeeiff.ggxhhikim;oopq/sNtu=wwx y|O}q~~`D "z\fp dddvvvzzz- Q XL.'S* !#%24=??Bd@@ BVB O V%Q( #%24=??b@hK+J@ BTBB P W-&R) #%24=??c@iK,K@ BUBB0ag~`<aaZb^dyee-ffggfhi[iiVnpo-pq.rstvwcx`zc|}%^__`e9fffilmin^{{{p||}$}}F~~~2D l{|d~l{{|W~ 15<CGNUdhov (9Qdkry &-9=DHOVZarvz~ &,28>DJPV\bhntzl{|f~_``````eQfffffffmnnnnnnnnn |<}~QlKnKpKpKpKsKsKuKwK{K}KKKKKKKKKKKKKKKKjKyKKKKK_`eVffmn{||}A}}~~>V-       q,&} core_intrinsicsfmt_helpers_for_deriveggvAΓR"[]vA-$P vA) 檢\o$uderive_clone_copy_internals  vAEt   vAmk5Z_`G vAٲ Ӻe,&}VvAaw}~'ei_derive_eq_internalsvAX    vAZ`*6 vAjךO&,vAZl  vA?[sѣe,:vA"]~r+ vA|uw7 + vA5'.o$&{  vA%}*- vAȰW5L'O_vAF  ! vA b`ze,vA,2H( vANROo$  vAA  vAWgq3x\A)Me1Qr9Y%=]-Ea5U!IimvޥR:ͦ;/% ̧r.fӤb+zVB*äLΥ𤽦ODHT 6y: uW,'zM_jvO*llxB|W59 Z=r"Hs IXVjڐ -S"gBJ][Wf]=-2a >S6eg9@Hn=: ?oNak\}x#G\Yo''p>x(`(L:+,6$Mې,RT- d*/7r%;3m4Г*1fF7Z#9ZŎ:CF;-r;4;aJ<+b =%2Hkf3V>7RE}?@`,'%AW. >BgO:P+^sB6wG6;Ee`#G-D@5HI |G8NMT2QldO?0ch~R exRBN)k6T E#U&d1fV'X|R4 căF,XU+zrԑZ> X 7F`\(S^xs^E٠1=A_2ʡ2-y^ Vujڞcetknd qY{2iPeJklU;nk$lڟf&izm_[<znbBjnJ0{xsFZs!v,L'| Gy50}}A!T~1:gLĥ6?ρAvAE~R Vr r+DWZ:إtمHCDnjZ}#H~$#!q(8fUǒ{jcwmqS "B`nXnEҜuKu|o iOz(xl vC,=P7q֔gz?!n|LѧvaMW8W\VK_-}qeuExU6W%F@ =n:~P7Էu!߂˷B|q|A@\m0{p(°P,)<#ʊh˯{s|>иHa8 U Y{=lXm'䣚NɁ嶿BC[%3fu;    "JF' 802 % t,ԢпC,HSx86_64-unknown-linux-gnuAu*F untrusted-6046503770adb7b5vAR  eeR%ohhhThTh%gohhhhhhhgGh<hh<hg\\\hhg ><<'rust-end-file