Is there any way to building static Qt with static OpenSSL?

Building Static Qt with Static OpenSSL: A Comprehensive Guide

Learn the intricate process of compiling Qt statically with a statically linked OpenSSL, ensuring a self-contained and secure application deployment.

Building Qt applications with static linking offers significant advantages, primarily creating self-contained executables that do not rely on external shared libraries. This simplifies deployment and reduces potential dependency conflicts. When your Qt application requires network communication, OpenSSL is often a critical dependency for secure connections (HTTPS, SSL/TLS). This article provides a detailed guide on how to achieve a fully static build of Qt, including a statically linked OpenSSL, addressing common challenges and best practices.

Why Static Linking Qt with OpenSSL?

The primary motivation for static linking is deployment simplicity. A statically linked application bundles all its necessary libraries directly into the executable, eliminating the need to distribute separate DLLs (on Windows) or shared objects (on Linux/macOS). This is particularly beneficial for commercial applications, embedded systems, or scenarios where strict control over the deployment environment is required. For Qt applications using QtNetwork, OpenSSL provides the cryptographic backbone for secure communication protocols. Statically linking OpenSSL ensures that the correct version and configuration of the security library are always present with your application, preventing runtime issues related to missing or incompatible OpenSSL installations on target systems.

flowchart TD
    A[Start] --> B{Download Qt Source}
    B --> C{Download OpenSSL Source}
    C --> D{Configure & Build Static OpenSSL}
    D --> E{Configure Static Qt with OpenSSL Path}
    E --> F{Build Static Qt}
    F --> G{Build Qt Application}
    G --> H[End: Self-Contained Executable]

High-level workflow for building static Qt with static OpenSSL

Prerequisites and Environment Setup

Before embarking on the build process, ensure you have the necessary tools and source code. This typically includes a C++ compiler (MSVC on Windows, GCC/Clang on Linux/macOS), Perl (required by OpenSSL's build system), and the source code for both Qt and OpenSSL. It's crucial to use compatible versions of Qt and OpenSSL. For example, Qt 5.x might work best with OpenSSL 1.1.1, while Qt 6.x might prefer OpenSSL 3.x. Always check the Qt documentation for recommended OpenSSL versions.

Key considerations for your build environment:

• Compiler: Use the same compiler for OpenSSL and Qt to avoid ABI incompatibilities.
• Perl: OpenSSL's Configure script relies on Perl. Ensure it's installed and accessible in your PATH.
• Directory Structure: Organize your source code and build directories logically to prevent path issues.

Step-by-Step Build Process

The process involves building OpenSSL statically first, and then configuring Qt to use this statically built OpenSSL. This ensures that Qt's QtNetwork module can link against the static OpenSSL libraries.

1. Build Static OpenSSL

Navigate to your OpenSSL source directory. The configuration and build steps vary slightly by OS.

On Windows (MSVC): Open a Visual Studio Developer Command Prompt.

perl Configure no-shared no-zlib no-asm --prefix=C:/OpenSSL-static VC-WIN64A
nmake
nmake install

On Linux/macOS:

./config no-shared no-zlib no-asm --prefix=/usr/local/openssl-static
make
make install

• no-shared: Crucial for a static build.
• no-zlib: Prevents linking against zlib, which might also need to be static.
• no-asm: Disables assembly optimizations, which can sometimes cause issues with static linking on certain platforms.
• --prefix: Specifies the installation directory for the static OpenSSL libraries and headers.

2. Configure and Build Static Qt

Navigate to your Qt source directory. The configuration step is critical for telling Qt where to find the static OpenSSL.

./configure -static -prefix C:/Qt/Static/5.15.2 -release -openssl-linked -I C:/OpenSSL-static/include -L C:/OpenSSL-static/lib -l ssleay32 -l libeay32 -nomake examples -nomake tests -skip qtwebengine

Explanation of key Qt configure options:

• -static: Enables static linking for Qt itself.
• -prefix: Specifies the installation path for the static Qt build.
• -release: Builds only release versions of libraries.
• -openssl-linked: Informs Qt to use a pre-built OpenSSL.
• -I C:/OpenSSL-static/include: Specifies the include path for OpenSSL headers.
• -L C:/OpenSSL-static/lib: Specifies the library path for OpenSSL static libraries.
• -l ssleay32 -l libeay32 (Windows) or -l ssl -l crypto (Linux/macOS): Explicitly links against the static OpenSSL libraries. Note the library names might vary slightly based on OpenSSL version and OS.
• -nomake examples -nomake tests: Skips building examples and tests, speeding up the build process.
• -skip qtwebengine: Skips modules like qtwebengine which are notoriously difficult to build statically.

After successful configuration, proceed with the build:

nmake (on Windows)
make -jN (on Linux/macOS, where N is number of cores)
nmake install (on Windows)
make install (on Linux/macOS)

This process can take several hours depending on your system and the number of Qt modules you're building.

Building Your Qt Application

Once you have a statically built Qt with static OpenSSL, you need to configure your Qt project (.pro file) to use this new Qt version. The simplest way is to use the Qt Creator kit configured with your static Qt build. Alternatively, you can manually specify the qmake path.

In your .pro file, ensure you include the network module:

QT += core gui network

When building your application, qmake will automatically pick up the static OpenSSL dependencies that were configured into your static Qt build. The resulting executable will be self-contained, including all necessary Qt and OpenSSL components.

#include <QCoreApplication>
#include <QNetworkAccessManager>
#include <QNetworkRequest>
#include <QNetworkReply>
#include <QUrl>
#include <QDebug>

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);

    QNetworkAccessManager manager;
    QObject::connect(&manager, &QNetworkAccessManager::finished,
                     [&](QNetworkReply *reply) {
        if (reply->error() == QNetworkReply::NoError) {
            qDebug() << "SSL connection successful!";
            qDebug() << reply->readAll();
        } else {
            qDebug() << "SSL Error:" << reply->errorString();
        }
        reply->deleteLater();
        a.quit();
    });

    QNetworkRequest request(QUrl("https://www.google.com"));
    manager.get(request);

    return a.exec();
}

Example Qt application using QNetworkAccessManager to test SSL connectivity