Pergunta

Olhando através destes vários documentos do OpenSSL 3.0

• https://security.stackexchange.com/questions/34791/openssl-vs-fips-enabled-openssl
• https://github.com/openssl/openssl/blob/master/README-FIPS.md
• https://www.openssl.org/docs/man3.0/man7/fips_module.html
• https://en.wikipedia.org/wiki/FIPS_140-2

Consegui montar uma solução para habilitar o modo FIPS no OpenSSL com o seguinte objetivo em mente:

A ênfase está no fato de que, uma vez habilitado o modo FIPS no OpenSSL, todas as operações criptográficas realizadas através do OpenSSL, incluindo aquelas usadas pelo C++ Boost.Asio para conexões SSL/TLS, utilizarão algoritmos aprovados pelo FIPS, garantindo a conformidade com os padrões FIPS em todo o Impulsione o aplicativo C++.

Esta é uma função válida enableFIPS()para ativar o modo OpenSSL FIPS para Boost C++?

Exemplo

principal.cpp

#include <iostream>
#include <string>
#include <boost/asio.hpp>
#include <boost/asio/ssl.hpp>
#include <openssl/provider.h>

bool PrintErrorSSL(const std::string& err)
{
   std::cerr << err << std::endl;
   unsigned long err_code;
   while ((err_code = ERR_get_error()) != 0)
   {
      char err_msg[256];
      ERR_error_string_n(err_code, err_msg, sizeof(err_msg));
      std::cerr << "OpenSSL error: " << err_msg << std::endl;
   }
   // FIPS mode not enabled.
   return false;
}

bool enableFIPS()
{
   std::string ConfigPath;
   std::string TestPath = "C:/Projects/sys-openssl-fips/Test/";
   
#ifdef _WIN32
    ConfigPath = TestPath + "openssl-fips.cnf";
#else
    ConfigPath = TestPath + "openssl-fips-linux.cnf";
#endif

   if (!OSSL_PROVIDER_set_default_search_path(nullptr, TestPath.c_str()))
   {
      return PrintErrorSSL("OSSL_PROVIDER_set_default_search_path() Failed");
   }

   if (!OSSL_LIB_CTX_load_config(nullptr, ConfigPath.c_str()))
   {
      return PrintErrorSSL("OSSL_LIB_CTX_load_config() Failed");
   }

   if (!OSSL_PROVIDER_available(nullptr, "fips") || !OSSL_PROVIDER_available(nullptr, "base"))
   {
      return PrintErrorSSL("OSSL_PROVIDER_available() Failed");
   }

   if (!EVP_default_properties_is_fips_enabled(nullptr))
   {
      return PrintErrorSSL("EVP_default_properties_is_fips_enabled() Failed");
   }

   // FIPS mode enabled.
   return true;
}

int main(int argc, char* argv[])
{
   if (enableFIPS())
   {
      using boost::asio::ip::tcp;
      boost::asio::io_context io_context;
      boost::asio::ssl::context ssl_context(boost::asio::ssl::context::tlsv12);
      boost::asio::ssl::stream<tcp::socket> socket(io_context, ssl_context);
      tcp::resolver resolver(io_context);
      auto endpoints = resolver.resolve("www.google.com", "443");
      boost::asio::connect(socket.lowest_layer(), endpoints);
      socket.handshake(boost::asio::ssl::stream_base::client);
      std::string request = "GET / HTTP/1.1\r\nHost: www.google.com\r\nConnection: close\r\n\r\n";
      boost::asio::write(socket, boost::asio::buffer(request));
      boost::asio::streambuf response;
      boost::system::error_code ec;
      boost::asio::read_until(socket, response, "\r\n", ec);
      std::istream response_stream(&response);
      std::string http_status;
      std::getline(response_stream, http_status);
      if (http_status.find("200 OK") != std::string::npos)
         return 0;
   }

   return 1;
}

openssl-fips.cnf

config_diagnostics = 1
openssl_conf = openssl_init

[fips_sect]
activate = 1
conditional-errors = 1
security-checks = 1
module-mac = D9:AB:CC:37:8A:4C:06:BF:E9:E3:A8:F7:B9:B5:02:48:58:71:76:EB:5E:71:8A:0F:87:AA:52:46:7D:60:B0:EB

[openssl_init]
providers = provider_sect
alg_section = algorithm_sect

[provider_sect]
fips = fips_sect
base = base_sect

[base_sect]
activate = 1

[algorithm_sect]
default_properties = fips=yes

Saída (Windows)

Modo OpenSSL FIPS: DESLIGADO

Os projetos utilizarão algoritmos não aprovados pelo FIPS fornecidos por essas bibliotecas estáticas do openssl

• libssl - Implementa o protocolo Transport Layer Security (TLS).
• libcrypto - Implementa algoritmos criptográficos.

