xp_cmdshell não pode ser usada com segurança. Ela não deve ser usada.xp_cmdshell inicializa uma shell de comando do Windows para executar a cadeia de comando fornecida. O comando é executado no sistema padrão ou em um contexto de proxy fornecido. No entanto, não há qualquer maneira de limitar um usuário a um conjunto pré-especificado de operações privilegiadas e qualquer concessão de privilégios permite o usuário a executar qualquer cadeia de comando.if é impossível de atender. Ela requer que a variável s seja não nula, embora no único caminho em que s pode receber um valor não nulo exista uma instrução return.
String s = null;
if (b) {
s = "Yes";
return;
}
if (s != null) {
Dead();
}
...
CALL FUNCTION 'ENQUE_SLEEP'
EXPORTING
SECONDS = usrInput.
...
GetTokenBucketLimiter() usa um endereço IP remoto (RemoteIpAddress) como chave de partição ao criar uma RateLimitPartition:
...
builder.Services.AddRateLimiter(limiterOptions => {
limiterOptions.GlobalLimiter = PartitionedRateLimiter.Create<HttpContext, IPAddress>(context => {
IPAddress? ip = context.Connection.RemoteIpAddress;
return RateLimitPartition.GetTokenBucketLimiter(ip!, _ =>
new TokenBucketRateLimiterOptions
{
TokenLimit = 7
});
});
});
...
unsigned int usrSleepTime = uatoi(usrInput);
sleep(usrSleepTime);
Sleep(url.duration);
Future será executada. Especificando um número grande, um invasor pode bloquear a função Future indefinidamente.
final duration = Platform.environment['DURATION'];
Future.delayed(Duration(seconds: int.parse(duration!)), () => ...);
func test(r *http.Request) {
...
i, _ := strconv.Atoi(r.FormValue("TIME"))
runtime.KeepAlive(i)
...
}
Exemplo 2: O código a seguir lê uma String de um arquivo zip. Por usar o método
int usrSleepTime = Integer.parseInt(usrInput);
Thread.sleep(usrSleepTime);
readLine(), ele levará uma quantidade ilimitada de entradas. Um invasor pode tirar proveito desse código para causar uma OutOfMemoryException ou consumir uma grande quantidade de memória para que o programa perca mais tempo realizando a coleta de lixo ou fique sem memória durante uma operação subsequente.
InputStream zipInput = zipFile.getInputStream(zipEntry);
Reader zipReader = new InputStreamReader(zipInput);
BufferedReader br = new BufferedReader(zipReader);
String line = br.readLine();
Exemplo 2: Este código grava em um arquivo. Uma vez que o arquivo pode ser continuamente escrito e reescrito até ser considerado fechado pelo agente do usuário, a cota de disco, a largura de banda E/S e os processos que podem exigir a análise do conteúdo do arquivo são afetados.
var fsync = requestFileSystemSync(0, userInput);
function oninit(fs) {
fs.root.getFile('applog.txt', {create: false}, function(fileEntry) {
fileEntry.createWriter(function(fileWriter) {
fileWriter.seek(fileWriter.length);
var bb = new BlobBuilder();
bb.append('Appending to a file');
fileWriter.write(bb.getBlob('text/plain'));
}, errorHandler);
}, errorHandler);
}
window.requestFileSystem(window.TEMPORARY, 1024*1024, oninit, errorHandler);
procedure go_sleep (
usrSleepTime in NUMBER)
is
dbms_lock.sleep(usrSleepTime);
connect. Especificando um número grande, um invasor pode bloquear a função connect indefinidamente.
...
insecure_config_ssl_connection_timeout = {
'user': username,
'password': retrievedPassword,
'host': databaseHost,
'port': "3306",
'connection_timeout': connection_timeout
}
mysql.connector.connect(**insecure_config_ssl_connection_timeout)
...
Exemplo 2: Este código lê uma cadeia a partir de um arquivo. Uma vez que ele utiliza o método
Kernel.sleep(user_input)
readline() sem especificar um limite, ele lerá uma quantidade ilimitada de entradas. Um invasor pode aproveitar esse código para fazer com que o processo pause enquanto consome mais e mais memória, até que possivelmente a memória se esgote.
fd = File.new(myFile)
line = fd.readline
Formatter.format().
...
Formatter formatter = new Formatter(Locale.US);
String format = "The customer: %s %s has the balance %4$." + userInput + "f";
formatter.format(format, firstName, lastName, accountNo, balance);
...
java.util.MissingFormatArgumentException, e, por não estar dentro de um bloco "try", essa exceção pode provocar falhas no aplicativo. accountNo fossem incluídas na string resultante.java.lang.Double.parseDouble() e métodos relacionados que pode provocar o travamento do thread durante a avaliação de qualquer número no intervalo [2^(-1022) - 2^(-1075) : 2^(-1022) - 2^(-1076)]. Esse defeito pode ser usado para executar um ataque de Negação de Serviço (DoS).
Double d = Double.parseDouble(request.getParameter("d"));
d é um valor no intervalo, como "0.0222507385850720119e-00306", para fazer com que o programa trave ao processar a solicitação.
(e+)+
([a-zA-Z]+)*
(e|ee)+
(e+)+
([a-zA-Z]+)*
(e|ee)+
(e+)+
([a-zA-Z]+)*
(e|ee)+
(e+)+
([a-zA-Z]+)*
(e|ee)+
(e+)+
([a-zA-Z]+)*
(e|ee)+
(e+)+
([a-zA-Z]+)*
(e|ee)+
(e+)+
([a-zA-Z]+)*
(e|ee)+
(e+)+
([a-zA-Z]+)*
(e|ee)+
NSString *regex = @"^(e+)+$";
NSPredicate *pred = [NSPRedicate predicateWithFormat:@"SELF MATCHES %@", regex];
if ([pred evaluateWithObject:mystring]) {
//do something
}
(e+)+
([a-zA-Z]+)*
(e|ee)+
(e+)+
([a-zA-Z]+)*
(e|ee)+
(e+)+
([a-zA-Z]+)*
(e+)+
([a-zA-Z]+)*
(e|ee)+
(e+)+
([a-zA-Z]+)*
(e|ee)+
let regex : String = "^(e+)+$"
let pred : NSPredicate = NSPRedicate(format:"SELF MATCHES \(regex)")
if (pred.evaluateWithObject(mystring)) {
//do something
}
Example 1, se o invasor fornecer a cadeia de correspondência "eeeZ", o analisador regex deverá verificar 16 avaliações internas para identificar uma correspondência. Se o invasor fornecer 16 "e"s ("eeeeeeeeeeeeeeeeZ") como a cadeia de correspondência, o analisador regex deverá verificar 65536 (2^16) avaliações. O invasor pode consumir recursos de computação facilmente por meio do aumento do número de caracteres de correspondência consecutivos. Não existem implementações conhecidas de expressões regulares que sejam imunes a essa vulnerabilidade. Todas as plataformas e linguagens são vulneráveis a esse ataque.routes.Ignore em aplicativos ASP.NET. Este método permite que entradas externas definam comportamentos de roteamento. Especificamente, o uso de curingas, como {*allaspx}, fornece aos invasores uma base para manipular ações de roteamento. O problema central surge quando a entrada que controla esses padrões curinga não é meticulosamente validada ou higienizada.
Marker child = MarkerManager.getMarker("child");
Marker parent = MarkerManager.getMarker("parent");
child.addParents(MarkerManager.getMarker(userInput));
parent.addParents(MarkerManager.getMarker(userInput2));
String toInfinity = child.toString();
child e parent para um marcador definido pelo usuário. Se o usuário inserir o pai de child como parent e o pai de parent como child, um link circular será criado na estrutura de dados Marker. Ao executar o método recursivo toString na estrutura de dados que contém o link circular, o programa lançará uma exceção de estouro de pilha e travará. Isso causa uma negação de serviço por meio do esgotamento da pilha.StringBuilder ou do StringBuffer inicializada com o tamanho padrão da matriz de apoio pode fazer com que a JVM consuma excessivamente o espaço de memória heap.StringBuilder ou do StringBuffer inicializada com o tamanho padrão da matriz de caracteres de apoio (16) pode fazer com que o aplicativo consuma grandes quantidades de memória heap ao redimensionar a matriz subjacente para ajustar os dados de usuário. Quando dados são anexados a uma instância de um StringBuilder ou de um StringBuffer, a instância determinará se a matriz de caracteres de apoio tem espaço suficiente para armazenar os dados. Se os dados não forem ajustados, uma nova instância do StringBuilder ou do StringBuffer irá criar outra matriz com pelo menos o dobro do tamanho da matriz anterior e a matriz antiga permanecerá no heap até que seja coletada como lixo. Os invasores podem usar esse detalhe da implementação para executar um ataque de Negação de Serviço (Denial of Service – DoS).StringBuilder inicializada com o construtor padrão.
...
StringBuilder sb = new StringBuilder();
final String lineSeparator = System.lineSeparator();
String[] labels = request.getParameterValues("label");
for (String label : labels) {
sb.append(label).append(lineSeparator);
}
...
StringBuilder ou do StringBuffer inicializada com o tamanho padrão da matriz de apoio pode fazer com que a JVM consuma excessivamente o espaço de memória heap.StringBuilder ou do StringBuffer inicializada com o tamanho padrão da matriz de caracteres de apoio (16) pode fazer com que o aplicativo consuma grandes quantidades de memória heap ao redimensionar a matriz subjacente para ajustar os dados do usuário. Quando dados são anexados a uma instância de um StringBuilder ou de um StringBuffer, a instância determinará se a matriz de caracteres de apoio tem espaço suficiente para armazenar os dados. Se os dados não forem ajustados, uma nova instância do StringBuilder ou do StringBuffer irá criar outra matriz com pelo menos o dobro do tamanho da matriz anterior e a matriz antiga permanecerá no heap até que seja coletada como lixo. Os invasores podem usar esse detalhe da implementação para executar um ataque de Negação de Serviço (Denial of Service – DoS).StringBuilder inicializada com o construtor padrão.
...
val sb = StringBuilder()
val labels = request.getParameterValues("label")
for (label in labels) {
sb.appendln(label)
}
...
chroot() pode permitir que os invasores escapem de uma prisão chroot.chroot() permite que um processo altere sua percepção do diretório raiz do sistema de arquivos. Depois de invocar chroot() corretamente, um processo não pode acessar arquivos fora da árvore de diretórios definida pelo novo diretório raiz. Esse ambiente recebe o nome de prisão chroot e é comumente utilizado para impedir que um processo possa ser corrompido e usado para acessar arquivos não autorizados. Por exemplo, muitos servidores FTP são executados em prisões chroot para impedir que um invasor que descobrir uma nova vulnerabilidade em um servidor seja capaz de baixar o arquivo de senha ou outros arquivos confidenciais do sistema.chroot() pode permitir que os invasores escapem da prisão chroot. A chamada de função chroot() não altera o diretório de trabalho atual do processo e, portanto, caminhos relativos ainda podem fazer referência a recursos do sistema de arquivos fora da prisão chroot depois que chroot() é chamada.
chroot("/var/ftproot");
...
fgets(filename, sizeof(filename), network);
localfile = fopen(filename, "r");
while ((len = fread(buf, 1, sizeof(buf), localfile)) != EOF) {
fwrite(buf, 1, sizeof(buf), network);
}
fclose(localfile);
GET. O servidor FTP chama chroot() em suas rotinas de inicialização, na tentativa de impedir o acesso a arquivos fora de /var/ftproot. Porém, como o servidor não consegue alterar o diretório de trabalho atual chamando chdir("/"), um invasor poderia solicitar o arquivo "../../../../../etc/passwd"e obter uma cópia do arquivo de senha do sistema.exclude. Isso é difícil de manter e está sujeito a erros. Caso os desenvolvedores adicionem novos campos ao formulário ou um Model que faça backup do formulário e esqueçam de atualizar o filtro exclude, eles poderão expor campos confidenciais aos atacantes. Os atacantes serão capazes de enviar e vincular dados maliciosos a qualquer campo não excluído.User, porém verifica uma lista de bloqueios para o id do usuário:
from myapp.models import User
...
class UserForm(ModelForm):
class Meta:
model = User
exclude = ['id']
...
User foi atualizado com um novo atributo role e o UserForm associado não foi atualizado, o atributo role será exposto no formulário.SECRET_KEY. Caso a SECRET_KEY vazar, um invasor não poderá somente falsificar os dados da sessão, mas se o aplicativo utilizar o Pickle para serializar os dados da sessão em cookies, um invasor será capaz de criar dados maliciosos tratados com o Pickle que executarão um código arbitrário no momento da desserialização.Host pode permitir que um invasor envie um valor Host falso que pode ser utilizado para solicitação intersite forjada, ataques de envenenamento de cache e envenenamento de links em emails.*" como uma entrada na configuração ALLOWED_HOSTS. Essa configuração é utilizada por django.http.HttpRequest.get_host() para validar o cabeçalho Host. Um valor de "*" permitirá qualquer host no cabeçalho Host. Um invasor pode usar isso em ataques de envenenamento de cache ou para envenenar links em e-mails.Host para referenciar o site que serve como um recurso de redefinição de senha a fim de evitar URLs codificadas. Por exemplo:
...
def reset_password(request):
url = "http://%s/new_password/?token=%s" % (request.get_host(), generate_token())
send_email(reset_link=url)
redirect("home")
...
Host falso apontando para um servidor controlado por ele ao e-mail da vítima. A vítima receberá um email com um link para o sistema de redefinição de senha, e se ela decidir visitar o link, visitará o site controlado pelo invasor, que servirá um formulário falso para recolher as credenciais da vítima.SECRET_KEY vazar, um invasor será capaz de armazenar dados arbitrários no cookie de sessão, o qual será desserializado no servidor, levando à execução do código arbitrário.SECRET_KEY se estiver codificado no arquivo de configuração settings.py:
...
def some_view_method(request):
url = request.GET['url']
if "http://" in url:
content = urllib.urlopen(url)
return HttpResponse(content)
...
Example 1 verifica se o parâmetro url é uma URL válida ao verificar se "http://" está presente na URL. Um invasor mal-intencionado pode enviar a seguinte URL para deixar vazar o arquivo de configuração settings.py que pode conter a SECRET_KEY:
file://proc/self/cwd/app/settings.py#http://
const dns = require('dns');
// User-controlled input for DNS servers
const customDnsServers = from_user_controlled_input;
// Set custom DNS servers
dns.setServers(customDnsServers);
customDnsServers recebe um valor derivado da entrada controlada pelo usuário. Em seguida, essa entrada é usada para configurar os servidores DNS usando dns.setServers(customDnsServers). Se um invasor fornecer endereços de servidores DNS mal-intencionados, ele poderá direcionar o aplicativo para resolver nomes de domínio usando seus servidores, o que pode retornar endereços IP falsos.Dockerfile não especifica um USER, os contêineres do Docker são executados com privilégios de superusuário por padrão. Esses privilégios de superusuário são propagados para o código em execução dentro do contêiner, o que geralmente é mais permissão do que o necessário. A execução do contêiner do Docker com privilégios de superusuário amplia a superfície de ataque que pode permitir que invasores executem formas mais sérias de exploração.