Struct xpcom::interfaces::nsICryptoHMAC

#[repr(C)]
pub struct nsICryptoHMAC { /* fields omitted */ }

interface nsICryptoHMAC : nsISupports

/**
 * nsICryptoHMAC
 * This interface provides HMAC signature algorithms.
 */

Methods

impl nsICryptoHMAC

pub fn coerce<T: nsICryptoHMACCoerce>(&self) -> &T

Cast this nsICryptoHMAC to one of its base interfaces.

impl nsICryptoHMAC

pub const MD5: i64

MD5: i64 = 2

/**
     * Hashing Algorithms. These values are to be used by the |init| method to
     * indicate which hashing function to use. These values map onto the values
     * defined in mozilla/security/nss/lib/softoken/pkcs11t.h and are switched
     * to a CKM_*_HMAC constant.
     */

pub const SHA1: i64

SHA1: i64 = 3

pub const SHA256: i64

SHA256: i64 = 4

pub const SHA384: i64

SHA384: i64 = 5

pub const SHA512: i64

SHA512: i64 = 6

pub unsafe fn Init(
    &self,
    aAlgorithm: uint32_t,
    aKeyObject: *const nsIKeyObject
) -> nsresult

/**
     * Initialize the hashing object. This method may be
     * called multiple times with different algorithm types.
     *
     * @param aAlgorithm the algorithm type to be used.
     *        This value must be one of the above valid
     *        algorithm types.
     *
     * @param aKeyObject
     *        Object holding a key. To create the key object use for instance:
     *        var keyObject = Components.classes["@mozilla.org/security/keyobjectfactory;1"]
     *            .getService(Components.interfaces.nsIKeyObjectFactory)
     *              .keyFromString(Components.interfaces.nsIKeyObject.HMAC, rawKeyData);
     *
     * WARNING: This approach is not FIPS compliant.
     *
     * @throws NS_ERROR_INVALID_ARG if an unsupported algorithm
     *        type is passed.
     *
     * NOTE: This method must be called before any other method on this
     *       interface is called.
     */

[must_use] void init (in unsigned long aAlgorithm, in nsIKeyObject aKeyObject);

pub unsafe fn Update(&self, aData: *const uint8_t, aLen: uint32_t) -> nsresult

/**
     * @param aData a buffer to calculate the hash over
     *
     * @param aLen the length of the buffer |aData|
     *
     * @throws NS_ERROR_NOT_INITIALIZED If |init| has not been called.
     */

[must_use] void update ([array, size_is (aLen), const] in octet aData, in unsigned long aLen);

pub unsafe fn UpdateFromStream(
    &self,
    aStream: *const nsIInputStream,
    aLen: uint32_t
) -> nsresult

/**
     * Calculates and updates a new hash based on a given data stream.
     *
     * @param aStream an input stream to read from.
     *
     * @param aLen How much to read from the given |aStream|. Passing UINT32_MAX
     *        indicates that all data available will be used to update the hash.
     *
     * @throws NS_ERROR_NOT_INITIALIZED If |init| has not been called.
     *
     * @throws NS_ERROR_NOT_AVAILABLE If the requested amount of data to be
     *         calculated into the hash is not available.
     *
     */

[must_use] void updateFromStream (in nsIInputStream aStream, in unsigned long aLen);

pub unsafe fn Finish(&self, aASCII: bool, _retval: &mut nsACString) -> nsresult

/**
     * Completes this HMAC object and produces the actual HMAC digest data.
     *
     * @param aASCII If true then the returned value is a base64 encoded string.
     *        If false, then the returned value is binary data.
     *
     * @return a hash of the data that was read by this object.  This can
     *         be either binary data or base 64 encoded.
     *
     * @throws NS_ERROR_NOT_INITIALIZED If |init| has not been called.
     *
     * NOTE: This method may be called any time after |init|
     *       is called.  This call resets the object to its
     *       pre-init state.
     */

[must_use] ACString finish (in boolean aASCII);

pub unsafe fn Reset(&self) -> nsresult

/**
     * Reinitialize HMAC context to be reused with the same settings (the key
     * and hash algorithm) but on a different set of data.
     */

[must_use] void reset ();

Methods from Deref<Target = nsISupports>

pub fn coerce<T: nsISupportsCoerce>(&self) -> &T

Cast this nsISupports to one of its base interfaces.

pub unsafe fn QueryInterface(
    &self,
    uuid: &nsIID,
    result: *mut *mut c_void
) -> nsresult

void QueryInterface (in nsIIDRef uuid, [iid_is (uuid), retval] out nsQIResult result);

pub unsafe fn AddRef(&self) -> nsrefcnt

[noscript,notxpcom] nsrefcnt AddRef ();

pub unsafe fn Release(&self) -> nsrefcnt

[noscript,notxpcom] nsrefcnt Release ();

Trait Implementations

impl XpCom for nsICryptoHMAC

const IID: nsIID

IID: nsIID = nsID(2414562428, 5697, 19067, [188, 109, 25, 100, 226, 9, 148, 151])

fn query_interface<T: XpCom>(&self) -> Option<RefPtr<T>>

Perform a QueryInterface call on this object, attempting to dynamically cast it to the requested interface type. Returns Some(RefPtr) if the cast succeeded, and None otherwise.

impl RefCounted for nsICryptoHMAC

unsafe fn addref(&self)

Increment the reference count.

unsafe fn release(&self)

Decrement the reference count, potentially freeing backing memory.

impl Deref for nsICryptoHMAC

type Target = nsISupports

The resulting type after dereferencing.

fn deref(&self) -> &nsISupports

Dereferences the value.