flawfinder - Online na nuvem

PROGRAMA:

NOME

flawfinder - encontre lexicalmente possíveis falhas de segurança ("acertos") no código-fonte

SINOPSE

localizador de falhas [--Socorro|-h] [--versão] [--listas]
[--allowlink] [--followdotdir] [--nolink]
[--patch =nome do arquivo|-P nome do arquivo]
[--entradas|-I] [ --minlevel =X | -m X ] [--falso positivo|-F]
[--nunca ignore|-n]
[--regex =PADRONIZAR | -e PADRONIZAR]
[--contexto|-c] [--colunas|-C] [--somente dados|-D] [--html|-H] [--imediato|-i]
[--única linha|-S] [--omittime] [--quieto|-Q]
[--loadhitlist =F] [--savehitlist =F] [--diffhitlist =F]
[--] [ fonte código lima or fonte raiz anuário ]+

DESCRIÇÃO

O Flawfinder pesquisa o código-fonte C / C ++ em busca de possíveis falhas de segurança. Para
execute o flawfinder, simplesmente forneça ao flawfinder uma lista de diretórios ou arquivos. Para cada diretório
dado, todos os arquivos que têm extensões de nome de arquivo C / C ++ nesse diretório (e seu
subdiretórios, recursivamente) serão examinados. Assim, para a maioria dos projetos, simplesmente dê
flawfinder o nome do diretório superior do código-fonte (use ``. '' para o atual
), e o flawfinder examinará todo o código-fonte C / C ++ do projeto. Se você
só quero ter alterar revisado, salve um diff unificado dessas mudanças (criado por GNU
"diff -u" ou "svn diff" ou "git diff") em um arquivo de patch e use a opção --patch (-P).

O Flawfinder produzirá uma lista de `` acessos '' (falhas de segurança em potencial), classificados por risco; a
os acertos mais arriscados são mostrados primeiro. O nível de risco é mostrado entre colchetes e varia
de 0, risco muito pequeno, a 5, risco grande. Este nível de risco não depende apenas do
função, mas nos valores dos parâmetros da função. Por exemplo, constante
strings são frequentemente menos arriscadas do que strings totalmente variáveis ​​em muitos contextos, e naqueles
contextos em que a ocorrência terá um nível de risco mais baixo. O Flawfinder sabe sobre gettext (um comum
biblioteca para programas internacionalizados) e tratará strings constantes passadas por
gettext como se fossem strings constantes; isso reduz o número de acertos falsos em
programas internacionalizados. O Flawfinder fará o mesmo tipo de coisa com _T () e
_TEXT (), macros comuns da Microsoft para lidar com programas internacionalizados. Flawfinder
ignora corretamente a maior parte do texto dentro de comentários e strings. Normalmente o flawfinder mostra todos
hits com um nível de risco de pelo menos 1, mas você pode usar a opção --minlevel para mostrar apenas
acertos com níveis de risco mais elevados, se desejar. As descrições de hit também observam o comum relevante
Identificador (es) de Enumeração de Fraqueza (CWE) entre parênteses, conforme discutido abaixo. Flawfinder
é oficialmente compatível com CWE.

Nem todo hit é realmente uma vulnerabilidade de segurança, e nem toda vulnerabilidade de segurança
é necessariamente encontrado. No entanto, o flawfinder pode ajudar a encontrar e remover
vulnerabilidades de segurança. Uma maneira comum de usar o flawfinder é primeiro aplicar o flawfinder em
um conjunto de código-fonte e examine os itens de maior risco. Então, use --inputs para examinar
os locais de entrada e verifique se apenas os valores de entrada legais e seguros são
aceito de usuários não confiáveis.

Depois de auditar um programa, você pode marcar as linhas do código-fonte que são realmente boas, mas
causar avisos falsos para que o localizador de falhas pare de reclamar deles. Para marcar um
linha para que esses avisos sejam suprimidos, coloque um comentário formatado especialmente em
a mesma linha (após o código-fonte) ou sozinho na linha anterior. O comentário
deve ter um dos dois formatos a seguir:

· // Localizador de falhas: ignorar

· / * Localizador de falhas: ignore * /

Para fins de compatibilidade, você pode substituir "Flawfinder:" por "ITS4:" ou "RATS:" nestes
comentários especialmente formatados. Uma vez que é possível que essas linhas estejam erradas, você pode usar
a opção --neverignore, que faz com que o flawfinder nunca ignore nenhuma linha, não importa o que
as diretivas de comentário dizem (de forma mais confusa, --neverignore ignora os ignora).

O Flawfinder usa um banco de dados interno chamado `` conjunto de regras ''; o conjunto de regras identifica
funções que são causas comuns de falhas de segurança. O conjunto de regras padrão inclui um grande
número de diferentes problemas potenciais, incluindo ambos os problemas gerais que podem afetar qualquer
Programa C / C ++, bem como uma série de funções específicas do Windows e do tipo Unix que são
especialmente problemático. A opção --listrules relata a lista de regras atuais e
seus níveis de risco padrão. Conforme observado acima, cada falha de segurança potencial encontrada em um determinado
arquivo de código-fonte (correspondendo a uma entrada no conjunto de regras) é chamado de `` hit, '' e o conjunto de
hits encontrados durante qualquer execução particular do programa são chamados de `` hitlist. '' Hitlists
pode ser salvo (usando --savehitlist), recarregado de volta para exibição (usando --loadhitlist), e
você pode mostrar apenas os resultados que são diferentes de outra execução (usando --diffhitlist).

