Struct Rsa

pub struct Rsa<'k> { /* private fields */ }

Available on crate feature dnssec and (crate features dnssec-openssl or dnssec-ring) only.

Rsa public key

Implementations

impl<'k> Rsa<'k>

pub fn from_public_bytes(raw: &'k [u8]) -> Result<Self, ProtoError>

RFC 3110              RSA SIGs and KEYs in the DNS              May 2001

      2. RSA Public KEY Resource Records

 RSA public keys are stored in the DNS as KEY RRs using algorithm
 number 5 [RFC2535].  The structure of the algorithm specific portion
 of the RDATA part of such RRs is as shown below.

       Field             Size
       -----             ----
       exponent length   1 or 3 octets (see text)
       exponent          as specified by length field
       modulus           remaining space

 For interoperability, the exponent and modulus are each limited to
 4096 bits in length.  The public key exponent is a variable length
 unsigned integer.  Its length in octets is represented as one octet
 if it is in the range of 1 to 255 and by a zero octet followed by a
 two octet unsigned length if it is longer than 255 bytes.  The public
 key modulus field is a multiprecision unsigned integer.  The length
 of the modulus can be determined from the RDLENGTH and the preceding
 RDATA fields including the exponent.  Leading zero octets are
 prohibited in the exponent and modulus.

 Note: KEY RRs for use with RSA/SHA1 DNS signatures MUST use this
 algorithm number (rather than the algorithm number specified in the
 obsoleted RFC 2537).

 Note: This changes the algorithm number for RSA KEY RRs to be the
 same as the new algorithm number for RSA/SHA1 SIGs.

Trait Implementations

impl<'k> PublicKey for Rsa<'k>

fn public_bytes(&self) -> &[u8]

Returns the public bytes of the public key, in DNS format

fn verify( &self, algorithm: Algorithm, message: &[u8], signature: &[u8], ) -> Result<(), ProtoError>

Verifies the hash matches the signature with the current key.

fn to_sig0key(&self, algorithm: Algorithm) -> KEY

Convert this keypair into a KEY record type for usage with SIG0 with key type entity (KeyUsage::Entity).

fn to_sig0key_with_usage(&self, algorithm: Algorithm, usage: KeyUsage) -> KEY

Convert this keypair into a KEY record type for usage with SIG0 with a given key (usage) type.

fn to_ds( &self, name: &Name, algorithm: Algorithm, digest_type: DigestType, ) -> DnsSecResult<DS>

Creates a DS record for this KeyPair associated to the given name

fn to_dnskey(&self, algorithm: Algorithm) -> DNSKEY

Creates a Record that represents the public key for this Signer

fn key_tag(&self) -> u16

The key tag is calculated as a hash to more quickly lookup a DNSKEY.