[−][src]Enum trust_dns_client::rr::dnssec::Algorithm
DNSSec signing and validation algorithms.
For reference the iana documents have all the officially registered algorithms.
RFC 6944, DNSSEC DNSKEY Algorithm Status, April 2013
2.2. Algorithm Implementation Status Assignment Rationale
RSASHA1 has an implementation status of Must Implement, consistent
with [RFC4034]. RSAMD5 has an implementation status of Must Not
Implement because of known weaknesses in MD5.
The status of RSASHA1-NSEC3-SHA1 is set to Recommended to Implement
as many deployments use NSEC3. The status of RSA/SHA-256 and RSA/
SHA-512 are also set to Recommended to Implement as major deployments
(such as the root zone) use these algorithms [ROOTDPS]. It is
believed that RSA/SHA-256 or RSA/SHA-512 algorithms will replace
older algorithms (e.g., RSA/SHA-1) that have a perceived weakness.
Likewise, ECDSA with the two identified curves (ECDSAP256SHA256 and
ECDSAP384SHA384) is an algorithm that may see widespread use due to
the perceived similar level of security offered with smaller key size
compared to the key sizes of algorithms such as RSA. Therefore,
ECDSAP256SHA256 and ECDSAP384SHA384 are Recommended to Implement.
All other algorithms used in DNSSEC specified without an
implementation status are currently set to Optional.
2.3. DNSSEC Implementation Status Table
The DNSSEC algorithm implementation status table is listed below.
Only the algorithms already specified for use with DNSSEC at the time
of writing are listed.
+------------+------------+-------------------+-------------------+
| Must | Must Not | Recommended | Optional |
| Implement | Implement | to Implement | |
+------------+------------+-------------------+-------------------+
| | | | |
| RSASHA1 | RSAMD5 | RSASHA256 | Any |
| | | RSASHA1-NSEC3 | registered |
| | | -SHA1 | algorithm |
| | | RSASHA512 | not listed in |
| | | ECDSAP256SHA256 | this table |
| | | ECDSAP384SHA384 | |
+------------+------------+-------------------+-------------------+
This table does not list the Reserved values in the IANA registry
table or the values for INDIRECT (252), PRIVATE (253), and PRIVATEOID
(254). These values may relate to more than one algorithm and are
therefore up to the implementer's discretion. As noted, any
algorithm not listed in the table is Optional. As of this writing,
the Optional algorithms are DSASHA1, DH, DSA-NSEC3-SHA1, and GOST-
ECC, but in general, anything not explicitly listed is Optional.
2.4. Specifying New Algorithms and Updating the Status of Existing
Entries
[RFC6014] establishes a parallel procedure for adding a registry
entry for a new algorithm other than a standards track document.
Because any algorithm not listed in the foregoing table is Optional,
algorithms entered into the registry using the [RFC6014] procedure
are automatically Optional.
It has turned out to be useful for implementations to refer to a
single document that specifies the implementation status of every
algorithm. Accordingly, when a new algorithm is to be registered
with a status other than Optional, this document shall be made
obsolete by a new document that adds the new algorithm to the table
in Section 2.3. Similarly, if the status of any algorithm in the
table in Section 2.3 changes, a new document shall make this document
obsolete; that document shall include a replacement of the table in
Section 2.3. This way, the goal of having one authoritative document
to specify all the status values is achieved.
This document cannot be updated, only made obsolete and replaced by a
successor document.
Variants
DO NOT USE, SHA1 is a compromised hashing function, it is here for backward compatibility
DO NOT USE, SHA1 is a compromised hashing function, it is here for backward compatibility
RSA public key with SHA256 hash
RSA public key with SHA512 hash
Unknown(u8)
An unknown algorithm identifier
Implementations
impl Algorithm
[src]
pub fn from_u8(value: u8) -> Algorithm
[src]
http://www.iana.org/assignments/dns-sec-alg-numbers/dns-sec-alg-numbers.xhtml
pub fn hash_len(self) -> Option<usize>
[src]
length in bytes that the hash portion of this function will produce
pub fn to_str(self) -> &'static str
[src]
use as_str instead
Convert to string form
pub fn as_str(self) -> &'static str
[src]
Convert to string form
Trait Implementations
impl<'r> BinDecodable<'r> for Algorithm
[src]
pub fn read(decoder: &mut BinDecoder<'r>) -> Result<Algorithm, ProtoError>
[src]
fn from_bytes(bytes: &'r [u8]) -> Result<Self, ProtoError>
[src]
impl BinEncodable for Algorithm
[src]
pub fn emit(&self, encoder: &mut BinEncoder<'_>) -> Result<(), ProtoError>
[src]
fn to_bytes(&self) -> Result<Vec<u8>, ProtoError>
[src]
impl Clone for Algorithm
[src]
impl Copy for Algorithm
[src]
impl Debug for Algorithm
[src]
impl Display for Algorithm
[src]
impl Eq for Algorithm
[src]
impl From<Algorithm> for DigestType
[src]
pub fn from(a: Algorithm) -> DigestType
[src]
impl From<Algorithm> for SupportedAlgorithms
[src]
pub fn from(algorithm: Algorithm) -> SupportedAlgorithms
[src]
impl Hash for Algorithm
[src]
pub fn hash<__H>(&self, state: &mut __H) where
__H: Hasher,
[src]
__H: Hasher,
fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,
1.3.0[src]
H: Hasher,
impl Ord for Algorithm
[src]
pub fn cmp(&self, other: &Algorithm) -> Ordering
[src]
#[must_use]fn max(self, other: Self) -> Self
1.21.0[src]
#[must_use]fn min(self, other: Self) -> Self
1.21.0[src]
#[must_use]fn clamp(self, min: Self, max: Self) -> Self
[src]
impl PartialEq<Algorithm> for Algorithm
[src]
impl PartialOrd<Algorithm> for Algorithm
[src]
pub fn partial_cmp(&self, other: &Algorithm) -> Option<Ordering>
[src]
pub fn lt(&self, other: &Algorithm) -> bool
[src]
pub fn le(&self, other: &Algorithm) -> bool
[src]
pub fn gt(&self, other: &Algorithm) -> bool
[src]
pub fn ge(&self, other: &Algorithm) -> bool
[src]
impl StructuralEq for Algorithm
[src]
impl StructuralPartialEq for Algorithm
[src]
Auto Trait Implementations
impl RefUnwindSafe for Algorithm
impl Send for Algorithm
impl Sync for Algorithm
impl Unpin for Algorithm
impl UnwindSafe for Algorithm
Blanket Implementations
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
pub fn borrow_mut(&mut self) -> &mut T
[src]
impl<T> From<T> for T
[src]
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
impl<T> ToOwned for T where
T: Clone,
[src]
T: Clone,
type Owned = T
The resulting type after obtaining ownership.
pub fn to_owned(&self) -> T
[src]
pub fn clone_into(&self, target: &mut T)
[src]
impl<T> ToString for T where
T: Display + ?Sized,
[src]
T: Display + ?Sized,
impl<T, U> TryFrom<U> for T where
U: Into<T>,
[src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
[src]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,
type Error = <U as TryFrom<T>>::Error
The type returned in the event of a conversion error.
pub fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
[src]
impl<V, T> VZip<V> for T where
V: MultiLane<T>,
V: MultiLane<T>,