O Flawfinder é uma ferramenta simples, que leva a alguns prós e contras fundamentais. Flawfinder funciona
fazendo tokenização lexical simples (pulando comentários e tokenizando strings corretamente),
procurando correspondências de tokens no banco de dados (principalmente para localizar chamadas de função).
O Flawfinder é, portanto, semelhante ao RATS e ITS4, que também usam tokenização lexical simples.
O Flawfinder então examina o texto dos parâmetros da função para estimar o risco. diferente
ferramentas como tala, sinalizadores de aviso do gcc e clang, o flawfinder faz não usar ou ter
acesso a informações sobre fluxo de controle, fluxo de dados ou tipos de dados ao pesquisar
vulnerabilidades potenciais ou estimando o nível de risco. Assim, o flawfinder irá
necessariamente produzem muitos falsos positivos para vulnerabilidades e falham em relatar muitos
vulnerabilidades. Por outro lado, o flawfinder pode encontrar vulnerabilidades em programas que
não pode ser construído ou não pode ser vinculado. Muitas vezes pode funcionar com programas que nem podem ser
compilado (pelo menos pelas ferramentas do revisor). O Flawfinder também não fica tão confuso com
definições de macro e outras estranhezas com as quais ferramentas mais sofisticadas têm problemas.
O Flawfinder também pode ser útil como uma introdução simples às ferramentas de análise estática em
geral, pois é fácil de usar e de entender.

Qualquer nome de arquivo fornecido na linha de comando será examinado (mesmo se não tiver um
Extensão de nome de arquivo C / C ++); assim, você pode forçar o flawfinder a examinar quaisquer arquivos específicos que você
desejo. Ao pesquisar diretórios recursivamente, o flawfinder só abre e examina
arquivos regulares com extensões de nome de arquivo C / C ++. O Flawfinder presume que os arquivos são
Arquivos C / C ++ se eles tiverem as extensões ".c", ".h", ".ec", ".ecp", ".pgc", ".C", ".cpp",
".CPP", ".cxx", ".cc", ".CC", ".pcc", ".hpp" ou ".H". O nome do arquivo `` - '' significa o
entrada padrão. Para evitar problemas de segurança, arquivos especiais (como arquivos especiais de dispositivos
e tubos nomeados) são sempre ignorados e, por padrão, os links simbólicos são ignorados (o
opção --allowlink segue links simbólicos).

Após a lista de acessos, há um breve resumo dos resultados (use -D para remover este
em formação). Ele mostrará o número de acertos, linhas analisadas (conforme relatado por wc -l) e
as linhas de código de origem física (SLOC) analisadas. Um SLOC físico é um não vazio, não
linha de comentário. Em seguida, mostrará o número de acertos em cada nível; note que haverá
nunca seja um hit em um nível inferior a minlevel (1 por padrão). Assim, "[0] 0 [1] 9"
significa que no nível 0 houve 0 ocorrências relatadas e no nível 1 houve 9 ocorrências
relatado. Em seguida, mostrará o número de acertos em um determinado nível ou maior (então nível 3+
tem a soma do número de ocorrências nos níveis 3, 4 e 5). Assim, uma entrada de "[0+] 37"
mostra que no nível 0 ou superior houve 37 resultados (o item 0+ será sempre o mesmo
como o número "hits" acima). Acessos por KSLOC são mostrados a seguir; este é cada um do "nível ou
valores mais altos "multiplicados por 1000 e divididos pelo SLOC físico. Se os links simbólicos fossem
pulado, a contagem deles é relatada. Se os hits foram suprimidos (usando o "ignorar"
nos comentários do código-fonte, conforme descrito acima), o número suprimido é relatado.
O nível mínimo de risco a ser incluído no relatório é exibido; por padrão, é 1
(use --minlevel para mudar isso). O resumo termina com lembretes importantes: nem todo hit
é necessariamente uma vulnerabilidade de segurança e pode haver outras vulnerabilidades de segurança
não relatado pela ferramenta.

O Flawfinder é lançado sob a licença GNU GPL versão 2 ou posterior (GPLv2 +).

O Flawfinder funciona de maneira semelhante a outro programa, ITS4, que não é totalmente de código aberto
software (conforme definido na Definição de Código Aberto) nem software livre (conforme definido pelo
Fundação do Software Livre). O autor do Flawfinder nunca viu o código-fonte do ITS4.

BREVE TUTORIAL

Aqui está um breve exemplo de como o flawfinder pode ser usado. Imagine que você tem o C / C ++
código-fonte para algum programa chamado xyzzy (que você pode ou não ter escrito), e
você está procurando vulnerabilidades de segurança (para que possa corrigi-las antes que os clientes
encontrar as vulnerabilidades). Para este tutorial, assumirei que você está usando um Unix-
sistema semelhante, como Linux, OpenBSD ou MacOS X.

Se o código-fonte estiver em um subdiretório chamado xyzzy, você provavelmente começará abrindo um
janela de texto e usando as configurações padrão do flawfinder, para analisar o programa e relatar um
lista priorizada de vulnerabilidades de segurança em potencial (o `` menos '' apenas garante que o
os resultados permanecem na tela):
flawfinder xyzzy | menos

