Merge branch 'mbedtls'

Replace Crypto++ 5.6.2 with Mbed TLS 3.6.0

Newer compilers are starting to show the age of the crypto library we've
been using, as it is sometimes a pain to recompile compass lately.  So,
the tracked version of Crypto++ was at least due for an upgrade.

However, I plan to soon begin reimplementing compass in C.  So, I'm
taking this opportunity to first just migrate the cryptography library
to a newer C alternative.  This branch does so, and integrates its use
into the current C++ version of compass.

* mbedtls:
  Remove unnecessary exception handler catch block
  Refactor random password generation to use mbedtls entropy source
  Refactor SHA256 function to use mbedtls
  Refactor AES functions to use mbedtls
  Add Mbedtls library
  Remove Crypto++ library

1 files changed, 0 insertions, 531 deletions

diff --git a/cryptopp562/socketft.cpp b/cryptopp562/socketft.cpp
deleted file mode 100644
index 6c5a8ff..0000000
--- a/cryptopp562/socketft.cpp
+++ /dev/null
@@ -1,531 +0,0 @@
-// socketft.cpp - written and placed in the public domain by Wei Dai
-
-#include "pch.h"
-#include "socketft.h"
-
-#ifdef SOCKETS_AVAILABLE
-
-#include "wait.h"
-
-#ifdef USE_BERKELEY_STYLE_SOCKETS
-#include <errno.h>
-#include <netdb.h>
-#include <unistd.h>
-#include <arpa/inet.h>
-#include <netinet/in.h>
-#include <sys/ioctl.h>
-#endif
-
-NAMESPACE_BEGIN(CryptoPP)
-
-#ifdef USE_WINDOWS_STYLE_SOCKETS
-const int SOCKET_EINVAL = WSAEINVAL;
-const int SOCKET_EWOULDBLOCK = WSAEWOULDBLOCK;
-typedef int socklen_t;
-#else
-const int SOCKET_EINVAL = EINVAL;
-const int SOCKET_EWOULDBLOCK = EWOULDBLOCK;
-#endif
-
-Socket::Err::Err(socket_t s, const std::string& operation, int error)
-	: OS_Error(IO_ERROR, "Socket: " + operation + " operation failed with error " + IntToString(error), operation, error)
-	, m_s(s)
-{
-}
-
-Socket::~Socket()
-{
-	if (m_own)
-	{
-		try
-		{
-			CloseSocket();
-		}
-		catch (...)
-		{
-		}
-	}
-}
-
-void Socket::AttachSocket(socket_t s, bool own)
-{
-	if (m_own)
-		CloseSocket();
-
-	m_s = s;
-	m_own = own;
-	SocketChanged();
-}
-
-socket_t Socket::DetachSocket()
-{
-	socket_t s = m_s;
-	m_s = INVALID_SOCKET;
-	SocketChanged();
-	return s;
-}
-
-void Socket::Create(int nType)
-{
-	assert(m_s == INVALID_SOCKET);
-	m_s = socket(AF_INET, nType, 0);
-	CheckAndHandleError("socket", m_s);
-	m_own = true;
-	SocketChanged();
-}
-
-void Socket::CloseSocket()
-{
-	if (m_s != INVALID_SOCKET)
-	{
-#ifdef USE_WINDOWS_STYLE_SOCKETS
-		CancelIo((HANDLE) m_s);
-		CheckAndHandleError_int("closesocket", closesocket(m_s));
-#else
-		CheckAndHandleError_int("close", close(m_s));
-#endif
-		m_s = INVALID_SOCKET;
-		SocketChanged();
-	}
-}
-
-void Socket::Bind(unsigned int port, const char *addr)
-{
-	sockaddr_in sa;
-	memset(&sa, 0, sizeof(sa));
-	sa.sin_family = AF_INET;
-
-	if (addr == NULL)
-		sa.sin_addr.s_addr = htonl(INADDR_ANY);
-	else
-	{
-		unsigned long result = inet_addr(addr);
-		if (result == -1)	// Solaris doesn't have INADDR_NONE
-		{
-			SetLastError(SOCKET_EINVAL);
-			CheckAndHandleError_int("inet_addr", SOCKET_ERROR);
-		}
-		sa.sin_addr.s_addr = result;
-	}
-
-	sa.sin_port = htons((u_short)port);
-
-	Bind((sockaddr *)&sa, sizeof(sa));
-}
-
-void Socket::Bind(const sockaddr *psa, socklen_t saLen)
-{
-	assert(m_s != INVALID_SOCKET);
-	// cygwin workaround: needs const_cast
-	CheckAndHandleError_int("bind", bind(m_s, const_cast<sockaddr *>(psa), saLen));
-}
-
-void Socket::Listen(int backlog)
-{
-	assert(m_s != INVALID_SOCKET);
-	CheckAndHandleError_int("listen", listen(m_s, backlog));
-}
-
-bool Socket::Connect(const char *addr, unsigned int port)
-{
-	assert(addr != NULL);
-
-	sockaddr_in sa;
-	memset(&sa, 0, sizeof(sa));
-	sa.sin_family = AF_INET;
-	sa.sin_addr.s_addr = inet_addr(addr);
-
-	if (sa.sin_addr.s_addr == -1)	// Solaris doesn't have INADDR_NONE
-	{
-		hostent *lphost = gethostbyname(addr);
-		if (lphost == NULL)
-		{
-			SetLastError(SOCKET_EINVAL);
-			CheckAndHandleError_int("gethostbyname", SOCKET_ERROR);
-		}
-
-		sa.sin_addr.s_addr = ((in_addr *)lphost->h_addr)->s_addr;
-	}
-
-	sa.sin_port = htons((u_short)port);
-
-	return Connect((const sockaddr *)&sa, sizeof(sa));
-}
-
-bool Socket::Connect(const sockaddr* psa, socklen_t saLen)
-{
-	assert(m_s != INVALID_SOCKET);
-	int result = connect(m_s, const_cast<sockaddr*>(psa), saLen);
-	if (result == SOCKET_ERROR && GetLastError() == SOCKET_EWOULDBLOCK)
-		return false;
-	CheckAndHandleError_int("connect", result);
-	return true;
-}
-
-bool Socket::Accept(Socket& target, sockaddr *psa, socklen_t *psaLen)
-{
-	assert(m_s != INVALID_SOCKET);
-	socket_t s = accept(m_s, psa, psaLen);
-	if (s == INVALID_SOCKET && GetLastError() == SOCKET_EWOULDBLOCK)
-		return false;
-	CheckAndHandleError("accept", s);
-	target.AttachSocket(s, true);
-	return true;
-}
-
-void Socket::GetSockName(sockaddr *psa, socklen_t *psaLen)
-{
-	assert(m_s != INVALID_SOCKET);
-	CheckAndHandleError_int("getsockname", getsockname(m_s, psa, psaLen));
-}
-
-void Socket::GetPeerName(sockaddr *psa, socklen_t *psaLen)
-{
-	assert(m_s != INVALID_SOCKET);
-	CheckAndHandleError_int("getpeername", getpeername(m_s, psa, psaLen));
-}
-
-unsigned int Socket::Send(const byte* buf, size_t bufLen, int flags)
-{
-	assert(m_s != INVALID_SOCKET);
-	int result = send(m_s, (const char *)buf, UnsignedMin(INT_MAX, bufLen), flags);
-	CheckAndHandleError_int("send", result);
-	return result;
-}
-
-unsigned int Socket::Receive(byte* buf, size_t bufLen, int flags)
-{
-	assert(m_s != INVALID_SOCKET);
-	int result = recv(m_s, (char *)buf, UnsignedMin(INT_MAX, bufLen), flags);
-	CheckAndHandleError_int("recv", result);
-	return result;
-}
-
-void Socket::ShutDown(int how)
-{
-	assert(m_s != INVALID_SOCKET);
-	int result = shutdown(m_s, how);
-	CheckAndHandleError_int("shutdown", result);
-}
-
-void Socket::IOCtl(long cmd, unsigned long *argp)
-{
-	assert(m_s != INVALID_SOCKET);
-#ifdef USE_WINDOWS_STYLE_SOCKETS
-	CheckAndHandleError_int("ioctlsocket", ioctlsocket(m_s, cmd, argp));
-#else
-	CheckAndHandleError_int("ioctl", ioctl(m_s, cmd, argp));
-#endif
-}
-
-bool Socket::SendReady(const timeval *timeout)
-{
-	fd_set fds;
-	FD_ZERO(&fds);
-	FD_SET(m_s, &fds);
-	int ready;
-	if (timeout == NULL)
-		ready = select((int)m_s+1, NULL, &fds, NULL, NULL);
-	else
-	{
-		timeval timeoutCopy = *timeout;	// select() modified timeout on Linux
-		ready = select((int)m_s+1, NULL, &fds, NULL, &timeoutCopy);
-	}
-	CheckAndHandleError_int("select", ready);
-	return ready > 0;
-}
-
-bool Socket::ReceiveReady(const timeval *timeout)
-{
-	fd_set fds;
-	FD_ZERO(&fds);
-	FD_SET(m_s, &fds);
-	int ready;
-	if (timeout == NULL)
-		ready = select((int)m_s+1, &fds, NULL, NULL, NULL);
-	else
-	{
-		timeval timeoutCopy = *timeout;	// select() modified timeout on Linux
-		ready = select((int)m_s+1, &fds, NULL, NULL, &timeoutCopy);
-	}
-	CheckAndHandleError_int("select", ready);
-	return ready > 0;
-}
-
-unsigned int Socket::PortNameToNumber(const char *name, const char *protocol)
-{
-	int port = atoi(name);
-	if (IntToString(port) == name)
-		return port;
-
-	servent *se = getservbyname(name, protocol);
-	if (!se)
-		throw Err(INVALID_SOCKET, "getservbyname", SOCKET_EINVAL);
-	return ntohs(se->s_port);
-}
-
-void Socket::StartSockets()
-{
-#ifdef USE_WINDOWS_STYLE_SOCKETS
-	WSADATA wsd;
-	int result = WSAStartup(0x0202, &wsd);
-	if (result != 0)
-		throw Err(INVALID_SOCKET, "WSAStartup", result);
-#endif
-}
-
-void Socket::ShutdownSockets()
-{
-#ifdef USE_WINDOWS_STYLE_SOCKETS
-	int result = WSACleanup();
-	if (result != 0)
-		throw Err(INVALID_SOCKET, "WSACleanup", result);
-#endif
-}
-
-int Socket::GetLastError()
-{
-#ifdef USE_WINDOWS_STYLE_SOCKETS
-	return WSAGetLastError();
-#else
-	return errno;
-#endif
-}
-
-void Socket::SetLastError(int errorCode)
-{
-#ifdef USE_WINDOWS_STYLE_SOCKETS
-	WSASetLastError(errorCode);
-#else
-	errno = errorCode;
-#endif
-}
-
-void Socket::HandleError(const char *operation) const
-{
-	int err = GetLastError();
-	throw Err(m_s, operation, err);
-}
-
-#ifdef USE_WINDOWS_STYLE_SOCKETS
-
-SocketReceiver::SocketReceiver(Socket &s)
-	: m_s(s), m_resultPending(false), m_eofReceived(false)
-{
-	m_event.AttachHandle(CreateEvent(NULL, true, false, NULL), true);
-	m_s.CheckAndHandleError("CreateEvent", m_event.HandleValid());
-	memset(&m_overlapped, 0, sizeof(m_overlapped));
-	m_overlapped.hEvent = m_event;
-}
-
-SocketReceiver::~SocketReceiver()
-{
-#ifdef USE_WINDOWS_STYLE_SOCKETS
-	CancelIo((HANDLE) m_s.GetSocket());
-#endif
-}
-
-bool SocketReceiver::Receive(byte* buf, size_t bufLen)
-{
-	assert(!m_resultPending && !m_eofReceived);
-
-	DWORD flags = 0;
-	// don't queue too much at once, or we might use up non-paged memory
-	WSABUF wsabuf = {UnsignedMin((u_long)128*1024, bufLen), (char *)buf};
-	if (WSARecv(m_s, &wsabuf, 1, &m_lastResult, &flags, &m_overlapped, NULL) == 0)
-	{
-		if (m_lastResult == 0)
-			m_eofReceived = true;
-	}
-	else
-	{
-		switch (WSAGetLastError())
-		{
-		default:
-			m_s.CheckAndHandleError_int("WSARecv", SOCKET_ERROR);
-		case WSAEDISCON:
-			m_lastResult = 0;
-			m_eofReceived = true;
-			break;
-		case WSA_IO_PENDING:
-			m_resultPending = true;
-		}
-	}
-	return !m_resultPending;
-}
-
-void SocketReceiver::GetWaitObjects(WaitObjectContainer &container, CallStack const& callStack)
-{
-	if (m_resultPending)
-		container.AddHandle(m_event, CallStack("SocketReceiver::GetWaitObjects() - result pending", &callStack));
-	else if (!m_eofReceived)
-		container.SetNoWait(CallStack("SocketReceiver::GetWaitObjects() - result ready", &callStack));
-}
-
-unsigned int SocketReceiver::GetReceiveResult()
-{
-	if (m_resultPending)
-	{
-		DWORD flags = 0;
-		if (WSAGetOverlappedResult(m_s, &m_overlapped, &m_lastResult, false, &flags))
-		{
-			if (m_lastResult == 0)
-				m_eofReceived = true;
-		}
-		else
-		{
-			switch (WSAGetLastError())
-			{
-			default:
-				m_s.CheckAndHandleError("WSAGetOverlappedResult", FALSE);
-			case WSAEDISCON:
-				m_lastResult = 0;
-				m_eofReceived = true;
-			}
-		}
-		m_resultPending = false;
-	}
-	return m_lastResult;
-}
-
-// *************************************************************
-
-SocketSender::SocketSender(Socket &s)
-	: m_s(s), m_resultPending(false), m_lastResult(0)
-{
-	m_event.AttachHandle(CreateEvent(NULL, true, false, NULL), true);
-	m_s.CheckAndHandleError("CreateEvent", m_event.HandleValid());
-	memset(&m_overlapped, 0, sizeof(m_overlapped));
-	m_overlapped.hEvent = m_event;
-}
-
-
-SocketSender::~SocketSender()
-{
-#ifdef USE_WINDOWS_STYLE_SOCKETS
-	CancelIo((HANDLE) m_s.GetSocket());
-#endif
-}
-
-void SocketSender::Send(const byte* buf, size_t bufLen)
-{
-	assert(!m_resultPending);
-	DWORD written = 0;
-	// don't queue too much at once, or we might use up non-paged memory
-	WSABUF wsabuf = {UnsignedMin((u_long)128*1024, bufLen), (char *)buf};
-	if (WSASend(m_s, &wsabuf, 1, &written, 0, &m_overlapped, NULL) == 0)
-	{
-		m_resultPending = false;
-		m_lastResult = written;
-	}
-	else
-	{
-		if (WSAGetLastError() != WSA_IO_PENDING)
-			m_s.CheckAndHandleError_int("WSASend", SOCKET_ERROR);
-
-		m_resultPending = true;
-	}
-}
-
-void SocketSender::SendEof()
-{
-	assert(!m_resultPending);
-	m_s.ShutDown(SD_SEND);
-	m_s.CheckAndHandleError("ResetEvent", ResetEvent(m_event));
-	m_s.CheckAndHandleError_int("WSAEventSelect", WSAEventSelect(m_s, m_event, FD_CLOSE));
-	m_resultPending = true;
-}
-
-bool SocketSender::EofSent()
-{
-	if (m_resultPending)
-	{
-		WSANETWORKEVENTS events;
-		m_s.CheckAndHandleError_int("WSAEnumNetworkEvents", WSAEnumNetworkEvents(m_s, m_event, &events));
-		if ((events.lNetworkEvents & FD_CLOSE) != FD_CLOSE)
-			throw Socket::Err(m_s, "WSAEnumNetworkEvents (FD_CLOSE not present)", E_FAIL);
-		if (events.iErrorCode[FD_CLOSE_BIT] != 0)
-			throw Socket::Err(m_s, "FD_CLOSE (via WSAEnumNetworkEvents)", events.iErrorCode[FD_CLOSE_BIT]);
-		m_resultPending = false;
-	}
-	return m_lastResult != 0;
-}
-
-void SocketSender::GetWaitObjects(WaitObjectContainer &container, CallStack const& callStack)
-{
-	if (m_resultPending)
-		container.AddHandle(m_event, CallStack("SocketSender::GetWaitObjects() - result pending", &callStack));
-	else
-		container.SetNoWait(CallStack("SocketSender::GetWaitObjects() - result ready", &callStack));
-}
-
-unsigned int SocketSender::GetSendResult()
-{
-	if (m_resultPending)
-	{
-		DWORD flags = 0;
-		BOOL result = WSAGetOverlappedResult(m_s, &m_overlapped, &m_lastResult, false, &flags);
-		m_s.CheckAndHandleError("WSAGetOverlappedResult", result);
-		m_resultPending = false;
-	}
-	return m_lastResult;
-}
-
-#endif
-
-#ifdef USE_BERKELEY_STYLE_SOCKETS
-
-SocketReceiver::SocketReceiver(Socket &s)
-	: m_s(s), m_lastResult(0), m_eofReceived(false)
-{
-}
-
-void SocketReceiver::GetWaitObjects(WaitObjectContainer &container, CallStack const& callStack)
-{
-	if (!m_eofReceived)
-		container.AddReadFd(m_s, CallStack("SocketReceiver::GetWaitObjects()", &callStack));
-}
-
-bool SocketReceiver::Receive(byte* buf, size_t bufLen)
-{
-	m_lastResult = m_s.Receive(buf, bufLen);
-	if (bufLen > 0 && m_lastResult == 0)
-		m_eofReceived = true;
-	return true;
-}
-
-unsigned int SocketReceiver::GetReceiveResult()
-{
-	return m_lastResult;
-}
-
-SocketSender::SocketSender(Socket &s)
-	: m_s(s), m_lastResult(0)
-{
-}
-
-void SocketSender::Send(const byte* buf, size_t bufLen)
-{
-	m_lastResult = m_s.Send(buf, bufLen);
-}
-
-void SocketSender::SendEof()
-{
-	m_s.ShutDown(SD_SEND);
-}
-
-unsigned int SocketSender::GetSendResult()
-{
-	return m_lastResult;
-}
-
-void SocketSender::GetWaitObjects(WaitObjectContainer &container, CallStack const& callStack)
-{
-	container.AddWriteFd(m_s, CallStack("SocketSender::GetWaitObjects()", &callStack));
-}
-
-#endif
-
-NAMESPACE_END
-
-#endif	// #ifdef SOCKETS_AVAILABLE