Partilhar via


strict_gs_check pragma

Este pragma proporciona uma verificação de segurança melhorada.

Sintaxe

#pragma strict_gs_check( [ push, ] { on | off } )
#pragma strict_gs_check( pop )

Comentários

Instrui o compilador a inserir um cookie aleatório na pilha de funções para ajudar a detetar algumas categorias de saturação de buffer baseada em pilha. Por padrão, a opção /GS compilador não insere um cookie para todas as funções. Para obter mais informações, consulte /GS (Buffer Security Check).

Compile usando /GS para habilitar strict_gs_check.

Use esse pragma em módulos de código expostos a dados potencialmente nocivos. strict_gs_check é um pragmaagressivo e é aplicado a funções que podem não precisar dessa defesa, mas é otimizado para minimizar seu efeito no desempenho do aplicativo resultante.

Mesmo se você usar este pragma, você deve se esforçar para escrever código seguro. Ou seja, certifique-se de que seu código não tenha saturações de buffer. strict_gs_check pode proteger seu aplicativo contra saturações de buffer que permanecem em seu código.

Exemplo

Neste exemplo, ocorre uma saturação de buffer quando copiamos uma matriz para uma matriz local. Quando você compila esse código com /GS, nenhum cookie é inserido na pilha, porque o tipo de dados da matriz é um ponteiro. Adicionar o strict_gs_checkpragma força o cookie de pilha na pilha de funções.

// pragma_strict_gs_check.cpp
// compile with: /c

#pragma strict_gs_check(on)

void ** ReverseArray(void **pData,
                     size_t cData)
{
    // *** This buffer is subject to being overrun!! ***
    void *pReversed[20];

    // Reverse the array into a temporary buffer
    for (size_t j = 0, i = cData; i ; --i, ++j)
        // *** Possible buffer overrun!! ***
            pReversed[j] = pData[i];

    // Copy temporary buffer back into input/output buffer
    for (size_t i = 0; i < cData ; ++i)
        pData[i] = pReversed[i];

    return pData;
}

Ver também

diretivas Pragma e as palavras-chave __pragma e _Pragma
/GS (verificação de segurança do buffer)