Neste ponto, você verá um grande número de entradas. Cada entrada possui um nome de arquivo, um
dois pontos, um número de linha, um nível de risco entre colchetes (onde 5 é o mais arriscado), uma categoria,
o nome da função e uma descrição de por que o flawfinder pensa que a linha é um
vulnerabilidade. O Flawfinder normalmente classifica por nível de risco, mostrando os itens mais arriscados primeiro;
se você tem tempo limitado, provavelmente é melhor começar a trabalhar nos itens mais arriscados e
continue até que você fique sem tempo. Se você quiser limitar a exibição de riscos com apenas um
determinado nível de risco ou superior, use a opção --minlevel. Se você está recebendo um
número extraordinário de falsos positivos porque os nomes das variáveis ​​parecem perigosos
nomes de funções, use a opção -F para remover relatórios sobre eles. Se você não entende
a mensagem de erro, consulte documentos como o Escrevendo Confie Programas para Linux e
Unix HOWTO ⟨http://www.dwheeler.com/secure-programs⟩ no http://www.dwheeler.com/secure-
programas que fornecem mais informações sobre como escrever programas seguros.

Depois de identificar o problema e entendê-lo, você pode corrigi-lo. Ocasionalmente, você pode
quero refazer a análise, porque os números das linhas mudarão e para ter a certeza
que o novo código ainda não introduz uma vulnerabilidade diferente.

Se você determinou que alguma linha não é realmente um problema, e tem certeza disso, você pode
insira um pouco antes ou na linha ofensiva um comentário como
/ * Flawfinder: ignore * /
para evitar que apareçam na saída.

Depois de fazer isso, você deve voltar e pesquisar as entradas do programa, para fazer
certifique-se de que o programa filtra fortemente qualquer uma de suas entradas não confiáveis. Flawfinder pode
identificar muitas entradas do programa usando a opção --inputs, como este:
detector de falhas --inputs xyzzy

O Flawfinder pode se integrar bem com editores de texto e ambientes de desenvolvimento integrados;
veja os exemplos para mais informações.

O Flawfinder inclui muitas outras opções, incluindo aquelas para criar versões HTML do
saída (útil para telas mais bonitas). A próxima seção descreve essas opções em mais
detalhe.

OPÇÕES

O Flawfinder tem uma série de opções, que podem ser agrupadas em opções que controlam o seu próprio
documentação, selecione dados de entrada, selecione quais hits exibir, selecione o formato de saída,
e realizar o gerenciamento da lista de ocorrências. O Flawfinder suporta a sintaxe padrão definida no
POSIX (Edição 7, Edição de 2013) seção `` Convenções de Utilitários ''. Ele também suporta o GNU
opções longas (opções de traço duplo do formulário -opção) conforme definido no GNU C Biblioteca
Referência manual `` Convenções de sintaxe de argumento do programa '' e GNU Codificação Standards
`` Padrões para interfaces de linha de comando ''. Argumentos de opção longos podem ser fornecidos como
`` --name = value '' ou `` -name value ''. Algumas opções só podem ser acessadas usando o mais
convenções de opções longas do GNU legíveis; opções comuns também são suportadas pelos mais antigos
convenção de opção de uma letra.

Documentação
--Socorro

-h Mostra informações de uso (ajuda).

--versão Mostra (apenas) o número da versão e sai.

--listas Liste os termos (tokens) que desencadeiam uma análise mais aprofundada, seu risco de inadimplência
nível, e o aviso padrão (incluindo o (s) identificador (es) CWE, se
aplicável), todos separados por tabulação. Os termos são principalmente nomes de potencialmente-
funções perigosas. Observe que o nível de risco relatado e aviso para alguns
código específico pode ser diferente do padrão, dependendo de como o termo é
usado. Combine com -D se você não quiser o cabeçalho usual. Flawfinder
a versão 1.29 mudou o separador de espaços para tabulações e adicionou o padrão
campo de aviso.

Selecionando Entrada Data
--allowlink Permitir o uso de links simbólicos; normalmente os links simbólicos são ignorados. Não
use esta opção se estiver analisando o código de outras pessoas; os invasores podem fazer muitos
coisas que podem causar problemas para uma análise com esta opção habilitada. Para
exemplo, um invasor pode inserir links simbólicos para arquivos como / Etc / passwd
(vazando informações sobre o arquivo) ou criar um loop circular, que iria
fazer com que o flawfinder execute "para sempre". Outro problema em habilitar este
opção é que se o mesmo arquivo for referenciado várias vezes usando
links, ele será analisado várias vezes (e, portanto, relatado várias vezes).
Observe que o flawfinder já inclui alguma proteção contra links simbólicos
para tipos de arquivo especiais, como tipos de arquivo de dispositivo (por exemplo, / dev / zero ou
C: \ mystuff \ com1). Observe que para o flawfinder versão 1.01 e anteriores, isso era
o padrão.

--followdotdir
Insira os diretórios cujos nomes começam com ".". Normalmente, esses diretórios são
ignorados, uma vez que normalmente incluem dados privados de controle de versão (como
.git / ou .svn /), configurações e assim por diante.

--nolink Ignorado. Historicamente, isso é desativado seguindo links simbólicos; esse comportamento
agora é o padrão.

--patch =arquivo de patch

