misc.cpp

// misc.cpp - originally written and placed in the public domain by Wei Dai
 
#include "pch.h"
#include "config.h"
 
#if CRYPTOPP_MSC_VERSION
# pragma warning(disable: 4189)
# if (CRYPTOPP_MSC_VERSION >= 1400)
#  pragma warning(disable: 6237)
# endif
#endif
 
#ifndef CRYPTOPP_IMPORTS
 
#include "misc.h"
#include "trap.h"
#include "words.h"
#include "stdcpp.h"
#include "integer.h"
#include "secblock.h"
 
// Hack for OpenBSD and GCC 4.2.1. I believe they are stuck at 4.2.1 due to GPLv3.
#if defined(__OpenBSD__)
# if defined (CRYPTOPP_GCC_VERSION) && (CRYPTOPP_GCC_VERSION < 43000)
#  undef  CRYPTOPP_DISABLE_ASM
#  define CRYPTOPP_DISABLE_ASM 1
# endif
#endif
 
#ifndef CRYPTOPP_DISABLE_ASM
# if defined(__SSE2__)
#  include <emmintrin.h>
# endif
# if defined(__AVX__)
#  include <immintrin.h>
# endif
 
# if defined(__aarch32__) || defined(__aarch64__) || defined(_M_ARM64)
#  if (CRYPTOPP_ARM_NEON_HEADER) || (CRYPTOPP_ARM_ASIMD_AVAILABLE)
#   include <arm_neon.h>
#  endif
# endif
#endif  // CRYPTOPP_DISABLE_ASM
 
NAMESPACE_BEGIN(CryptoPP)
 
byte* BytePtr(SecByteBlock& str)
{
    // Caller wants a writeable pointer
    CRYPTOPP_ASSERT(str.empty() == false);
 
    if (str.empty())
        return NULLPTR;
    return reinterpret_cast<byte*>(str.data());
}
 
const byte* ConstBytePtr(const SecByteBlock& str)
{
    if (str.empty())
        return NULLPTR;
    return reinterpret_cast<const byte*>(str.data());
}
 
size_t BytePtrSize(const SecByteBlock& str)
{
    return str.size();
}
 
// xorbuf simplified at https://github.com/weidai11/cryptopp/issues/1020
void xorbuf(byte *buf, const byte *mask, size_t count)
{
    CRYPTOPP_ASSERT(buf != NULLPTR);
    CRYPTOPP_ASSERT(mask != NULLPTR);
    CRYPTOPP_ASSERT(count > 0);
 
#ifndef CRYPTOPP_DISABLE_ASM
# if defined(__AVX__)
    while (count >= 32)
    {
        __m256i b = _mm256_loadu_si256(reinterpret_cast<const __m256i*>(buf));
        __m256i m = _mm256_loadu_si256(reinterpret_cast<const __m256i*>(mask));
        _mm256_storeu_si256(reinterpret_cast<__m256i*>(buf), _mm256_castps_si256(
            _mm256_xor_ps(_mm256_castsi256_ps(b), _mm256_castsi256_ps(m))));
        buf += 32; mask += 32; count -= 32;
    }
    // https://software.intel.com/en-us/articles/avoiding-avx-sse-transition-penalties
    _mm256_zeroupper();
# endif
# if defined(__SSE2__)
    while (count >= 16)
    {
        __m128i b = _mm_loadu_si128(reinterpret_cast<const __m128i*>(buf));
        __m128i m = _mm_loadu_si128(reinterpret_cast<const __m128i*>(mask));
        _mm_storeu_si128(reinterpret_cast<__m128i*>(buf), _mm_castps_si128(
            _mm_xor_ps(_mm_castsi128_ps(b), _mm_castsi128_ps(m))));
        buf += 16; mask += 16; count -= 16;
    }
# endif
# if defined(__aarch64__) || defined(__aarch32__) || defined(_M_ARM64)
    while (count >= 16)
    {
        vst1q_u8(buf, veorq_u8(vld1q_u8(buf), vld1q_u8(mask)));
        buf += 16; mask += 16; count -= 16;
    }
# endif
#endif  // CRYPTOPP_DISABLE_ASM
 
#if CRYPTOPP_BOOL_PPC32 || CRYPTOPP_BOOL_PPC64
    // word64 and stride of 8 slows things down on x86_64.
    // word64 and stride of 8 makes no difference on ARM.
    // word64 and stride of 16 benefits PowerPC.
    while (count >= 16)
    {
        word64 r[2], b[2], m[2];
        std::memcpy(&b, buf, 16); std::memcpy(&m, mask, 16);
 
        r[0] = b[0] ^ m[0];
        r[1] = b[1] ^ m[1];
        std::memcpy(buf, &r, 16);
 
        buf += 16; mask += 16; count -= 16;
    }
#endif
 
    // One of the arch specific xor's may have cleared the request
    if (count == 0) return;
 
    while (count >= 4)
    {
        word32 r, b, m;
        std::memcpy(&b, buf, 4); std::memcpy(&m, mask, 4);
 
        r = b ^ m;
        std::memcpy(buf, &r, 4);
 
        buf += 4; mask += 4; count -= 4;
    }
 
    for (size_t i=0; i<count; i++)
        buf[i] ^= mask[i];
}
 
