<doc>
  <assembly>
    <name>Rebex.Security</name>
  </assembly>
  <members>
    <member name="T:Rebex.Security.Cryptography.AesGcm">
      <summary>
            Represents the AES-GCM cryptographic operation.
            </summary>
    </member>
    <member name="F:Rebex.Security.Cryptography.AesGcm.KeyByteSizes">
      <summary>
            Gets the key sizes (in bytes) supported by this instance.
            </summary>
      <value>The key sizes supported by this instance: 16, 24, or 32 bytes (128, 192, or 256 bits).</value>
    </member>
    <member name="F:Rebex.Security.Cryptography.AesGcm.TagByteSizes">
      <summary>
            Gets the tag sizes (in bytes) supported by this instance.
            </summary>
      <value>The tag sizes supported by this instance: 12, 13, 14, 15, or 16 bytes (96, 104, 112, 120, or 128 bits).</value>
    </member>
    <member name="F:Rebex.Security.Cryptography.AesGcm.NonceByteSizes">
      <summary>
            Gets the nonce sizes (in bytes) supported by this instance.
            </summary>
      <value>The nonce sizes supported by this instance: 12 bytes (96 bits).</value>
    </member>
    <member name="M:Rebex.Security.Cryptography.AesGcm.#ctor(System.Byte[])">
      <summary>
            Initializes new <see cref="T:Rebex.Security.Cryptography.AesGcm" /> instance with the provided key.
            </summary>
      <param name="key">The secret key to be used by this instance (check <see cref="F:Rebex.Security.Cryptography.AesGcm.KeyByteSizes" /> for valid key sizes).</param>
      <remarks>The key value is copied into </remarks>
    </member>
    <member name="M:Rebex.Security.Cryptography.AesGcm.Encrypt(System.Byte[],System.Byte[],System.Byte[],System.Byte[],System.Byte[])">
      <summary>
            Encrypts plaintext data and computes the authentication tag.
            </summary>
      <param name="nonce">The nonce associated with this message, which should be unique for every operation with the same key.</param>
      <param name="plaintext">The data to encrypt.</param>
      <param name="ciphertext">The byte array to store the encrypted data to.</param>
      <param name="authTag">The byte array to store the computed authentication tag to.</param>
      <param name="additionalAuthData">Additional authenticated data (AAD) associated with this message, which must also be provided during decryption.</param>
    </member>
    <member name="M:Rebex.Security.Cryptography.AesGcm.Decrypt(System.Byte[],System.Byte[],System.Byte[],System.Byte[],System.Byte[])">
      <summary>
            Decrypts ciphertext data and validates the authentication tag.
            </summary>
      <param name="nonce">The nonce associated with this message, which was used during encryption.</param>
      <param name="ciphertext">The encrypted data to decrypt.</param>
      <param name="authTag">The authentication tag computed for this message during encryption.</param>
      <param name="plaintext">The byte array to store the decrypted data to.</param>
      <param name="additionalAuthData">Additional authenticated data (AAD) associated with this message, which was used during encryption.</param>
    </member>
    <member name="M:Rebex.Security.Cryptography.AesGcm.Dispose(System.Boolean)">
      <summary>
            Releases the unmanaged resources used by the current instance and optionally releases the managed resources.
            </summary>
      <param name="disposing">
        <b>true</b> to release both managed and unmanaged resources; <b>false</b> to release only unmanaged resources.</param>
    </member>
    <member name="M:Rebex.Security.Cryptography.AesGcm.Dispose">
      <summary>
            Releases the resources used by the current instance.
            </summary>
    </member>
    <member name="T:Rebex.Security.Cryptography.Argon2">
      <summary>
            This class represents Argon2 memory-hard hash algorithm for password hashing and proof-of-work applications.
            Specified by <a href="https://datatracker.ietf.org/doc/html/rfc9106">RFC 9106</a>.
            Supports all Argon2 variants: <see cref="F:Rebex.Security.Cryptography.Argon2Type.Argon2i" />, <see cref="F:Rebex.Security.Cryptography.Argon2Type.Argon2d" />, and <see cref="F:Rebex.Security.Cryptography.Argon2Type.Argon2id" />.
            </summary>
      <remarks>
        <para>
          <see cref="T:Rebex.Security.Cryptography.Argon2" /> class inherits from .NET's <see cref="T:System.Security.Cryptography.DeriveBytes" /> class and overrides the <see cref="M:Rebex.Security.Cryptography.Argon2.GetBytes(System.Int32)" /> method.
            However, in scenarios where an instance of this class is not needed, the following static (shared in VB) methods are recommended:
            </para>
        <ul>
          <li>
            <c>HashData</c> - computes a raw Argon2 hash from the specified data.
            </li>
          <li>
            <c>HashPassword</c> - computes Argon2 hash from the specified password and encodes it.
            </li>
          <li>
            <c>VerifyPassword</c> - verifies password by computing an Argon2 hash and matching it agains the specified hash.
            </li>
        </ul>
        <para>
            Encoded hashes in <c>HashPasswordand</c>/<c>VerifyPassword</c> methods use the following format:
            </para>
        <para>
          <c>$argon2&lt;argon2variant&gt;$v=&lt;argon2version&gt;$m=&lt;number&gt;,t=&lt;number&gt;,p=&lt;number&gt;$&lt;salt&gt;$&lt;hash&gt;</c>
        </para>
        <para>
            Example:
            </para>
        <para>
          <c>$argon2d$v=19$m=4096,t=4,p=1$CIlDXZQtjjt97RIvRQ7+6A$xZpr76HnKT27Q5ZMe6eVppaANEAXEFC5YwdDjDtCWBk</c>
        </para>
        <para>
            Description:
            </para>
        <ul>
          <li>
            <c>argon2variant</c> - Argon2 variant (argon2i, argon2d, or argon2id).
            </li>
          <li>
            <c>v=&lt;argon2version&gt;</c> - Argon2 algorithm version. Only value 19 (0x13) representing Argon2 version 1.3 is currently supported.
            </li>
          <li>
            <c>m=&lt;number&gt;</c> - amount of memory, in kilobytes (KB), used by the <see cref="T:Rebex.Security.Cryptography.Argon2" /> algorithm. Parameter 'm' from Argon2 specification.
            </li>
          <li>
            <c>t=&lt;number&gt;</c> - number of <see cref="T:Rebex.Security.Cryptography.Argon2" /> iterations. Parameter 't' from Argon2 specification.
            </li>
          <li>
            <c>p=&lt;number&gt;</c> - number of independent computation lanes. Parameter 'p' from Argon2 specification.
            </li>
          <li>
            <c>&lt;salt&gt;</c> - Base64-encoded salt. Parameter 'S' from Argon2 specification.
            </li>
          <li>
            <c>&lt;hash&gt;</c> - Base64-encoded hash of the password.
            </li>
        </ul>
      </remarks>
      <seealso cref="T:Rebex.Security.Cryptography.Argon2Type" />
      <seealso cref="T:Rebex.Security.Cryptography.Argon2Configuration" />
      <example>
        <code>
            public string HashUserPassword(string userPassword)
            {
                // Use Argon2 configuration suitable for your environment.
                // In typical 'hash user password' scenarios, the configuration does not change between
                // method calls, so it is recommended to cache the Argon2Configuration instance.
                var configuration = new Argon2Configuration(argon2Type: Argon2Type.Argon2id,
                    numberOfLanes: 4, numberOfIterations: 10, memoryCost: 65536);
                
                // The size of the raw hash to compute. Must be at least 4 bytes long.
                // Please note that the encoded hash (in string form) will be longer than the raw hash.
                int hashLength = 32;
                
                // Compute the hash of the password.
                // This method generates a random (16 bytes long) salt value.
                // To provide custom salt, use another overload of the HashPassword method.
                string encodedHash = Argon2.HashPassword(userPassword, hashLength, configuration);
                
                // Return the computed hash. Encoded hash has the following structure:
                // $argon2id$v=19$m=65536,t=10,p=4$MTIzNDU2Nzg$GVfTf0x89BTwcW7HhQMYRcgPwOzswaw6UUBWDBXP0kc
                return encodedHash;
            }
            
            // An encodedPasswordHash value previously created using the HashUserPassword method above.
            // Encoded hash has the following structure:
            // $argon2id$v=19$m=65536,t=10,p=4$MTIzNDU2Nzg$GVfTf0x89BTwcW7HhQMYRcgPwOzswaw6UUBWDBXP0kc
            public bool CanAuthenticateUser(string encodedPasswordHash, byte[] userPasswordFromUi)
            {
                // Returns true when encodePasswordHash matches the hash of userPasswordFromUi;
                // otherwise returns false.
                return Argon2.VerifyPassword(encodedPasswordHash, userPasswordFromUi);
            }
            </code>
      </example>
    </member>
    <member name="M:Rebex.Security.Cryptography.Argon2.#ctor(Rebex.Security.Cryptography.Argon2Configuration,System.Byte[],System.Byte[],System.Byte[],System.Byte[])">
      <summary>
            Initializes a new instance of <see cref="T:Rebex.Security.Cryptography.Argon2" /> class.
            </summary>
      <param name="configuration">Argon2 configuration.</param>
      <param name="password">
            The password used in <see cref="T:System.Security.Cryptography.DeriveBytes" /> method. Parameter 'P' from Argon2 specification. When a null value is specified, the password is treated as an empty array.
            </param>
      <param name="salt">
            The salt used used in <see cref="T:System.Security.Cryptography.DeriveBytes" /> method. Must be at least 8 bytes long. Parameter 'S' from Argon2 specification.
            </param>
      <param name="key">
            The secret key used in <see cref="T:System.Security.Cryptography.DeriveBytes" /> method. Parameter 'K' from Argon2 specification. When a null value is specified, the key is treated as an empty array.
            </param>
      <param name="associatedData">
            The associated data used in <see cref="T:System.Security.Cryptography.DeriveBytes" /> method. Parameter 'X' from Argon2 specification. When a null value is specified, the associatedData is treated as an empty array.
            </param>
      <exception cref="T:System.ArgumentNullException">The <paramref name="configuration" /> is null or the <paramref name="salt" /> is null.</exception>
      <exception cref="T:System.ArgumentException">The <paramref name="salt" /> has length less than 8 bytes.</exception>
      <remarks>
        <ul>
          <li>The instance of <see cref="T:Rebex.Security.Cryptography.Argon2" /> class creates, uses, and clears a copy of the <paramref name="password" />.</li>
          <li>The instance of <see cref="T:Rebex.Security.Cryptography.Argon2" /> class <strong>is not</strong> the owner of the <paramref name="password" />.</li>
          <li>The instance of <see cref="T:Rebex.Security.Cryptography.Argon2" /> class creates, uses, and clears a copy of the <paramref name="salt" />.</li>
          <li>The instance of <see cref="T:Rebex.Security.Cryptography.Argon2" /> class <strong>is not</strong> the owner of the <paramref name="salt" />.</li>
          <li>The instance of <see cref="T:Rebex.Security.Cryptography.Argon2" /> class creates, uses, and clears a copy of the <paramref name="key" />.</li>
          <li>The instance of <see cref="T:Rebex.Security.Cryptography.Argon2" /> class <strong>is not</strong> the owner of the <paramref name="key" />.</li>
          <li>The instance of <see cref="T:Rebex.Security.Cryptography.Argon2" /> class creates, uses, and clears a copy of the <paramref name="associatedData" />.</li>
          <li>The instance of <see cref="T:Rebex.Security.Cryptography.Argon2" /> class <strong>is not</strong> the owner of the <paramref name="associatedData" />.</li>
        </ul>
      </remarks>
    </member>
    <member name="M:Rebex.Security.Cryptography.Argon2.#ctor(Rebex.Security.Cryptography.Argon2Configuration,System.Byte[],System.Byte[],System.Byte[])">
      <summary>
            Initializes a new instance of <see cref="T:Rebex.Security.Cryptography.Argon2" /> class.
            </summary>
      <param name="configuration">Argon2 configuration.</param>
      <param name="password">
            The password used in the <see cref="T:System.Security.Cryptography.DeriveBytes" /> method. Parameter 'P' from Argon2 specification. When a null value is specified, the password is treated as an empty array.
            </param>
      <param name="salt">
            The salt used used in the <see cref="T:System.Security.Cryptography.DeriveBytes" /> method. Must be at least 8 bytes long. Parameter 'S' from Argon2 specification.
            </param>
      <param name="key">
            The secret used in <see cref="T:System.Security.Cryptography.DeriveBytes" /> method. Parameter 'K' from Argon2 specification. When a null value is specified, the key is treated as an empty array.
            </param>
      <exception cref="T:System.ArgumentNullException">The <paramref name="configuration" /> is null or the <paramref name="salt" /> is null.</exception>
      <exception cref="T:System.ArgumentException">The <paramref name="salt" /> has length less than 8 bytes.</exception>
      <remarks>
        <ul>
          <li>An instance of <see cref="T:Rebex.Security.Cryptography.Argon2" /> class creates, uses, and clears a copy of the <paramref name="password" />.</li>
          <li>An instance of <see cref="T:Rebex.Security.Cryptography.Argon2" /> class <strong>is not</strong> the owner of the <paramref name="password" />.</li>
          <li>An instance of <see cref="T:Rebex.Security.Cryptography.Argon2" /> class creates, uses, and clears a copy of the <paramref name="salt" />.</li>
          <li>An instance of <see cref="T:Rebex.Security.Cryptography.Argon2" /> class <strong>is not</strong> the owner of the <paramref name="salt" />.</li>
          <li>An instance of <see cref="T:Rebex.Security.Cryptography.Argon2" /> class creates, uses, and clears a copy of the <paramref name="key" />.</li>
          <li>An instance of <see cref="T:Rebex.Security.Cryptography.Argon2" /> class <strong>is not</strong> the owner of the <paramref name="key" />.</li>
        </ul>
      </remarks>
    </member>
    <member name="M:Rebex.Security.Cryptography.Argon2.#ctor(Rebex.Security.Cryptography.Argon2Configuration,System.Byte[],System.Byte[])">
      <summary>
            Initializes a new instance of <see cref="T:Rebex.Security.Cryptography.Argon2" /> class.
            </summary>
      <param name="configuration">Argon2 configuration.</param>
      <param name="password">
            The password used in the <see cref="T:System.Security.Cryptography.DeriveBytes" /> method. Parameter 'P' from Argon2 specification. When a null value is specified, the password is treated as an empty array.
            </param>
      <param name="salt">
            The salt used used in the <see cref="T:System.Security.Cryptography.DeriveBytes" /> method. Must be at least 8 bytes long. Parameter 'S' from Argon2 specification.
            </param>
      <exception cref="T:System.ArgumentNullException">The <paramref name="configuration" /> is null or the <paramref name="salt" /> is null.</exception>
      <exception cref="T:System.ArgumentOutOfRangeException">The <paramref name="salt" /> has length less than 8 bytes.</exception>
      <remarks>
        <ul>
          <li>An instance of <see cref="T:Rebex.Security.Cryptography.Argon2" /> class creates, uses, and clears a copy of the <paramref name="password" />.</li>
          <li>An instance of <see cref="T:Rebex.Security.Cryptography.Argon2" /> class <strong>is not</strong> the owner of the <paramref name="password" />.</li>
          <li>An instance of <see cref="T:Rebex.Security.Cryptography.Argon2" /> class creates, uses, and clears a copy of the <paramref name="salt" />.</li>
          <li>An instance of <see cref="T:Rebex.Security.Cryptography.Argon2" /> class <strong>is not</strong> the owner of the <paramref name="salt" />.</li>
        </ul>
      </remarks>
    </member>
    <member name="P:Rebex.Security.Cryptography.Argon2.Configuration">
      <summary>
            Gets Argon2 configuration for this instance.
            </summary>
    </member>
    <member name="M:Rebex.Security.Cryptography.Argon2.GetBytes(System.Int32)">
      <summary>
            Derives bytes (a hash) using Argon2 algorithm.
            </summary>
      <param name="cb">Number of bytes to be derived. The number of bytes must be at least 4. Parameter 'T' from Argon2 specification.</param>
      <returns>A byte array with derived bytes (a hash).</returns>
      <exception cref="T:System.ArgumentOutOfRangeException">The <paramref name="cb" /> is less than 4.</exception>
    </member>
    <member name="M:Rebex.Security.Cryptography.Argon2.Reset">
      <summary>
            Resets the state of the <see cref="T:Rebex.Security.Cryptography.Argon2" /> instance.
            </summary>
    </member>
    <member name="M:Rebex.Security.Cryptography.Argon2.HashData(System.ArraySegment{System.Byte},System.ArraySegment{System.Byte},System.ArraySegment{System.Byte},System.ArraySegment{System.Byte},System.ArraySegment{System.Byte},Rebex.Security.Cryptography.Argon2Configuration)">
      <summary>
            Computes a hash using Argon2 memory-hard hash algorithm.
            </summary>
      <param name="source">The <see cref="T:System.ArraySegment`1" /> that contains data (password) to be hashed. The 'P' parameter from Argon2 specification.</param>
      <param name="salt">The <see cref="T:System.ArraySegment`1" /> that contains the salt. Must be at least 8 bytes long. Parameter 'S' from Argon2 specification.</param>
      <param name="key">The <see cref="T:System.ArraySegment`1" /> that contains key (secret). Parameter 'K' from Argon2 specification. Can be empty.</param>
      <param name="associatedData">The <see cref="T:System.ArraySegment`1" /> that contains associated data. Parameter 'X' from Argon2 specification. Can be empty.</param>
      <param name="destination">The <see cref="T:System.ArraySegment`1" /> that will receive the calculated hash. Must be at least 4 bytes long.</param>
      <param name="configuration">Argon2 configuration.</param>
      <returns>The number of bytes written to <paramref name="destination" /> (hash size).</returns>
      <exception cref="T:System.ArgumentNullException">The <paramref name="configuration" /> is null.</exception>
      <exception cref="T:System.ArgumentException">
            The <paramref name="destination" /> length is invalid,
            or <paramref name="salt" /> length is invalid.
            </exception>
      <example>
        <code>
            public ArraySegment&lt;byte&gt; HashData()
            {
                // Data to be hashed.
                ArraySegment&lt;byte&gt; sourceData = GetSourceData();
                
                // Prepare salt. Must be at least 8 bytes long.
                ArraySegment&lt;byte&gt; salt = GetSalt();
                
                // Prepare key. Can be empty.
                ArraySegment&lt;byte&gt; key = GetKey();
                
                // Prepare associated data. Can be empty.
                ArraySegment&lt;byte&gt; associatedData = GetAssociatedData();
                
                // Use Argon2 configuration suitable for your environment.
                var configuration = new Argon2Configuration(argon2Type: Argon2Type.Argon2id,
                    numberOfLanes: 1, numberOfIterations: 4, memoryCost: 4096 /*KB*/);
                
                // Create the destination ArraySegment which will receive the computed hash.
                // Must be at least 4 bytes long, although a larger size is recommended.
                var outputHash = new ArraySegment&lt;byte&gt;(new byte[32]);
                
                // Compute the hash. Returns the hash size in bytes (32 in this case).
                int hashLength = Argon2.HashData(sourceData,
                                                 salt,
                                                 key,
                                                 associatedData,
                                                 outputHash,
                                                 configuration);
                
                // Return the computed hash for further processing.
                return outputHash;
            }
            </code>
      </example>
    </member>
    <member name="M:Rebex.Security.Cryptography.Argon2.HashData(System.ArraySegment{System.Byte},System.ArraySegment{System.Byte},System.ArraySegment{System.Byte},Rebex.Security.Cryptography.Argon2Configuration)">
      <summary>
            Computes a hash using Argon2 memory-hard hash algorithm.
            </summary>
      <param name="source">The <see cref="T:System.ArraySegment`1" /> that contains data (password) to be hashed. Parameter 'P' from Argon2 specification.</param>
      <param name="salt">The <see cref="T:System.ArraySegment`1" /> that contains the salt. Must be at least 8 bytes long. Parameter 'S' from Argon2 specification.</param>
      <param name="destination">The <see cref="T:System.ArraySegment`1" /> that will receive the calculated hash. Must be at least 4 bytes long.</param>
      <param name="configuration">Argon2 configuration.</param>
      <returns>The number of bytes written to <paramref name="destination" /> (hash size).</returns>
      <exception cref="T:System.ArgumentNullException">The <paramref name="configuration" /> is null.</exception>
      <exception cref="T:System.ArgumentException">
            The <paramref name="destination" /> length is invalid,
            or <paramref name="salt" /> length is invalid.
            </exception>
      <example>
        <code>
            public ArraySegment&lt;byte&gt; HashData()
            {
                // Data to be hashed.
                ArraySegment&lt;byte&gt; sourceData = GetSourceData();
                
                // Prepare salt. Must be at least 8 bytes long.
                ArraySegment&lt;byte&gt; salt = GetSalt();
                
                // Use Argon2 configuration suitable for your environment.
                var configuration = new Argon2Configuration(argon2Type: Argon2Type.Argon2id,
                    numberOfLanes: 1, numberOfIterations: 4, memoryCost: 4096 /*KB*/);
                
                // Create the destination ArraySegment which will receive the computed hash.
                // Must be at least 4 bytes long, although a larger size is recommended.
                var outputHash = new ArraySegment&lt;byte&gt;(new byte[32]);
               
                // Compute the hash. Returns the hash size in bytes (32 in this case).
                int hashLength = Argon2.HashData(sourceData,
                                                 salt,
                                                 outputHash,
                                                 configuration);
                
                // Return the computed hash for further processing.
                return outputHash;
            }
            </code>
      </example>
    </member>
    <member name="M:Rebex.Security.Cryptography.Argon2.HashData(System.ArraySegment{System.Byte},System.ArraySegment{System.Byte},System.Int32,Rebex.Security.Cryptography.Argon2Configuration)">
      <summary>
            Computes a hash using Argon2 memory-hard hash algorithm.
            </summary>
      <param name="source">The <see cref="T:System.ArraySegment`1" /> that contains data (password) to be hashed. Parameter 'P' from Argon2 specification.</param>
      <param name="salt">The <see cref="T:System.ArraySegment`1" /> that contains the salt. Must be at least 8 bytes long. Parameter 'S' from Argon2 specification.</param>
      <param name="hashLength">The required hash length. Must be at least 4 bytes long. Parameter 'T' from Argon2 specification.</param>
      <param name="configuration">Argon2 configuration.</param>
      <returns>A byte array that contains the computed hash.</returns>
      <exception cref="T:System.ArgumentNullException">The <paramref name="configuration" /> is null.</exception>
      <exception cref="T:System.ArgumentException">The <paramref name="salt" /> length is invalid.</exception>
      <exception cref="T:System.ArgumentOutOfRangeException">The <paramref name="hashLength" /> is invalid.</exception>
      <example>
        <code>
            public byte[] HashData()
            {
                // Data to be hashed.
                ArraySegment&lt;byte&gt; sourceData = GetSourceData();
                
                // Prepare salt. Must be at least 8 bytes long.
                ArraySegment&lt;byte&gt; salt = GetSalt();
                
                // Use Argon2 configuration suitable for your environment.
                var configuration = new Argon2Configuration(argon2Type: Argon2Type.Argon2id,
                    numberOfLanes: 1, numberOfIterations: 4, memoryCost: 4096 /*KB*/);
                
                // The size of the hash to compute. Must be at least 4 bytes long.
                int requiredHashSize = 32;
                
                // Compute the hash.
                byte[] hash = Argon2.HashData(sourceData,
                                              salt,
                                              requiredHashSize,
                                              configuration);
                
                // Return the computed hash for further processing.
                return hash;
            }
            </code>
      </example>
    </member>
    <member name="M:Rebex.Security.Cryptography.Argon2.HashData(System.Byte[],System.Byte[],System.Int32,Rebex.Security.Cryptography.Argon2Configuration)">
      <summary>
            Computes a hash using Argon2 memory-hard hash algorithm.
            </summary>
      <param name="source">The byte array that contains data (password) to be hashed. Parameter 'P' from Argon2 specification.</param>
      <param name="salt">The byte array that contains the salt. Must be at least 8 bytes long. Parameter 'S' from Argon2 specification.</param>
      <param name="hashLength">The required hash length. Must be at least 4 bytes long. Parameter 'T' from Argon2 specification.</param>
      <param name="configuration">Argon2 configuration.</param>
      <returns>A byte array that contains the computed hash.</returns>
      <exception cref="T:System.ArgumentNullException">
            The <paramref name="configuration" /> is null, or
            the <paramref name="salt" /> is null.
            </exception>
      <exception cref="T:System.ArgumentException">The <paramref name="salt" /> length is invalid.</exception>
      <exception cref="T:System.ArgumentOutOfRangeException">The <paramref name="hashLength" /> is invalid.</exception>
      <example>
        <code>
            public byte[] HashData()
            {
                // Data to be hashed.
                byte[] sourceData = GetSourceData();
                
                // Prepare salt. Must be at least 8 bytes long.
                byte[] salt = GetSalt();
                
                // Use Argon2 configuration suitable for your environment.
                var configuration = new Argon2Configuration(argon2Type: Argon2Type.Argon2id,
                    numberOfLanes: 1, numberOfIterations: 4, memoryCost: 4096 /*KB*/);
                
                // The size of the hash to compute. Must be at least 4 bytes long.
                int requiredHashSize = 32;
                
                // Compute the hash.
                byte[] hash = Argon2.HashData(sourceData,
                                              salt,
                                              requiredHashSize,
                                              configuration);
                
                // Return the computed hash for further processing.
                return hash;
            }
            </code>
      </example>
    </member>
    <member name="M:Rebex.Security.Cryptography.Argon2.HashPassword(System.ArraySegment{System.Byte},System.ArraySegment{System.Byte},System.Int32,Rebex.Security.Cryptography.Argon2Configuration)">
      <summary>
            Computes a hash of the specified <paramref name="password" /> and returns it in encoded form.
            The format of the encoded hash is described in the remarks section of <see cref="T:Rebex.Security.Cryptography.Argon2" /> class documentation.
            </summary>
      <param name="password">The <see cref="T:System.ArraySegment`1" /> that contains a password to hash. Parameter 'P' from Argon2 specification.</param>
      <param name="salt">The <see cref="T:System.ArraySegment`1" /> that contains the salt. Must be at least 8 bytes long. Parameter 'S' from Argon2 specification.
            When the <paramref name="salt" /> is empty, a random (16 bytes long) salt will be generated.</param>
      <param name="hashLength">The required hash length. Must be at least 4 bytes long. Parameter 'T' from Argon2 specification.</param>
      <param name="configuration">Argon2 configuration.</param>
      <returns>A string that contains an encoded hash of the <paramref name="password" />.</returns>
      <exception cref="T:System.ArgumentNullException">The <paramref name="configuration" /> is null.</exception>
      <exception cref="T:System.ArgumentException">The <paramref name="salt" /> length is invalid.</exception>
      <exception cref="T:System.ArgumentOutOfRangeException">The <paramref name="hashLength" /> is invalid.</exception>
      <seealso cref="M:Rebex.Security.Cryptography.Argon2.VerifyPassword(System.String,System.ArraySegment{System.Byte})" />
      <example>
        <code>
            public string HashPassword(ArraySegment&lt;byte&gt; password, ArraySegment&lt;byte&gt; salt)
            {
                // Convert password to a byte array segment.
                var passwordBytes = new ArraySegment&lt;byte&gt;(Encoding.UTF8.GetBytes(password));
                
                // Use Argon2 configuration suitable for your environment.
                var configuration = new Argon2Configuration(argon2Type: Argon2Type.Argon2id,
                    numberOfLanes: 4, numberOfIterations: 10, memoryCost: 65536);
                
                // The size of the raw hash to compute. Must be at least 4 bytes long.
                // Please note that the encoded hash (in string form) will be longer than the raw hash.
                int hashLength = 32;
                
                // Compute the hash of the password.
                string encodedHash = Argon2.HashPassword(passwordBytes, salt, hashLength, configuration);
                
                // Return the computed hash. Encoded hash has the following structure:
                // $argon2id$v=19$m=65536,t=10,p=4$MTIzNDU2Nzg$GVfTf0x89BTwcW7HhQMYRcgPwOzswaw6UUBWDBXP0kc
                return encodedHash;
            }
            </code>
      </example>
    </member>
    <member name="M:Rebex.Security.Cryptography.Argon2.HashPassword(System.String,System.ArraySegment{System.Byte},System.Int32,Rebex.Security.Cryptography.Argon2Configuration)">
      <summary>
            Computes a hash of the specified <paramref name="password" /> and returns it in encoded form.
            The format of the encoded hash is described in the remarks section of <see cref="T:Rebex.Security.Cryptography.Argon2" /> class documentation.
            </summary>
      <param name="password">
            The string that contains a password to hash. Parameter 'P' from Argon2 specification.
            The <paramref name="password" /> is converted to a byte array (using the UTF-8 character encoding) before the hashing operation.
            When the <paramref name="password" /> is null, it will be treated as an empty string.</param>
      <param name="salt">The <see cref="T:System.ArraySegment`1" /> that contains the salt. Must be at least 8 bytes long. Parameter 'S' from Argon2 specification.
            When the <paramref name="salt" /> is empty, a random (16 bytes long) salt will be generated.</param>
      <param name="hashLength">The required hash length. Must be at least 4 bytes long. Parameter 'T' from Argon2 specification.</param>
      <param name="configuration">Argon2 configuration.</param>
      <returns>A string that contains an encoded hash of the <paramref name="password" />.</returns>
      <exception cref="T:System.ArgumentNullException">The <paramref name="configuration" /> is null.</exception>
      <exception cref="T:System.ArgumentException">The <paramref name="salt" /> length is invalid.</exception>
      <exception cref="T:System.ArgumentOutOfRangeException">The <paramref name="hashLength" /> is invalid.</exception>
      <seealso cref="M:Rebex.Security.Cryptography.Argon2.VerifyPassword(System.String,System.String)" />
      <example>
        <code>
            public string HashPassword(string password, ArraySegment&lt;byte&gt; salt)
            {
                // Use Argon2 configuration suitable for your environment.
                var configuration = new Argon2Configuration(argon2Type: Argon2Type.Argon2id,
                    numberOfLanes: 4, numberOfIterations: 10, memoryCost: 65536);
                
                // The size of the raw hash to compute. Must be at least 4 bytes long.
                // Please note that the encoded hash (in string form) will be longer than the raw hash.
                int hashLength = 32;
                
                // Compute the hash of the password.
                string encodedHash = Argon2.HashPassword(password, salt, hashLength, configuration);
                
                // Return the computed hash. Encoded hash has the following structure:
                // $argon2id$v=19$m=65536,t=10,p=4$MTIzNDU2Nzg$GVfTf0x89BTwcW7HhQMYRcgPwOzswaw6UUBWDBXP0kc
                return encodedHash;
            }
            </code>
      </example>
    </member>
    <member name="M:Rebex.Security.Cryptography.Argon2.HashPassword(System.ArraySegment{System.Byte},System.Int32,Rebex.Security.Cryptography.Argon2Configuration)">
      <summary>
            Computes a hash of the specified <paramref name="password" /> and returns it in encoded form.
            The method generates a random (16 bytes long) salt (parameter 'S' from Argon2 specification) before hashing.
            The format of the encoded hash is described in the remarks section of <see cref="T:Rebex.Security.Cryptography.Argon2" /> class documentation.
            </summary>
      <param name="password">The <see cref="T:System.ArraySegment`1" /> that contains a password to hash. Parameter 'P' from Argon2 specification.</param>
      <param name="hashLength">The required hash length. Must be at least 4 bytes long. Parameter 'T' from Argon2 specification.</param>
      <param name="configuration">Argon2 configuration.</param>
      <returns>A string that contains an encoded hash of the <paramref name="password" />.</returns>
      <exception cref="T:System.ArgumentNullException">The <paramref name="configuration" /> is null.</exception>
      <exception cref="T:System.ArgumentOutOfRangeException">The <paramref name="hashLength" /> is invalid.</exception>
      <seealso cref="M:Rebex.Security.Cryptography.Argon2.VerifyPassword(System.String,System.ArraySegment{System.Byte})" />
      <example>
        <code>
            public string HashPassword(ArraySegment&lt;byte&gt; password)
            {
                // Use Argon2 configuration suitable for your environment.
                var configuration = new Argon2Configuration(argon2Type: Argon2Type.Argon2id,
                    numberOfLanes: 4, numberOfIterations: 10, memoryCost: 65536);
                
                // The size of the raw hash to compute. Must be at least 4 bytes long.
                // Please note that the encoded hash (in string form) will be longer than the raw hash.
                int hashLength = 32;
                
                // Compute the hash of the password.
                // This method generates a random (16 bytes long) salt value.
                string encodedHash = Argon2.HashPassword(password, hashLength, configuration);
                
                // Return the computed hash. Encoded hash has the following structure.
                // $argon2id$v=19$m=65536,t=10,p=4$MTIzNDU2Nzg$GVfTf0x89BTwcW7HhQMYRcgPwOzswaw6UUBWDBXP0kc
                return encodedHash;
            }
            </code>
      </example>
    </member>
    <member name="M:Rebex.Security.Cryptography.Argon2.HashPassword(System.String,System.Int32,Rebex.Security.Cryptography.Argon2Configuration)">
      <summary>
            Computes a hash of the specified <paramref name="password" /> and returns it in encoded form.
            The method generates a random (16 bytes long) salt (parameter 'S' from Argon2 specification) before hashing.
            The format of the encoded hash is described in the remarks section of <see cref="T:Rebex.Security.Cryptography.Argon2" /> class documentation.
            </summary>
      <param name="password">
            The string that contains a password to hash. Parameter 'P' from Argon2 specification.
            The <paramref name="password" /> is converted to a byte array (using the UTF-8 character encoding) before the hashing operation.
            When the <paramref name="password" /> is null, it will be treated as an empty string.</param>
      <param name="hashLength">The required hash length. Must be at least 4 bytes long. Parameter 'T' from Argon2 specification.</param>
      <param name="configuration">Argon2 configuration.</param>
      <returns>A string that contains an encoded hash of the <paramref name="password" />.</returns>
      <exception cref="T:System.ArgumentNullException">The <paramref name="configuration" /> is null.</exception>
      <exception cref="T:System.ArgumentOutOfRangeException">The <paramref name="hashLength" /> is invalid.</exception>
      <seealso cref="M:Rebex.Security.Cryptography.Argon2.VerifyPassword(System.String,System.String)" />
      <example>
        <code>
            public string HashPassword(string password)
            {
                // Use Argon2 configuration suitable for your environment.
                var configuration = new Argon2Configuration(argon2Type: Argon2Type.Argon2id,
                    numberOfLanes: 4, numberOfIterations: 10, memoryCost: 65536);
                
                // The size of the raw hash to compute. Must be at least 4 bytes long.
                // Please note that the encoded hash (in string form) will be longer than the raw hash.
                int hashLength = 32;
                
                // Compute the hash of the password.
                // This method generates a random (16 bytes long) salt value.
                string encodedHash = Argon2.HashPassword(password, hashLength, configuration);
                
                // Return the computed hash. Encoded hash has the following structure.
                // $argon2id$v=19$m=65536,t=10,p=4$MTIzNDU2Nzg$GVfTf0x89BTwcW7HhQMYRcgPwOzswaw6UUBWDBXP0kc
                return encodedHash;
            }
            </code>
      </example>
    </member>
    <member name="M:Rebex.Security.Cryptography.Argon2.HashPassword(System.Byte[],System.Byte[],System.Int32,Rebex.Security.Cryptography.Argon2Configuration)">
      <summary>
            Computes a hash of the specified <paramref name="password" /> and returns it in encoded form.
            The format of the encoded hash is described in the remarks section of <see cref="T:Rebex.Security.Cryptography.Argon2" /> class documentation.
            </summary>
      <param name="password">
            The byte array that contains a password to hash. Parameter 'P' from Argon2 specification.
            When the <paramref name="password" /> is null, it will be treated as an empty array.</param>
      <param name="salt">The byte array that contains the salt. Must be at least 8 bytes long. Parameter 'S' from Argon2 specification.
            When the <paramref name="salt" /> is null or empty, a random (16 bytes long) salt will be generated.</param>
      <param name="hashLength">The required hash length. Must be at least 4 bytes long. Parameter 'T' from Argon2 specification.</param>
      <param name="configuration">Argon2 configuration.</param>
      <returns>A string that contains an encoded hash of the <paramref name="password" />.</returns>
      <exception cref="T:System.ArgumentNullException">The <paramref name="configuration" /> is null.</exception>
      <exception cref="T:System.ArgumentException">The <paramref name="salt" /> length is invalid.</exception>
      <exception cref="T:System.ArgumentOutOfRangeException">The <paramref name="hashLength" /> is invalid.</exception>
      <seealso cref="M:Rebex.Security.Cryptography.Argon2.VerifyPassword(System.String,System.Byte[])" />
      <example>
        <code>
            public string HashPassword(string password, byte[] salt)
            {
                // Convert password to a byte array.
                byte[] passwordBytes = Encoding.UTF8.GetBytes(password);
                
                // Use Argon2 configuration suitable for your environment.
                var configuration = new Argon2Configuration(argon2Type: Argon2Type.Argon2id,
                    numberOfLanes: 4, numberOfIterations: 10, memoryCost: 65536);
                
                // The size of the raw hash to compute. Must be at least 4 bytes long.
                // Please note that the encoded hash (in string form) will be longer than the raw hash.
                int hashLength = 32;
                
                // Compute the hash of the password.
                string encodedHash = Argon2.HashPassword(passwordBytes, salt, hashLength, configuration);
                
                // Return the computed hash. Encoded hash has the following structure:
                // $argon2id$v=19$m=65536,t=10,p=4$MTIzNDU2Nzg$GVfTf0x89BTwcW7HhQMYRcgPwOzswaw6UUBWDBXP0kc
                return encodedHash;
            }
            </code>
      </example>
    </member>
    <member name="M:Rebex.Security.Cryptography.Argon2.HashPassword(System.String,System.Byte[],System.Int32,Rebex.Security.Cryptography.Argon2Configuration)">
      <summary>
            Computes a hash of the specified <paramref name="password" /> and returns it in encoded form.
            The format of the encoded hash is described in the remarks section of <see cref="T:Rebex.Security.Cryptography.Argon2" /> class documentation.
            </summary>
      <param name="password">
            The string that contains a password to hash. Parameter 'P' from Argon2 specification.
            The <paramref name="password" /> is converted to a byte array (using the UTF-8 character encoding) before the hashing operation.
            When the <paramref name="password" /> is null, it will be treated as an empty string.</param>
      <param name="salt">The byte array that contains the salt. Must be at least 8 bytes long. Parameter 'S' from Argon2 specification.
            When the <paramref name="salt" /> is null or empty, a random (16 bytes long) salt will be generated.</param>
      <param name="hashLength">The required hash length. Must be at least 4 bytes long. Parameter 'T' from Argon2 specification.</param>
      <param name="configuration">Argon2 configuration.</param>
      <returns>A string that contains an encoded hash of the <paramref name="password" />.</returns>
      <exception cref="T:System.ArgumentNullException">The <paramref name="configuration" /> is null.</exception>
      <exception cref="T:System.ArgumentException">The <paramref name="salt" /> length is invalid.</exception>
      <exception cref="T:System.ArgumentOutOfRangeException">The <paramref name="hashLength" /> is invalid.</exception>
      <seealso cref="M:Rebex.Security.Cryptography.Argon2.VerifyPassword(System.String,System.String)" />
      <example>
        <code>
            public string HashPassword(string password, byte[] salt)
            {
                // Use Argon2 configuration suitable for your environment.
                var configuration = new Argon2Configuration(argon2Type: Argon2Type.Argon2id,
                    numberOfLanes: 4, numberOfIterations: 10, memoryCost: 65536);
                
                // The size of the raw hash to compute. Must be at least 4 bytes long.
                // Please note that the encoded hash (in string form) will be longer than the raw hash.
                int hashLength = 32;
                
                // Compute the hash of the password.
                string encodedHash = Argon2.HashPassword(password, salt, hashLength, configuration);
                
                // Return the computed hash. Encoded hash has the following structure:
                // $argon2id$v=19$m=65536,t=10,p=4$MTIzNDU2Nzg$GVfTf0x89BTwcW7HhQMYRcgPwOzswaw6UUBWDBXP0kc
                return encodedHash;
            }
            </code>
      </example>
    </member>
    <member name="M:Rebex.Security.Cryptography.Argon2.HashPassword(System.Byte[],System.Int32,Rebex.Security.Cryptography.Argon2Configuration)">
      <summary>
            Computes a hash of the specified <paramref name="password" /> and returns it in encoded form.
            Generates a random (16 bytes long) salt (parameter 'S' from Argon2 specification) before hashing.
            The format of the encoded hash is described in the remarks section of <see cref="T:Rebex.Security.Cryptography.Argon2" /> class documentation.
            </summary>
      <param name="password">The byte array that contains a password to hash. Parameter 'P' from Argon2 specification.
            When the <paramref name="password" /> is null, it will be treated as an empty string.</param>
      <param name="hashLength">The required hash length. Must be at least 4 bytes long. Parameter 'T' from Argon2 specification.</param>
      <param name="configuration">Argon2 configuration.</param>
      <returns>A string that contains an encoded hash of the <paramref name="password" />.</returns>
      <exception cref="T:System.ArgumentNullException">The <paramref name="configuration" /> is null.</exception>
      <exception cref="T:System.ArgumentOutOfRangeException">The <paramref name="hashLength" /> is invalid.</exception>
      <seealso cref="M:Rebex.Security.Cryptography.Argon2.VerifyPassword(System.String,System.String)" />
      <example>
        <code>
            public string HashPassword(string password)
            {
                // Convert password to a byte array.
                byte[] passwordBytes = Encoding.UTF8.GetBytes(password);
                
                // Use Argon2 configuration suitable for your environment.
                var configuration = new Argon2Configuration(argon2Type: Argon2Type.Argon2id,
                    numberOfLanes: 4, numberOfIterations: 10, memoryCost: 65536);
                
                // The size of the raw hash to compute. Must be at least 4 bytes long.
                // Please note that the encoded hash (in string form) will be longer than the raw hash.
                int hashLength = 32;
                
                // Compute the hash of the password.
                // This method generates a random 16-bytes long salt value.
                string encodedHash = Argon2.HashPassword(passwordBytes, hashLength, configuration);
                
                // Return the computed hash. Encoded hash has the following structure:
                // $argon2id$v=19$m=65536,t=10,p=4$MTIzNDU2Nzg$GVfTf0x89BTwcW7HhQMYRcgPwOzswaw6UUBWDBXP0kc
                return encodedHash;
            }
            </code>
      </example>
    </member>
    <member name="M:Rebex.Security.Cryptography.Argon2.VerifyPassword(System.String,System.ArraySegment{System.Byte})">
      <summary>
            Verifies that the <paramref name="encodedPasswordHash" /> matches the hash of the <paramref name="password" />.
            The format of the encoded hash is described in the remarks section of <see cref="T:Rebex.Security.Cryptography.Argon2" /> class documentation.
            </summary>
      <remarks>
            Encoded hash can be created using a <c>HashPassword</c> method.
            </remarks>
      <param name="encodedPasswordHash">The string that contains an encoded password hash.</param>
      <param name="password">The <see cref="T:System.ArraySegment`1" /> that contains a password to hash and compare with <paramref name="encodedPasswordHash" />.</param>
      <returns>True if the <paramref name="encodedPasswordHash" /> matches the <paramref name="password" />; otherwise false.</returns>
      <exception cref="T:System.ArgumentException">The <paramref name="encodedPasswordHash" /> has invalid format.</exception>
      <seealso cref="M:Rebex.Security.Cryptography.Argon2.HashPassword(System.ArraySegment{System.Byte},System.ArraySegment{System.Byte},System.Int32,Rebex.Security.Cryptography.Argon2Configuration)" />
      <seealso cref="M:Rebex.Security.Cryptography.Argon2.HashPassword(System.ArraySegment{System.Byte},System.Int32,Rebex.Security.Cryptography.Argon2Configuration)" />
      <example>
        <code>
            // encodedPasswordHash has been previously created using the HashPassword method.
            // Encoded password hash has the following structure:
            // $argon2id$v=19$m=65536,t=10,p=4$MTIzNDU2Nzg$GVfTf0x89BTwcW7HhQMYRcgPwOzswaw6UUBWDBXP0kc
            public bool CanAuthenticateUser(string encodedPasswordHash, string userPasswordFromUi)
            {
                // Convert password to a byte array segment.
                var passwordBytes = new ArraySegment&lt;byte&gt;(Encoding.UTF8.GetBytes(userPasswordFromUi));
                
                // Returns true when encodePasswordHash matches the hash of userPasswordFromUi;
                // otherwise returns false.
                return Argon2.VerifyPassword(encodedPasswordHash, passwordBytes);
            }
            </code>
      </example>
    </member>
    <member name="M:Rebex.Security.Cryptography.Argon2.VerifyPassword(System.String,System.String)">
      <summary>
            Verifies that the <paramref name="encodedPasswordHash" /> matches the hash of the <paramref name="password" />.
            The format of the encoded hash is described in the remarks section of <see cref="T:Rebex.Security.Cryptography.Argon2" /> class documentation.
            </summary>
      <remarks>
            Encoded hash can be created using a <c>HashPassword</c> method.
            </remarks>
      <param name="encodedPasswordHash">The string that contains an encoded password hash.</param>
      <param name="password">
            The <see cref="T:System.String" /> that contains a password to hash compare with <paramref name="encodedPasswordHash" />.
            The <paramref name="password" /> is converted to a byte array (using the UTF-8 character encoding) before the hashing operation.
            When the <paramref name="password" /> is null, it will be treated as an empty string.
            </param>
      <returns>True if the <paramref name="encodedPasswordHash" /> matches the <paramref name="password" />; otherwise false.</returns>
      <exception cref="T:System.ArgumentException">The <paramref name="encodedPasswordHash" /> has invalid format.</exception>
      <seealso cref="M:Rebex.Security.Cryptography.Argon2.HashPassword(System.String,System.ArraySegment{System.Byte},System.Int32,Rebex.Security.Cryptography.Argon2Configuration)" />
      <seealso cref="M:Rebex.Security.Cryptography.Argon2.HashPassword(System.String,System.Int32,Rebex.Security.Cryptography.Argon2Configuration)" />
      <seealso cref="M:Rebex.Security.Cryptography.Argon2.HashPassword(System.String,System.Byte[],System.Int32,Rebex.Security.Cryptography.Argon2Configuration)" />
      <example>
        <code>
            // encodedPasswordHash has been previously created using the HashPassword method.
            // Encoded hash has the following structure:
            // $argon2id$v=19$m=65536,t=10,p=4$MTIzNDU2Nzg$GVfTf0x89BTwcW7HhQMYRcgPwOzswaw6UUBWDBXP0kc
            public bool CanAuthenticateUser(string encodedPasswordHash, string userPasswordFromUi)
            {
                // Returns true when encodePasswordHash matches the hash of userPasswordFromUi;
                // otherwise returns false.
                return Argon2.VerifyPassword(encodedPasswordHash, userPasswordFromUi);
            }
            </code>
      </example>
    </member>
    <member name="M:Rebex.Security.Cryptography.Argon2.VerifyPassword(System.String,System.Byte[])">
      <summary>
            Verifies that the <paramref name="encodedPasswordHash" /> matches the hash of the <paramref name="password" />.
            The format of the encoded hash is described in the remarks section of <see cref="T:Rebex.Security.Cryptography.Argon2" /> class documentation.
            </summary>
      <remarks>
            Encoded hash can be created using a <c>HashPassword</c> method.
            </remarks>
      <param name="encodedPasswordHash">The string that contains an encoded password hash.</param>
      <param name="password">
            The byte array that contains a password to hash and compare with <paramref name="encodedPasswordHash" />.
            When the <paramref name="password" /> is null, it will be treated as an empty array.
            </param>
      <returns>True if the <paramref name="encodedPasswordHash" /> matches the <paramref name="password" />; otherwise false.</returns>
      <exception cref="T:System.ArgumentException">The <paramref name="encodedPasswordHash" /> has invalid format.</exception>
      <seealso cref="M:Rebex.Security.Cryptography.Argon2.HashPassword(System.Byte[],System.Byte[],System.Int32,Rebex.Security.Cryptography.Argon2Configuration)" />
      <seealso cref="M:Rebex.Security.Cryptography.Argon2.HashPassword(System.Byte[],System.Int32,Rebex.Security.Cryptography.Argon2Configuration)" />
      <example>
        <code>
            // encodedPasswordHash has been previously created using the HashPassword method.
            // Encoded hash has the following structure:
            // $argon2id$v=19$m=65536,t=10,p=4$MTIzNDU2Nzg$GVfTf0x89BTwcW7HhQMYRcgPwOzswaw6UUBWDBXP0kc
            public bool CanAuthenticateUser(string encodedPasswordHash, byte[] userPasswordFromUi)
            {
                // Returns true when encodePasswordHash matches the hash of userPasswordFromUi;
                // otherwise returns false.
                return Argon2.VerifyPassword(encodedPasswordHash, userPasswordFromUi);
            }
            </code>
      </example>
    </member>
    <member name="T:Rebex.Security.Cryptography.Argon2Configuration">
      <summary>
            Configuration for <see cref="T:Rebex.Security.Cryptography.Argon2" /> class.
            </summary>
      <seealso cref="T:Rebex.Security.Cryptography.Argon2" />
      <seealso cref="T:Rebex.Security.Cryptography.Argon2Type" />
    </member>
    <member name="M:Rebex.Security.Cryptography.Argon2Configuration.#ctor(Rebex.Security.Cryptography.Argon2Type,System.Int32,System.Int32,System.Int32)">
      <summary>
            Initializes a new instance of <see cref="T:Rebex.Security.Cryptography.Argon2Configuration" /> class.
            </summary>
      <param name="argon2Type">The type of Argon2 algorithm. Parameter 'y' from Argon2 specification.</param>
      <param name="numberOfLanes">The number of independent computation lanes. Parameter 'p' from Argon2 specification. This valid range for this value is 1 to 16 777 215.</param>
      <param name="numberOfIterations">The number of <see cref="T:Rebex.Security.Cryptography.Argon2" /> iterations. Parameter 't' from Argon2 specification. This value must be greater than 0.</param>
      <param name="memoryCost">The amount of memory, in kilobytes (KB), used by the <see cref="T:Rebex.Security.Cryptography.Argon2" /> algorithm. Parameter 'm' from Argon2 specification. This value must be equal to or greater than 1 KB.</param>
      <exception cref="T:System.ArgumentOutOfRangeException">
            The <paramref name="argon2Type" /> is not defined;
            or the <paramref name="numberOfLanes" /> has an invalid value;
            or <paramref name="numberOfIterations" /> has an invalid value;
            or the <paramref name="memoryCost" /> has an invalid value.
            </exception>
    </member>
    <member name="P:Rebex.Security.Cryptography.Argon2Configuration.Argon2Type">
      <summary>
            Gets the type of the Argon2 algorithm. Parameter 'y' from Argon2 specification.
            </summary>
    </member>
    <member name="P:Rebex.Security.Cryptography.Argon2Configuration.NumberOfLanes">
      <summary>
            Gets the number of the independent computation lanes. Parameter 'p' from Argon2 specification.
            </summary>
    </member>
    <member name="P:Rebex.Security.Cryptography.Argon2Configuration.NumberOfIterations">
      <summary>
            Gets the number of <see cref="T:Rebex.Security.Cryptography.Argon2" /> iterations. Parameter 't' from Argon2 specification.
            </summary>
    </member>
    <member name="P:Rebex.Security.Cryptography.Argon2Configuration.MemoryCost">
      <summary>
            The amount of memory used by the <see cref="T:Rebex.Security.Cryptography.Argon2" /> algorithm, in kilobytes (KB). Parameter 'm' from Argon2 specification.
            </summary>
    </member>
    <member name="M:Rebex.Security.Cryptography.Argon2Configuration.Equals(Rebex.Security.Cryptography.Argon2Configuration)">
      <summary>
            Determines whether the specified <paramref name="other" /> is equal to this object.
            </summary>
      <param name="other">The <see cref="T:Rebex.Security.Cryptography.Argon2Configuration" /> to compare with this object.</param>
      <returns>
        <c>true</c> if the specified <paramref name="other" /> is equal to this object; otherwise, <c>false</c>.
            </returns>
    </member>
    <member name="M:Rebex.Security.Cryptography.Argon2Configuration.Equals(System.Object)">
      <summary>
            Determines whether the specified <paramref name="obj" /> is equal to this object.
            </summary>
      <param name="obj">The <see cref="T:System.Object" /> to compare with this object.</param>
      <returns>
        <c>true</c> if the specified <paramref name="obj" /> is equal to this object; otherwise, <c>false</c>.
            </returns>
    </member>
    <member name="M:Rebex.Security.Cryptography.Argon2Configuration.GetHashCode">
      <summary>
            Gets a hash code of this object.
            </summary>
      <returns>
            A hash code of this object.
            </returns>
    </member>
    <member name="M:Rebex.Security.Cryptography.Argon2Configuration.ToString">
      <summary>
            Returns a string representation of this <see cref="T:Rebex.Security.Cryptography.Argon2Configuration" />.
            </summary>
      <returns>A string representation of this object.</returns>
    </member>
    <member name="T:Rebex.Security.Cryptography.Argon2Type">
      <summary>
            Specifies a variant of the <see cref="T:Rebex.Security.Cryptography.Argon2" /> algorithm.
            </summary>
      <seealso cref="T:Rebex.Security.Cryptography.Argon2" />
      <seealso cref="T:Rebex.Security.Cryptography.Argon2Configuration" />
    </member>
    <member name="F:Rebex.Security.Cryptography.Argon2Type.Argon2d">
      <summary>
            Argon 2 with data-dependent memory addressing. Argon2d is usually faster than other variants, but it is more vulnerable to side-channel attacks.
            </summary>
    </member>
    <member name="F:Rebex.Security.Cryptography.Argon2Type.Argon2i">
      <summary>
            Argon 2 with data-independent memory addressing. 
            </summary>
    </member>
    <member name="F:Rebex.Security.Cryptography.Argon2Type.Argon2id">
      <summary>
            Argon2id uses both data-dependent memory addressing and data-independent memory addressing.
            This variant of <see cref="T:Rebex.Security.Cryptography.Argon2" /> is recommended for password hashing and password-based key derivation.
            </summary>
    </member>
    <member name="T:Rebex.Security.Cryptography.Blake2b">
      <summary>
             This class represents the BLAKE2b cryptographic hash and message authentication code (MAC) algorithm with custom (user-defined) hash size.
             Specified by <a href="https://datatracker.ietf.org/doc/html/rfc7693">RFC 7693</a>.
             BLAKE2 provides better security than SHA-2 (it is comparable to that of SHA-3).
             </summary>
      <example>
        <code>
             // sourceData argument contains data to be hashed.
             // hashSizeInBytes argument specifies the requested hash size (1-64 bytes).
             public byte[] CalculateHash(byte[] sourceData, int hashSizeInBytes)
             {
                 // create an instance of Blake2b class
                 using (var blake2b = new Blake2b(hashSizeInBytes))
                 {
                     // compute and return the hash
                     return blake2b.ComputeHash(sourceData);
            
                 } // blake2b instance is disposed
             }
             </code>
      </example>
      <seealso cref="T:Rebex.Security.Cryptography.Blake2b256" />
      <seealso cref="T:Rebex.Security.Cryptography.Blake2b384" />
      <seealso cref="T:Rebex.Security.Cryptography.Blake2b512" />
      <seealso cref="M:Rebex.Security.Cryptography.Blake2b256.HashData(System.ArraySegment{System.Byte},System.ArraySegment{System.Byte})" />
      <seealso cref="M:Rebex.Security.Cryptography.Blake2b384.HashData(System.ArraySegment{System.Byte},System.ArraySegment{System.Byte})" />
      <seealso cref="M:Rebex.Security.Cryptography.Blake2b512.HashData(System.ArraySegment{System.Byte},System.ArraySegment{System.Byte})" />
    </member>
    <member name="M:Rebex.Security.Cryptography.Blake2b.#ctor(System.Int32,System.Byte[])">
      <summary>
            Initializes a new instance of the <see cref="T:Rebex.Security.Cryptography.Blake2b" /> class.
            </summary>
      <param name="hashSizeInBytes">
            Output hash size in bytes.
            The hash size must be a value between 1 and 64 bytes.
            It is strongly recommended to use a hash size of 32 bytes or more.
            </param>
      <param name="key">
        <para>Key to use in HMAC calculation.</para>
        <para>
            The <paramref name="key" /> must be a 0 - 64 bytes long array or null. When a null value is provided, the key is treated as an empty array.
            When the <paramref name="key" /> is null or an empty array, the instance will calculate hashes.
            When the <paramref name="key" /> is 1 - 64 bytes long, the instance will calculate message authentication codes (HMAC).
            An instance of the <see cref="T:Rebex.Security.Cryptography.Blake2b" /> class creates, uses, and clears a copy of the <paramref name="key" />.
            An instance of the <see cref="T:Rebex.Security.Cryptography.Blake2b" /> class <strong>is not</strong> the owner of the <paramref name="key" />
            and the <paramref name="key" /><strong>will not</strong> be cleared when the <see cref="M:Rebex.Security.Cryptography.Blake2b.Dispose(System.Boolean)" /> method is called.
            The owner of the <paramref name="key" /> should clear the key.
            </para>
      </param>
    </member>
    <member name="M:Rebex.Security.Cryptography.Blake2b.#ctor(System.Int32)">
      <summary>
            Initializes a new instance of the <see cref="T:Rebex.Security.Cryptography.Blake2b" /> class.
            </summary>
      <param name="hashSizeInBytes">
            Output hash size in bytes.
            The hash size must be a value between 1 and 64 bytes.
            It is strongly recommended to use a hash size of 32 bytes or more.
            </param>
    </member>
    <member name="P:Rebex.Security.Cryptography.Blake2b.Key">
      <summary>
        <para>Key to use in HMAC calculations.</para>
        <para>
            The key must be a 0 - 64 bytes long array or null. When a null value is provided, the key is treated as an empty array.
            When the key is null or an empty array, the instance will calculate hashes.
            When the key is 1 - 64 bytes long, the instance will calculate message authentication codes (HMAC).
            An instance of the <see cref="T:Rebex.Security.Cryptography.Blake2b" /> class creates, uses, and clears a copy of key.
            An instance of the <see cref="T:Rebex.Security.Cryptography.Blake2b" /> class <strong>is not</strong> the owner of the key.
            Every call of the get accessor returns a new deep copy of the key.
            and the key <strong>will not</strong> be cleared when the <see cref="M:Rebex.Security.Cryptography.Blake2b.Dispose(System.Boolean)" /> method is called.
            </para>
      </summary>
    </member>
    <member name="P:Rebex.Security.Cryptography.Blake2b.HashSize">
      <summary>
            Gets the size of the hash in bits.
            </summary>
    </member>
    <member name="P:Rebex.Security.Cryptography.Blake2b.CanReuseTransform">
      <summary>
            Gets a value indicating whether the current transform can be reused.
            </summary>
      <remarks>
            Always returns true.
            </remarks>
    </member>
    <member name="P:Rebex.Security.Cryptography.Blake2b.CanTransformMultipleBlocks">
      <summary>
            Gets the value indicating whether the instance can transform multiple blocks.
            </summary>
      <remarks>
            Always returns true.
            </remarks>
    </member>
    <member name="M:Rebex.Security.Cryptography.Blake2b.Initialize">
      <summary>
            Resets the instance to its initial state. Discards all data from the previous or current hash computation.
            </summary>
    </member>
    <member name="M:Rebex.Security.Cryptography.Blake2b.HashCore(System.Byte[],System.Int32,System.Int32)">
      <summary>
            Hashes the specified segment of the specified <paramref name="array" />.
            </summary>
      <param name="array">The byte array that contains data to be hashed.</param>
      <param name="ibStart">Start index of the segment to be hashed of the <paramref name="array" />.</param>
      <param name="cbSize">Size of the segment to be hashed of the <paramref name="array" />.</param>
    </member>
    <member name="M:Rebex.Security.Cryptography.Blake2b.HashFinal">
      <summary>
            Finishes hash computation.
            </summary>
      <returns>A byte array that contains the computed hash.</returns>
    </member>
    <member name="M:Rebex.Security.Cryptography.Blake2b.Dispose(System.Boolean)">
      <summary>
            Releases the resources used by this instance of the <see cref="T:Rebex.Security.Cryptography.Blake2b" /> class.
            </summary>
      <param name="disposing">If the <paramref name="disposing" /> is true, releases both managed and unmanaged resources.
            If the <paramref name="disposing" /> is false, releases unmanaged resources only.</param>
    </member>
    <member name="T:Rebex.Security.Cryptography.Blake2b256">
      <summary>
             This class represents the BLAKE2b cryptographic hash and message authentication code (MAC) algorithm with hash size of 256 bits (32 bytes).
             </summary>
      <example>
        <code>
             // sourceData argument contains data to be hashed.
             public byte[] Calculate256BitsHash(byte[] sourceData)
             {
                 // create an instance of Blake2b256 class
                 using (var blake2b256 = new Blake2b256())
                 {
                     // compute and return the 256-bit (32-byte) hash
                     return blake2b256.ComputeHash(sourceData);
            
                 } // blake2b256 instance is disposed
             }
             </code>
      </example>
      <remarks>
             The 256-bit (32-byte) BLAKE2b hash value can be computed using an instance of this class that offers methods
             declared by .NET <see cref="T:System.Security.Cryptography.KeyedHashAlgorithm" /> base class.
             In scenarios where instantiating this class presents an unnecessary overhead, a hash value can also be created
             using static (shared in VB) Blake2b256.HashData methods.
             </remarks>
      <seealso cref="T:Rebex.Security.Cryptography.Blake2b" />
      <seealso cref="T:Rebex.Security.Cryptography.Blake2b384" />
      <seealso cref="T:Rebex.Security.Cryptography.Blake2b512" />
    </member>
    <member name="M:Rebex.Security.Cryptography.Blake2b256.#ctor(System.Byte[])">
      <summary>
            Initializes a new instance of the <see cref="T:Rebex.Security.Cryptography.Blake2b" /> class.
            </summary>
      <param name="key">
        <para>Key to use in HMAC calculation.</para>
        <para>
            The <paramref name="key" /> must be a 0 - 64 bytes long array or null. When a null value is provided, the key is treated as an empty array.
            When the <paramref name="key" /> is null or an empty array, the instance will calculate hashes.
            When the <paramref name="key" /> is 1 - 64 bytes long, the instance will calculate message authentication codes (HMAC).
            An instance of the <see cref="T:Rebex.Security.Cryptography.Blake2b256" /> class creates, uses, and clears a copy of the <paramref name="key" />.
            An instance of the <see cref="T:Rebex.Security.Cryptography.Blake2b256" /> class <strong>is not</strong> the owner of the <paramref name="key" />
            and the <paramref name="key" /><strong>will not</strong> be cleared when the Dispose method is called.
            The owner of the <paramref name="key" /> should clear the key.
            </para>
      </param>
    </member>
    <member name="M:Rebex.Security.Cryptography.Blake2b256.#ctor">
      <summary>
            Initializes a new instance of the <see cref="T:Rebex.Security.Cryptography.Blake2b256" /> class.
            </summary>
    </member>
    <member name="M:Rebex.Security.Cryptography.Blake2b256.HashData(System.Byte[],System.Byte[])">
      <summary>
            Computes a 256-bit (32-byte) hash using the BLAKE2b cryptographic hash and message authentication code (MAC) algorithm.
            </summary>
      <param name="key">
        <para>Key to use in HMAC calculation.</para>
        <para>
            The <paramref name="key" /> must be a 0 - 64 bytes long array or null. When a null value is provided, the key is treated as an empty array.
            When the <paramref name="key" /> is null or an empty array, the method will calculate a hash.
            When the <paramref name="key" /> is 1 - 64 bytes long, the method will calculate a message authentication code (HMAC).
            </para>
      </param>
      <param name="source">An array that contains data to be hashed.</param>
      <returns>The hash of the <paramref name="source" />.</returns>
      <example>
        <code>
            // prepare data to be hashed
            byte[] sourceBytes = GetSourceBytes();
            // prepare the key (can be null)
            byte[] keyBytes = GetKeyBytes();
            // compute the hash;
            // the 'hash' variable is going to contain a 32-byte-long hash value
            byte[] hash = Blake2b256.HashData(keyBytes, sourceBytes);
            </code>
      </example>
    </member>
    <member name="M:Rebex.Security.Cryptography.Blake2b256.HashData(System.ArraySegment{System.Byte},System.ArraySegment{System.Byte})">
      <summary>
            Computes a 256-bit (32-byte) hash using the BLAKE2b cryptographic hash and message authentication code (MAC) algorithm.
            </summary>
      <param name="key">
        <para>Key to use in HMAC calculation.</para>
        <para>
            The <paramref name="key" /> must be a 0 - 64 bytes long <see cref="T:System.ArraySegment`1" />.
            When the <paramref name="key" /> is empty, the method will calculate a hash.
            When the <paramref name="key" /> is 1 - 64 bytes long, the method will calculate a message authentication code (HMAC).
            </para>
      </param>
      <param name="source">An <see cref="T:System.ArraySegment`1" /> that contains data to be hashed.</param>
      <returns>The hash of the <paramref name="source" />.</returns>
      <example>
        <code>
            // prepare data to be hashed
            ArraySegment&lt;byte&gt; sourceArraySegment = GetSourceData();
            // prepare the key (can be an empty ArraySegment)
            ArraySegment&lt;byte&gt; keyArraySegment = GetKey();
            // compute the hash;
            // the 'hash' variable is going to contain a 32-byte-long hash value
            byte[] hash = Blake2b512.HashData(keyArraySegment, sourceArraySegment);
            </code>
      </example>
    </member>
    <member name="M:Rebex.Security.Cryptography.Blake2b256.HashData(System.ArraySegment{System.Byte},System.ArraySegment{System.Byte},System.ArraySegment{System.Byte})">
      <summary>
            Computes a 256-bit (32-byte) hash using the BLAKE2b cryptographic hash and message authentication code (MAC) algorithm.
            </summary>
      <param name="key">
        <para>Key to use in HMAC calculation.</para>
        <para>
            The <paramref name="key" /> must be a 0 - 64 bytes long <see cref="T:System.ArraySegment`1" />.
            When the <paramref name="key" /> is empty, the method will calculate a hash.
            When the <paramref name="key" /> is 1 - 64 bytes long, the method will calculate a message authentication code (HMAC).
            </para>
      </param>
      <param name="source">An <see cref="T:System.ArraySegment`1" /> that contains data to be hashed.</param>
      <param name="destination">An <see cref="T:System.ArraySegment`1" /> where the calculated hash will be stored.
            Must be at least 32 bytes long, otherwise an <see cref="T:System.ArgumentException" /> will be thrown.</param>
      <returns>The number of bytes written to the <paramref name="destination" />. Always returns the hash size (32 bytes).</returns>
      <example>
        <code>
            // prepare data to be hashed
            ArraySegment&lt;byte&gt; sourceArraySegment = GetSourceData();
            // prepare the key (can be an empty ArraySegment)
            ArraySegment&lt;byte&gt; keyArraySegment = GetKey();
            // prepare an ArraySegment which will receive the 32-byte long hash
            ArraySegment&lt;byte&gt; outputHashArraySegment = new ArraySegment&lt;byte&gt;(new byte[32]);
            // compute the 32-byte hash and store it into outputHashArraySegment;
            // the hashSize variable will contain the value of 32 (hash size in bytes)
            int hashSize = Blake2b256.HashData(keyArraySegment, sourceArraySegment, outputHashArraySegment);
            </code>
      </example>
    </member>
    <member name="T:Rebex.Security.Cryptography.Blake2b384">
      <summary>
             This class represents the BLAKE2b cryptographic hash and message authentication code (MAC) algorithm with hash size of 384 bits (48 bytes).
             </summary>
      <example>
        <code>
             // sourceData argument contains data to be hashed.
             public byte[] Calculate384BitsHash(byte[] sourceData)
             {
                 // create an instance of Blake2b384 class
                 using (var blake2b384 = new Blake2b384())
                 {
                     // compute and return the 384-bit (48-byte) hash
                     return blake2b384.ComputeHash(sourceData);
            
                 } // blake2b384 instance is disposed
             }
             </code>
      </example>
      <remarks>
             The 384-bit (48-byte) BLAKE2b hash value can be computed using an instance of this class that offers methods
             declared by .NET <see cref="T:System.Security.Cryptography.KeyedHashAlgorithm" /> base class.
             In scenarios where instantiating this class presents an unnecessary overhead, a hash value can also be created
             using static (shared in VB) Blake2b384.HashData methods.
             </remarks>
      <seealso cref="T:Rebex.Security.Cryptography.Blake2b" />
      <seealso cref="T:Rebex.Security.Cryptography.Blake2b256" />
      <seealso cref="T:Rebex.Security.Cryptography.Blake2b512" />
    </member>
    <member name="M:Rebex.Security.Cryptography.Blake2b384.#ctor(System.Byte[])">
      <summary>
            Initializes a new instance of the <see cref="T:Rebex.Security.Cryptography.Blake2b" /> class.
            </summary>
      <param name="key">
        <para>Key to use in HMAC calculation.</para>
        <para>
            The <paramref name="key" /> must be a 0 - 64 bytes long array or null. When a null value is provided, the key is treated as an empty array.
            When the <paramref name="key" /> is null or an empty array, the instance will calculate hashes.
            When the <paramref name="key" /> is 1 - 64 bytes long, the instance will calculate message authentication codes (HMAC).
            An instance of the <see cref="T:Rebex.Security.Cryptography.Blake2b384" /> class creates, uses, and clears a copy of the <paramref name="key" />.
            An instance of the <see cref="T:Rebex.Security.Cryptography.Blake2b384" /> class <strong>is not</strong> the owner of the <paramref name="key" />
            and the <paramref name="key" /><strong>will not</strong> be cleared when the Dispose method is called.
            The owner of the <paramref name="key" /> should clear the key.
            </para>
      </param>
    </member>
    <member name="M:Rebex.Security.Cryptography.Blake2b384.#ctor">
      <summary>
            Initializes a new instance of the <see cref="T:Rebex.Security.Cryptography.Blake2b384" /> class.
            </summary>
    </member>
    <member name="M:Rebex.Security.Cryptography.Blake2b384.HashData(System.Byte[],System.Byte[])">
      <summary>
            Computes a 384-bit (48-byte) hash using the BLAKE2b cryptographic hash and message authentication code (MAC) algorithm.
            </summary>
      <param name="key">
        <para>Key to use in HMAC calculation.</para>
        <para>
            The <paramref name="key" /> must be a 0 - 64 bytes long array or null. When a null value is provided, the key is treated as an empty array.
            When the <paramref name="key" /> is null or an empty array, the method will calculate a hash.
            When the <paramref name="key" /> is 1 - 64 bytes long, the method will calculate a message authentication code (HMAC).
            </para>
      </param>
      <param name="source">An array that contains data to be hashed.</param>
      <returns>The hash of the <paramref name="source" />.</returns>
      <example>
        <code>
            // prepare data to be hashed
            byte[] sourceBytes = GetSourceBytes();
            // prepare the key (can be null)
            byte[] keyBytes = GetKeyBytes();
            // compute the hash;
            // the 'hash' variable contains a 48-byte-long hash value
            byte[] hash = Blake2b384.HashData(keyBytes, sourceBytes);
            </code>
      </example>
    </member>
    <member name="M:Rebex.Security.Cryptography.Blake2b384.HashData(System.ArraySegment{System.Byte},System.ArraySegment{System.Byte})">
      <summary>
            Computes a 384-bit (48-byte) hash using the BLAKE2b cryptographic hash and message authentication code (MAC) algorithm.
            </summary>
      <param name="key">
        <para>Key to use in HMAC calculation.</para>
        <para>
            The <paramref name="key" /> must be a 0 - 64 bytes long <see cref="T:System.ArraySegment`1" />.
            When the <paramref name="key" /> is empty, the method will calculate a hash.
            When the <paramref name="key" /> is 1 - 64 bytes long, the method will calculate a message authentication code (HMAC).
            </para>
      </param>
      <param name="source">An <see cref="T:System.ArraySegment`1" /> that contains data to be hashed.</param>
      <returns>The hash of the <paramref name="source" />.</returns>
      <example>
        <code>
            // prepare data to be hashed
            ArraySegment&lt;byte&gt; sourceArraySegment = GetSourceData();
            // prepare the key (can be an empty ArraySegment)
            ArraySegment&lt;byte&gt; keyArraySegment = GetKey();
            // compute the hash;
            // the 'hash' variable contains a 48-byte-long hash value
            byte[] hash = Blake2b384.HashData(keyArraySegment, sourceArraySegment);
            </code>
      </example>
    </member>
    <member name="M:Rebex.Security.Cryptography.Blake2b384.HashData(System.ArraySegment{System.Byte},System.ArraySegment{System.Byte},System.ArraySegment{System.Byte})">
      <summary>
            Computes a 384-bit (48-byte) hash using the BLAKE2b cryptographic hash and message authentication code (MAC) algorithm.
            </summary>
      <param name="key">
        <para>Key to use in HMAC calculation.</para>
        <para>
            The <paramref name="key" /> must be a 0 - 64 bytes long <see cref="T:System.ArraySegment`1" />.
            When the <paramref name="key" /> is empty, the method will calculate a hash.
            When the <paramref name="key" /> is 1 - 64 bytes long, the method will calculate a message authentication code (HMAC).
            </para>
      </param>
      <param name="source">An <see cref="T:System.ArraySegment`1" /> that contains data to be hashed.</param>
      <param name="destination">An <see cref="T:System.ArraySegment`1" /> where the calculated hash will be stored.
            Must be at least 48 bytes long, otherwise an <see cref="T:System.ArgumentException" /> will be thrown.</param>
      <returns>The number of bytes written to the <paramref name="destination" />. Always returns the hash size (48 bytes).</returns>
      <example>
        <code>
            // prepare data to be hashed
            ArraySegment&lt;byte&gt; sourceArraySegment = GetSourceData();
            // prepare the key (can be an empty ArraySegment)
            ArraySegment&lt;byte&gt; keyArraySegment = GetKey();
            // prepare an ArraySegment which will receive the 48-byte long hash
            ArraySegment&lt;byte&gt; outputHashArraySegment = new ArraySegment&lt;byte&gt;(new byte[48]);
            // compute the 48-byte hash and store it into outputHashArraySegment;
            // the hashSize variable will contain the value of 48 (hash size in bytes)
            int hashSize = Blake2b384.HashData(keyArraySegment, sourceArraySegment, outputHashArraySegment);
            </code>
      </example>
    </member>
    <member name="T:Rebex.Security.Cryptography.Blake2b512">
      <summary>
             This class represents the BLAKE2b cryptographic hash and message authentication code (MAC) algorithm with hash size of 512 bits (64 bytes).
             </summary>
      <example>
        <code>
             // sourceData argument contains data to be hashed.
             public byte[] Calculate512BitsHash(byte[] sourceData)
             {
                 // create an instance of Blake2b512 class
                 using (var blake2b512 = new Blake2b512())
                 {
                     // compute and return the 512-bit (64-byte) hash
                     return blake2b512.ComputeHash(sourceData);
            
                 } // blake2b512 instance is disposed
             }
             </code>
      </example>
      <remarks>
             The 512-bit (64-byte) BLAKE2b hash value can be computed using an instance of this class that offers methods
             declared by .NET <see cref="T:System.Security.Cryptography.KeyedHashAlgorithm" /> base class.
             In scenarios where instantiating this class presents an unnecessary overhead, a hash value can also be created
             using static (shared in VB) Blake2b512.HashData methods.
             </remarks>
      <seealso cref="T:Rebex.Security.Cryptography.Blake2b" />
      <seealso cref="T:Rebex.Security.Cryptography.Blake2b256" />
      <seealso cref="T:Rebex.Security.Cryptography.Blake2b384" />
    </member>
    <member name="M:Rebex.Security.Cryptography.Blake2b512.#ctor(System.Byte[])">
      <summary>
            Initializes a new instance of the <see cref="T:Rebex.Security.Cryptography.Blake2b" /> class.
            </summary>
      <param name="key">
        <para>Key to use in HMAC calculation.</para>
        <para>
            The <paramref name="key" /> must be a 0 - 64 bytes long array or null. When a null value is provided, the key is treated as an empty array.
            When the <paramref name="key" /> is null or an empty array, the instance will calculate hashes.
            When the <paramref name="key" /> is 1 - 64 bytes long, the instance will calculate message authentication codes (HMAC).
            An instance of the <see cref="T:Rebex.Security.Cryptography.Blake2b512" /> class creates, uses, and clears a copy of the <paramref name="key" />.
            An instance of the <see cref="T:Rebex.Security.Cryptography.Blake2b512" /> class <strong><strong>is not</strong></strong> the owner of the <paramref name="key" />
            and the <paramref name="key" /><strong>will not</strong> be cleared when the Dispose method is called.
            The owner of the <paramref name="key" /> should clear the key.
            </para>
      </param>
    </member>
    <member name="M:Rebex.Security.Cryptography.Blake2b512.#ctor">
      <summary>
            Initializes a new instance of the <see cref="T:Rebex.Security.Cryptography.Blake2b512" /> class.
            </summary>
    </member>
    <member name="M:Rebex.Security.Cryptography.Blake2b512.HashData(System.Byte[],System.Byte[])">
      <summary>
            Computes a 512-bit (64-byte) hash using the BLAKE2b cryptographic hash and message authentication code (MAC) algorithm.
            </summary>
      <param name="key">
        <para>Key to use in HMAC calculation.</para>
        <para>
            The <paramref name="key" /> must be a 0 - 64 bytes long array or null. When a null value is provided, the key is treated as an empty array.
            When the <paramref name="key" /> is null or an empty array, the method will calculate a hash.
            When the <paramref name="key" /> is 1 - 64 bytes long, the method will calculate a message authentication code (HMAC).
            </para>
      </param>
      <param name="source">An array that contains data to be hashed.</param>
      <returns>The hash of the <paramref name="source" />.</returns>
      <example>
        <code>
            // prepare data to be hashed
            byte[] sourceBytes = GetSourceBytes();
            // prepare the key (can be null)
            byte[] keyBytes = GetKeyBytes();
            // compute the hash;
            // the 'hash' variable contains a 64-byte-long hash value
            byte[] hash = Blake2b512.HashData(keyBytes, sourceBytes);
            </code>
      </example>
    </member>
    <member name="M:Rebex.Security.Cryptography.Blake2b512.HashData(System.ArraySegment{System.Byte},System.ArraySegment{System.Byte})">
      <summary>
            Computes a 512-bit (64-byte) hash using the BLAKE2b cryptographic hash and message authentication code (MAC) algorithm.
            </summary>
      <param name="key">
        <para>Key to use in HMAC calculation.</para>
        <para>
            The <paramref name="key" /> must be a 0 - 64 bytes long <see cref="T:System.ArraySegment`1" />.
            When the <paramref name="key" /> is empty, the method will calculate a hash.
            When the <paramref name="key" /> is 1 - 64 bytes long, the method will calculate a message authentication code (HMAC).
            </para>
      </param>
      <param name="source">An <see cref="T:System.ArraySegment`1" /> that contains data to be hashed.</param>
      <returns>The hash of the <paramref name="source" />.</returns>
      <example>
        <code>
            // prepare data to be hashed
            ArraySegment&lt;byte&gt; sourceArraySegment = GetSourceData();
            // prepare the key (can be an empty ArraySegment)
            ArraySegment&lt;byte&gt; keyArraySegment = GetKey();
            // compute the hash;
            // the 'hash' variable contains a 64-byte-long hash value
            byte[] hash = Blake2b512.HashData(keyArraySegment, sourceArraySegment);
            </code>
      </example>
    </member>
    <member name="M:Rebex.Security.Cryptography.Blake2b512.HashData(System.ArraySegment{System.Byte},System.ArraySegment{System.Byte},System.ArraySegment{System.Byte})">
      <summary>
            Computes a 512-bit (64-byte) hash using the BLAKE2b cryptographic hash and message authentication code (MAC) algorithm.
            </summary>
      <param name="key">
        <para>Key to use in HMAC calculation.</para>
        <para>
            The <paramref name="key" /> must be a 0 - 64 bytes long <see cref="T:System.ArraySegment`1" />.
            When the <paramref name="key" /> is empty, the method will calculate a hash.
            When the <paramref name="key" /> is 1 - 64 bytes long, the method will calculate a message authentication code (HMAC).
            </para>
      </param>
      <param name="source">An <see cref="T:System.ArraySegment`1" /> that contains data to be hashed.</param>
      <param name="destination">An <see cref="T:System.ArraySegment`1" /> where the calculated hash will be stored.
            Must be at least 64 bytes long, otherwise an <see cref="T:System.ArgumentException" /> will be thrown.</param>
      <returns>The number of bytes written to the <paramref name="destination" />. Always returns the hash size (64 bytes).</returns>
      <example>
        <code>
            // prepare data to be hashed
            ArraySegment&lt;byte&gt; sourceArraySegment = GetSourceData();
            // prepare the key (can be an empty ArraySegment)
            ArraySegment&lt;byte&gt; keyArraySegment = GetKey();
            // prepare an ArraySegment which will receive the 64-byte long hash
            ArraySegment&lt;byte&gt; outputHashArraySegment = new ArraySegment&lt;byte&gt;(new byte[64]);
            // compute the 64-byte hash and store it into outputHashArraySegment;
            // the hashSize variable will contain the value of 64 (hash size in bytes)
            int hashSize = Blake2b512.HashData(keyArraySegment, sourceArraySegment, outputHashArraySegment);
            </code>
      </example>
    </member>
    <member name="T:Rebex.Security.Cryptography.ChaCha20Poly1305">
      <summary>
             Represents an authenticated encryption with associated data (AEAD) ChaCha20/Poly1305 cipher.
             </summary>
      <example>
        <code>
            public void EncryptAndDecryptData()
            {
                //Prepare plain text.
                byte[] plainText = GetMyPlainText();
            
                //Create the  array for the resulting cipher text.
                byte[] cipherText = new byte[plainText.Length];
            
                byte[] key;
                byte[] nonce;
                using (var randomGenerator = RandomNumberGenerator.Create())
                {
                    //Generate random key.
                    key = new byte[ChaCha20Poly1305.KeySize];
                    randomGenerator.GetBytes(key);
            
                    //Generate random nonce.
                    nonce = new byte[ChaCha20Poly1305.NonceSize];
                    randomGenerator.GetBytes(nonce);
                }
            
                //Prepare additional authentication data. Can be null.
                byte[] aaaData = GetMyAadData();
            
                //Prepare the array in which will be stored authentication tag.
                var authTag = new byte[ChaCha20Poly1305.AuthenticationTagSize];
            
                //Create the instance of the ChaCha20Poly1305 class.
                using (var chacha20Poly1305 = new ChaCha20Poly1305(key))
                {
                    //Encrypt data.
                    chacha20Poly1305.Encrypt(nonce, plainText, cipherText, authTag, aaaData);
                    //After a successful call cipherText contains encrypted data and authTag contains authentication tag.
            
                }
            
                //Later decrypt data.
            
                //Prepare an array in which decrypted data will be stored.
                byte[] decryptedData = new byte[cipherText.Length];
            
                //Create the instance of the ChaCha20Poly1305 class and use the same key.
                using (var chacha20Poly1305 = new ChaCha20Poly1305(key))
                {
                    //Decrypt data. Use the same nonce, same additional authentication data, and use the authTag from the previous encrypt operation.
                    chacha20Poly1305.Decrypt(nonce, cipherText, authTag, decryptedData, aaaData);
                    //After a successful call decryptedData contains decrypted data.
            
                }
            }
             </code>
      </example>
    </member>
    <member name="F:Rebex.Security.Cryptography.ChaCha20Poly1305.KeySize">
      <summary>
            Required <see cref="T:Rebex.Security.Cryptography.ChaCha20Poly1305" /> key size (in bytes). The value of the constant is 32.
            </summary>
    </member>
    <member name="F:Rebex.Security.Cryptography.ChaCha20Poly1305.NonceSize">
      <summary>
            Required <see cref="T:Rebex.Security.Cryptography.ChaCha20Poly1305" /> nonce size (in bytes). The value of the constant is 12.
            </summary>
    </member>
    <member name="F:Rebex.Security.Cryptography.ChaCha20Poly1305.AuthenticationTagSize">
      <summary>
        <see cref="T:Rebex.Security.Cryptography.ChaCha20Poly1305" /> authentication tag size (in bytes). The value of the constant is 16.
            </summary>
    </member>
    <member name="M:Rebex.Security.Cryptography.ChaCha20Poly1305.#ctor(System.Byte[])">
      <summary>
            Initializes a new <see cref="T:Rebex.Security.Cryptography.ChaCha20Poly1305" /> instance with the provided <paramref name="key" />.
            </summary>
      <param name="key">The 32-byte ChaCha20/Poly1305 key to be used by this instance.
            An instance of the <see cref="T:Rebex.Security.Cryptography.ChaCha20Poly1305" /> class makes, uses, and clears a copy of the <paramref name="key" />.
            An instance of the <see cref="T:Rebex.Security.Cryptography.ChaCha20Poly1305" /> class IS NOT the owner of the <paramref name="key" />
            and the <paramref name="key" /> WILL NOT be cleared when the <see cref="M:Rebex.Security.Cryptography.ChaCha20Poly1305.Dispose" /> method is called.
            The owner of the <paramref name="key" /> should clear the key.</param>
    </member>
    <member name="M:Rebex.Security.Cryptography.ChaCha20Poly1305.Encrypt(System.Byte[],System.Byte[],System.Byte[],System.Byte[],System.Byte[])">
      <summary>
             Encrypts <paramref name="plaintext" /> using the secret key and <paramref name="nonce" />, stores the result to the <paramref name="ciphertext" /> and
             authenticates resulting <paramref name="ciphertext" /> with optional <paramref name="additionalAuthData" /> and stores the authentication tag to the <paramref name="authTag" />.
             </summary>
      <example>
        <code>
            using (var chacha20Poly1305 = new ChaCha20Poly1305(key))
            {
                //Encrypt data.
                chacha20Poly1305.Encrypt(nonce, plainText, cipherText, authTag, aaaData);
                //After a successful call cipherText contains encrypted data and authTag contains authentication tag.
            
            }
             </code>
      </example>
      <param name="nonce">The 12-byte nonce.</param>
      <param name="plaintext">The byte array that contains plain text that will be encrypted.</param>
      <param name="ciphertext">The byte array in which the resulting cipher text will be stored.</param>
      <param name="authTag">The 16-byte array in which generated authentication tag will be stored.</param>
      <param name="additionalAuthData">Optional (can be null) byte array that contains additional authenticated data (AAD).
             Same additional authenticated data must be provided when <paramref name="ciphertext" /> is decrypted. </param>
    </member>
    <member name="M:Rebex.Security.Cryptography.ChaCha20Poly1305.Decrypt(System.Byte[],System.Byte[],System.Byte[],System.Byte[],System.Byte[])">
      <summary>
             Decrypts <paramref name="ciphertext" /> using the secret key and <paramref name="nonce" />, stores the result to the <paramref name="ciphertext" />
             and validates <paramref name="authTag" />.
             </summary>
      <example>
        <code>
            using (var chacha20Poly1305 = new ChaCha20Poly1305(key))
            {
                //Decrypt data. Use the same nonce, same additional authentication data, and use the authTag from the previous encrypt operation.
                chacha20Poly1305.Decrypt(nonce, cipherText, authTag, decryptedData, aaaData);
                //After a successful call decryptedData contains decrypted data.
            
            }
             </code>
      </example>
      <remarks>
             When the validation of the authentication tag check fails, then <see cref="T:System.Security.Cryptography.CryptographicException" /> is thrown and <paramref name="ciphertext" /> is not decrypted.
             </remarks>
      <param name="nonce">The 12-byte nonce.</param>
      <param name="ciphertext">The byte array that contains cipher text that will be decrypted.</param>
      <param name="authTag">The 16-byte array that contains authentication tag.</param>
      <param name="plaintext">The byte array in which the resulting plain text will be stored.</param>
      <param name="additionalAuthData">Optional (can be null) byte array that contains additional authenticated data (AAD).
             This byte array should contain the exactly same additional authenticated data that were provided to previous encryption operation;
             otherwise decryption fails.</param>
    </member>
    <member name="M:Rebex.Security.Cryptography.ChaCha20Poly1305.Dispose">
      <summary>
            Releases the resources used by the current instance.
            </summary>
    </member>
    <member name="T:Rebex.Security.Cryptography.HKDF">
      <summary>
            Implements HMAC-based Extract-and-Expand key derivation function (HKDF)
            as specified by <a href="https://datatracker.ietf.org/doc/html/rfc5869">RFC 5869</a>.
            Provides <c>Extract</c>, <c>Expand</c> and <c>DeriveKey</c> derivation functions.
            </summary>
    </member>
    <member name="M:Rebex.Security.Cryptography.HKDF.Extract(Rebex.Security.Cryptography.HashingAlgorithmId,System.Byte[],System.Byte[])">
      <summary>
            HKDF Extract function according to <a href="https://datatracker.ietf.org/doc/html/rfc5869#section-2.2">section 2.2 of RFC 5869</a>.
            </summary>
      <param name="hashingAlgorithmId">The hash algorithm for HMAC operations.</param>
      <param name="ikm">A byte array that contains input keying material. This is the 'IKM' parameter from RFC 5869.</param>
      <param name="salt">
            A byte array that contains the salt. When null or empty salt is specified,
            this method will use a zero-filled salt with size equal to the hash size of <paramref name="hashingAlgorithmId" />.
            This is the 'salt' parameter from RFC 5869.
            </param>
      <returns>A byte array that contains the pseudorandom key (the 'PRK' output from RFC 5869).</returns>
      <exception cref="T:System.ArgumentNullException">The <paramref name="ikm" /> is null.</exception>
      <exception cref="T:System.ArgumentException">The <paramref name="ikm" /> is an empty array,
            or <paramref name="hashingAlgorithmId" /> is not supported.</exception>
    </member>
    <member name="M:Rebex.Security.Cryptography.HKDF.Extract(Rebex.Security.Cryptography.HashingAlgorithmId,System.ArraySegment{System.Byte},System.ArraySegment{System.Byte},System.ArraySegment{System.Byte})">
      <summary>
            HKDF Extract function according to <a href="https://datatracker.ietf.org/doc/html/rfc5869#section-2.2">section 2.2 of RFC 5869</a>.
            </summary>
      <param name="hashingAlgorithmId">The hash algorithm for HMAC operations.</param>
      <param name="ikm">An <see cref="T:System.ArraySegment`1" /> that contains input keying material. This is the 'IKM' parameter from RFC 5869.</param>
      <param name="salt">
            An <see cref="T:System.ArraySegment`1" /> that contains the salt. When an empty salt is specified,
            this method will use a zero-filled salt with size equal to the hash size of <paramref name="hashingAlgorithmId" />.
            This is the 'salt' parameter from RFC 5869.
            </param>
      <param name="prk">An <see cref="T:System.ArraySegment`1" /> that will receive the pseudorandom key (the 'PRK' output from RFC 5869).
            The length of <paramref name="prk" /> must be equal to or greater than the hash size of <paramref name="hashingAlgorithmId" />.</param>
      <returns>The number of bytes written to <paramref name="prk" />.</returns>
      <exception cref="T:System.ArgumentException">The <paramref name="ikm" /> is empty,
            or <paramref name="hashingAlgorithmId" /> is not supported.</exception>
    </member>
    <member name="M:Rebex.Security.Cryptography.HKDF.Expand(Rebex.Security.Cryptography.HashingAlgorithmId,System.Byte[],System.Int32,System.Byte[])">
      <summary>
            HKDF Expand function according to <a href="https://datatracker.ietf.org/doc/html/rfc5869#section-2.3">section 2.3 of RFC 5869</a>.
            </summary>
      <param name="hashingAlgorithmId">The hash algorithm for HMAC operations.</param>
      <param name="prk">
            A byte array that contains the pseudorandom key (the 'PRK' argument from RFC 5869).
            Its length must be equal to or greater than the hash size of <paramref name="hashingAlgorithmId" />.
            This key is usually computed using the <see cref="M:Rebex.Security.Cryptography.HKDF.Extract(Rebex.Security.Cryptography.HashingAlgorithmId,System.Byte[],System.Byte[])" /> method.
            </param>
      <param name="outputLength">
            The length (in bytes) of the output keying material. This is the 'L' argument from RFC 5869.
            The value must be between 1 and '255 * hash size of <paramref name="hashingAlgorithmId" /> in bytes'.
            </param>
      <param name="info">
            A byte array that contains the context and application-specific information. Can be null.
            This is the 'info' argument from RFC 5869.
            </param>
      <returns>A byte array that contains the output keying material (the 'OKM' output from RFC 5869).</returns>
      <exception cref="T:System.ArgumentNullException">The <paramref name="prk" /> is null.</exception>
      <exception cref="T:System.ArgumentException">
            The <paramref name="prk" /> has an invalid length, or
            the <paramref name="outputLength" /> is invalid, or
            the <paramref name="hashingAlgorithmId" /> is not supported.
            </exception>
      <seealso cref="M:Rebex.Security.Cryptography.HKDF.Extract(Rebex.Security.Cryptography.HashingAlgorithmId,System.Byte[],System.Byte[])" />
    </member>
    <member name="M:Rebex.Security.Cryptography.HKDF.Expand(Rebex.Security.Cryptography.HashingAlgorithmId,System.ArraySegment{System.Byte},System.ArraySegment{System.Byte},System.ArraySegment{System.Byte})">
      <summary>
            HKDF Expand function according to <a href="https://datatracker.ietf.org/doc/html/rfc5869#section-2.3">section 2.3 of RFC 5869</a>.
            </summary>
      <param name="hashingAlgorithmId">The hash algorithm for HMAC operations.</param>
      <param name="prk">
            An <see cref="T:System.ArraySegment`1" /> that contains the pseudorandom key (the 'PRK' argument from RFC 5869).
            Its length must be equal to or greater than the hash size of <paramref name="hashingAlgorithmId" />.
            This key is usually computed using the <see cref="M:Rebex.Security.Cryptography.HKDF.Extract(Rebex.Security.Cryptography.HashingAlgorithmId,System.ArraySegment{System.Byte},System.ArraySegment{System.Byte},System.ArraySegment{System.Byte})" /> method.
            </param>
      <param name="output">
            An <see cref="T:System.ArraySegment`1" /> that will receive the output keying material (the 'OKM' output from RFC 5869).
            The length of the <paramref name="output" /> (the 'L' argument from RFC 5869) must be between 1 and '255 * hash size of <paramref name="hashingAlgorithmId" /> in bytes'.
            </param>
      <param name="info">
            An <see cref="T:System.ArraySegment`1" /> that contains the context and application-specific information. Can be empty <see cref="T:System.ArraySegment`1" />.
            This is the 'info' argument from RFC 5869.
            </param>
      <exception cref="T:System.ArgumentException">
            The <paramref name="prk" /> has an invalid length, or
            the <paramref name="output" /> has an invalid length, or
            the <paramref name="hashingAlgorithmId" /> is not supported.
            </exception>
      <seealso cref="M:Rebex.Security.Cryptography.HKDF.Extract(Rebex.Security.Cryptography.HashingAlgorithmId,System.Byte[],System.Byte[])" />
    </member>
    <member name="M:Rebex.Security.Cryptography.HKDF.DeriveKey(Rebex.Security.Cryptography.HashingAlgorithmId,System.Byte[],System.Int32,System.Byte[],System.Byte[])">
      <summary>
            Derives the output keying material using the Extract-and-Expand key derivation function
            (<a href="https://datatracker.ietf.org/doc/html/rfc5869#section-2.3">HKDF</a>).
            </summary>
      <param name="hashingAlgorithmId">The hash algorithm for HMAC operations.</param>
      <param name="ikm">A byte array that contains the input keying material.</param>
      <param name="outputLength">
            The length in bytes of the output keying material.
            The value must be between 1 and '255 * hash size of <paramref name="hashingAlgorithmId" /> in bytes'.
            </param>
      <param name="salt">
            A byte array that contains the salt. When null or empty salt is specified,
            this method will use a zero-filled salt with size equal to the hash size of <paramref name="hashingAlgorithmId" />.
            </param>
      <param name="info">
            A byte array that contains the context and application-specific information. Can be null.
            </param>
      <returns>A byte array that contains the output keying material.</returns>
      <exception cref="T:System.ArgumentNullException">The <paramref name="ikm" /> is null.</exception>
      <exception cref="T:System.ArgumentException">
            The <paramref name="ikm" /> is empty, or
            the <paramref name="outputLength" /> is invalid, or
            the <paramref name="hashingAlgorithmId" /> is not supported.
            </exception>
    </member>
    <member name="M:Rebex.Security.Cryptography.HKDF.DeriveKey(Rebex.Security.Cryptography.HashingAlgorithmId,System.ArraySegment{System.Byte},System.ArraySegment{System.Byte},System.ArraySegment{System.Byte},System.ArraySegment{System.Byte})">
      <summary>
            Derives the output keying material using the Extract-and-Expand key derivation function
            (<a href="https://datatracker.ietf.org/doc/html/rfc5869#section-2.3">HKDF</a>).
            </summary>
      <param name="hashingAlgorithmId">The hash algorithm for HMAC operations.</param>
      <param name="ikm">An <see cref="T:System.ArraySegment`1" /> that contains the input keying material.</param>
      <param name="output">
            An <see cref="T:System.ArraySegment`1" /> that will receive the output keying material. 
            The length of the <paramref name="output" /> must be between 1 and '255 * hash size of <paramref name="hashingAlgorithmId" /> in bytes'.
            </param>
      <param name="salt">
            An <see cref="T:System.ArraySegment`1" /> that contains the salt. When an empty salt is specified,
            this method will use a zero-filled salt with size equal to the hash size of <paramref name="hashingAlgorithmId" />.
            </param>
      <param name="info">
            An <see cref="T:System.ArraySegment`1" /> that contains the context and application-specific information. Can be empty.
            </param>
      <exception cref="T:System.ArgumentException">
            The <paramref name="ikm" /> is empty, or
            the <paramref name="output" /> has an invalid length, or
            the <paramref name="hashingAlgorithmId" /> is not supported.
            </exception>
    </member>
    <member name="T:Rebex.Security.Cryptography.Xts">
      <summary>
            Represents XTS-AES, a standard algorithm for protection of stored data defined by IEEE P1619.
            </summary>
      <remarks>
            This is low level API. For higher level API see <see cref="T:Rebex.Security.XtsStream" />.
            </remarks>
    </member>
    <member name="P:Rebex.Security.Cryptography.Xts.BlockSize">
      <summary>
            Gets the block size in bytes.
            </summary>
    </member>
    <member name="M:Rebex.Security.Cryptography.Xts.#ctor(System.Byte[],System.Byte[])">
      <summary>
            Initializes a new instance of the <see cref="T:Rebex.Security.Cryptography.Xts" /> class.
            </summary>
      <param name="encryptionKey" />
      <param name="tweakingKey" />
    </member>
    <member name="M:Rebex.Security.Cryptography.Xts.EncryptSector(System.Byte[],System.Byte[],System.Int32,System.Int32,System.Byte[],System.Int32)">
      <summary>
            Encrypts the specified region of the input byte array and copies the result to the specified region of the output byte array.
            </summary>
      <param name="tweak">The tweak value (check <see cref="P:Rebex.Security.Cryptography.Xts.BlockSize" /> for required length).</param>
      <param name="inputBuffer">The input for which to compute the transform.</param>
      <param name="inputOffset">The offset into the input byte array from which to begin using data.</param>
      <param name="inputCount">The number of bytes in the input byte array to use as data.</param>
      <param name="outputBuffer">The output to which to write the transform.</param>
      <param name="outputOffset">The offset into the output byte array from which to begin writing data.</param>
    </member>
    <member name="M:Rebex.Security.Cryptography.Xts.DecryptSector(System.Byte[],System.Byte[],System.Int32,System.Int32,System.Byte[],System.Int32)">
      <summary>
            Decrypts the specified region of the input byte array and copies the result to the specified region of the output byte array.
            </summary>
      <param name="tweak">The tweak value (check <see cref="P:Rebex.Security.Cryptography.Xts.BlockSize" /> for required length).</param>
      <param name="inputBuffer">The input for which to compute the transform.</param>
      <param name="inputOffset">The offset into the input byte array from which to begin using data.</param>
      <param name="inputCount">The number of bytes in the input byte array to use as data.</param>
      <param name="outputBuffer">The output to which to write the transform.</param>
      <param name="outputOffset">The offset into the output byte array from which to begin writing data.</param>
    </member>
    <member name="M:Rebex.Security.Cryptography.Xts.Dispose">
      <summary>
            Releases all resources used by the <see cref="T:Rebex.Security.Cryptography.Xts" /> object.
            </summary>
    </member>
    <member name="T:Rebex.Security.FileEncryptionAlgorithm">
      <summary>
            Specifies algorithm used to encrypt or decrypt.
            </summary>
    </member>
    <member name="F:Rebex.Security.FileEncryptionAlgorithm.AesXts">
      <summary>
            AES in XTS mode.
            </summary>
    </member>
    <member name="F:Rebex.Security.FileEncryptionAlgorithm.AesCbc">
      <summary>
            AES in CBC mode.
            </summary>
    </member>
    <member name="F:Rebex.Security.FileEncryptionAlgorithm.TripleDesCbc">
      <summary>
            TripleDes in CBC mode.
            </summary>
    </member>
    <member name="F:Rebex.Security.FileEncryptionAlgorithm.TwofishCbc">
      <summary>
            Twofish in CBC mode.
            </summary>
    </member>
    <member name="T:Rebex.Security.KeyDerivationAlgorithm">
      <summary>
            Specifies key derivation algorithm from password.
            </summary>
    </member>
    <member name="F:Rebex.Security.KeyDerivationAlgorithm.Rfc2898">
      <summary>
            Use RFC 2898 implementation of key derivation from password.
            </summary>
    </member>
    <member name="T:Rebex.Security.FileEncryption">
      <summary>
            Provides high level API for encrypting and decrypting files and streams.
            </summary>
    </member>
    <member name="M:Rebex.Security.FileEncryption.#ctor">
      <summary>
            Creates a new instance of <see cref="T:Rebex.Security.FileEncryption" /> object.
            </summary>
    </member>
    <member name="M:Rebex.Security.FileEncryption.Decrypt(System.String,System.String)">
      <summary>
            Decrypts a source file into a target file.
            </summary>
      <param name="sourceFile">The file to decrypt.</param>
      <param name="targetFile">The name of the decrypted file. This cannot be a directory.</param>
    </member>
    <member name="M:Rebex.Security.FileEncryption.Decrypt(System.IO.Stream,System.IO.Stream)">
      <summary>
            Decrypts data from a source stream into a target stream.
            </summary>
      <param name="sourceStream">Readable stream with encrypted data.</param>
      <param name="targetStream">Writable stream that will receive the decrypted data.</param>
    </member>
    <member name="M:Rebex.Security.FileEncryption.Encrypt(System.String,System.String)">
      <summary>
            Encrypts a source file into a target file.
            </summary>
      <param name="sourceFile">The file to encrypt.</param>
      <param name="targetFile">The name of the encrypted file. This cannot be a directory.</param>
    </member>
    <member name="M:Rebex.Security.FileEncryption.Encrypt(System.IO.Stream,System.IO.Stream)">
      <summary>
            Encrypts data from a source stream into a target stream.
            </summary>
      <param name="sourceStream">Readable stream with input data.</param>
      <param name="targetStream">Writable stream that will receive the encrypted data.</param>
    </member>
    <member name="P:Rebex.Security.FileEncryption.OverwriteExistingFile">
      <summary>
            Get or sets a value indicating whether to overwrite existing target files.
            </summary>
    </member>
    <member name="P:Rebex.Security.FileEncryption.EncryptionAlgorithm">
      <summary>
            Gets or sets the encryption algorithm used for encryption and decryption.
            </summary>
    </member>
    <member name="P:Rebex.Security.FileEncryption.EncryptionKeySize">
      <summary>
            Gets or sets the encryption key size (null indicates default key size).
            </summary>
    </member>
    <member name="P:Rebex.Security.FileEncryption.XtsBlockSize">
      <summary>
            Gets or sets XTS algorithm block size in bytes. Must be multiple of 16. Default value is 65536, maximum number is 1048576.
            This is only used for <see cref="F:Rebex.Security.FileEncryptionAlgorithm.AesXts" />.
            Use smaller buffer if you read very small parts of a stream from different places, or use larger buffer if you do sequential reads of large blocks. 
            Setting this value might negatively impact the performance.
            </summary>
    </member>
    <member name="M:Rebex.Security.FileEncryption.SetPassword(System.Byte[])">
      <summary>
            Sets password for encryption and decryption.
            </summary>
      <param name="password">Password for encryption and decryption.</param>
    </member>
    <member name="M:Rebex.Security.FileEncryption.SetPassword(System.String)">
      <summary>
            Sets password for encryption and decryption.
            </summary>
      <param name="password">Password for encryption and decryption.</param>
    </member>
    <member name="M:Rebex.Security.FileEncryption.SetPassword(System.Byte[],Rebex.Security.KeyDerivationAlgorithm)">
      <summary>
            Sets password for encryption and decryption.
            </summary>
      <param name="password">Password for encryption and decryption.</param>
      <param name="algorithm">Key derivation algorithm.</param>
    </member>
    <member name="M:Rebex.Security.FileEncryption.SetPassword(System.String,Rebex.Security.KeyDerivationAlgorithm)">
      <summary>
            Sets password for encryption and decryption.
            </summary>
      <param name="password">Password for encryption and decryption.</param>
      <param name="algorithm">Key derivation algorithm.</param>
    </member>
    <member name="M:Rebex.Security.FileEncryption.DecryptAsync(System.String,System.String,System.Object)">
      <summary>
            Begins asynchronous Decrypt operation.
            Decrypts a source file into a target file.
            </summary>
      <param name="sourceFile">The file to decrypt.</param>
      <param name="targetFile">The name of the decrypted file. This cannot be a directory.</param>
      <param name="state">An optional user-provided object that identifies this particular asynchronous operation.</param>
    </member>
    <member name="M:Rebex.Security.FileEncryption.DecryptAsync(System.IO.Stream,System.IO.Stream,System.Object)">
      <summary>
            Begins asynchronous Decrypt operation.
            Decrypts data from a source stream into a target stream.
            </summary>
      <param name="sourceStream">Readable stream with encrypted data.</param>
      <param name="targetStream">Writable stream that will receive the decrypted data.</param>
      <param name="state">An optional user-provided object that identifies this particular asynchronous operation.</param>
    </member>
    <member name="M:Rebex.Security.FileEncryption.EncryptAsync(System.String,System.String,System.Object)">
      <summary>
            Begins asynchronous Encrypt operation.
            Encrypts a source file into a target file.
            </summary>
      <param name="sourceFile">The file to encrypt.</param>
      <param name="targetFile">The name of the encrypted file. This cannot be a directory.</param>
      <param name="state">An optional user-provided object that identifies this particular asynchronous operation.</param>
    </member>
    <member name="M:Rebex.Security.FileEncryption.EncryptAsync(System.IO.Stream,System.IO.Stream,System.Object)">
      <summary>
            Begins asynchronous Encrypt operation.
            Encrypts data from a source stream into a target stream.
            </summary>
      <param name="sourceStream">Readable stream with input data.</param>
      <param name="targetStream">Writable stream that will receive the encrypted data.</param>
      <param name="state">An optional user-provided object that identifies this particular asynchronous operation.</param>
    </member>
    <member name="T:Rebex.Security.XtsSettings">
      <summary>
            XTS settings.
            </summary>
    </member>
    <member name="M:Rebex.Security.XtsSettings.#ctor">
      <summary>
            Creates a new instance of <see cref="T:Rebex.Security.XtsSettings" />.
            </summary>
    </member>
    <member name="P:Rebex.Security.XtsSettings.BlockSize">
      <summary>
            The XTS algorithm block size in bytes. Must be multiple of 16. Default value is 65536, maximum number is 1048576.
            Use smaller buffer if you read very small parts of a stream from different places, or use larger buffer if you do sequential reads of large blocks. 
            Setting this value might negatively impact the performance.
            </summary>
    </member>
    <member name="P:Rebex.Security.XtsSettings.KeySize">
      <summary>
            Length of AES keys (derived from the password using PBKDF2 defined by RFC 2898).
            </summary>
    </member>
    <member name="P:Rebex.Security.XtsSettings.Iterations">
      <summary>
            Number of iterations for key derivation (derived from the password using PBKDF2 defined by RFC 2898).
            </summary>
    </member>
    <member name="T:Rebex.Security.XtsStream">
      <summary>
            Implements XTS-AES, a standard algorithm for protection of stored data defined by IEEE P1619.
            </summary>
    </member>
    <member name="F:Rebex.Security.XtsStream.DefaultBlockSize">
      <summary>
            Default block size (64 KB).
            </summary>
    </member>
    <member name="P:Rebex.Security.XtsStream.BlockSize">
      <summary>
            Gets a size of one XTS block in bytes
            </summary>
    </member>
    <member name="P:Rebex.Security.XtsStream.CanRead">
      <summary>
            Gets a value indicating whether the stream supports reading.
            </summary>
      <returns>true if the stream supports reading; otherwise, false.</returns>
      <exception cref="T:System.ObjectDisposedException">
            Methods were called after the stream was closed.
            </exception>
    </member>
    <member name="P:Rebex.Security.XtsStream.CanSeek">
      <summary>
            Gets a value indicating whether the stream supports seeking.
            </summary>
      <returns>true if the stream supports seeking; otherwise, false.</returns>
      <exception cref="T:System.ObjectDisposedException">
            Methods were called after the stream was closed.
            </exception>
    </member>
    <member name="P:Rebex.Security.XtsStream.CanWrite">
      <summary>
            Gets a value indicating whether the stream supports writing.
            </summary>
      <returns>true if the stream supports writing; otherwise, false.</returns>
      <exception cref="T:System.ObjectDisposedException">
            Methods were called after the stream was closed.
            </exception>
    </member>
    <member name="P:Rebex.Security.XtsStream.Length">
      <summary>
            Gets the length in bytes of the stream.
            </summary>
      <returns>
            A long value representing the length of the stream in bytes.
            </returns>
      <exception cref="T:System.NotSupportedException">
            A class derived from Stream does not support seeking.
            </exception>
      <exception cref="T:System.ObjectDisposedException">
            Methods were called after the stream was closed.
            </exception>
    </member>
    <member name="P:Rebex.Security.XtsStream.Position">
      <summary>
            Gets or sets the position within the stream.
            </summary>
      <returns>
            The current position within the stream.
            </returns>
      <exception cref="T:System.IO.IOException">
            An I/O error occurs.
            </exception>
      <exception cref="T:System.NotSupportedException">
            The stream does not support seeking.
            </exception>
      <exception cref="T:System.ObjectDisposedException">
            Methods were called after the stream was closed.
            </exception>
      <exception cref="T:System.InvalidOperationException">
            Position is set to a negative number or is greater than the stream length. If you need to increase stream length, use the SetLength method first.
            </exception>
    </member>
    <member name="M:Rebex.Security.XtsStream.#ctor(System.String,System.String)">
      <summary>
            Initializes a new instance of the <see cref="T:Rebex.Security.XtsStream" /> class.
            </summary>
      <param name="filePath">The base stream that contains or will contain encrypted data in the Rebex XTS format.</param>
      <param name="password">The password that is used to generate the encryption key.</param>
      <exception cref="T:System.NotSupportedException">
        <paramref name="filePath" /> is not readable or seekable.
            </exception>
      <exception cref="T:System.ArgumentNullException">
        <paramref name="filePath" /> or <paramref name="password" /> is null.
            </exception>
    </member>
    <member name="M:Rebex.Security.XtsStream.#ctor(System.String,System.Byte[])">
      <summary>
            Initializes a new instance of the <see cref="T:Rebex.Security.XtsStream" /> class.
            </summary>
      <param name="filePath">The base stream that contains or will contain encrypted data in the Rebex XTS format.</param>
      <param name="password">The password that is used to generate the encryption key.</param>
      <exception cref="T:System.NotSupportedException">
        <paramref name="filePath" /> is not readable or seekable.
            </exception>
      <exception cref="T:System.ArgumentNullException">
        <paramref name="filePath" /> or <paramref name="password" /> is null.
            </exception>
    </member>
    <member name="M:Rebex.Security.XtsStream.#ctor(System.String,System.String,Rebex.Security.XtsSettings)">
      <summary>
            Initializes a new instance of the <see cref="T:Rebex.Security.XtsStream" /> class.
            </summary>
      <param name="filePath">The base stream that contains or will contain encrypted data in the Rebex XTS format.</param>
      <param name="password">The password that is used to generate the encryption key.</param>
            /// <param name="settings">XTS settings.</param><exception cref="T:System.NotSupportedException"><paramref name="filePath" /> is not readable or seekable.
            </exception><exception cref="T:System.ArgumentNullException"><paramref name="filePath" /> or <paramref name="password" /> is null.
            </exception></member>
    <member name="M:Rebex.Security.XtsStream.#ctor(System.String,System.Byte[],Rebex.Security.XtsSettings)">
      <summary>
            Initializes a new instance of the <see cref="T:Rebex.Security.XtsStream" /> class.
            </summary>
      <param name="filePath">The base stream that contains or will contain encrypted data in the Rebex XTS format.</param>
      <param name="password">The password that is used to generate the encryption key.</param>
            /// <param name="settings">XTS settings.</param><exception cref="T:System.NotSupportedException"><paramref name="filePath" /> is not readable or seekable.
            </exception><exception cref="T:System.ArgumentNullException"><paramref name="filePath" /> or <paramref name="password" /> is null.
            </exception></member>
    <member name="M:Rebex.Security.XtsStream.#ctor(System.String,Rebex.Security.Cryptography.AsymmetricKeyAlgorithm,Rebex.Security.XtsSettings)">
      <summary>
            Initializes a new instance of the <see cref="T:Rebex.Security.XtsStream" /> class.
            </summary>
      <param name="filePath">The base stream that contains or will contain encrypted data in the Rebex XTS format.</param>
      <param name="key">The public key used to encrypt a randomly-generated password.</param>
            /// <param name="settings">XTS settings.</param><exception cref="T:System.NotSupportedException"><paramref name="filePath" /> is not readable or seekable.
            </exception><exception cref="T:System.ArgumentNullException"><paramref name="filePath" /> is null.
            </exception></member>
    <member name="M:Rebex.Security.XtsStream.#ctor(System.IO.Stream,System.String)">
      <summary>
            Initializes a new instance of the <see cref="T:Rebex.Security.XtsStream" /> class.
            </summary>
      <param name="baseStream">The base stream that contains or will contain encrypted data in the Rebex XTS format.</param>
      <param name="password">The password that is used to generate the encryption key.</param>
      <exception cref="T:System.NotSupportedException">
        <paramref name="baseStream" /> is not readable or seekable.
            </exception>
      <exception cref="T:System.ArgumentNullException">
        <paramref name="baseStream" /> or <paramref name="password" /> is null.
            </exception>
    </member>
    <member name="M:Rebex.Security.XtsStream.#ctor(System.IO.Stream,System.Byte[])">
      <summary>
            Initializes a new instance of the <see cref="T:Rebex.Security.XtsStream" /> class.
            </summary>
      <param name="baseStream">The base stream that contains or will contain encrypted data in the Rebex XTS format.</param>
      <param name="password">The password that is used to generate the encryption key.</param>
      <exception cref="T:System.NotSupportedException">
        <paramref name="baseStream" /> is not readable or seekable.
            </exception>
      <exception cref="T:System.ArgumentNullException">
        <paramref name="baseStream" /> or <paramref name="password" /> is null.
            </exception>
    </member>
    <member name="M:Rebex.Security.XtsStream.#ctor(System.IO.Stream,System.String,Rebex.Security.XtsSettings)">
      <summary>
            Initializes a new instance of the <see cref="T:Rebex.Security.XtsStream" /> class.
            </summary>
      <param name="baseStream">The base stream that contains or will contain encrypted data in the Rebex XTS format.</param>
      <param name="password">The password that is used to generate the encryption key.</param>
      <param name="settings">XTS settings.</param>
      <exception cref="T:System.NotSupportedException">
        <paramref name="baseStream" /> is not readable or seekable.
            </exception>
      <exception cref="T:System.ArgumentNullException">
        <paramref name="baseStream" /> or <paramref name="password" /> is null.
            </exception>
    </member>
    <member name="M:Rebex.Security.XtsStream.#ctor(System.IO.Stream,System.Byte[],Rebex.Security.XtsSettings)">
      <summary>
            Initializes a new instance of the <see cref="T:Rebex.Security.XtsStream" /> class.
            </summary>
      <param name="baseStream">The base stream that contains or will contain encrypted data in the Rebex XTS format.</param>
      <param name="password">The password that is used to generate the encryption key.</param>
      <param name="settings">XTS settings.</param>
      <exception cref="T:System.NotSupportedException">
        <paramref name="baseStream" /> is not readable or seekable.
            </exception>
      <exception cref="T:System.ArgumentNullException">
        <paramref name="baseStream" /> or <paramref name="password" /> is null.
            </exception>
    </member>
    <member name="M:Rebex.Security.XtsStream.#ctor(System.IO.Stream,Rebex.Security.Cryptography.Pkcs.PublicKeyInfo,Rebex.Security.XtsSettings)">
      <summary>
            Initializes a new instance of the <see cref="T:Rebex.Security.XtsStream" /> class.
            </summary>
      <param name="baseStream">The base stream that contains or will contain encrypted data in the Rebex XTS format.</param>
      <param name="key">The public key used to encrypt a randomly-generated password.</param>
      <param name="settings">XTS settings.</param>
      <exception cref="T:System.NotSupportedException">
        <paramref name="baseStream" /> is not readable or seekable.
            </exception>
      <exception cref="T:System.ArgumentNullException">
        <paramref name="baseStream" /> or <paramref name="key" /> is null.
            </exception>
    </member>
    <member name="M:Rebex.Security.XtsStream.#ctor(System.IO.Stream,Rebex.Security.Cryptography.Pkcs.PrivateKeyInfo,Rebex.Security.XtsSettings)">
      <summary>
            Initializes a new instance of the <see cref="T:Rebex.Security.XtsStream" /> class.
            </summary>
      <param name="baseStream">The base stream that contains or will contain encrypted data in the Rebex XTS format.</param>
      <param name="key">The private key used to encrypt or decrypt a randomly-generated password.</param>
      <param name="settings">XTS settings.</param>
      <exception cref="T:System.NotSupportedException">
        <paramref name="baseStream" /> is not readable or seekable.
            </exception>
      <exception cref="T:System.ArgumentNullException">
        <paramref name="baseStream" /> or <paramref name="key" /> is null.
            </exception>
    </member>
    <member name="M:Rebex.Security.XtsStream.#ctor(System.IO.Stream,Rebex.Security.Cryptography.AsymmetricKeyAlgorithm,Rebex.Security.XtsSettings)">
      <summary>
            Initializes a new instance of the <see cref="T:Rebex.Security.XtsStream" /> class.
            </summary>
      <param name="baseStream">The base stream that contains or will contain encrypted data in the Rebex XTS format.</param>
      <param name="key">The public or private key used to encrypt or decrypt a randomly-generated password.</param>
      <param name="settings">XTS settings.</param>
      <exception cref="T:System.NotSupportedException">
        <paramref name="baseStream" /> is not readable or seekable.
            </exception>
      <exception cref="T:System.ArgumentNullException">
        <paramref name="baseStream" /> or <paramref name="key" /> is null.
            </exception>
    </member>
    <member name="M:Rebex.Security.XtsStream.#ctor(System.IO.Stream,System.String,System.Int32)">
      <summary>
            Initializes a new instance of the <see cref="T:Rebex.Security.XtsStream" /> class.
            </summary>
      <param name="baseStream">The base stream that contains or will contain encrypted data in the Rebex XTS format.</param>
      <param name="password">The password that is used to generate the encryption key.</param>
      <param name="blockSize">The XTS algorithm block size in bytes. Must be multiple of 16. Default value is 65536. 
            Use smaller buffer if you read very small parts of a stream from different places, or use larger buffer if you do sequential reads of large blocks. 
            Setting this value might negatively impact the performance.</param>
      <exception cref="T:System.NotSupportedException">
        <paramref name="baseStream" /> is not readable or seekable.
            </exception>
      <exception cref="T:System.ArgumentNullException">
        <paramref name="baseStream" /> or <paramref name="password" /> is null.
            </exception>
      <exception cref="T:System.ArgumentException">
        <paramref name="blockSize" /> is negative, zero or not multiple of 16.
            </exception>
    </member>
    <member name="M:Rebex.Security.XtsStream.#ctor(System.IO.Stream,System.Byte[],System.Int32)">
      <summary>
            Initializes a new instance of the <see cref="T:Rebex.Security.XtsStream" /> class.
            </summary>
      <param name="baseStream">The base stream that contains or will contain encrypted data in the Rebex XTS format.</param>
      <param name="password">The password that is used to generate the encryption key.</param>
      <param name="blockSize">The XTS algorithm block size in bytes. Must be multiple of 16. Default value is 65536, maximum number is 1048576.
            Use smaller buffer if you read very small parts of a stream from different places, or use larger buffer if you do sequential reads of large blocks. 
            Setting this value might negatively impact the performance.</param>
      <exception cref="T:System.NotSupportedException">
        <paramref name="baseStream" /> is not readable or seekable.
            </exception>
      <exception cref="T:System.ArgumentNullException">
        <paramref name="baseStream" /> or <paramref name="password" /> is null.
            </exception>
      <exception cref="T:System.ArgumentException">
        <paramref name="blockSize" /> is negative, zero or not multiple of 16.
            </exception>
    </member>
    <member name="M:Rebex.Security.XtsStream.#ctor(System.IO.Stream,Rebex.Security.Cryptography.Pkcs.PublicKeyInfo,System.Int32)">
      <summary>
            Initializes a new instance of the <see cref="T:Rebex.Security.XtsStream" /> class.
            </summary>
      <param name="baseStream">The base stream that contains or will contain encrypted data in the Rebex XTS format.</param>
      <param name="key">The public key used to encrypt a randomly-generated password.</param>
      <param name="blockSize">The XTS algorithm block size in bytes. Must be multiple of 16. Default value is 65536, maximum number is 1048576.
            Use smaller buffer if you read very small parts of a stream from different places, or use larger buffer if you do sequential reads of large blocks. 
            Setting this value might negatively impact the performance.</param>
      <exception cref="T:System.NotSupportedException">
        <paramref name="baseStream" /> is not readable or seekable.
            </exception>
      <exception cref="T:System.ArgumentNullException">
        <paramref name="baseStream" /> or <paramref name="key" /> is null.
            </exception>
      <exception cref="T:System.ArgumentException">
        <paramref name="blockSize" /> is negative, zero or not multiple of 16.
            </exception>
    </member>
    <member name="M:Rebex.Security.XtsStream.#ctor(System.IO.Stream,Rebex.Security.Cryptography.Pkcs.PrivateKeyInfo,System.Int32)">
      <summary>
            Initializes a new instance of the <see cref="T:Rebex.Security.XtsStream" /> class.
            </summary>
      <param name="baseStream">The base stream that contains or will contain encrypted data in the Rebex XTS format.</param>
      <param name="key">The private key used to encrypt or decrypt a randomly-generated password.</param>
      <param name="blockSize">The XTS algorithm block size in bytes. Must be multiple of 16. Default value is 65536, maximum number is 1048576.
            Use smaller buffer if you read very small parts of a stream from different places, or use larger buffer if you do sequential reads of large blocks. 
            Setting this value might negatively impact the performance.</param>
      <exception cref="T:System.NotSupportedException">
        <paramref name="baseStream" /> is not readable or seekable.
            </exception>
      <exception cref="T:System.ArgumentNullException">
        <paramref name="baseStream" /> or <paramref name="key" /> is null.
            </exception>
      <exception cref="T:System.ArgumentException">
        <paramref name="blockSize" /> is negative, zero or not multiple of 16.
            </exception>
    </member>
    <member name="M:Rebex.Security.XtsStream.#ctor(System.IO.Stream,Rebex.Security.Cryptography.AsymmetricKeyAlgorithm,System.Int32)">
      <summary>
            Initializes a new instance of the <see cref="T:Rebex.Security.XtsStream" /> class.
            </summary>
      <param name="baseStream">The base stream that contains or will contain encrypted data in the Rebex XTS format.</param>
      <param name="key">The public or private key used to encrypt or decrypt a randomly-generated password.</param>
      <param name="blockSize">The XTS algorithm block size in bytes. Must be multiple of 16. Default value is 65536, maximum number is 1048576.
            Use smaller buffer if you read very small parts of a stream from different places, or use larger buffer if you do sequential reads of large blocks. 
            Setting this value might negatively impact the performance.</param>
      <exception cref="T:System.NotSupportedException">
        <paramref name="baseStream" /> is not readable or seekable.
            </exception>
      <exception cref="T:System.ArgumentNullException">
        <paramref name="baseStream" /> or <paramref name="key" /> is null.
            </exception>
      <exception cref="T:System.ArgumentException">
        <paramref name="blockSize" /> is negative, zero or not multiple of 16.
            </exception>
    </member>
    <member name="M:Rebex.Security.XtsStream.Flush">
      <summary>
            Clears all buffers for this stream and causes any buffered data to be written to the underlying device.
            </summary>
      <exception cref="T:System.IO.IOException">
            An I/O error occurs.
            </exception>
      <exception cref="T:System.ObjectDisposedException">
            Methods were called after the stream was closed.
            </exception>
    </member>
    <member name="M:Rebex.Security.XtsStream.Read(System.Byte[],System.Int32,System.Int32)">
      <summary>
            Reads a sequence of bytes from the stream and advances the position within the stream by the number of bytes read.
            </summary>
      <param name="buffer">An array of bytes. When this method returns, the buffer contains the specified byte array with the values between <paramref name="offset" /> and (<paramref name="offset" /> + <paramref name="count" /> - 1) replaced by the bytes read from the current source.</param>
      <param name="offset">The zero-based byte offset in <paramref name="buffer" /> at which to begin storing the data read from the stream.</param>
      <param name="count">The maximum number of bytes to be read from the stream.</param>
      <returns>
            The total number of bytes read into the buffer. This can be less than the number of bytes requested if that many bytes are not currently available, or zero (0) if the end of the stream has been reached.
            </returns>
      <exception cref="T:System.ArgumentException">
            The sum of <paramref name="offset" /> and <paramref name="count" /> is larger than the buffer length.
            </exception>
      <exception cref="T:System.ArgumentNullException">
        <paramref name="buffer" /> is null.
            </exception>
      <exception cref="T:System.ArgumentOutOfRangeException">
        <paramref name="offset" /> or <paramref name="count" /> is negative.
            </exception>
      <exception cref="T:System.IO.IOException">
            An I/O error occurs.
            </exception>
      <exception cref="T:System.NotSupportedException">
            The stream does not support reading.
            </exception>
      <exception cref="T:System.ObjectDisposedException">
            Methods were called after the stream was closed.
            </exception>
    </member>
    <member name="M:Rebex.Security.XtsStream.Seek(System.Int64,System.IO.SeekOrigin)">
      <summary>
            Sets the position within the stream.
            </summary>
      <param name="offset">A byte offset relative to the <paramref name="origin" /> parameter.</param>
      <param name="origin">A value of type <see cref="T:System.IO.SeekOrigin" /> indicating the reference point used to obtain the new position.</param>
      <returns>
            The new position within the stream.
            </returns>
      <exception cref="T:System.IO.IOException">
            An I/O error occurs.
            </exception>
      <exception cref="T:System.ObjectDisposedException">
            Methods were called after the stream was closed.
            </exception>
      <exception cref="T:System.InvalidOperationException">
            Position is set to a negative number or is greater than the stream length. If you need to increase stream length, use the SetLength method first.
            </exception>
    </member>
    <member name="M:Rebex.Security.XtsStream.SetLength(System.Int64)">
      <summary>
            Sets the length of the stream.
            </summary>
      <param name="value">The desired length of the stream in bytes.</param>
      <exception cref="T:System.IO.IOException">
            An I/O error occurs.
            </exception>
      <exception cref="T:System.NotSupportedException">
            The stream does not support both writing and seeking, such as if the stream is constructed from a pipe or console output.
            </exception>
      <exception cref="T:System.ObjectDisposedException">
            Methods were called after the stream was closed.
            </exception>
    </member>
    <member name="M:Rebex.Security.XtsStream.Write(System.Byte[],System.Int32,System.Int32)">
      <summary>
            Writes a sequence of bytes to the stream and advances the current position within this stream by the number of bytes written.
            </summary>
      <param name="buffer">An array of bytes. This method copies <paramref name="count" /> bytes from <paramref name="buffer" /> to the stream.</param>
      <param name="offset">The zero-based byte offset in <paramref name="buffer" /> at which to begin copying bytes to the stream.</param>
      <param name="count">The number of bytes to be written to the stream.</param>
      <exception cref="T:System.ArgumentException">
            The sum of <paramref name="offset" /> and <paramref name="count" /> is greater than the buffer length.
            </exception>
      <exception cref="T:System.ArgumentNullException">
        <paramref name="buffer" /> is null.
            </exception>
      <exception cref="T:System.ArgumentOutOfRangeException">
        <paramref name="offset" /> or <paramref name="count" /> is negative.
            </exception>
      <exception cref="T:System.IO.IOException">
            An I/O error occurs.
            </exception>
      <exception cref="T:System.NotSupportedException">
            The stream does not support writing.
            </exception>
      <exception cref="T:System.ObjectDisposedException">
            Methods were called after the stream was closed.
            </exception>
    </member>
    <member name="M:Rebex.Security.XtsStream.Dispose(System.Boolean)">
      <summary>
            Releases resources used by this stream.
            </summary>
      <param name="disposing">true to release both managed and unmanaged resources; false to release only unmanaged resources.</param>
    </member>
    <member name="T:Rebex.Legacy.FileEncryptionExtensions">
      <summary>
            Extension class for FileEncryption.
            </summary>
    </member>
    <member name="M:Rebex.Legacy.FileEncryptionExtensions.BeginDecrypt(Rebex.Security.FileEncryption,System.String,System.String,System.AsyncCallback,System.Object)">
      <summary>
            Begins asynchronous Decrypt operation.
            Decrypts a source file into a target file.
            </summary>
      <param name="sourceFile">The file to decrypt.</param>
      <param name="targetFile">The name of the decrypted file. This cannot be a directory.</param>
      <remarks>
        <p>In builds for .NET 4.0 and higher, this method is available as an extension method. Add 'using Rebex.Legacy' (C#) or 'Import Rebex.Legacy' (VB.NET) to your code in order to use it.</p>
      </remarks>
      <param name="callback">An optional asynchronous callback to be called when the operation is complete.</param>
      <param name="state">A user-provided object that identifies this particular asynchronous operation.</param>
      <param name="instance">Instance of FileEncryption.</param>
      <returns>
            An <see cref="T:System.IAsyncResult" /> that references the asynchronous operation.
            </returns>
    </member>
    <member name="M:Rebex.Legacy.FileEncryptionExtensions.BeginDecrypt(Rebex.Security.FileEncryption,System.IO.Stream,System.IO.Stream,System.AsyncCallback,System.Object)">
      <summary>
            Begins asynchronous Decrypt operation.
            Decrypts data from a source stream into a target stream.
            </summary>
      <param name="sourceStream">Readable stream with encrypted data.</param>
      <param name="targetStream">Writable stream that will receive the decrypted data.</param>
      <remarks>
        <p>In builds for .NET 4.0 and higher, this method is available as an extension method. Add 'using Rebex.Legacy' (C#) or 'Import Rebex.Legacy' (VB.NET) to your code in order to use it.</p>
      </remarks>
      <param name="callback">An optional asynchronous callback to be called when the operation is complete.</param>
      <param name="state">A user-provided object that identifies this particular asynchronous operation.</param>
      <param name="instance">Instance of FileEncryption.</param>
      <returns>
            An <see cref="T:System.IAsyncResult" /> that references the asynchronous operation.
            </returns>
    </member>
    <member name="M:Rebex.Legacy.FileEncryptionExtensions.EndDecrypt(Rebex.Security.FileEncryption,System.IAsyncResult)">
      <summary>
            Ends an asynchronous BeginDecrypt operation.
            </summary>
      <param name="asyncResult">Stores state information for this asynchronous operation as well as any user defined data.</param>
      <param name="instance">Instance of FileEncryption.</param>
    </member>
    <member name="M:Rebex.Legacy.FileEncryptionExtensions.BeginEncrypt(Rebex.Security.FileEncryption,System.String,System.String,System.AsyncCallback,System.Object)">
      <summary>
            Begins asynchronous Encrypt operation.
            Encrypts a source file into a target file.
            </summary>
      <param name="sourceFile">The file to encrypt.</param>
      <param name="targetFile">The name of the encrypted file. This cannot be a directory.</param>
      <remarks>
        <p>In builds for .NET 4.0 and higher, this method is available as an extension method. Add 'using Rebex.Legacy' (C#) or 'Import Rebex.Legacy' (VB.NET) to your code in order to use it.</p>
      </remarks>
      <param name="callback">An optional asynchronous callback to be called when the operation is complete.</param>
      <param name="state">A user-provided object that identifies this particular asynchronous operation.</param>
      <param name="instance">Instance of FileEncryption.</param>
      <returns>
            An <see cref="T:System.IAsyncResult" /> that references the asynchronous operation.
            </returns>
    </member>
    <member name="M:Rebex.Legacy.FileEncryptionExtensions.BeginEncrypt(Rebex.Security.FileEncryption,System.IO.Stream,System.IO.Stream,System.AsyncCallback,System.Object)">
      <summary>
            Begins asynchronous Encrypt operation.
            Encrypts data from a source stream into a target stream.
            </summary>
      <param name="sourceStream">Readable stream with input data.</param>
      <param name="targetStream">Writable stream that will receive the encrypted data.</param>
      <remarks>
        <p>In builds for .NET 4.0 and higher, this method is available as an extension method. Add 'using Rebex.Legacy' (C#) or 'Import Rebex.Legacy' (VB.NET) to your code in order to use it.</p>
      </remarks>
      <param name="callback">An optional asynchronous callback to be called when the operation is complete.</param>
      <param name="state">A user-provided object that identifies this particular asynchronous operation.</param>
      <param name="instance">Instance of FileEncryption.</param>
      <returns>
            An <see cref="T:System.IAsyncResult" /> that references the asynchronous operation.
            </returns>
    </member>
    <member name="M:Rebex.Legacy.FileEncryptionExtensions.EndEncrypt(Rebex.Security.FileEncryption,System.IAsyncResult)">
      <summary>
            Ends an asynchronous BeginEncrypt operation.
            </summary>
      <param name="asyncResult">Stores state information for this asynchronous operation as well as any user defined data.</param>
      <param name="instance">Instance of FileEncryption.</param>
    </member>
  </members>
</doc>