-P arquivo de patch
Examine os arquivos ou diretórios selecionados, mas relate apenas ocorrências em linhas que
são adicionados ou modificados pelo arquivo de patch fornecido. O arquivo de patch deve estar em um
formato diff unificado reconhecido (por exemplo, a saída do GNU "diff -u old new",
"svn diff" ou "git diff [commit]"). O Flawfinder assume que o patch
já foi aplicado aos arquivos. O arquivo de patch também pode incluir mudanças para
arquivos irrelevantes (eles serão simplesmente ignorados). Os números de linha fornecidos no
arquivo de patch são usados ​​para determinar quais linhas foram alteradas, então se você tiver
modificou os arquivos desde que o arquivo de patch foi criado, regenere o arquivo de patch
primeiro. Esteja ciente de que os nomes dos novos arquivos fornecidos no arquivo de patch
deve corresponder exatamente, incluindo maiúsculas / minúsculas, prefixo do caminho e diretório
separador (\ vs. /). Apenas o formato diff unificado é aceito (GNU diff, svn
saída diff e git diff está bem); se você tiver um formato diferente, novamente
regenere-o primeiro. Apenas acertos que ocorrem nas linhas alteradas resultantes, ou
imediatamente acima e abaixo deles, são relatados. Esta opção implica
--nunca ignore.

Selecionando acessos para Ecrã
--entradas

-I Mostra apenas funções que obtêm dados de fora do programa; isso também define
minlevel a 0.

--minlevel =X

-m X Defina o nível mínimo de risco como X para inclusão na lista de ocorrências. Pode ser de 0 (`` não
risco '') a 5 (`` risco máximo ''); o padrão é 1.

--falso positivo

-F Não inclua resultados que provavelmente sejam falsos positivos. Atualmente, isso significa
que os nomes das funções são ignorados se não forem seguidos por "(", e que
declarações de matrizes de caracteres não são observadas. Assim, se você usar uma variável
chamado de "acesso" em todos os lugares, isso eliminará referências a este
variável. Este não é o padrão, porque também aumenta a probabilidade de
faltando acertos importantes; em particular, nomes de função em cláusulas #define e chamadas
através de ponteiros de função serão perdidos.

--nunca ignore

-n Nunca ignore os problemas de segurança, mesmo se eles tiverem uma diretiva `` ignore '' em um
Como? ”Ou“ O quê.

--regexp =PADRONIZAR

-e PADRONIZAR
Relate apenas ocorrências com texto que corresponda ao padrão de expressão regular PATTERN.
Por exemplo, para relatar apenas hits contendo o texto "CWE-120", use `` --regex
CWE-120 ''. Esses nomes de sinalizadores de opção são iguais a grep.

Selecionando saída Formato
--colunas

-C Mostra o número da coluna (bem como o nome do arquivo e o número da linha) de cada ocorrência;
isso é mostrado após o número da linha, adicionando-se dois pontos e o número da coluna em
a linha (o primeiro caractere em uma linha é o número da coluna 1). Isso é útil
para editores que podem pular para colunas específicas, ou para integração com outros
ferramentas (como aquelas para filtrar ainda mais os falsos positivos).

--contexto

-c Mostra o contexto, ou seja, a linha com o "acerto" / falha potencial. Por padrão, o
linha é mostrada imediatamente após o aviso.

--somente dados

-D Não exiba o cabeçalho e o rodapé. Use isso junto com --quiet para ver apenas
os próprios dados.

--html

-H Formate a saída como HTML em vez de texto simples.

--imediato

-i Exiba resultados imediatamente (não espere até o fim).

--única linha

-S Exibir como uma única linha de saída de texto para cada hit. Útil para interagir
com ferramentas de compilação.

--omittime Omitir informações de tempo. Isso é útil para testes de regressão do flawfinder
em si, de modo que a saída não varie dependendo de quanto tempo a análise
leva.

--quieto

-Q Não exiba informações de status (ou seja, quais arquivos estão sendo examinados) enquanto
a análise está acontecendo.

Lista de hits Assistência Domiciliária
--savehitlist =F
Salve todos os hits resultantes (a "lista de hits") em F.

--loadhitlist =F
Carregue a lista de ocorrências de F em vez de analisar os programas de origem. Aviso: Faça não
carregar listas de ocorrências de fontes não confiáveis ​​(por razões de segurança).

--diffhitlist =F
Mostrar apenas hits (carregados ou analisados) que não estão em F. F foi provavelmente criado
anteriormente usando --savehitlist. Aviso: Faça não diff hitlists de não confiáveis
fontes (por razões de segurança). Se a opção --loadhitlist não for fornecida,
isso mostrará os acessos nos arquivos de código-fonte analisados ​​que não foram
previamente armazenado em F. Se usado junto com --loadhitlist, isso mostrará o
acertos na lista de acertos carregada não em F. O algoritmo de diferença é
conservador; hits são apenas considerados os mesmos se eles tiverem o mesmo
nome do arquivo, número da linha, posição da coluna, nome da função e nível de risco.

EXEMPLOS

Aqui estão vários exemplos de como invocar o flawfinder. Os primeiros exemplos mostram vários
opções de linha de comando simples. O Flawfinder foi projetado para funcionar bem com editores de texto e
ambientes de desenvolvimento integrados, então as próximas seções mostram como integrar o flawfinder
em vim e emacs.

simples de linha de comando opções
localizador de falhas /usr/src/linux-3.16
Examine todos os arquivos C / C ++ no diretório /usr/src/linux-3.16 e todos os seus
subdiretórios (recursivamente), informando sobre todos os hits encontrados. Por padrão
o flawfinder irá pular links simbólicos e diretórios com nomes que começam com
um periodo.