// xorbuf simplified at https://github.com/weidai11/cryptopp/issues/1020
void xorbuf(byte *output, const byte *input, const byte *mask, size_t count)
{
    CRYPTOPP_ASSERT(output != NULLPTR);
    CRYPTOPP_ASSERT(input != NULLPTR);
    CRYPTOPP_ASSERT(count > 0);
 
#ifndef CRYPTOPP_DISABLE_ASM
# if defined(__AVX__)
    while (count >= 32)
    {
        __m256i b = _mm256_loadu_si256(reinterpret_cast<const __m256i*>(input));
        __m256i m = _mm256_loadu_si256(reinterpret_cast<const __m256i*>(mask));
        _mm256_storeu_si256(reinterpret_cast<__m256i*>(output), _mm256_castps_si256(
            _mm256_xor_ps(_mm256_castsi256_ps(b), _mm256_castsi256_ps(m))));
        output += 32; input += 32; mask += 32; count -= 32;
    }
    // https://software.intel.com/en-us/articles/avoiding-avx-sse-transition-penalties
    _mm256_zeroupper();
# endif
# if defined(__SSE2__)
    while (count >= 16)
    {
        __m128i b = _mm_loadu_si128(reinterpret_cast<const __m128i*>(input));
        __m128i m = _mm_loadu_si128(reinterpret_cast<const __m128i*>(mask));
        _mm_storeu_si128(reinterpret_cast<__m128i*>(output), _mm_castps_si128(
            _mm_xor_ps(_mm_castsi128_ps(b), _mm_castsi128_ps(m))));
        output += 16; input += 16; mask += 16; count -= 16;
    }
# endif
# if defined(__aarch64__) || defined(__aarch32__) || defined(_M_ARM64)
    while (count >= 16)
    {
        vst1q_u8(output, veorq_u8(vld1q_u8(input), vld1q_u8(mask)));
        output += 16; input += 16; mask += 16; count -= 16;
    }
# endif
#endif  // CRYPTOPP_DISABLE_ASM
 
#if CRYPTOPP_BOOL_PPC32 || CRYPTOPP_BOOL_PPC64
    // word64 and stride of 8 slows things down on x86_64.
    // word64 and stride of 8 makes no difference on ARM.
    // word64 and stride of 16 benefits PowerPC.
    while (count >= 16)
    {
        word64 b[2], m[2], r[2];
        std::memcpy(&b, input, 16); std::memcpy(&m, mask, 16);
 
        r[0] = b[0] ^ m[0];
        r[1] = b[1] ^ m[1];
        std::memcpy(output, &r, 16);
 
        output += 16; input += 16; mask += 16; count -= 16;
    }
#endif
 
    // One of the arch specific xor's may have cleared the request
    if (count == 0) return;
 
    while (count >= 4)
    {
        word32 b, m, r;
        std::memcpy(&b, input, 4); std::memcpy(&m, mask, 4);
 
        r = b ^ m;
        std::memcpy(output, &r, 4);
 
        output += 4; input += 4; mask += 4; count -= 4;
    }
 
    for (size_t i=0; i<count; i++)
        output[i] = input[i] ^ mask[i];
}
 
// VerifyBufsEqual simplified at https://github.com/weidai11/cryptopp/issues/1020
bool VerifyBufsEqual(const byte *buf, const byte *mask, size_t count)
{
    CRYPTOPP_ASSERT(buf != NULLPTR);
    CRYPTOPP_ASSERT(mask != NULLPTR);
    // CRYPTOPP_ASSERT(count > 0);
 
#if CRYPTOPP_BOOL_X64 || CRYPTOPP_BOOL_ARM64 || CRYPTOPP_BOOL_PPC64 || CRYPTOPP_BOOL_MIPS64 || CRYPTOPP_BOOL_SPARC64
    word64 acc64 = 0;
    while (count >= 8)
    {
        word64 b, m;
        std::memcpy(&b, buf, 8); std::memcpy(&m, mask, 8);
        acc64 |= b ^ m;
 
        buf += 8; mask += 8; count -= 8;
    }
 
    word32 acc8 = (acc64 >> 32) | (acc64 & 0xffffffff);
    acc8 = static_cast<byte>(acc8) | static_cast<byte>(acc8 >> 8) |
        static_cast<byte>(acc8 >> 16) | static_cast<byte>(acc8 >> 24);
#else
    word32 acc32 = 0;
    while (count >= 4)
    {
        word32 b, m;
        std::memcpy(&b, buf, 4); std::memcpy(&m, mask, 4);
        acc32 |= b ^ m;
 
        buf += 4; mask += 4; count -= 4;
    }
 
    word32 acc8 = acc32;
    acc8 = static_cast<byte>(acc8) | static_cast<byte>(acc8 >> 8) |
        static_cast<byte>(acc8 >> 16) | static_cast<byte>(acc8 >> 24);
#endif
 
    for (size_t i=0; i<count; i++)
        acc8 |= buf[i] ^ mask[i];
 
    // word32 results in this tail code on x86:
    //   33a:  85 c0     test  %eax, %eax
    //   33c:  0f 94 c0  sete  %al
    //   33f:  c3        ret
    return acc8 == 0;
}
 
