crypto.h

/*
    ​​​​SPDX-License-Identifier: GPL-3.0-or-later
    Copyright © 2016-2022 Amebis
    Copyright © 2016 GÉANT
*/
 
#pragma once
 
#include "common.h"
 
#include <codeanalysis\warnings.h>
#pragma warning(push)
#pragma warning(disable: WXWIDGETS_CODE_ANALYSIS_WARNINGS)
#include <wx/buffer.h>
#include <wx/ffile.h>
#include <wx/log.h>
#include <wx/string.h>
#pragma warning(pop)
 
#include <Wincrypt.h>
 
 
class WXEXTEND_API wxCryptoSession
{
protected:
    HCRYPTPROV m_h; 
 
public:
    wxCryptoSession();
 
 
    virtual ~wxCryptoSession();
 
 
    inline bool IsOk() const noexcept
    {
        return m_h != NULL;
    }
 
 
    inline operator HCRYPTPROV() const noexcept
    {
        return m_h;
    }
};
 
 
class WXEXTEND_API wxCryptoSessionRSAAES : public wxCryptoSession
{
public:
    wxCryptoSessionRSAAES();
};
 
 
class WXEXTEND_API wxCryptoHash
{
protected:
    HCRYPTHASH m_h; 
 
public:
    wxCryptoHash();
 
 
    virtual ~wxCryptoHash();
 
 
    inline bool IsOk() const noexcept
    {
        return m_h != NULL;
    }
 
 
    inline operator HCRYPTHASH() const noexcept
    {
        return m_h;
    }
 
 
    _Success_(return != 0) bool Hash(_In_reads_bytes_(size) const void *data, _In_ size_t size);
 
 
    inline _Success_(return != 0) bool Hash(_In_ const wxMemoryBuffer &data)
    {
        return Hash(data.GetData(), data.GetDataLen());
    }
 
 
    inline _Success_(return != 0) bool HashAsUTF8(_In_ const wxString &str)
    {
        const wxScopedCharBuffer buf(str.ToUTF8());
        return Hash(buf.data(), buf.length());
    }
 
 
    inline _Success_(return != 0) bool HashFile(_In_ const wxString &fileName)
    {
        wxFFile file(fileName, wxT("rb"));
        if (file.IsOpened()) {
            wxMemoryBuffer buf(4*1024);
            void *data = buf.GetData();
            const size_t nBlock = buf.GetBufSize();
            while (!file.Eof())
                Hash(data, file.Read(data, nBlock));
 
            return true;
        } else {
            wxLogError(wxT("Can not open %s file for reading."), fileName);
            return false;
        }
    }
 
 
    virtual _Success_(return != 0) bool GetValue(_Out_ wxMemoryBuffer &hash);
 
 
    _Success_(return != 0) bool Sign(_Inout_ wxMemoryBuffer &signature);
 
 
    inline wxMemoryBuffer Sign()
    {
        wxMemoryBuffer signature;
        wxVERIFY(Sign(signature));
        return signature;
    }
};
 
 
class WXEXTEND_API wxCryptoHashSHA1 : public wxCryptoHash
{
public:
    wxCryptoHashSHA1(wxCryptoSession &session);
 
 
    virtual _Success_(return != 0) bool GetValue(_Out_ wxMemoryBuffer &hash);
};
 
 
#if (NTDDI_VERSION > NTDDI_WINXPSP2)
 
class WXEXTEND_API wxCryptoHashSHA256 : public wxCryptoHash
{
public:
    wxCryptoHashSHA256(wxCryptoSession &session);
 
 
    virtual _Success_(return != 0) bool GetValue(_Out_ wxMemoryBuffer &hash);
};
 
#endif
 
 
class WXEXTEND_API wxCryptoKey
{
protected:
    HCRYPTKEY m_h;  
 
public:
    wxCryptoKey();
 
 
    virtual ~wxCryptoKey();
 
 
    inline bool IsOk() const noexcept
    {
        return m_h != NULL;
    }
 
 
    inline operator HCRYPTKEY() const noexcept
    {
        return m_h;
    }
 
 
    _Success_(return != 0) bool ImportPrivate(_Inout_ wxCryptoSession &session, _In_reads_bytes_(size) const void *data, _In_ size_t size);
 
 
    _Success_(return != 0) bool ImportPublic(_Inout_ wxCryptoSession &session, _In_reads_bytes_(size) const void *data, _In_ size_t size);
};
 
 
_Success_(return != 0) bool WXEXTEND_API wxCryptoVerifySignature(_In_ const wxCryptoHash &hash, _In_reads_bytes_(signature_size) const void *signature_data, _In_ size_t signature_size, _In_ const wxCryptoKey &key);
 
 
inline _Success_(return != 0) bool wxCryptoVerifySignature(_In_ const wxCryptoHash &hash, _In_ const wxMemoryBuffer &signature, _In_ const wxCryptoKey &key)
{
    return wxCryptoVerifySignature(hash, signature.GetData(), signature.GetDataLen(), key);
}