localizador de falhas --minlevel = 4 .
Examine todos os arquivos C / C ++ no diretório atual e seus subdiretórios
(recursivamente); relatar apenas vulnerabilidades de nível 4 e superior (as duas mais altas
níveis de risco).

localizador de falhas --entradas meudir
Examine todos os arquivos C / C ++ em mydir e seus subdiretórios (recursivamente) e
funções de relatório que recebem entradas (para que você possa garantir que filtrem o
entradas apropriadamente).

localizador de falhas --nunca ignore meudir
Examine todos os arquivos C / C ++ no diretório mydir e seus subdiretórios,
incluindo até mesmo os acessos marcados para ignorar nos comentários do código.

localizador de falhas -QD meudir
Examine mydir e relate apenas os resultados reais (removendo o cabeçalho e
rodapé da saída). Este formulário é útil se a saída for canalizada para
outras ferramentas para análise posterior. O -C (--columns) e -S (--singleline)
as opções também podem ser úteis se você estiver canalizando os dados para outras ferramentas.

localizador de falhas -QDSC meudir
Examine mydir, relatando apenas os resultados reais (sem cabeçalho ou rodapé). Cada
a ocorrência é relatada em uma linha e os números das colunas são relatados. Isso pode ser um
comando útil se você estiver alimentando a saída do flawfinder para outras ferramentas.

localizador de falhas --quieto --html --contexto meudir > resultados.html
Examine todos os arquivos C / C ++ no diretório mydir e seus subdiretórios e
produzir uma versão formatada em HTML dos resultados. Gerenciamento de código fonte
sistemas (como SourceForge e Savannah) podem usar um comando como este.

localizador de falhas --quieto --savehitlist save.hits *.[CH]
Examine todos os arquivos .c e .h no diretório atual. Não faça relatórios sobre o
status de processamento e salve a lista de hits resultante (o conjunto de todos os hits) em
o arquivo saved.hits.

localizador de falhas --diffhitlist save.hits *.[CH]
Examine todos os arquivos .c e .h no diretório atual e mostre todos os acessos que
ainda não estavam no arquivo saved.hits. Isso pode ser usado para mostrar apenas o
`` novas '' vulnerabilidades em um programa modificado, se saved.hits foi criado a partir de
a versão mais antiga do programa que está sendo analisado.

localizador de falhas --correção remendo recente .
Examine o diretório atual recursivamente, mas apenas as linhas de relatório que foram
alterado ou adicionado ao arquivo de patch já aplicado denominado remendo recente.

localizador de falhas --regex "CWE-120 | CWE-126" src /
Examine o diretório src recursivamente, mas apenas relatar ocorrências onde CWE-120 ou
CWE-126 se aplica.

Invocando da vitalidade
O editor de texto vim inclui um mecanismo de "correção rápida" que funciona bem com o flawfinder, então
que você pode visualizar facilmente as mensagens de aviso e pular para o código-fonte relevante.

Primeiro, você precisa invocar o flawfinder para criar uma lista de resultados, e há duas maneiras de
fazem isto. A primeira maneira é iniciar o flawfinder primeiro e, em seguida, (usando sua saída) invocar
vim. A segunda maneira é iniciar (ou continuar a executar) o vim e, em seguida, invocar o flawfinder
(normalmente de dentro do vim).

Para a primeira forma, execute o flawfinder e armazene sua saída em algum FLAWFILE (diga "flawfile"),
em seguida, invoque o vim usando sua opção -q, como este: "vim -q flawfile". A segunda maneira
(iniciar o flawfinder após iniciar o vim) pode ser feito de várias maneiras. Um é invocar
flawfinder usando um comando shell, ":! flawfinder-command> FLAWFILE" e, em seguida, siga-o com
o comando ": cf FLAWFILE". Outra maneira é armazenar o comando flawfinder em seu
makefile (como, digamos, um pseudocomando como "flaw"), e então execute ": make flaw".

Em todos esses casos, você precisa de um comando para que o flawfinder seja executado. Um comando plausível, que
coloca cada hit em sua própria linha (-S) e remove cabeçalhos e rodapés que podem confundir
isto é:

localizador de falhas -SQD .

Agora você pode usar vários comandos de edição para visualizar os resultados. O comando ": cn" exibe
o próximo golpe; ": cN" exibe o acerto anterior e ": cr" retrocede para o primeiro acerto.
": copen" abrirá uma janela para mostrar a lista atual de acessos, chamada de "correção rápida
janela ";": cclose "fechará a janela de correção rápida. Se o buffer na janela usada tiver
alterado, e o erro estiver em outro arquivo, pular para o erro falhará. Voce tem que
certifique-se de que a janela contém um buffer que pode ser abandonado antes de tentar pular para um
novo arquivo, digamos, salvando o arquivo; isso evita a perda acidental de dados.

Invocando da emacs
O editor de texto / sistema operacional emacs inclui "modo grep" e "modo de compilação"
mecanismos que funcionam bem com o flawfinder, facilitando a visualização de mensagens de aviso,
ao código-fonte relevante e corrija todos os problemas que encontrar.

Primeiro, você precisa invocar o flawfinder para criar uma lista de mensagens de aviso. Você pode usar
"modo grep" ou "modo de compilação" para criar esta lista. Freqüentemente, o "modo grep" é mais conveniente;
ele deixa o modo de compilação intocado para que você possa recompilar facilmente uma vez que você mudou
algo. No entanto, se você quiser pular para a posição exata da coluna de um hit, compile
modo pode ser mais conveniente porque emacs pode usar a saída de coluna do flawfinder para
pule diretamente para o local certo sem qualquer configuração especial.

