Package org.forgerock.opendj.server.config.client

Interface Argon2PasswordStorageSchemeCfgClient

    • Method Detail

      • getArgon2Iterations

        ValueOrExpression<Integer> getArgon2Iterations()
        Gets the "argon2-iterations" property.

        The number of iterations to perform.

        By default, changes to this setting impact only newly created and updated passwords. However, if the rehash-policy is set to always or only-increase, it causes the server to recalculate each user's password hash on their next authentication, and write the new hash to the user's entry on disk. Changing the number of iterations therefore leads to a short-term spike in CPU and disk use as the server updates each user's password when they next authenticate. Longer term, increasing this setting results in more secure passwords at the expense of much higher CPU consumption and lower throughput.

        Default value: 2

        Returns:
        Returns the value of the "argon2-iterations" property.

      • setArgon2Iterations

        void setArgon2Iterations​(ValueOrExpression<Integer> value)
                  throws PropertyException
        Sets the "argon2-iterations" property.

        The number of iterations to perform.

        By default, changes to this setting impact only newly created and updated passwords. However, if the rehash-policy is set to always or only-increase, it causes the server to recalculate each user's password hash on their next authentication, and write the new hash to the user's entry on disk. Changing the number of iterations therefore leads to a short-term spike in CPU and disk use as the server updates each user's password when they next authenticate. Longer term, increasing this setting results in more secure passwords at the expense of much higher CPU consumption and lower throughput.

        Parameters:
        value - The value of the "argon2-iterations" property.
        Throws:
        PropertyException - If the new value is invalid.

      • getArgon2Length

        ValueOrExpression<Integer> getArgon2Length()
        Gets the "argon2-length" property.

        The length of the produced hash.

        By default, changes to this setting impact only newly created and updated passwords. However, if the rehash-policy is set to always or only-increase, it causes the server to recalculate each user's password hash on their next authentication, and write the new hash to the user's entry on disk. Changing the length of the produced hash therefore leads to a short-term spike in CPU and disk use as the server updates each user's password when they next authenticate. Longer term, increasing this setting results in more secure passwords at the expense of much higher CPU consumption and lower throughput.

        Default value: 32

        Returns:
        Returns the value of the "argon2-length" property.

      • setArgon2Length

        void setArgon2Length​(ValueOrExpression<Integer> value)
              throws PropertyException
        Sets the "argon2-length" property.

        The length of the produced hash.

        By default, changes to this setting impact only newly created and updated passwords. However, if the rehash-policy is set to always or only-increase, it causes the server to recalculate each user's password hash on their next authentication, and write the new hash to the user's entry on disk. Changing the length of the produced hash therefore leads to a short-term spike in CPU and disk use as the server updates each user's password when they next authenticate. Longer term, increasing this setting results in more secure passwords at the expense of much higher CPU consumption and lower throughput.

        Parameters:
        value - The value of the "argon2-length" property.
        Throws:
        PropertyException - If the new value is invalid.

      • getArgon2Memory

        ValueOrExpression<Integer> getArgon2Memory()
        Gets the "argon2-memory" property.

        The amount of memory to use for a single hash, expressed in kibibytes.

        By default, changes to this setting impact only newly created and updated passwords. However, if the rehash-policy is set to always or only-increase, it causes the server to recalculate each user's password hash on their next authentication, and write the new hash to the user's entry on disk. Changing the amount of memory to use therefore leads to a short-term spike in CPU and disk use as the server updates each user's password when they next authenticate. Longer term, increasing this setting results in more secure passwords at the expense of longer response times and lower throughput.

        Default value: 15360

        Returns:
        Returns the value of the "argon2-memory" property.

      • setArgon2Memory

        void setArgon2Memory​(ValueOrExpression<Integer> value)
              throws PropertyException
        Sets the "argon2-memory" property.

        The amount of memory to use for a single hash, expressed in kibibytes.

        By default, changes to this setting impact only newly created and updated passwords. However, if the rehash-policy is set to always or only-increase, it causes the server to recalculate each user's password hash on their next authentication, and write the new hash to the user's entry on disk. Changing the amount of memory to use therefore leads to a short-term spike in CPU and disk use as the server updates each user's password when they next authenticate. Longer term, increasing this setting results in more secure passwords at the expense of longer response times and lower throughput.

        Parameters:
        value - The value of the "argon2-memory" property.
        Throws:
        PropertyException - If the new value is invalid.

      • getArgon2MemoryPoolSize

        ValueOrExpression<Integer> getArgon2MemoryPoolSize()
        Gets the "argon2-memory-pool-size" property.

        The amount of memory dedicated to Argon2 password hashing, expressed in kibibytes.

        This amount of memory places an upper limit on the number of argon2 password hashes which can be computed concurrently. Every bind request using argon2 password hashing will acquire memory from this pool, and release it once computation has completed. When the pool is empty, incoming bind requests using argon2 will be paused, waiting for concurrent argon2 computation to finish and return memory to the pool.

        Default value: 122880

        Returns:
        Returns the value of the "argon2-memory-pool-size" property.

      • setArgon2MemoryPoolSize

        void setArgon2MemoryPoolSize​(ValueOrExpression<Integer> value)
                      throws PropertyException
        Sets the "argon2-memory-pool-size" property.

        The amount of memory dedicated to Argon2 password hashing, expressed in kibibytes.

        This amount of memory places an upper limit on the number of argon2 password hashes which can be computed concurrently. Every bind request using argon2 password hashing will acquire memory from this pool, and release it once computation has completed. When the pool is empty, incoming bind requests using argon2 will be paused, waiting for concurrent argon2 computation to finish and return memory to the pool.

        Parameters:
        value - The value of the "argon2-memory-pool-size" property.
        Throws:
        PropertyException - If the new value is invalid.

      • getArgon2Parallelism

        ValueOrExpression<Integer> getArgon2Parallelism()
        Gets the "argon2-parallelism" property.

        The number of threads to use in parallel to compute a hash.

        The number of threads should not exceed twice the number of physical CPU cores that are dedicated to password hashing. By default, changes to this setting impact only newly created and updated passwords. However, if the rehash-policy is set to always or only-increase, it causes the server to recalculate each user's password hash on their next authentication, and write the new hash to the user's entry on disk. Changing the amount of parallelism to use therefore leads to a short-term spike in CPU and disk use as the server updates each user's password when they next authenticate. Longer term, increasing this setting results in more secure passwords at the expense of much higher CPU consumption and lower throughput.

        Default value: 1

        Returns:
        Returns the value of the "argon2-parallelism" property.

      • setArgon2Parallelism

        void setArgon2Parallelism​(ValueOrExpression<Integer> value)
                   throws PropertyException
        Sets the "argon2-parallelism" property.

        The number of threads to use in parallel to compute a hash.

        The number of threads should not exceed twice the number of physical CPU cores that are dedicated to password hashing. By default, changes to this setting impact only newly created and updated passwords. However, if the rehash-policy is set to always or only-increase, it causes the server to recalculate each user's password hash on their next authentication, and write the new hash to the user's entry on disk. Changing the amount of parallelism to use therefore leads to a short-term spike in CPU and disk use as the server updates each user's password when they next authenticate. Longer term, increasing this setting results in more secure passwords at the expense of much higher CPU consumption and lower throughput.

        Parameters:
        value - The value of the "argon2-parallelism" property.
        Throws:
        PropertyException - If the new value is invalid.

      • getArgon2SaltLength

        ValueOrExpression<Integer> getArgon2SaltLength()
        Gets the "argon2-salt-length" property.

        The length of the salt used during the hash.

        By default, changes to this setting impact only newly created and updated passwords.

        Default value: 16

        Returns:
        Returns the value of the "argon2-salt-length" property.

      • setArgon2SaltLength

        void setArgon2SaltLength​(ValueOrExpression<Integer> value)
                  throws PropertyException
        Sets the "argon2-salt-length" property.

        The length of the salt used during the hash.

        By default, changes to this setting impact only newly created and updated passwords.

        Parameters:
        value - The value of the "argon2-salt-length" property.
        Throws:
        PropertyException - If the new value is invalid.

      • getArgon2Variant

        ValueOrExpression<Argon2PasswordStorageSchemeCfgDefn.Argon2Variant> getArgon2Variant()
        Gets the "argon2-variant" property.

        The variant of Argon2 algorithm to use (between I, D and ID).

        Argon2D maximizes resistance to GPU cracking attacks. Argon2I is optimized to resist side-channel attacks. Argon2ID is a hybrid version that combines both approaches and has stronger resistance to attacks, but it's more expensive. By default, changes to this setting impact only newly created and updated passwords. However, if the rehash-policy is set to always or only-increase, it causes the server to recalculate each user's password hash on their next authentication, and writes the new hash to the user's entry on disk. Changing the variant of Argon2 algorithm to use therefore leads to a short-term spike in CPU and disk use as the server updates each user's password when they next authenticate. Longer term, increasing this setting results in more secure passwords at the expense of much higher CPU consumption and lower throughput.

        Default value: ID

        Returns:
        Returns the value of the "argon2-variant" property.

      • setArgon2Variant

        void setArgon2Variant​(ValueOrExpression<Argon2PasswordStorageSchemeCfgDefn.Argon2Variant> value)
               throws PropertyException
        Sets the "argon2-variant" property.

        The variant of Argon2 algorithm to use (between I, D and ID).

        Argon2D maximizes resistance to GPU cracking attacks. Argon2I is optimized to resist side-channel attacks. Argon2ID is a hybrid version that combines both approaches and has stronger resistance to attacks, but it's more expensive. By default, changes to this setting impact only newly created and updated passwords. However, if the rehash-policy is set to always or only-increase, it causes the server to recalculate each user's password hash on their next authentication, and writes the new hash to the user's entry on disk. Changing the variant of Argon2 algorithm to use therefore leads to a short-term spike in CPU and disk use as the server updates each user's password when they next authenticate. Longer term, increasing this setting results in more secure passwords at the expense of much higher CPU consumption and lower throughput.

        Parameters:
        value - The value of the "argon2-variant" property.
        Throws:
        PropertyException - If the new value is invalid.

      • getJavaClass

        @MandatoryProperty
