strict_gs_check pragma

Este pragma fornece verificação de segurança aprimorada.

Sintaxe

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

Comentários

Ele instrui o compilador a inserir um cookie aleatório na pilha de função para ajudar a detectar algumas categorias de saturação de buffer baseada em fila. Por padrão, a opção do compilador /GS não insere um cookie para todas as funções. Para mais informações, confira /GS (Verificação de segurança do buffer).

Compilar usando /GS para habilitar strict_gs_check.

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

Mesmo ao usar esse pragma, o ideal é escrever um código seguro. Ou seja, verifique se seu código não tem saturações de buffer. strict_gs_check pode proteger seu aplicativo de saturações de buffer remanescentes em seu código.

Exemplo

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

// 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;
}

Confira também

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