Para usar o modo grep, digite o comando "Mx grep" e digite o localizador de falhas necessário
comando. Para usar o modo de compilação, digite o comando "Compilar Mx" e digite o necessário
comando flawfinder. Este é um comando de meta-chave, então você precisará usar a meta-chave para
seu teclado (geralmente é a tecla ESC). Tal como acontece com todos os comandos emacs, você precisará
pressione RETURN após digitar "grep" ou "compilar". Então, em muitos sistemas, o modo grep é
invocado digitando ESC xgrep RETURN.

Em seguida, você precisa inserir um comando, removendo o que estava lá antes, se necessário. UMA
o comando plausível é:

localizador de falhas -SQDC .

Este comando torna cada relatório de acerto em uma única linha, o que é muito mais fácil para as ferramentas
lidar. As opções quiet e dataonly removem as outras informações de status não necessárias para
usar dentro do emacs. O ponto final significa que o diretório atual e todos
descendentes são pesquisados ​​em busca de código C / C ++ e analisados ​​em busca de falhas.

Depois de invocar o flawfinder, você pode usar o emacs para navegar pelos resultados. o
o comando Cx `(Control-x backtick) visita o local do código-fonte para o próximo aviso
mensagem. Cu Cx `(control-u control-x backtick) reinicia do início. Você pode
visite a fonte de qualquer mensagem de erro específica movendo-se para essa mensagem de hit no
* compilação * buffer ou * grep * buffer e digitando a tecla return. (Nota técnica: no
buffer de compilação, isso invoca compile-goto-error.) Você também pode clicar no botão Mouse-2
na mensagem de erro (você não precisa mudar para o buffer de * compilação * primeiro).

Se você quiser usar o modo grep para pular para colunas específicas de um hit, você precisará
configure especialmente o emacs para fazer isso. Para fazer isso, modifique a variável emacs "grep-regexp-
alist ". Esta variável diz ao Emacs como analisar a saída de um comando" grep ", semelhante ao
variável "compilation-error-regexp-alist" que lista vários formatos de erro de compilação
mensagens.

Invocando da Integral Desenvolvimento Ambientes (IDE)
Para (outros) IDEs, consulte o conjunto de plug-ins do IDE.

COMUM FRAQUEZA ENUMERAÇÃO (CWE)

