It is never a good idea to pass an empty value as the password argument to a cryptographic password-based key derivation function (PBKDF). In this scenario, the derived key will be based solely on the provided salt (rendering it significantly weaker), and fixing the problem is extremely difficult. After the offending code is in production, the empty password often cannot be changed without patching the software. If an account protected by a derived key based on an empty password is compromised, the owners of the system might be forced to choose between security and availability.

Example 1: The following code passes a hardcoded value as the password argument to a cryptographic PBKDF:

...
Rfc2898DeriveBytes rdb = new Rfc2898DeriveBytes("password", salt,100000);
...

Not only will anyone who has access to the code be able to determine that it generates one or more cryptographic keys based on a hardcoded password argument, but anyone with even basic cracking techniques is much more likely to successfully gain access to any resources protected by the offending keys. If an attacker also has access to the salt value used to generate any of the keys based on a hardcoded password, cracking those keys becomes trivial. After the program ships, there is likely no way to change the hardcoded password unless the program is patched. An employee with access to this information can use it to break into the system. Even if attackers only had access to the application's executable, they could extract evidence of the use of a hardcoded password.

Never pass a hardcoded value as the password argument to a cryptographic password-based key derivation function (PBKDF). In this scenario, the derived key is based mostly on the provided salt (rendering it significantly weaker), and fixing the problem is extremely difficult. After the offending code is in production, the hardcoded password often cannot be changed without patching the software. If an account protected by a derived key based on a hardcoded password is compromised, the owners of the system might be forced to choose between security and availability.

Example 1: The following code passes a hardcoded value as the password argument to a cryptographic PBKDF:

...
CCKeyDerivationPBKDF(kCCPBKDF2,
                     "secret",
                     6,
                     salt,
                     saltLen
                     kCCPRFHmacAlgSHA256,
                     100000,
                     derivedKey,
                     derivedKeyLen);
...

Not only will anyone who has access to the code be able to determine that it generates one or more cryptographic keys based on a hardcoded password argument, but anyone with even basic cracking techniques is much more likely to successfully gain access to any resources protected by the offending keys. If an attacker also has access to the salt value used to generate any of the keys based on a hardcoded password, cracking those keys becomes trivial. After the program ships, there is likely no way to change the hardcoded password unless the program is patched. An employee with access to this information can use it to break into the system. Even if attackers only had access to the application's executable, they could extract evidence of the use of a hardcoded password.

Never pass a hardcoded value as the password argument to a cryptographic password-based key derivation function (PBKDF). In this scenario, the derived key is based mostly on the provided salt (rendering it significantly weaker), and fixing the problem is extremely difficult. After the offending code is in production, the hardcoded password often cannot be changed without patching the software. If an account protected by a derived key based on a hardcoded password is compromised, the owners of the system might be forced to choose between security and availability.

Example 1: The following code passes a hardcoded value as the password argument to a cryptographic PBKDF:

...
$zip = new ZipArchive();
$zip->open("test.zip", ZipArchive::CREATE);
$zip->setEncryptionIndex(0, ZipArchive::EM_AES_256, "hardcodedpassword");
...

Anyone with access to the code can determine that it generates one or more cryptographic keys based on a hardcoded password argument. Additionally, anyone with even basic cracking techniques might successfully gain access to any resources protected by the offending keys. If an attacker also has access to the salt value used to generate any of the keys based on a hardcoded password, cracking those keys becomes trivial. After the program ships, there is likely no way to change the hardcoded password unless the program is patched. An employee with access to this information can use it to break into the system. Even if attackers only had access to the application's executable, they could extract evidence of the use of a hardcoded password.

Never pass a hardcoded value as the password argument to a cryptographic password-based key derivation function (PBKDF). In this scenario, the derived key is based mostly on the provided salt (rendering it significantly weaker), and fixing the problem is extremely difficult. After the offending code is in production, the hardcoded password often cannot be changed without patching the software. If an account protected by a derived key based on a hardcoded password is compromised, the owners of the system might be forced to choose between security and availability.

Example 1: The following code passes a hardcoded value as the password argument to a cryptographic PBKDF:

from hashlib import pbkdf2_hmac
...
dk = pbkdf2_hmac('sha256', 'password', salt, 100000)
...

Not only will anyone who has access to the code be able to determine that it generates one or more cryptographic keys based on a hardcoded password argument, but anyone with even basic cracking techniques is much more likely to successfully gain access to any resources protected by the offending keys. If an attacker also has access to the salt value used to generate any of the keys based on a hardcoded password, cracking those keys becomes trivial. After the program ships, there is likely no way to change the hardcoded password unless the program is patched. An employee with access to this information can use it to break into the system. Even if attackers only had access to the application's executable, they could extract evidence of the use of a hardcoded password.

Never pass a hardcoded value as the password argument to a cryptographic password-based key derivation function (PBKDF). In this scenario, the derived key is based mostly on the provided salt (rendering it significantly weaker), and fixing the problem is extremely difficult. After the offending code is in production, the hardcoded password often cannot be changed without patching the software. If an account protected by a derived key based on a hardcoded password is compromised, the owners of the system might be forced to choose between security and availability.

Example 1: The following code passes a hardcoded value as the password argument to a cryptographic PBKDF:

...
key = OpenSSL::PKCS5::pbkdf2_hmac('password', salt, 100000, 256, 'SHA256')
...

Not only will anyone who has access to the code be able to determine that it generates one or more cryptographic keys based on a hardcoded password argument, but anyone with even basic cracking techniques is much more likely to successfully gain access to any resources protected by the offending keys. If an attacker also has access to the salt value used to generate any of the keys based on a hardcoded password, cracking those keys becomes trivial. After the program ships, there is likely no way to change the hardcoded password unless the program is patched. An employee with access to this information can use it to break into the system. Even if attackers only had access to the application's executable, they could extract evidence of the use of a hardcoded password.

Never pass a hardcoded value as the password argument to a cryptographic password-based key derivation function (PBKDF). In this scenario, the derived key is based mostly on the provided salt (rendering it significantly weaker), and fixing the problem is extremely difficult. After the offending code is in production, the hardcoded password often cannot be changed without patching the software. If an account protected by a derived key based on a hardcoded password is compromised, the owners of the system might be forced to choose between security and availability.

Example 1: The following code passes a hardcoded value as the password argument to a cryptographic PBKDF:

...
CCKeyDerivationPBKDF(CCPBKDFAlgorithm(kCCPBKDF2),
"secret",
6,
salt,
saltLen,
CCPseudoRandomAlgorithm(kCCPRFHmacAlgSHA256),
100000,
derivedKey,
derivedKeyLen)
...

Not only will anyone who has access to the code be able to determine that it generates one or more cryptographic keys based on a hardcoded password argument, but anyone with even basic cracking techniques is much more likely to successfully gain access to any resources protected by the offending keys. If an attacker also has access to the salt value used to generate any of the keys based on a hardcoded password, cracking those keys becomes trivial. After the program ships, there is likely no way to change the hardcoded password unless the program is patched. An employee with access to this information can use it to break into the system. Even if attackers only had access to the application's executable, they could extract evidence of the use of a hardcoded password.

An API operation has been detected that allows credentials to travel over an unencrypted channel. OpenAPI security requirements and target servers definitions for an API operation will always override the respective global settings.

However, when these settings are not defined for an operation, they default to the globally specified values.