ValueOrExpression<String> getJavaClass()
        Gets the "java-class" property.

        Specifies the fully-qualified name of the Java class that provides the Argon2 Password Storage Scheme implementation.

        Default value: org.opends.server.extensions.Argon2PasswordStorageScheme

        Specified by:
        getJavaClass in interface PasswordStorageSchemeCfgClient
        Returns:
        Returns the value of the "java-class" property.

      • getRehashPolicy

        ValueOrExpression<Argon2PasswordStorageSchemeCfgDefn.RehashPolicy> getRehashPolicy()
        Gets the "rehash-policy" property.

        Indicates whether the server should rehash passwords after the cost has been changed.

        Passwords will be rehashed when a user successfully authenticates. Note that rehashing will increase the write load on the server.

        Default value: never

        Returns:
        Returns the value of the "rehash-policy" property.

      • setRehashPolicy

        void setRehashPolicy​(ValueOrExpression<Argon2PasswordStorageSchemeCfgDefn.RehashPolicy> value)
              throws PropertyException
        Sets the "rehash-policy" property.

        Indicates whether the server should rehash passwords after the cost has been changed.

        Passwords will be rehashed when a user successfully authenticates. Note that rehashing will increase the write load on the server.

        Parameters:
        value - The value of the "rehash-policy" property.
        Throws:
        PropertyException - If the new value is invalid.