A Enumeração de Fraqueza Comum (CWE) é `` uma lista formal ou dicionário de software comum
fraquezas que podem ocorrer na arquitetura, design, código ou implementação de software que
pode levar a vulnerabilidades de segurança exploráveis ​​... criado para servir como uma linguagem comum
para descrever os pontos fracos de segurança do software '' (http://cwe.mitre.org/about/faq.html). Para
mais informações sobre CWEs, consulte http://cwe.mitre.org.

O Flawfinder suporta o CWE e é oficialmente compatível com o CWE. Descrições de hit normalmente
incluir um identificador Common Weakness Enumeration (CWE) relevante entre parênteses onde houver
é conhecido por ser um CWE relevante. Por exemplo, muitos dos hits relacionados ao buffer mencionam
CWE-120, o identificador CWE para `` cópia do buffer sem verificar o tamanho da entrada '' (também conhecido como
`` Classic Buffer Overflow ''). Em alguns casos, mais de um identificador CWE pode ser listado.
O relatório HTML também inclui links de hipertexto para as definições CWE hospedadas no MITER. No
desta forma, o flawfinder foi projetado para atender ao requisito de saída CWE.

Muitos dos CWEs relatados pelo flawfinder são identificados na lista dos 25 principais CWE / SANS de 2011
(http://cwe.mitre.org/top25/) Muitas pessoas vão querer procurar CWEs nesta lista,
como CWE-120 (estouro de buffer clássico), quando o flawfinder mapeia para um CWE que é mais
geral do que um dos 25 principais itens, ele o lista como mais geral: mais específico (por exemplo,
CWE-119: CWE-120), em que mais geral é o mapeamento real. Se o flawfinder mapeia para um mais
item específico do CWE, que é um caso específico de um dos 25 principais itens, está listado no formulário
top-25 / mais específico (por exemplo, CWE-362 / CWE-367), onde o mapeamento real é o mais específico
Entrada CWE. Se a mesma entrada for mapeada para vários CWEs, os CWEs serão separados por vírgulas
(isso geralmente ocorre com CWE-20, validação de entrada inadequada). Isso simplifica a busca por
certos CWEs.

O CWE versão 2.7 (lançado em 23 de junho de 2014) foi usado para o mapeamento. O CWE atual
os mapeamentos selecionam o CWE mais específico que a ferramenta pode determinar. Em teoria, a maioria dos CWE
elementos de segurança (assinaturas / padrões que a ferramenta procura) poderiam, teoricamente, ser
mapeado para CWE-676 (Uso de Função Potencialmente Perigosa), mas tal mapeamento não seria
útil. Assim, mapeamentos mais específicos eram preferidos onde um pudesse ser encontrado. Flawfinder
é uma ferramenta de análise lexical; como resultado, é impraticável ser mais específico do que
os mapeamentos implementados atualmente. Isso também significa que é improvável que precise de muito
atualização para moeda do mapa; simplesmente não tem informações suficientes para refinar para um
nível CWE detalhado que as alterações do CWE normalmente afetariam. A lista de identificadores CWE
foi gerado automaticamente usando "make show-cwes", então é certo que esta lista
está correto. Por favor, reporte os problemas de mapeamento CWE como bugs, se você encontrar algum.

O Flawfinder pode não conseguir encontrar uma vulnerabilidade, mesmo que o flawfinder cubra um desses CWE
fraquezas. Dito isso, o flawfinder encontra vulnerabilidades listadas pelos CWEs que cobre,
e não relatará linhas sem essas vulnerabilidades em muitos casos. Assim, como
necessário para qualquer ferramenta que pretenda ser compatível com CWE, o flawfinder tem uma taxa de
positivos inferiores a 100% e uma taxa de falsos negativos inferior a 100%. Flawfinder quase
sempre relata sempre que encontra uma correspondência para um elemento de segurança CWE (uma assinatura / padrão como
definido em seu banco de dados), embora certas construções obscuras possam fazer com que ele falhe (veja BUGS
abaixo).

O Flawfinder pode relatar os seguintes CWEs (esses são os CWEs que o flawfinder cobre;
`` * '' marca aqueles na lista dos 25 principais CWE / SANS):

· CWE-20: Validação de entrada imprópria

· CWE-22: Limitação imprópria de um caminho para um diretório restrito (`` Path Traversal '')

· CWE-78: Neutralização imprópria de elementos especiais usados ​​em um comando OS (`` Comando OS
Injeção '') *

· CWE-119: Restrição imprópria de operações dentro dos limites de um buffer de memória (a
pai de CWE-120 *, então isso é mostrado como CWE-119: CWE-120)

· CWE-120: Cópia de buffer sem verificar o tamanho da entrada (`` Estouro de buffer clássico '') *

· CWE-126: Sobre-leitura do buffer

· CWE-134: String de formato não controlado *

· CWE-190: Inteiro Estouro ou Wraparound *

· CWE-250: Execução com privilégios desnecessários

· CWE-327: Uso de um algoritmo criptográfico quebrado ou arriscado *

· CWE-362: Execução simultânea usando recurso compartilhado com sincronização imprópria
(`` Condição de corrida '')

· CWE-377: Arquivo temporário inseguro

· CWE-676: Uso de função potencialmente perigosa *

· CWE-732: Atribuição de permissão incorreta para recurso crítico *

· CWE-785: Uso da função de manipulação de caminho sem buffer de tamanho máximo (filho de
CWE-120 *, então é mostrado como CWE-120 / CWE-785)

· CWE-807: Confiança em entradas não confiáveis ​​em uma decisão de segurança *

· CWE-829: Inclusão de funcionalidade da esfera de controle não confiável *

Você pode selecionar um subconjunto específico de CWEs para relatar usando a opção `` --regex '' (-e).
Esta opção aceita uma expressão regular, então você pode selecionar vários CWEs, por exemplo, `` --regex
"CWE-120 | CWE-126" ''. Se você selecionar vários CWEs com `` | '' em uma linha de comando, você
normalmente precisa citar os parâmetros (já que um `` | '' não citado é o símbolo de barra vertical).
O Flawfinder foi projetado para atender ao requisito CWE-Searchable.

Se o seu objetivo é relatar um subconjunto de CWEs que estão listados em um arquivo, isso pode ser alcançado
em um sistema do tipo Unix usando a opção `` --regex '' também conhecida como `` -e ''. O arquivo deve estar em
formato de expressão regular. Por exemplo, `` flawfinder -e $ (cat file1) '' reportaria apenas
hits que correspondiam ao padrão em `` arquivo1 ''. Se o arquivo 1 continha `` CWE-120 | CWE-126 '', ele
reportaria apenas acertos correspondentes a esses CWEs.

Uma lista de todos os elementos de segurança CWE (as assinaturas / padrões que o flawfinder procura)
pode ser encontrado usando a opção `` --listrules ''. Cada linha lista o token de assinatura
(normalmente um nome de função) que pode levar a um acerto, o nível de risco padrão e o
aviso padrão (que inclui o identificador CWE padrão). Para a maioria dos propósitos, isso é
também o suficiente se você quiser ver quais elementos de segurança CWE mapeiam para quais CWEs, ou o
reverter. Por exemplo, para ver o máximo das assinaturas (nomes de funções) que mapeiam para
CWE-327, sem ver o nível de risco padrão ou texto de aviso detalhado, execute `` flawfinder
--listrules | grep CWE-327 | cut -f1 ''. Você também pode ver os tokens sem um mapeamento CWE
desta forma executando `` flawfinder -D --listrules | grep -v CWE- ''. No entanto, enquanto
--listrules lista todos os elementos de segurança CWE, apenas lista os mapeamentos padrão do CWE
elementos de segurança para identificadores CWE. Não inclui os refinamentos que o flawfinder
se aplica (por exemplo, examinando os parâmetros da função).

Se você deseja um mapeamento detalhado e exato entre os elementos de segurança CWE e CWE
identificadores, o código-fonte do flawfinder (incluído na distribuição) é o melhor lugar
para essa informação. Essas informações detalhadas são de interesse principalmente para aqueles poucos
pessoas que estão tentando refinar os mapeamentos do CWE do flawfinder ou refinar o CWE em geral.
O código-fonte documenta o mapeamento entre os elementos de segurança para o respectivo CWE
identificadores e é um único arquivo Python. O conjunto de dados `` c_rules '' define a maioria das regras,
com referência a uma função que pode fazer mais refinamentos. Você pode pesquisar o
conjunto de dados para nomes de função para ver o CWE que ele gera por padrão; se o primeiro parâmetro é
não `` normal '', então esse é o nome de um método de refinação Python que pode selecionar diferentes
CWEs (dependendo de informações adicionais). Por outro lado, você pode pesquisar por `` número CWE ''
e descobrir quais elementos de segurança (assinaturas ou padrões) se referem a esse identificador CWE.
Para a maioria das pessoas, isso é muito mais do que precisam; a maioria das pessoas só quer escanear seus
código-fonte para encontrar problemas rapidamente.

SEGURANÇA

O objetivo dessa ferramenta é ajudar a encontrar vulnerabilidades para que possam ser corrigidas.
No entanto, os desenvolvedores e revisores devem saber como desenvolver um software seguro para usar este
ferramenta, porque caso contrário, a enganar com a ferramenta is ainda a enganar. Meu livro em
http://www.dwheeler.com/secure-programs pode ajudar.

Essa ferramenta deve ser, no máximo, uma pequena parte de um processo maior de desenvolvimento de software
projetado para eliminar ou reduzir o impacto das vulnerabilidades. Desenvolvedores e revisores
precisam saber como desenvolver software seguro e precisam aplicar esse conhecimento para reduzir
os riscos de vulnerabilidades em primeiro lugar.

Diferentes ferramentas de descoberta de vulnerabilidades tendem a encontrar diferentes vulnerabilidades. Assim, você
é melhor usar a revisão humana e uma variedade de ferramentas. Esta ferramenta pode ajudar a encontrar alguns
vulnerabilidades, mas de forma alguma todas.

Você deve sempre analisar um cópia do programa de origem que está sendo analisado, não um diretório
que pode ser modificado por um desenvolvedor enquanto o flawfinder está realizando a análise. Isto é
especialmente verdadeiro se você não confiar necessariamente em um desenvolvedor do programa que está sendo analisado.
Se um invasor tiver controle sobre os arquivos enquanto você os analisa, ele pode
mover arquivos ou alterar seu conteúdo para evitar a exposição de um problema de segurança
(ou criar a impressão de um problema onde não há nenhum). Se você está preocupado com
programadores mal-intencionados, você deve fazer isso de qualquer maneira, porque após a análise, você precisará
verifique se o código eventualmente executado é o código que você analisou. Além disso, não use o
opção --allowlink em tais casos; invasores podem criar links simbólicos maliciosos para arquivos
fora de sua área de código-fonte (como / Etc / passwd).

Os sistemas de gerenciamento de código-fonte (como SourceForge e Savannah) definitivamente se enquadram nisso
categoria; se você estiver mantendo um desses sistemas, primeiro copie ou extraia os arquivos para
um diretório separado (que não pode ser controlado por invasores) antes de executar o flawfinder ou
qualquer outra ferramenta de análise de código.

Observe que o flawfinder só abre arquivos regulares, diretórios e (se solicitado) simbólicos
links; ele nunca abrirá outros tipos de arquivos, mesmo que um link simbólico seja feito para eles.
Isso neutraliza os invasores que inserem tipos de arquivo incomuns no código-fonte. No entanto, este
só funciona se o sistema de arquivos que está sendo analisado não puder ser modificado por um invasor durante o
análise, conforme recomendado acima. Essa proteção também não funciona em plataformas Cygwin,
infelizmente.

Os sistemas Cygwin (emulação Unix no topo do Windows) têm um problema adicional se o flawfinder
é usado para analisar programas nos quais o analista não pode confiar. O problema é devido a um design
falha no Windows (que é herdada do MS-DOS). No Windows e no MS-DOS, certos nomes de arquivo
(por exemplo, `` com1 '') são tratados automaticamente pelo sistema operacional como os nomes de
periféricos, e isso é verdade mesmo quando um nome de caminho completo é fornecido. Sim, Windows e MS-DOS
realmente são projetados tão mal. O Flawfinder lida com isso verificando o que é um sistema de arquivos
objeto é, e então apenas abrindo diretórios e arquivos regulares (e links simbólicos, se habilitados).
Infelizmente, isso não funciona no Cygwin; em pelo menos algumas versões do Cygwin em alguns
versões do Windows, apenas tentar determinar se um arquivo é um tipo de dispositivo pode causar o
programa para travar. Uma solução alternativa é excluir ou renomear todos os nomes de arquivo que são interpretados
como nomes de dispositivos antes de realizar a análise. Esses chamados `` nomes reservados '' são
CON, PRN, AUX, CLOCK $, NUL, COM1-COM9 e LPT1-LPT9, opcionalmente seguido por uma extensão
(por exemplo, `` com1.txt ''), em qualquer diretório, e em qualquer caso (o Windows não faz distinção entre maiúsculas e minúsculas).

Do não carregar ou comparar listas de ocorrências de fontes não confiáveis. Eles são implementados usando o
Módulo pickle Python, e o módulo pickle não se destina a ser seguro contra erros
ou dados construídos de forma maliciosa. As listas de ocorrências armazenadas destinam-se ao uso posterior pelo mesmo
usuário que criou a lista de ocorrências; nesse contexto, esta restrição não é um problema.

Use o flawfinder online usando os serviços onworks.net