# Struct openssl::sign::Signer [−] [src]

    pub struct Signer<'a> { /* fields omitted */ }

A type which computes cryptographic signatures of data.

## Implementations

### `impl<'a> Signer<'a>` [src]

#### `pub fn new<T>(
type_: MessageDigest,
pkey: &'a PKeyRef<T>
) -> Result<Signer<'a>, ErrorStack> where
T: HasPrivate,` [src]

Creates a new `Signer`.

This cannot be used with Ed25519 or Ed448 keys. Please refer to `new_without_digest`.

OpenSSL documentation at `EVP_DigestSignInit`.

#### `pub fn new_without_digest<T>(
pkey: &'a PKeyRef<T>
) -> Result<Signer<'a>, ErrorStack> where
T: HasPrivate,` [src]

Creates a new `Signer` without a digest.

This is the only way to create a `Verifier` for Ed25519 or Ed448 keys. It can also be used to create a CMAC.

OpenSSL documentation at `EVP_DigestSignInit`.

#### `pub fn rsa_padding(&self) -> Result<Padding, ErrorStack>` [src]

Returns the RSA padding mode in use.

This is only useful for RSA keys.

This corresponds to `EVP_PKEY_CTX_get_rsa_padding`.

#### `pub fn set_rsa_padding(&mut self, padding: Padding) -> Result<(), ErrorStack>` [src]

Sets the RSA padding mode.

This is only useful for RSA keys.

This corresponds to `EVP_PKEY_CTX_set_rsa_padding`.

#### `pub fn set_rsa_pss_saltlen(
&mut self,
len: RsaPssSaltlen
) -> Result<(), ErrorStack>` [src]

Sets the RSA PSS salt length.

This is only useful for RSA keys.

This corresponds to `EVP_PKEY_CTX_set_rsa_pss_saltlen`.

#### `pub fn set_rsa_mgf1_md(&mut self, md: MessageDigest) -> Result<(), ErrorStack>` [src]

Sets the RSA MGF1 algorithm.

This is only useful for RSA keys.

This corresponds to `EVP_PKEY_CTX_set_rsa_mgf1_md`.

#### `pub fn update(&mut self, buf: &[u8]) -> Result<(), ErrorStack>` [src]

Feeds more data into the `Signer`.

Please note that PureEdDSA (Ed25519 and Ed448 keys) do not support streaming. Use `sign_oneshot` instead.

OpenSSL documentation at `EVP_DigestUpdate`.

#### `pub fn len(&self) -> Result<usize, ErrorStack>` [src]

Computes an upper bound on the signature length.

The actual signature may be shorter than this value. Check the return value of `sign` to get the exact length.

OpenSSL documentation at `EVP_DigestSignFinal`.

#### `pub fn sign(&self, buf: &mut [u8]) -> Result<usize, ErrorStack>` [src]

Writes the signature into the provided buffer, returning the number of bytes written.

This method will fail if the buffer is not large enough for the signature. Use the `len` method to get an upper bound on the required size.

OpenSSL documentation at `EVP_DigestSignFinal`.

#### `pub fn sign_to_vec(&self) -> Result<Vec<u8>, ErrorStack>` [src]

Returns the signature.

This is a simple convenience wrapper over `len` and `sign`.

#### `pub fn sign_oneshot(
&mut self,
sig_buf: &mut [u8],
data_buf: &[u8]
) -> Result<usize, ErrorStack>` [src]

Signs the data in data_buf and writes the signature into the buffer sig_buf, returning the number of bytes written.

For PureEdDSA (Ed25519 and Ed448 keys) this is the only way to sign data.

This method will fail if the buffer is not large enough for the signature. Use the `len` method to get an upper bound on the required size.

OpenSSL documentation at `EVP_DigestSign`.

#### `pub fn sign_oneshot_to_vec(
&mut self,
data_buf: &[u8]
) -> Result<Vec<u8>, ErrorStack>` [src]

Returns the signature.

This is a simple convenience wrapper over `len` and `sign_oneshot`.

## Trait Implementations

### `impl<'a> Drop for Signer<'a>` [src]

#### `fn drop(&mut self)` [src]

Executes the destructor for this type. Read more

### `impl<'a> Send for Signer<'a>` [src]

### `impl<'a> Sync for Signer<'a>` [src]

### `impl<'a> Write for Signer<'a>` [src]

#### `fn write(&mut self, buf: &[u8]) -> Result<usize>` [src]

Write a buffer into this writer, returning how many bytes were written. Read more

#### `fn flush(&mut self) -> Result<()>` [src]

Flush this output stream, ensuring that all intermediately buffered contents reach their destination. Read more

#### `pub fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> Result<usize, Error>`1.36.0 [src]

Like `write`, except that it writes from a slice of buffers. Read more

#### `pub fn is_write_vectored(&self) -> bool` [src]

🔬 This is a nightly-only experimental API. (`can_vector`)

Determines if this `Write`r has an efficient `write_vectored` implementation. Read more

#### `pub fn write_all(&mut self, buf: &[u8]) -> Result<(), Error>`1.0.0 [src]

Attempts to write an entire buffer into this writer. Read more

#### `pub fn write_all_vectored(
&mut self,
bufs: &mut [IoSlice<'_>]
) -> Result<(), Error>` [src]

🔬 This is a nightly-only experimental API. (`write_all_vectored`)

Attempts to write multiple buffers into this writer. Read more

#### `pub fn write_fmt(&mut self, fmt: Arguments<'_>) -> Result<(), Error>`1.0.0 [src]

Writes a formatted string into this writer, returning any error encountered. Read more

#### `pub fn by_ref(&mut self) -> &mut Self` 1.0.0 [src]

Creates a “by reference” adaptor for this instance of `Write`. Read more

## Auto Trait Implementations

### `impl<'a> RefUnwindSafe for Signer<'a>`

### `impl<'a> Unpin for Signer<'a>`

### `impl<'a> UnwindSafe for Signer<'a>`

## Blanket Implementations

### `impl<T> Any for T where
T: 'static + ?Sized,` [src]

#### `pub fn type_id(&self) -> TypeId` [src]

Gets the `TypeId` of `self`. Read more

### `impl<T> Borrow<T> for T where
T: ?Sized,` [src]

#### `pub fn borrow(&self) -> &T` [src]

Immutably borrows from an owned value. Read more

### `impl<T> BorrowMut<T> for T where
T: ?Sized,` [src]

#### `pub fn borrow_mut(&mut self) -> &mut T` [src]

Mutably borrows from an owned value. Read more

### `impl<T> From<T> for T` [src]

#### `pub fn from(t: T) -> T` [src]

Performs the conversion.

### `impl<T, U> Into<U> for T where
U: From<T>,` [src]

#### `pub fn into(self) -> U` [src]

Performs the conversion.

### `impl<T, U> TryFrom<U> for T where
U: Into<T>,` [src]

#### `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]

Performs the conversion.

### `impl<T, U> TryInto<U> for T where
U: TryFrom<T>,` [src]

#### `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]

Performs the conversion.