Function format_serial

Source
pub fn format_serial(i: &[u8]) -> String
Expand description

Formats a slice to a colon-separated hex string (for ex 01:02:ff:ff)

Examples found in repository?
examples/print-crl.rs (line 31)
23fn print_authority_key_identifier(aki: &AuthorityKeyIdentifier, level: usize) {
24    if let Some(id) = &aki.key_identifier {
25        println!("{:indent$}keyid: {:x}", "", id, indent = level);
26    }
27    if aki.authority_cert_issuer.is_some() {
28        unimplemented!();
29    }
30    if let Some(serial) = aki.authority_cert_serial {
31        let s = format_serial(serial);
32        println!("{:indent$}serial: {}", "", &s, indent = level);
33    }
34}
More examples
Hide additional examples
examples/print-cert.rs (line 65)
46fn print_x509_extension(oid: &Oid, ext: &X509Extension) {
47    println!(
48        "    [crit:{} l:{}] {}: ",
49        ext.critical,
50        ext.value.len(),
51        format_oid(oid)
52    );
53    match ext.parsed_extension() {
54        ParsedExtension::AuthorityKeyIdentifier(aki) => {
55            println!("      X509v3 Authority Key Identifier");
56            if let Some(key_id) = &aki.key_identifier {
57                println!("        Key Identifier: {:x}", key_id);
58            }
59            if let Some(issuer) = &aki.authority_cert_issuer {
60                for name in issuer {
61                    println!("        Cert Issuer: {}", name);
62                }
63            }
64            if let Some(serial) = aki.authority_cert_serial {
65                println!("        Cert Serial: {}", format_serial(serial));
66            }
67        }
68        ParsedExtension::BasicConstraints(bc) => {
69            println!("      X509v3 CA: {}", bc.ca);
70        }
71        ParsedExtension::CRLDistributionPoints(points) => {
72            println!("      X509v3 CRL Distribution Points:");
73            for point in points.iter() {
74                if let Some(name) = &point.distribution_point {
75                    println!("        Full Name: {:?}", name);
76                }
77                if let Some(reasons) = &point.reasons {
78                    println!("        Reasons: {}", reasons);
79                }
80                if let Some(crl_issuer) = &point.crl_issuer {
81                    print!("        CRL Issuer: ");
82                    for gn in crl_issuer {
83                        print!("{} ", generalname_to_string(gn));
84                    }
85                    println!();
86                }
87                println!();
88            }
89        }
90        ParsedExtension::KeyUsage(ku) => {
91            println!("      X509v3 Key Usage: {}", ku);
92        }
93        ParsedExtension::NSCertType(ty) => {
94            println!("      Netscape Cert Type: {}", ty);
95        }
96        ParsedExtension::SubjectAlternativeName(san) => {
97            for name in &san.general_names {
98                let s = match name {
99                    GeneralName::DNSName(s) => {
100                        format!("DNS:{}", s)
101                    }
102                    GeneralName::IPAddress(b) => {
103                        let ip = match b.len() {
104                            4 => {
105                                let b = <[u8; 4]>::try_from(*b).unwrap();
106                                let ip = Ipv4Addr::from(b);
107                                format!("{}", ip)
108                            }
109                            16 => {
110                                let b = <[u8; 16]>::try_from(*b).unwrap();
111                                let ip = Ipv6Addr::from(b);
112                                format!("{}", ip)
113                            }
114                            l => format!("invalid (len={})", l),
115                        };
116                        format!("IP Address:{}", ip)
117                    }
118                    _ => {
119                        format!("{:?}", name)
120                    }
121                };
122                println!("      X509v3 SAN: {}", s);
123            }
124        }
125        ParsedExtension::SubjectKeyIdentifier(id) => {
126            println!("      X509v3 Subject Key Identifier: {:x}", id);
127        }
128        x => println!("      {:?}", x),
129    }
130}