var params:Object = LoaderInfo(this.root.loaderInfo).parameters;
var ctl:String = String(params["ctl"]);
var ao:Worker;
if (ctl == "Add) {
ao = new AddCommand();
} else if (ctl == "Modify") {
ao = new ModifyCommand();
} else {
throw new UnknownActionError();
}
ao.doAction(params);
var params:Object = LoaderInfo(this.root.loaderInfo).parameters;
var ctl:String = String(params["ctl"]);
var ao:Worker;
var cmdClass:Class = getDefinitionByName(ctl + "Command") as Class;
ao = new cmdClass();
ao.doAction(params);
if/else foram totalmente eliminados e agora é possível adicionar novos tipos de comando sem modificar o expedidor de comandos.Worker. Se o expedidor de comandos ainda for responsável pelo controle de acesso, sempre que os programadores criarem uma nova classe que implementa a interface Worker, eles deverão se lembrar de modificar o código de controle de acesso do expedidor. Se o código de controle de acesso não for modificado, algumas classes Worker não terão controle de acesso.Worker responsável pela execução da verificação de controle de acesso. Veja a seguir um exemplo do código novamente refatorado:
var params:Object = LoaderInfo(this.root.loaderInfo).parameters;
var ctl:String = String(params["ctl"]);
var ao:Worker;
var cmdClass:Class = getDefinitionByName(ctl + "Command") as Class;
ao = new cmdClass();
ao.checkAccessControl(params);
ao.doAction(params);
Continuation pode permitir que invasores criem caminhos de fluxo de controle inesperados através do aplicativo, potencialmente ignorando as verificações de segurança.continuationMethod, que determina o nome do método a ser chamado ao receber uma resposta.
public Object startRequest() {
Continuation con = new Continuation(40);
Map<String,String> params = ApexPages.currentPage().getParameters();
if (params.containsKey('contMethod')) {
con.continuationMethod = params.get('contMethod');
} else {
con.continuationMethod = 'processResponse';
}
HttpRequest req = new HttpRequest();
req.setMethod('GET');
req.setEndpoint(LONG_RUNNING_SERVICE_URL);
this.requestLabel = con.addHttpRequest(req);
return con;
}
continuationMethod seja definida por parâmetros de solicitação de tempo de execução, o que permite que invasores chamem qualquer função que corresponda ao nome.
...
Dim ctl As String
Dim ao As New Worker()
ctl = Request.Form("ctl")
If (String.Compare(ctl,"Add") = 0) Then
ao.DoAddCommand(Request)
Else If (String.Compare(ctl,"Modify") = 0) Then
ao.DoModifyCommand(Request)
Else
App.EventLog("No Action Found", 4)
End If
...
...
Dim ctl As String
Dim ao As New Worker()
ctl = Request.Form("ctl")
CallByName(ao, ctl, vbMethod, Request)
...
if/else foram totalmente eliminados e agora é possível adicionar novos tipos de comando sem modificar o expedidor de comandos.Worker. Se o dispatcher de comandos for responsável pelo controle de acesso, sempre que os programadores criarem um novo método na classe Worker, eles deverão modificar a lógica de controle de acesso do dispatcher. Se essa lógica de controle de acesso se tornar obsoleta, alguns métodos Worker não terão controle de acesso.Worker responsável pela execução da verificação de controle de acesso. Veja a seguir um exemplo do código novamente refatorado:
...
Dim ctl As String
Dim ao As New Worker()
ctl = Request.Form("ctl")
If (ao.checkAccessControl(ctl,Request) = True) Then
CallByName(ao, "Do" & ctl & "Command", vbMethod, Request)
End If
...
clazz.
char* ctl = getenv("ctl");
...
jmethodID mid = GetMethodID(clazz, ctl, sig);
status = CallIntMethod(env, clazz, mid, JAVA_ARGS);
...
Exemplo 2: De forma semelhante no exemplo anterior, o aplicativo usa o pacote
...
func beforeExampleCallback(scope *Scope){
input := os.Args[1]
if input{
scope.CallMethod(input)
}
}
...
reflect para obter o nome de uma função a ser chamada de um argumento da linha de comando.
...
input := os.Args[1]
var worker WokerType
reflect.ValueOf(&worker).MethodByName(input).Call([]reflect.Value{})
...
String ctl = request.getParameter("ctl");
Worker ao = null;
if (ctl.equals("Add")) {
ao = new AddCommand();
} else if (ctl.equals("Modify")) {
ao = new ModifyCommand();
} else {
throw new UnknownActionError();
}
ao.doAction(request);
String ctl = request.getParameter("ctl");
Class cmdClass = Class.forName(ctl + "Command");
Worker ao = (Worker) cmdClass.newInstance();
ao.doAction(request);
if/else foram totalmente eliminados e agora é possível adicionar novos tipos de comando sem modificar o expedidor de comandos.Worker. Se o expedidor de comandos ainda for responsável pelo controle de acesso, sempre que os programadores criarem uma nova classe que implementa a interface Worker, eles deverão se lembrar de modificar o código de controle de acesso do expedidor. Se o código de controle de acesso não for modificado, algumas classes Worker não terão controle de acesso.Worker responsável pela execução da verificação de controle de acesso. Veja a seguir um exemplo do código novamente refatorado:
String ctl = request.getParameter("ctl");
Class cmdClass = Class.forName(ctl + "Command");
Worker ao = (Worker) cmdClass.newInstance();
ao.checkAccessControl(request);
ao.doAction(request);
Worker; o construtor padrão para qualquer objeto no sistema pode ser invocado. Se o objeto não implementar a interface Worker, um ClassCastException será lançado antes da atribuição a ao, mas, se o construtor realizar operações que funcionarem a favor do invasor, os danos já terão sido feitos. Embora esse cenário seja relativamente favorável em aplicativos simples, em aplicativos maiores, nos quais a complexidade cresce exponencialmente, não é absurdo considerar que um invasor possa encontrar um construtor a ser otimizado como parte de um ataque.performSelector, o que pode permitir que eles criem caminhos inesperados de controle de fluxo por meio do aplicativo, potencialmente ignorando as verificações de segurança.UIApplicationDelegate.
...
- (BOOL)application:(UIApplication *)application openURL:(NSURL *)url
sourceApplication:(NSString *)sourceApplication annotation:(id)annotation {
NSString *query = [url query];
NSString *pathExt = [url pathExtension];
[self performSelector:NSSelectorFromString(pathExt) withObject:query];
...
$ctl = $_GET["ctl"];
$ao = null;
if (ctl->equals("Add")) {
$ao = new AddCommand();
} else if ($ctl.equals("Modify")) {
$ao = new ModifyCommand();
} else {
throw new UnknownActionError();
}
$ao->doAction(request);
$ctl = $_GET["ctl"];
$args = $_GET["args"];
$cmdClass = new ReflectionClass(ctl . "Command");
$ao = $cmdClass->newInstance($args);
$ao->doAction(request);
if/else foram totalmente eliminados e agora é possível adicionar novos tipos de comando sem modificar o expedidor de comandos.Worker. Se o expedidor de comandos ainda for responsável pelo controle de acesso, sempre que os programadores criarem uma nova classe que implementa a interface Worker, eles deverão se lembrar de modificar o código de controle de acesso do expedidor. Se o código de controle de acesso não for modificado, algumas classes Worker não terão controle de acesso.Worker responsável pela execução da verificação de controle de acesso. Veja a seguir um exemplo do código novamente refatorado:
$ctl = $_GET["ctl"];
$args = $_GET["args"];
$cmdClass = new ReflectionClass(ctl . "Command");
$ao = $cmdClass->newInstance($args);
$ao->checkAccessControl(request);
ao->doAction(request);
Worker; o construtor padrão para qualquer objeto no sistema pode ser invocado. Se o objeto não implementar a interface Worker, um ClassCastException será lançado antes da atribuição a $ao, mas, se o construtor realizar operações que funcionarem a favor do invasor, os danos já terão sido feitos. Embora esse cenário seja relativamente favorável em aplicativos simples, em aplicativos maiores, nos quais a complexidade cresce exponencialmente, não é absurdo considerar que um invasor possa encontrar um construtor a ser otimizado como parte de um ataque.
ctl = req['ctl']
if ctl=='add'
addCommand(req)
elsif ctl=='modify'
modifyCommand(req)
else
raise UnknownCommandError.new
end
ctl = req['ctl']
ctl << "Command"
send(ctl)
if/else foram totalmente eliminados e agora é possível adicionar novos tipos de comando sem modificar o expedidor de comandos.define_method(), ou pode ser chamá-los ao substituir missing_method(). Fazer a auditoria e o rastreio desses métodos assim como de que maneira o código de controle é utilizado com eles é muito difícil e, ao considerar essa situação, ela também dependerá de quais outros códigos de biblioteca estão carregados; isso fará com que essa tarefa seja quase impossível de realizar corretamente.
def exec(ctl: String) = Action { request =>
val cmdClass = Platform.getClassForName(ctl + "Command")
Worker ao = (Worker) cmdClass.newInstance()
ao.doAction(request)
...
}
if/else foram totalmente eliminados e agora é possível adicionar novos tipos de comando sem modificar o expedidor de comandos.Worker. Se o expedidor de comandos ainda for responsável pelo controle de acesso, sempre que os programadores criarem uma nova classe que implementa a interface Worker, eles deverão se lembrar de modificar o código de controle de acesso do expedidor. Se o código de controle de acesso não for modificado, algumas classes Worker não terão controle de acesso.Worker responsável pela execução da verificação de controle de acesso. Veja a seguir um exemplo do código novamente refatorado:
def exec(ctl: String) = Action { request =>
val cmdClass = Platform.getClassForName(ctl + "Command")
Worker ao = (Worker) cmdClass.newInstance()
ao.checkAccessControl(request);
ao.doAction(request)
...
}
Worker; o construtor padrão para qualquer objeto no sistema pode ser invocado. Se o objeto não implementar a interface Worker, um ClassCastException será lançado antes da atribuição a ao, mas, se o construtor realizar operações que funcionarem a favor do invasor, os danos já terão sido feitos. Embora esse cenário seja relativamente favorável em aplicativos simples, em aplicativos maiores, nos quais a complexidade cresce exponencialmente, não é absurdo considerar que um invasor possa encontrar um construtor a ser otimizado como parte de um ataque.performSelector, o que pode permitir que eles criem caminhos inesperados de controle de fluxo por meio do aplicativo, potencialmente ignorando as verificações de segurança.UIApplicationDelegate.
func application(app: UIApplication, openURL url: NSURL, options: [String : AnyObject]) -> Bool {
...
let query = url.query
let pathExt = url.pathExtension
let selector = NSSelectorFromString(pathExt!)
performSelector(selector, withObject:query)
...
}
...
Dim ctl As String
Dim ao As new Worker
ctl = Request.Form("ctl")
If String.Compare(ctl,"Add") = 0 Then
ao.DoAddCommand Request
Else If String.Compare(ctl,"Modify") = 0 Then
ao.DoModifyCommand Request
Else
App.EventLog "No Action Found", 4
End If
...
...
Dim ctl As String
Dim ao As Worker
ctl = Request.Form("ctl")
CallByName ao, ctl, vbMethod, Request
...
if/else foram totalmente eliminados e agora é possível adicionar novos tipos de comando sem modificar o expedidor de comandos.Worker. Se o dispatcher de comandos ainda for responsável pelo controle de acesso, sempre que os programadores criarem um novo método na classe Worker, eles deverão se lembrar de modificar o código de controle de acesso do dispatcher. Se eles não conseguirem modificar o código de controle de acesso, alguns métodos Worker não terão nenhum controle de acesso.Worker responsável pela execução da verificação de controle de acesso. Veja a seguir um exemplo do código novamente refatorado:
...
Dim ctl As String
Dim ao As Worker
ctl = Request.Form("ctl")
If ao.checkAccessControl(ctl,Request) = True Then
CallByName ao, "Do" & ctl & "Command", vbMethod, Request
End If
...
NSData *imageData = [NSData dataWithContentsOfFile:file];
CC_MD5(imageData, [imageData length], result);
let encodedText = text.cStringUsingEncoding(NSUTF8StringEncoding)
let textLength = CC_LONG(text.lengthOfBytesUsingEncoding(NSUTF8StringEncoding))
let digestLength = Int(CC_MD5_DIGEST_LENGTH)
let result = UnsafeMutablePointer<CUnsignedChar>.alloc(digestLength)
CC_MD5(encodedText, textLength, result)
...
private static final String salt = "";
...
PBEKeySpec pbeSpec=new PBEKeySpec(password);
SecretKeyFactory keyFact=SecretKeyFactory.getInstance(CIPHER_ALG);
PBEParameterSpec defParams=new PBEParameterSpec(salt,100000);
Cipher cipher=Cipher.getInstance(CIPHER_ALG);
cipher.init(cipherMode,keyFact.generateSecret(pbeSpec),defParams);
...
...
const salt = "";
crypto.pbkdf2(
password,
salt,
iterations,
keyLength,
"sha256",
function (err, derivedKey) { ... }
);
...
CCKeyDerivationPBKDF(kCCPBKDF2,
password,
passwordLen,
"",
0,
kCCPRFHmacAlgSHA256,
100000,
derivedKey,
derivedKeyLen);
...
...
$hash = hash_pbkdf2('sha256', $password, '', 100000);
...
from hashlib import pbkdf2_hmac
...
dk = pbkdf2_hmac('sha256', password, '', 100000)
...
...
dk = OpenSSL::PKCS5.pbkdf2_hmac(password, "", 100000, 256, digest)
...
...
let ITERATION = UInt32(100000)
...
CCKeyDerivationPBKDF(CCPBKDFAlgorithm(kCCPBKDF2),
password,
passwordLength,
"",
0,
CCPseudoRandomAlgorithm(kCCPRFHmacAlgSHA256),
ITERATION,
derivedKey,
derivedKeyLength)
...
PKCS5_PBKDF2_HMAC(pass, strlen(pass), "2!@$(5#@532@%#$253l5#@$", 2, ITERATION, EVP_sha512(), outputBytes, digest);
...
...
private static final String salt = "2!@$(5#@532@%#$253l5#@$";
...
PBEKeySpec pbeSpec=new PBEKeySpec(password);
SecretKeyFactory keyFact=SecretKeyFactory.getInstance(CIPHER_ALG);
PBEParameterSpec defParams=new PBEParameterSpec(salt,100000);
Cipher cipher=Cipher.getInstance(CIPHER_ALG);
cipher.init(cipherMode,keyFact.generateSecret(pbeSpec),defParams);
...
...
const salt = "some constant value";
crypto.pbkdf2(
password,
salt,
iterations,
keyLength,
"sha256",
function (err, derivedKey) { ... }
);
...
CCKeyDerivationPBKDF(kCCPBKDF2,
password,
passwordLen,
"2!@$(5#@532@%#$253l5#@$",
2,
kCCPRFHmacAlgSHA256,
100000,
derivedKey,
derivedKeyLen);
...
...
$hash = hash_pbkdf2('sha256', $password, '2!@$(5#@532@%#$253l5#@$', 100000)
...
...
from hashlib import pbkdf2_hmac
dk = pbkdf2_hmac('sha256', password, '2!@$(5#@532@%#$253l5#@$', 100000)
...
...
dk = OpenSSL::PKCS5.pbkdf2_hmac(password, '2!@$(5#@532@%#$253l5#@$', 100000, 256, digest)
...
...
let ITERATION = UInt32(100000)
let salt = "2!@$(5#@532@%#$253l5#@$"
...
CCKeyDerivationPBKDF(CCPBKDFAlgorithm(kCCPBKDF2),
password,
passwordLength,
salt,
salt.lengthOfBytesUsingEncoding(NSUTF8StringEncoding),
CCPseudoRandomAlgorithm(kCCPRFHmacAlgSHA256),
ITERATION,
derivedKey,
derivedKeyLength)
...
...
crypt(password, "2!@$(5#@532@%#$253l5#@$");
...
...
salt := "2!@$(5#@532@%#$253l5#@$"
password := get_password()
sha256.Sum256([]byte(salt + password)
...
...
Encryptor instance = ESAPI.encryptor();
String hash1 = instance.hash(input, "2!@$(5#@532@%#$253l5#@$");
...
javap -c para acessar o código desmontado, que conterá os valores do sal utilizado.
...
crypt($password, '2!@$(5#@532@%#$253l5#@$');
...
...
from django.contrib.auth.hashers import make_password
make_password(password, salt="2!@$(5#@532@%#$253l5#@$")
...
require 'openssl'
...
password = get_password()
salt = '2!@$(5#@532@%#$253l5#@$'
hash = OpenSSL::Digest::SHA256.digest(salt + password)
...
...
Rfc2898DeriveBytes rdb8 = new Rfc2898DeriveBytes(password, salt,50);
...
...
#define ITERATION 50
...
PKCS5_PBKDF2_HMAC(pass, sizeof(pass), salt, sizeof(salt), ITERATION, EVP_sha512(), outputBytes, digest);
...
...
final int iterationCount=50;
PBEParameterSpec pbeps=new PBEParameterSpec(salt,iterationCount);
...
...
const iterations = 50;
crypto.pbkdf2(
password,
salt,
iterations,
keyLength,
"sha256",
function (err, derivedKey) { ... }
);
...
#define ITERATION 50
...
CCKeyDerivationPBKDF(kCCPBKDF2,
password,
passwordLen,
salt,
saltLen
kCCPRFHmacAlgSHA256,
ITERATION,
derivedKey,
derivedKeyLen);
...
...
$hash = hash_pbkdf2('sha256', $password, $salt, 50);
...
...
from hashlib import pbkdf2_hmac
dk = pbkdf2_hmac('sha256', password, salt, 50)
...
bcrypt_hash = bcrypt(b64pwd, 11)
bcrypt no Pycryptodome, é fundamental observar que o parâmetro de custo desempenha uma função significativa na determinação da complexidade computacional do processo de hashing subjacente. É altamente recomendável definir o parâmetro de custo com um valor de pelo menos 12 para garantir um nível suficiente de segurança. Esse valor influencia diretamente o tempo necessário para calcular o hash, o que torna mais dispendioso do ponto de vista computacional para os possíveis invasores realizarem ataques de força bruta ou de dicionário.
require 'openssl'
...
key = OpenSSL::PKCS5::pbkdf2_hmac(pass, salt, 50, 256, 'SHA256')
...
let ITERATION = UInt32(50)
...
CCKeyDerivationPBKDF(CCPBKDFAlgorithm(kCCPBKDF2),
password,
passwordLength,
saltBytes,
saltLength,
CCPseudoRandomAlgorithm(kCCPRFHmacAlgSHA256),
ITERATION,
derivedKey,
derivedKeyLength)
...
...
<param name="keyObtentionIterations" value="50"/>
...
CL_ABAP_HMAC->UPDATE, o que resultará na criação de um hash que não se baseia em nenhum dado:
...
DATA: obj TYPE REF TO cl_abap_hmac.
CALL METHOD cl_abap_hmac=>get_instance
EXPORTING
if_key = 'ABCDEFG123456789'
RECEIVING
ro_object = obj.
obj->final( ).
....
CryptCreateHash, o que resultará na criação de um hash que não se baseia em nenhum dado:
...
if(!CryptAcquireContext(&hCryptProv, NULL, MS_ENH_RSA_AES_PROV, PROV_RSA_AES, 0)) {
break;
}
if(!CryptHashData(hHash, (BYTE*)hashData, strlen(hashData), 0)) {
break;
}
...
MessageDigest.update(), o que resultará na criação de um hash que não se baseia em nenhum dado:
...
MessageDigest messageDigest = MessageDigest.getInstance("SHA-512");
io.writeLine(MyUtilClass.bytesToHex(messageDigest.digest()));
....
...
string hashname = ConfigurationManager.AppSettings["hash"];
...
HashAlgorithm ha = HashAlgorithm.Create(hashname);
...
Example 1 será executado com êxito, mas qualquer pessoa que possa chegar a essa funcionalidade conseguirá manipular o algoritmo de hash modificando a propriedade hash. Após a distribuição do programa, poderá ser difícil desfazer um problema com algoritmos controlados pelo usuário, pois seria extremamente difícil saber se um usuário mal-intencionado determinou o parâmetro do algoritmo de um hash criptográfico específico.
...
Properties prop = new Properties();
prop.load(new FileInputStream("config.properties"));
String algorithm = prop.getProperty("hash");
...
MessageDigest messageDigest = MessageDigest.getInstance(algorithm);
messageDigest.update(hashInput.getBytes("UTF-8"));
...
Example 1 será executado com êxito, mas qualquer pessoa que possa chegar a essa funcionalidade conseguirá manipular o algoritmo de hash modificando a propriedade hash. Após a distribuição do programa, poderá ser difícil desfazer um problema com algoritmos controlados pelo usuário, pois seria extremamente difícil saber se um usuário mal-intencionado determinou o parâmetro do algoritmo de um hash criptográfico específico.
require 'openssl'
require 'csv'
...
CSV.read(my_file).each do |row|
...
hash = row[4]
...
digest = OpenSSL::Digest.new(hash, data)
...
end
Example 1 executará com êxito, mas qualquer pessoa que possa chegar a essa funcionalidade será capaz de manipular o algoritmo de hash ao modificar o parâmetro hash a partir do arquivo CSV. Após a distribuição do programa, poderá ser difícil desfazer um problema com algoritmos controlados pelo usuário, pois seria extremamente difícil saber se um usuário mal-intencionado determinou o parâmetro do algoritmo de um hash criptográfico específico.
...
String minimumBits = prop.getProperty("minimumbits");
Hashing.goodFastHash(minimumBits).hashString("foo", StandardCharsets.UTF_8);
...
Example 1 será executado com êxito, mas qualquer usuário que puder acessar essa funcionalidade poderá manipular o mínimo de bits usado para obter o hash da senha modificando a propriedade minimumBits. Depois que o programa é distribuído, pode ser difícil desfazer um problema envolvendo mínimo de bits controlado pelo usuário, pois você não poderia saber se um hash de senha teve ou não o respectivo mínimo de bits determinado por um usuário mal-intencionado.
string salt = ConfigurationManager.AppSettings["salt"];
...
Rfc2898DeriveBytes rfc = new Rfc2898DeriveBytes("password", Encoding.ASCII.GetBytes(salt));
...
Example 1 será executado com êxito, mas qualquer pessoa que possa chegar a essa funcionalidade conseguirá manipular o sal para derivar a chave ou a senha modificando a propriedade salt. Após a distribuição do programa, pode ser não trivial desfazer um problema referente aos sais controlados pelo usuário, pois é extremamente difícil saber se um usuário mal-intencionado determinou o sal de um hash de senha.
...
salt = getenv("SALT");
PKCS5_PBKDF2_HMAC(pass, sizeof(pass), salt, sizeof(salt), ITERATION, EVP_sha512(), outputBytes, digest);
...
Example 1 será executado com êxito, qualquer pessoa que puder acessar essa funcionalidade conseguirá manipular o sal usado para derivar a chave ou a senha modificando a variável de ambiente SALT. Após a distribuição do programa, pode ser não trivial desfazer um problema referente aos sais controlados pelo usuário, pois é extremamente difícil saber se um usuário mal-intencionado determinou o sal de um hash de senha.
...
Properties prop = new Properties();
prop.load(new FileInputStream("local.properties"));
String salt = prop.getProperty("salt");
...
PBEKeySpec pbeSpec=new PBEKeySpec(password);
SecretKeyFactory keyFact=SecretKeyFactory.getInstance(CIPHER_ALG);
PBEParameterSpec defParams=new PBEParameterSpec(salt,100000);
Cipher cipher=Cipher.getInstance(CIPHER_ALG);
cipher.init(cipherMode,keyFact.generateSecret(pbeSpec),defParams);
...
Example 1 será executado com êxito, mas qualquer pessoa que possa chegar a essa funcionalidade conseguirá manipular o sal para derivar a chave ou a senha modificando a propriedade salt. Após a distribuição do programa, pode ser não trivial desfazer um problema referente aos sais controlados pelo usuário, pois é extremamente difícil saber se um usuário mal-intencionado determinou o sal de um hash de senha.
app.get('/pbkdf2', function(req, res) {
...
let salt = req.params['salt'];
crypto.pbkdf2(
password,
salt,
iterations,
keyLength,
"sha256",
function (err, derivedKey) { ... }
);
}
Example 1 será executado com êxito, mas qualquer pessoa que possa chegar a essa funcionalidade conseguirá manipular o sal para derivar a chave ou a senha modificando a propriedade salt. Após a distribuição do programa, pode ser não trivial desfazer um problema referente aos sais controlados pelo usuário, pois é extremamente difícil saber se um usuário mal-intencionado determinou o sal de um hash de senha.
...
@property (strong, nonatomic) IBOutlet UITextField *inputTextField;
...
NSString *salt = _inputTextField.text;
const char *salt_cstr = [salt cStringUsingEncoding:NSUTF8StringEncoding];
...
CCKeyDerivationPBKDF(kCCPBKDF2,
password,
passwordLen,
salt_cstr,
salt.length,
kCCPRFHmacAlgSHA256,
100000,
derivedKey,
derivedKeyLen);
...
Example 1 será executado com êxito, mas qualquer pessoa que puder acessar essa funcionalidade conseguirá manipular o sal usado para derivar a chave ou a senha modificando o texto no UITextField inputTextField. Após a distribuição do programa, pode ser não trivial desfazer um problema referente aos sais controlados pelo usuário, pois é extremamente difícil saber se um usuário mal-intencionado determinou o sal de um hash de senha.
function register(){
$password = $_GET['password'];
$username = $_GET['username'];
$salt = getenv('SALT');
$hash = hash_pbkdf2('sha256', $password, $salt, 100000);
...
Example 1 será executado com êxito, qualquer pessoa que puder acessar essa funcionalidade conseguirá manipular o sal usado para derivar a chave ou a senha modificando a variável de ambiente SALT. Após a distribuição do programa, pode ser não trivial desfazer um problema referente aos sais controlados pelo usuário, pois é extremamente difícil saber se um usuário mal-intencionado determinou o sal de um hash de senha.
import hashlib, binascii
def register(request):
password = request.GET['password']
username = request.GET['username']
salt = os.environ['SALT']
dk = hashlib.pbkdf2_hmac('sha256', password, salt, 100000)
hash = binascii.hexlify(dk)
store(username, hash)
...
Example 1 será executado com êxito, qualquer pessoa que puder acessar essa funcionalidade conseguirá manipular o sal usado para derivar a chave ou a senha modificando a variável de ambiente SALT. Após a distribuição do programa, pode ser não trivial desfazer um problema referente aos sais controlados pelo usuário, pois é extremamente difícil saber se um usuário mal-intencionado determinou o sal de um hash de senha.
...
salt=io.read
key = OpenSSL::PKCS5::pbkdf2_hmac(pass, salt, iter_count, 256, 'SHA256')
...
Example 1 será executado com êxito, qualquer pessoa que puder acessar essa funcionalidade conseguirá manipular o sal usado para derivar a chave ou a senha modificando o texto em salt. Após a distribuição do programa, pode ser não trivial desfazer um problema referente aos sais controlados pelo usuário, pois é extremamente difícil saber se um usuário mal-intencionado determinou o sal de um hash de senha.
...
@IBOutlet weak var inputTextField : UITextField!
...
let salt = (inputTextField.text as NSString).dataUsingEncoding(NSUTF8StringEncoding)
let saltPointer = UnsafePointer<UInt8>(salt.bytes)
let saltLength = size_t(salt.length)
...
let algorithm : CCPBKDFAlgorithm = CCPBKDFAlgorithm(kCCPBKDF2)
let prf : CCPseudoRandomAlgorithm = CCPseudoRandomAlgorithm(kCCPRFHmacAlgSHA256)
CCKeyDerivationPBKDF(algorithm,
passwordPointer,
passwordLength,
saltPointer,
saltLength,
prf,
100000,
derivedKeyPointer,
derivedKeyLength)
...
Example 1 será executado com êxito, mas qualquer pessoa que puder acessar essa funcionalidade conseguirá manipular o sal usado para derivar a chave ou a senha modificando o texto no UITextField inputTextField. Após a distribuição do programa, pode ser não trivial desfazer um problema referente aos sais controlados pelo usuário, pois é extremamente difícil saber se um usuário mal-intencionado determinou o sal de um hash de senha.
...
salt = getenv("SALT");
password = crypt(getpass("Password:"), salt);
...
Example 1 será executado com êxito, mas qualquer usuário que puder acessar essa funcionalidade será capaz de manipular o sal usado para obter o hash da senha modificando a variável de ambiente SALT. Além disso, esse código usa a função crypt(), que não deve ser usada para fazer o hash criptográfico de senhas. Após a distribuição do programa, pode ser não trivial desfazer um problema referente aos sais controlados pelo usuário, pois é extremamente difícil saber se um usuário mal-intencionado determinou o sal de um hash de senha.
func someHandler(w http.ResponseWriter, r *http.Request){
r.parseForm()
salt := r.FormValue("salt")
password := r.FormValue("password")
...
sha256.Sum256([]byte(salt + password))
}
Example 1 será executado com êxito, mas qualquer usuário que puder acessar essa funcionalidade poderá manipular o sal usado para obter o hash da senha modificando a variável de ambiente salt. Além disso, esse código usa a função de hash criptográfico Sum256, que não deve ser usada para fazer o hash criptográfico de senhas. Após a distribuição do programa, não é trivial desfazer um problema referente aos sais controlados pelo usuário, pois é extremamente difícil saber se um usuário mal-intencionado determinou o sal de um hash de senha.
...
Properties prop = new Properties();
prop.load(new FileInputStream("local.properties"));
String salt = prop.getProperty("salt");
...
MessageDigest digest = MessageDigest.getInstance("SHA-256");
digest.reset();
digest.update(salt);
return digest.digest(password.getBytes("UTF-8"));
...
Example 1 será executado com êxito, mas qualquer pessoa que puder acessar essa funcionalidade conseguirá manipular o sal usado para obter o hash da senha modificando a propriedade salt. Depois que o programa é distribuído, pode ser muito difícil desfazer um problema envolvendo sais controlados pelo usuário, uma vez que provavelmente não seria possível saber se um hash de senha teve ou não o respectivo sal determinado por um usuário mal-intencionado.
import hashlib, binascii
def register(request):
password = request.GET['password']
username = request.GET['username']
salt = os.environ['SALT']
hash = hashlib.md5("%s:%s" % (salt, password,)).hexdigest()
store(username, hash)
...
Example 1 será executado com êxito, mas qualquer usuário que puder acessar essa funcionalidade será capaz de manipular o sal usado para obter o hash da senha modificando a variável de ambiente SALT. Além disso, esse código usa a função de hash criptográfico md5(), que não deve ser usada para fazer o hash criptográfico de senhas. Após a distribuição do programa, pode ser não trivial desfazer um problema referente aos sais controlados pelo usuário, pois é extremamente difícil saber se um usuário mal-intencionado determinou o sal de um hash de senha.
...
salt = req.params['salt']
hash = @userPassword.crypt(salt)
...
Example 1 será executado com êxito, mas qualquer pessoa que puder acessar essa funcionalidade será capaz de manipular o sal usado para obter o hash da senha modificando o parâmetro salt. Além disso, esse código usa a função String#crypt(), que não deve ser usada para fazer o hash criptográfico de senhas. Após a distribuição do programa, pode ser não trivial desfazer um problema referente aos sais controlados pelo usuário, pois é extremamente difícil saber se um usuário mal-intencionado determinou o sal de um hash de senha.
let saltData = userInput.data(using: .utf8)
sharedSecret.hkdfDerivedSymmetricKey(
using: SHA256.self,
salt: saltData,
sharedInfo: info,
outputByteCount: 1000
)
Exemplo 1 será executado com êxito, mas qualquer usuário que puder acessar essa funcionalidade poderá manipular o salt usado para derivar a chave de criptografia modificando o valor de userInput. Após a distribuição do programa, não é trivial desfazer um problema referente aos salts controlados pelo usuário, pois é extremamente difícil saber se um usuário mal-intencionado determinou o salt de um hash de senha.
...
String seed = prop.getProperty("seed");
Hashing.murmur3_32_fixed(Integer.parseInt(seed)).hashString("foo", StandardCharsets.UTF_8);
...
Example 1 será executado com êxito, mas qualquer usuário que puder acessar essa funcionalidade poderá manipular a semente usada para obter o hash da senha modificando a propriedade seed. Depois que o programa é distribuído, pode ser difícil desfazer um problema envolvendo sementes controladas pelo usuário, pois você não poderia saber se um hash de senha teve ou não a respectiva semente determinada por um usuário mal-intencionado.k que deve ser criptograficamente aleatório, mantido em segredo e nunca reutilizado. Se um invasor puder adivinhar o valor de k ou induzir o signatário a usar um valor fornecido, ele poderá recuperar a chave privada e, em seguida, forjar qualquer assinatura, representando o signatário legítimo. Da mesma forma, um invasor pode recuperar a chave privada se o valor de k é reutilizado para assinar várias mensagens.k que deve ser criptograficamente aleatório, mantido em segredo e nunca reutilizado. Se um invasor puder adivinhar o valor de k ou induzir o signatário a usar um valor fornecido, ele poderá recuperar a chave privada e, em seguida, forjar qualquer assinatura, representando o signatário legítimo. Da mesma forma, um invasor pode recuperar a chave privada se o valor de k é reutilizado para assinar várias mensagens.k que deve ser criptograficamente aleatório, mantido em segredo e nunca reutilizado. Se um invasor puder adivinhar o valor de k ou induzir o signatário a usar um valor fornecido, ele poderá recuperar a chave privada e, em seguida, forjar qualquer assinatura, representando o signatário legítimo. Da mesma forma, um invasor pode recuperar a chave privada se o valor de k é reutilizado para assinar várias mensagens.k que deve ser criptograficamente aleatório, mantido em segredo e nunca reutilizado. Se um invasor puder adivinhar o valor de k ou induzir o signatário a usar um valor fornecido, ele poderá recuperar a chave privada e, em seguida, forjar qualquer assinatura, representando o signatário legítimo. Da mesma forma, um invasor pode recuperar a chave privada se o valor de k é reutilizado para assinar várias mensagens.
...
DSA dsa = new DSACryptoServiceProvider(1024);
...
...
DSA_generate_parameters_ex(dsa, 1024, NULL, 0, NULL, NULL, NULL);
...
...
dsa.GenerateParameters(params, rand.Reader, dsa.L1024N160)
privatekey := new(dsa.PrivateKey)
privatekey.PublicKey.Parameters = *params
dsa.GenerateKey(privatekey, rand.Reader)
...
...
KeyPairGenerator keyGen = KeyPairGenerator.getInstance("DSA", "SUN");
SecureRandom random = SecureRandom.getInstance("SHA256PRNG", "SUN");
keyGen.initialize(1024, random);
...
...
from Crypto.PublicKey import DSA
key = DSA.generate(1024)
...
require 'openssl'
...
key = OpenSSL::PKey::DSA.new(1024)
...
EVP_SignUpdate, o que resultará na criação de uma assinatura que não se baseia em nenhum dado:
...
rv = EVP_SignInit(ctx, EVP_sha512());
...
rv = EVP_SignFinal(ctx, sig, &sig_len, key);
...
update, o que resultará na criação de uma assinatura que não se baseia em nenhum dado:
...
Signature sig = Signature.getInstance("SHA256withRSA");
sig.initSign(keyPair.getPrivate());
...
byte[] signatureBytes = sig.sign();
...
Exemplo 2: O código a seguir desativa a validação segura da assinatura XML com
Properties props = System.getProperties();
...
properties.setProperty("org.jcp.xml.dsig.secureValidation", "false");
XMLCryptoContext.setProperty:
DOMCryptoContext cryptoContext = new DOMCryptoContext() {...};
...
cryptoContext.setProperty("org.jcp.xml.dsig.secureValidation", false);
...
CCCrypt(kCCEncrypt,
kCCAlgorithmDES,
kCCOptionPKCS7Padding,
key,
kCCKeySizeDES, // 64-bit key size
iv,
plaintext,
sizeof(plaintext),
ciphertext,
sizeof(ciphertext),
&numBytesEncrypted);
...
...
let iv = getTrueRandomIV()
...
let cStatus = CCCrypt(UInt32(kCCEncrypt),
UInt32(kCCAlgorithmDES),
UInt32(kCCOptionPKCS7Padding),
key,
keyLength,
iv,
plaintext,
plaintextLength,
ciphertext,
ciphertextLength,
&numBytesEncrypted)
...
String pode levar a uma perda significativa de entropia.StringExemplo 1: O código a seguir cria uma chave de criptografia e, em seguida, converte-a em uma String.
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
...
KeyGenerator keygen = KeyGenerator.newInstance("AES");
...
SecretKey cryptoKey = keygen.generateKey();
byte[] rawCryptoKey = cryptoKey.getEncoded();
...
String key = new String(rawCryptoKey);
...
String usando o conjunto de caracteres do sistema padrão. Porém, não fica claro o que acontece quando o construtor recebe bytes fora do intervalo válido desse conjunto de caracteres. No estado em que se encontra, key provavelmente terá uma perda significativa de entropia em comparação à chave de criptografia original rawCryptoKey.
static public byte[] EncryptWithRSA(byte[] plaintext, RSAParameters key) {
try {
RSACryptoServiceProvider rsa = new RSACryptoServiceProvider();
rsa.ImportParameters(key);
return rsa.Encrypt(plaintext, false);
}
catch(CryptographicException e) {
Console.WriteLine(e.Message);
return null;
}
}
void encrypt_with_rsa(BIGNUM *out, BIGNUM *in, RSA *key) {
u_char *inbuf, *outbuf;
int ilen;
...
ilen = BN_num_bytes(in);
inbuf = xmalloc(ilen);
BN_bn2bin(in, inbuf);
if ((len = RSA_public_encrypt(ilen, inbuf, outbuf, key, RSA_NO_PADDING)) <= 0) {
fatal("encrypt_with_rsa() failed");
}
...
}
...
import "crypto/rsa"
...
plaintext := []byte("Attack at dawn")
cipherText, err := rsa.EncryptPKCS1v15(rand.Reader, &k.PublicKey, plaintext)
...
public Cipher getRSACipher() {
Cipher rsa = null;
try {
rsa = javax.crypto.Cipher.getInstance("RSA/NONE/NoPadding");
}
catch (java.security.NoSuchAlgorithmException e) {
log("this should never happen", e);
}
catch (javax.crypto.NoSuchPaddingException e) {
log("this should never happen", e);
}
return rsa;
}
+ (NSData *) encryptData:(NSData *) plaintextData withKey:(SecKeyRef *) publicKey {
CFErrorRef error = nil;
NSData *ciphertextData = (NSData*) CFBridgingRelease(
SecKeyCreateEncryptedData(*publicKey,
kSecKeyAlgorithmRSAEncryptionPKCS1,
(__bridge CFDataRef) plaintextData,
&error));
if (error) {
// handle error ...
}
return ciphertextData;
}
function encrypt($input, $key) {
$output='';
openssl_public_encrypt($input, $output, $key, OPENSSL_NO_PADDING);
return $output;
}
...
from Crypto.PublicKey import RSA
message = 'Attack at dawn'
key = RSA.importKey(open('pubkey.der').read())
ciphertext = key.encrypt(message)
...
require 'openssl'
...
key = OpenSSL::PKey::RSA.new 2048
public_encrypted = key.public_encrypt(data) #padding type not specified
...
Example 1OpenSSL::PKey::RSA#public_encrypt só é chamado com uma string, e não especifica o tipo de preenchimento a ser usado. O preenchimento usa como padrão OpenSSL::PKey::RSA::PKCS1_PADDING.
func encrypt(data plaintextData:Data, publicKey:SecKey) throws -> Data {
var error: Unmanaged<CFError>?
guard let ciphertextData = SecKeyCreateEncryptedData(publicKey,
.rsaEncryptionPKCS1,
plaintextData as CFData,
&error) else {
throw error!.takeRetainedValue() as Error
}
return ciphertextData as Data;
}