std::string StringNarrow(const wchar_t *str, bool throwOnError)
{
    CRYPTOPP_ASSERT(str);
    std::string result;
 
    // Safer functions on Windows for C&A, https://github.com/weidai11/cryptopp/issues/55
#if (CRYPTOPP_MSC_VERSION >= 1400)
    size_t len=0, size=0;
    errno_t err = 0;
 
    //const wchar_t* ptr = str;
    //while (*ptr++) len++;
    len = wcslen(str)+1;
 
    err = wcstombs_s(&size, NULLPTR, 0, str, len*sizeof(wchar_t));
    CRYPTOPP_ASSERT(err == 0);
    if (err != 0)
    {
        if (throwOnError)
            throw InvalidArgument("StringNarrow: wcstombs_s() failed with error " + IntToString(err));
        else
            return std::string();
    }
 
    result.resize(size);
    err = wcstombs_s(&size, &result[0], size, str, len*sizeof(wchar_t));
    CRYPTOPP_ASSERT(err == 0);
    if (err != 0)
    {
        if (throwOnError)
            throw InvalidArgument("StringNarrow: wcstombs_s() failed with error " + IntToString(err));
        else
            return std::string();
    }
 
    // The safe routine's size includes the NULL.
    if (!result.empty() && result[size - 1] == '\0')
        result.erase(size - 1);
#else
    size_t size = wcstombs(NULLPTR, str, 0);
    CRYPTOPP_ASSERT(size != (size_t)-1);
    if (size == (size_t)-1)
    {
        if (throwOnError)
            throw InvalidArgument("StringNarrow: wcstombs() failed");
        else
            return std::string();
    }
 
    result.resize(size);
    size = wcstombs(&result[0], str, size);
    CRYPTOPP_ASSERT(size != (size_t)-1);
    if (size == (size_t)-1)
    {
        if (throwOnError)
            throw InvalidArgument("StringNarrow: wcstombs() failed");
        else
            return std::string();
    }
#endif
 
    return result;
}
 
std::wstring StringWiden(const char *str, bool throwOnError)
{
    CRYPTOPP_ASSERT(str);
    std::wstring result;
 
    // Safer functions on Windows for C&A, https://github.com/weidai11/cryptopp/issues/55
#if (CRYPTOPP_MSC_VERSION >= 1400)
    size_t len=0, size=0;
    errno_t err = 0;
 
    //const char* ptr = str;
    //while (*ptr++) len++;
    len = std::strlen(str)+1;
 
    err = mbstowcs_s(&size, NULLPTR, 0, str, len);
    CRYPTOPP_ASSERT(err == 0);
    if (err != 0)
    {
        if (throwOnError)
            throw InvalidArgument("StringWiden: wcstombs_s() failed with error " + IntToString(err));
        else
            return std::wstring();
    }
 
    result.resize(size);
    err = mbstowcs_s(&size, &result[0], size, str, len);
    CRYPTOPP_ASSERT(err == 0);
    if (err != 0)
    {
        if (throwOnError)
            throw InvalidArgument("StringWiden: wcstombs_s() failed with error " + IntToString(err));
        else
            return std::wstring();
    }
 
    // The safe routine's size includes the NULL.
    if (!result.empty() && result[size - 1] == '\0')
        result.erase(size - 1);
#else
    size_t size = mbstowcs(NULLPTR, str, 0);
    CRYPTOPP_ASSERT(size != (size_t)-1);
    if (size == (size_t)-1)
    {
        if (throwOnError)
            throw InvalidArgument("StringWiden: mbstowcs() failed");
        else
            return std::wstring();
    }
 
    result.resize(size);
    size = mbstowcs(&result[0], str, size);
    CRYPTOPP_ASSERT(size != (size_t)-1);
    if (size == (size_t)-1)
    {
        if (throwOnError)
            throw InvalidArgument("StringWiden: mbstowcs() failed");
        else
            return std::wstring();
    }
#endif
 
    return result;
}
 
NAMESPACE_END
 
#endif