Modo OpenSSL FIPS: LIGADO

Os projetos utilizarão algoritmos aprovados pelo FIPS fornecidos por essas bibliotecas compartilhadas do openssl

• fips.so (no Linux)
• fips.dll (no Windows)

Usando Process Explorer , fips.dllé carregado:

Comecei a aprender sobre segurança no Linux e a ler alguns artigos sobre hash de senha MD5.

Esta demonstração do Godbolt usa a função crypt

char *crypt(const char *key, const char *salt);

e passa esse saltvalor

const char *salt = "$1$rockyou"; 

onde

• $1$é MD5
• rockyoué o sal.

Pergunta

Suponha que o salt contenha um $símbolo, como rock$you, como ele deve ser formatado antes de passá-lo para crypt ?

O antivírus do Windows Cortex XDR Agent version 8.1.1está ativo na minha máquina de desenvolvimento. Ao executar alguns instantâneos de processos especificados usando CreateToolhelp32Snapshot , de repente o Cortex apareceu uma mensagem dizendo Malicious tampering threat detectedseguido por um BSOD

Depois de algumas horas de depuração, aqui está a reprodução mínima

// HeapTest.c - Release x64 build with Visual C++ 2022 
// BSOD with Bug Check 0x139 in Cortex XDR

#include <windows.h>
#include <tlhelp32.h>

int main()
{
    CreateToolhelp32Snapshot(TH32CS_SNAPHEAPLIST, 8456);
}

onde o ID do processo 8456 é para cytray.exe .

O Windows criou um minidmp %SystemRoot%\Minidumpe abriu-o com o Windbgdepurador.

Microsoft (R) Windows Debugger Version 6.12.0002.633 AMD64
Copyright (c) Microsoft Corporation. All rights reserved.


Loading Dump File [C:\Windows\Minidump\090223-14718-01.dmp]
Mini Kernel Dump File: Only registers and stack trace are available

Symbol search path is: SRV*C:\Symbols*http://msdl.microsoft.com/download/symbols
Executable search path is: 
Windows 7 Kernel Version 22621 MP (16 procs) Free x64
Product: WinNt, suite: TerminalServer SingleUserTS
Machine Name:
Kernel base = 0xfffff807`72600000 PsLoadedModuleList = 0xfffff807`732130e0
Debug session time: Sat Sep  2 19:35:12.743 2023 (UTC - 4:00)
System Uptime: 0 days 5:06:37.745
Loading Kernel Symbols
...............................................................
................................................................
................................................................
....................................................
Loading User Symbols
Loading unloaded module list
...................
*******************************************************************************
*                                                                             *
*                        Bugcheck Analysis                                    *
*                                                                             *
*******************************************************************************

Use !analyze -v to get detailed debugging information.

BugCheck 139, {a, 0, 0, fffff80772a2dfc0}

Probably caused by : Unknown_Image ( PAGE_NOT_ZERO )

Followup: MachineOwner
---------

 *** Memory manager detected 178688 instance(s) of page corruption, target is likely to have memory corruption.



6: kd> !analyze -v
*******************************************************************************
*                                                                             *
*                        Bugcheck Analysis                                    *
*                                                                             *
*******************************************************************************

Unknown bugcheck code (139)
Unknown bugcheck description
Arguments:
Arg1: 000000000000000a
Arg2: 0000000000000000
Arg3: 0000000000000000
Arg4: fffff80772a2dfc0

Debugging Details:
------------------


CUSTOMER_CRASH_COUNT:  1

DEFAULT_BUCKET_ID:  VISTA_DRIVER_FAULT

BUGCHECK_STR:  0x139

PROCESS_NAME:  HeapTest.exe

CURRENT_IRQL:  0

BAD_PAGES_DETECTED: 2ba00

LAST_CONTROL_TRANSFER:  from fffff80772a3bf8e to fffff80772a31250

STACK_TEXT:  
ffffa20c`050b6988 fffff807`72a3bf8e : 00000000`00000139 00000000`0000000a 00000000`00000000 00000000`00000000 : nt!KeBugCheckEx
ffffa20c`050b6990 00000000`00000000 : 00000000`00000000 00000000`00000000 00000000`00000000 00000000`00000000 : nt!guard_icall_bugcheck+0x1e


STACK_COMMAND:  kb

SYMBOL_NAME:  PAGE_NOT_ZERO

FOLLOWUP_NAME:  MachineOwner

MODULE_NAME: Unknown_Module

IMAGE_NAME:  Unknown_Image

DEBUG_FLR_IMAGE_TIMESTAMP:  0

BUCKET_ID:  PAGE_NOT_ZERO

Followup: MachineOwner
---------

 *** Memory manager detected 178688 instance(s) of page corruption, target is likely to have memory corruption.

Com base nas informações de prevenção do Cortex

OS version: 10.0.22621
Component: Anti Tampering Protection
Cortex XDR code: C04000AC
Prevention description: Malicious tampering threat detected
Verdict: 0
Quarantined: False
Post-Detected: False
Rule name: anti_tampering.8

é mais provável que seja um bug em um dos seguintes drivers Cortex XDR

C:\Program Files\Palo Alto Networks\Traps\cyverak.sys
C:\Program Files\Palo Alto Networks\Traps\cyvrmtgn.sys
C:\Program Files\Palo Alto Networks\Traps\cyvrfsfd.sys
C:\Program Files\Palo Alto Networks\Traps\tedrdrv.sys
C:\Program Files\Palo Alto Networks\Traps\tdevflt.sys
C:\Program Files\Palo Alto Networks\Traps\tedrpers-<version>.sys
C:\Windows\System32\drivers\telam.sys

Pergunta

Por curiosidade, existe uma maneira de identificar o nome do driver sys com bugs?

Estou tentando encontrar o endereço base do kernel32 assumindo diretamente que kernel32.dll é sempre o terceiro módulo carregado.

ModLoad: 00400000 024077eb   image00400000
ModLoad: 77ad0000 77c7f000   ntdll.dll
ModLoad: 75c80000 75d70000   C:\WINDOWS\SysWOW64\KERNEL32.DLL
ModLoad: 77160000 773d3000   C:\WINDOWS\SysWOW64\KERNELBASE.dll
...

Eu tinha um loop for para executar os módulos, mas notei que kernel32.dll era sempre a terceira entrada.

Posso presumir que isso é confiável?

O programa C produz

Endereço base Kernel32.dll: 0x75C80000

#include <stdio.h>
#include <stdint.h>
#include <windows.h>
#include <winternl.h>

int main()
{
    PPEB peb = (PPEB)__readfsdword(0x30);
    uintptr_t kernel32Base = 0;

    /* Skip first two entries as kernel32.dll is always the third entry */
    PLIST_ENTRY ptr = peb->Ldr->InMemoryOrderModuleList.Flink->Flink->Flink;
    PLDR_DATA_TABLE_ENTRY e = CONTAINING_RECORD(ptr, LDR_DATA_TABLE_ENTRY, InMemoryOrderLinks);
    kernel32Base = (uintptr_t)e->DllBase;
    printf("Kernel32.dll Base Address: 0x%p\n", (void*)kernel32Base);

    return 0;
}

Por exemplo, windbg está carregando DbgView.exe

Atualizar

Com base na resposta de Josh, a sugestão foi usarInLoadOrderModuleList

Depois de hackear por uma hora, finalmente consegui funcionar

Endereço base Kernel32.dll: 0x75C80000

A solução é declarar minhas próprias estruturas typedef customizadas para LDR_DATA_TABLE_ENTRY, PEB_LDR_DATA e PEB.

#include <stdio.h>
#include <stdint.h>
#include <windows.h>

typedef struct MY_PEB_LDR_DATA {
    ULONG Length;
    UCHAR Initialized;
    VOID* SsHandle;
    LIST_ENTRY InLoadOrderModuleList;
    // ... other fields
} MY_PEB_LDR_DATA, *MY_PPEB_LDR_DATA;

typedef struct MY_LDR_DATA_TABLE_ENTRY {
    LIST_ENTRY InLoadOrderLinks;
    LIST_ENTRY InMemoryOrderLinks;
    LIST_ENTRY InInitializationOrderLinks;
    PVOID DllBase;
    // ... other fields
} MY_LDR_DATA_TABLE_ENTRY, *MY_PLDR_DATA_TABLE_ENTRY;

typedef struct MY_PEB {
    BYTE Reserved1[2];
    BYTE BeingDebugged;
    BYTE Reserved2[1];
    PVOID Reserved3[2];
    MY_PPEB_LDR_DATA Ldr;
    // ... other fields
} MY_PEB, *MY_PPEB;

int main()
{
    MY_PPEB peb = (MY_PPEB)__readfsdword(0x30);
    uintptr_t kernel32Base = 0;

    // Order of modules loaded into the process: [image][ntdll][kernel32]
    // Skip first two entries as kernel32.dll is always the third entry.
    PLIST_ENTRY ptr = peb->Ldr->InLoadOrderModuleList.Flink->Flink->Flink;
    MY_PLDR_DATA_TABLE_ENTRY e = CONTAINING_RECORD(ptr, MY_LDR_DATA_TABLE_ENTRY, InLoadOrderLinks);
    kernel32Base = (uintptr_t)e->DllBase;

    printf("Kernel32.dll Base Address: 0x%p\n", (void*)kernel32Base);

    return 0;
}

Notas

InLoadOrderModuleListEsta lista contém os módulos na ordem em que foram carregados no processo. Normalmente, o próprio executável é a primeira entrada, seguido por DLLs importantes do sistema, como ntdll.dll e kernel32.dll.

InMemoryOrderModuleListEsta lista contém os módulos na ordem em que estão dispostos na memória. Não é necessariamente igual à ordem de carregamento, embora muitas vezes seja semelhante.

Estou curioso para saber qual método de cópia é mais eficiente para substrings grandes de MB.

Aqui está um exemplo de programa C++ com muitas maneiras de copiar uma substring de const char*para std::string, mas como determinar qual método é mais eficiente? Relacionado a Copiar uma substring de const char* para std::string .

Poderia avaliar todas essas maneiras possíveis, mas talvez falte um método melhor? Talvez existam documentos que indiquem quais evitar imediatamente, pois exigem cópias temporárias ineficientes de dados, etc., ...

Raio Deus

#include <iostream>
#include <sstream>
#include <string>

const char* str = "Hello World!";
const char* startOfWorld = str + 6;  // Pointing to "World!"
size_t length = 6;                   // Length of "World!"

void StoreWorldIntoString(std::string& result)
{
    result.assign(startOfWorld, length);

    // Slower methods...
    // result = std::string(startOfWorld, length);
    // result.replace(0, result.length(), startOfWorld, length);
    // result = std::string(startOfWorld, startOfWorld + length);
    // result.append(startOfWorld, length);
    // std::string fullString(str); result = fullString.substr(6, length);
    // result.insert(0, startOfWorld, length);
    // std::copy(startOfWorld, startOfWorld + length, std::back_inserter(result));
    // std::stringstream ss; ss.write(startOfWorld, length); result = ss.str();
}

int main()
{
    std::string result;
    StoreWorldIntoString(result);
    std::cout << result << std::endl;
    return 0;
}

O vencedor

Com base no benchmarking e nos comentários abaixo, o método mais eficiente é assign.

Fonte

Em um programa C multithread Windows/Linux, se uma unsigned intvariável global for acessada por três threads sem nenhuma sincronização, onde

• Thread 1 escreve o valor 0
• O thread 2 grava o valor 0xFFFFFFFF
• Thread 3 lê o valor

Pergunta

É possível que o Thread 3 recupere um valor parcial, digamos 0x0000FFFF da variável global?

Sempre presumi que, se um unsigned intestiver alinhado corretamente, uma operação de gravação é atômica; portanto, nesse caso, o Thread 3 sempre seria 0 ou 0xFFFFFFFF.

Atualmente olhando para operações atômicas em C/C++ usando GCC e descobri que variáveis ​​globais alinhadas naturalmente na memória têm leituras e gravações atômicas.

No entanto, eu estava tentando bitwise AND uma variável global e percebi que se resume a uma sequência de leitura-modificação-gravação que é problemática se houver vários threads operando naquele valor de byte.

Depois de algumas pesquisas, decidi por esses dois exemplos:

Exemplo C - extensão GCC__sync_fetch_and_and

#include <stdio.h>
#include <stdint.h>

uint8_t byteC = 0xFF;

int main() {
    __sync_fetch_and_and(&byteC, 0xF0);
    printf("Value of byteC: 0x%X\n", byteC);
    return 0;
}

Exemplo C++ - C++11 usando atômicofetch_and

#include <iostream>
#include <atomic>

std::atomic<uint8_t> byteCpp(0xFF);

int main() {
    byteCpp.fetch_and(0xF0);
    std::cout << "Value of byteCpp: 0x" << std::hex << static_cast<int>(byteCpp.load()) << std::endl;
    return 0;
}

Seguem outros exemplos, mas parecem menos intuitivos e mais caros computacionalmente.

Usando umpthread_mutex_lock

uint8_t byte = 0xFF;
pthread_mutex_t byte_mutex = PTHREAD_MUTEX_INITIALIZER;

pthread_mutex_lock(&byte_mutex);
byte &= 0xF0;
pthread_mutex_unlock(&byte_mutex);

Usando um mutexlock_guard

#include <mutex>

uint8_t byte;
std::mutex byte_mutex;

void atomic_and() {
    std::lock_guard<std::mutex> lock(byte_mutex);
    byte &= 0xF0;
}

Usando umcompare_exchange_weak

std::atomic<uint8_t> byte;

void atomic_and() {
    uint8_t old_val, new_val;
    do {
        old_val = byte.load();
        new_val = old_val & 0xF0;
    } while (!byte.compare_exchange_weak(old_val, new_val));
}

Pergunta

Qual é o melhor método atômico para uma sequência de leitura-modificação-gravação em um programa C/C++ multithread?