unit OpenSSLAPI;

Classes

{$IFDEF WINDOWS} ,windows {$ENDIF}

{$IFDEF FPC}

,ctypes

{$IFDEF UNIX}

, UnixType, BaseUnix

{$ENDIF}

{$ENDIF}

, SysUtils;

{$IFDEF OPENSSL_USE_SHARED_LIBRARY}

{$MESSAGE Error. Static and Shared Link Models cannot be requested at the same time!}

{$ENDIF}

{$IFNDEF OPENSSL_STATIC_LINK_MODEL}

OpenSSL_Using_Dynamic_Library_Load = true;

{$ENDIF}

{$IFDEF OPENSSL_USE_SHARED_LIBRARY}

OpenSSL_Using_Shared_Library = true;

{$ENDIF}

{The default SSLLibraryPath is empty. You can override this by setting the

OpenSSLLibraryPath = 'OPENSSL_LIBRARY_PATH'; {environment variable name}

{$IFNDEF OPENSSL_NO_MIN_VERSION}

min_supported_ssl_version = ((((((byte(1) shl 8) + byte(0)) shl 8) + byte (0)) shl 8) + byte(0)) shl 4; {1.0.0}

{$ELSE}

min_supported_ssl_version = 0;

{$ENDIF}

CLibCryptoBase = 'libcrypto';

CLibSSLBase = 'libssl';

{The following lists are used when trying to locate the libcrypto and libssl libraries.

{$IFDEF OPENSSL_USE_STATIC_LIBRARY}

CLibCrypto = '';

CLibSSL = '';

{$IFDEF FPC}

{$LINKLIB ssl.a}

{$LINKLIB crypto.a}

{$ENDIF}

{$ENDIF}

{$IFDEF OPENSSL_USE_SHARED_LIBRARY}

{$IFDEF UNIX}

CLibCrypto = 'crypto';

CLibSSL = 'ssl';

{$ENDIF}

{$IFDEF WINDOWS}

{$IFDEF CPU64}

CLibCrypto = 'libcrypto-3-x64.dll';

CLibSSL = 'libssl-3-x64.dll';

{$ENDIF}

{$IFDEF CPU32}

CLibCrypto = 'libcrypto-3.dll';

CLibSSL = 'libssl-3.dll';

{$ENDIF}

{$ENDIF}

{$ENDIF}

{$IFDEF UNIX}

DirListDelimiter = ':';

LibSuffix = '.so';

DefaultLibVersions = ':.3:.1.1:.1.0.2:.1.0.0:.0.9.9:.0.9.8:.0.9.7:.0.9.6';

{$ENDIF}

{$IFDEF WINDOWS}

DirListDelimiter = ';';

LibSuffix = '';

LegacyLibCrypto = 'libeay32';

LegacyLibssl = 'ssleay32';

{$IFDEF CPU64}

DefaultLibVersions = '-3-x64;-1-x64';

{$ENDIF}

{$IFDEF CPU32}

DefaultLibVersions = '-3;-1';

{$ENDIF}

{$ENDIF}

TLibHandle = THandle;

NilHandle = TLibHandle(0);

{$IFDEF WINDOWS}

const LineEnding = #$0D#$0A;

{$ELSE}

const LineEnding = #$0A;

{$ENDIF}

{$IFDEF POSIX}

const DirectorySeparator = '/';

{$ELSE}

DirectorySeparator = '\';

{$ENDIF}

{$IFDEF FPC}

TOpenSSL_C_LONG = cLong;

TOpenSSL_C_ULONG = cuLong;

TOpenSSL_C_INT = cInt;

TOpenSSL_C_UINT = cuInt;

TOpenSSL_C_INT64 = cint64;

TOpenSSL_C_SHORT = cshort;

TOpenSSL_C_UINT8 = cuint8;

TOpenSSL_C_UINT16 = cuint16;

TOpenSSL_C_UINT32 = cuint32;

TOpenSSL_C_UINT64 = cuint64;

TOpenSSL_C_USHORT = cushort;

TOpenSSL_C_DOUBLE = cdouble;

{$if declared(size_t)}

TOpenSSL_C_SIZET = size_t;

{$else}

{$if declared(PtrUInt)}

TOpenSSL_C_SIZET = PtrUInt;

{$ELSE}

{$IFDEF CPU32}

TOpenSSL_C_SIZET = TOpenSSL_C_UINT32;

{$ENDIF}

{$IFDEF CPU64}

TOpenSSL_C_SIZET = TOpenSSL_C_UINT64;

{$ENDIF}

{$ifend}

{$ifend}

{$if declared(ssize_t)}

TOpenSSL_C_SSIZET = ssize_t;

{$ELSE}

{$if declared(PtrInt)}

TOpenSSL_C_SSIZET = PtrInt;

{$ELSE}

{$IFDEF CPU32}

TOpenSSL_C_SSIZET = TOpenSSL_C_INT32;

{$ENDIF}

{$IFDEF CPU64}

TOpenSSL_C_SSIZET = TOpenSSL_C_INT64;

{$ENDIF}

{$ifend}

{$ifend}

{$if declared(time_t))}

TOpenSSL_C_TIMET = time_t;

{$ELSE}

{$if declared(PtrInt)}

TOpenSSL_C_TIMET = PtrInt;

{$ELSE}

{$IFDEF CPU32}

TOpenSSL_C_TIMET = TOpenSSL_C_INT32;

{$ENDIF}

{$IFDEF CPU64}

TOpenSSL_C_TIMET = TOpenSSL_C_INT64;

{$ENDIF}

{$ifend}

{$ifend}

PPByte = ^PByte;

PPPAnsiChar = ^PAnsiChar;

TOpenSSL_C_LONG = LongInt;

TOpenSSL_C_ULONG = LongWord;

TOpenSSL_C_INT = Integer;

TOpenSSL_C_UINT = Cardinal;

TOpenSSL_C_INT64 = Int64;

TOpenSSL_C_UINT8 = Byte;

TOpenSSL_C_UINT16 = SmallInt;

TOpenSSL_C_UINT32 = Cardinal;

TOpenSSL_C_UINT64 = UINT64;

TOpenSSL_C_SHORT = Smallint;

TOpenSSL_C_USHORT = Word;

TOpenSSL_C_DOUBLE = Double;

{$if declared(size_t)}

TOpenSSL_C_SIZET = size_t;

{$else}

{$if declared(NativeUInt)}

TOpenSSL_C_SIZET = NativeUInt;

{$else}

{$IFDEF CPU32}

TOpenSSL_C_SIZET = TOp/OpenSSLPackageSplitTake3enSSL_C_UINT32;

{$ENDIF}

{$IFDEF CPU64}

TOpenSSL_C_SIZET = TOpenSSL_C_UINT64;

{$ENDIF}

{$ifend}

{$ifend}

{$if declared(NativeInt)}

TOpenSSL_C_SSIZET = NativeInt;

{$ELSE}

{$IFDEF CPU32}

TOpenSSL_C_SSIZET = TOpenSSL_C_INT32;

{$ENDIF}

{$IFDEF CPU64}

TOpenSSL_C_SSIZET = TOpenSSL_C_INT64;

{$ENDIF}

{$ifend}

{$if declared(time_t))}

TOpenSSL_C_TIMET = time_t;

{$ELSE}

{$if declared(NativeInt)}

TOpenSSL_C_TIMET = NativeInt;

{$ELSE}

{$IFDEF CPU32}

TOpenSSL_C_TIMET = TOpenSSL_C_INT32;

{$ENDIF}

{$IFDEF CPU64}

TOpenSSL_C_TIMET = TOpenSSL_C_INT64;

{$ENDIF}

{$ifend}

{$ifend}

POpenSSL_C_LONG = ^TOpenSSL_C_LONG;

POpenSSL_C_ULONG = ^TOpenSSL_C_ULONG;

POpenSSL_C_INT = ^TOpenSSL_C_INT;

POpenSSL_C_INT64 = ^TOpenSSL_C_INT64;

POpenSSL_C_SIZET = ^TOpenSSL_C_SIZET;

POpenSSL_C_SSIZET = ^TOpenSSL_C_SSIZET;

POpenSSL_C_UINT = ^TOpenSSL_C_UINT;

POpenSSL_C_UINT8 = ^TOpenSSL_C_UINT8;

POpenSSL_C_UINT16 = ^TOpenSSL_C_UINT16;

POpenSSL_C_UINT32 = ^TOpenSSL_C_UINT32;

POpenSSL_C_UINT64 = ^TOpenSSL_C_UINT64;

POpenSSL_C_SHORT = ^TOpenSSL_C_SHORT;

POpenSSL_C_USHORT = ^TOpenSSL_C_USHORT;

POpenSSL_C_TIMET = ^TOpenSSL_C_TIMET ;

PPPByte = ^PPByte;

PPOpenSSL_C_INT = ^POpenSSL_C_INT;

POpenSSL_C_DOUBLE = ^TOpenSSL_C_DOUBLE;

TOpenSSL_C_TM = record

tm_sec: TOpenSSL_C_INT; (* seconds, range 0 to 59 *)

tm_min: TOpenSSL_C_INT; (* minutes, range 0 to 59 *)

tm_hour: TOpenSSL_C_INT; (* hours, range 0 to 23 *)

tm_mday: TOpenSSL_C_INT; (* day of the month, range 1 to 31 *)

tm_mon: TOpenSSL_C_INT; (* month, range 0 to 11 *)

tm_year: TOpenSSL_C_INT; (* The number of years since 1900 *)

tm_wday: TOpenSSL_C_INT; (* day of the week, range 0 to 6 *)

tm_yday: TOpenSSL_C_INT; (* day in the year, range 0 to 365 *)

tm_isdst: TOpenSSL_C_INT; (* daylight saving time *)

end;

POpenSSL_C_TM = ^TOpenSSL_C_TM;

PPOpenSSL_C_TM = ^POpenSSL_C_TM;

TOpenSSL_LinkModel = (lmDynamic, lmShared, lmStatic);

IOpenSSL = interface

['{aed66223-1700-4199-b1c5-8222648e8cd5}']

function GetOpenSSLPath: string;

function GetOpenSSLVersionStr: string;

function GetOpenSSLVersion: TOpenSSL_C_ULONG;

function GetLinkModel: TOpenSSL_LinkModel;

function Init: boolean;

end;

function GetIOpenSSL: IOpenSSL;

IOpenSSLDLL = interface(IOpenSSL)

['{1d6cd9e7-e656-4981-80d2-288b12a69306}']

procedure SetOpenSSLPath(const Value: string);

function GetSSLLibVersions: string;

procedure SetSSLLibVersions(AValue: string);

function GetSSLBaseLibName: string;

procedure SetSSLBaseLibName(AValue: string);

function GetCryptoBaseLibName: string;

procedure SetCryptoBaseLibName(AValue: string);

function GetAllowLegacyLibsFallback: boolean;

procedure SetAllowLegacyLibsFallback(AValue: boolean);

function GetLibCryptoHandle: TLibHandle;

function GetLibSSLHandle: TLibHandle;

function GetLibCryptoFilePath: string;

function GetLibSSLFilePath: string;

function GetFailedToLoadList: TStrings;

function Load: Boolean;

procedure Unload;

function IsLoaded: boolean;

property SSLLibVersions: string read GetSSLLibVersions write SetSSLLibVersions;

property SSLBaseLibame: string read GetSSLBaseLibName write SetSSLBaseLibName;

property CryptoBaseLibName: string read GetCryptoBaseLibName write SetCryptoBaseLibName;

property AllowLegacyLibsFallback: boolean read GetAllowLegacyLibsFallback write SetAllowLegacyLibsFallback;

end;

function GetIOpenSSLDDL: IOpenSSLDLL;

function LoadLibCryptoFunction(const AProcName: string): Pointer;

function LoadLibSSLFunction(const AProcName: string): Pointer;

TOpenSSLLoadProc = procedure(LibVersion: TOpenSSL_C_UINT; const AFailed: TStringList);

TOpenSSLUnloadProc = procedure;

procedure Register_SSLLoader(LoadProc: TOpenSSLLoadProc);

procedure Register_SSLUnloader(UnloadProc: TOpenSSLUnloadProc);

uses SyncObjs,

OpenSSL_ssl,

OpenSSL_crypto,

OpenSSLExceptionHandlers,

OpenSSLResourceStrings;

{ TOpenSSLProvider }

TOpenSSLStaticLibProvider = class(TInterfacedObject, IOpenSSL)

private

class var FOpenSSL: IOpenSSL;

private

FInitDone: boolean;

FThreadLock: TCriticalSection;

FOpenSSLPath: string;

public

constructor Create;

destructor Destroy; override;

property OpenSSLPath: string read FOpenSSLPath;

public

{IOpenSSL}

function GetOpenSSLPath: string; virtual;

function GetOpenSSLVersionStr: string; virtual;

function GetOpenSSLVersion: TOpenSSL_C_ULONG; virtual;

function GetLinkModel: TOpenSSL_LinkModel; virtual;

function Init: boolean; virtual;

end;

{$IFNDEF OPENSSL_STATIC_LINK_MODEL}

{ TOpenSSLDynamicLibProvider }

TOpenSSLDynamicLibProvider = class(TOpenSSLStaticLibProvider,IOpenSSLDLL)

private

class var FOpenSSLDDL: IOpenSSLDLL;

class var FLibLoadList: TList;

class var FUnLoadList: TList;

private

FLibCrypto: TLibHandle;

FLibSSL: TLibHandle;

FLibCryptoFilePath: string;

FLibSSLFilePath: string;

FFailed: TStringList;

FSSLLibVersions: string;

FFailedToLoad: boolean;

FSSLBaseLibName: string;

FCryptoBaseLibName: string;

FAllowLegacyLibsFallback: boolean;

function FindLibrary(LibName, LibVersions: string; var FilePath: string): TLibHandle;

public

constructor Create;

destructor Destroy; override;

{IOpenSSL}

function GetOpenSSLPath: string; override;

function GetOpenSSLVersionStr: string; override;

function GetOpenSSLVersion: TOpenSSL_C_ULONG; override;

function GetLinkModel: TOpenSSL_LinkModel; override;

function Init: boolean; override;

public

{IOpenSSLDLL}

procedure SetOpenSSLPath(const Value: string);

function GetSSLLibVersions: string;

procedure SetSSLLibVersions(AValue: string);

function GetSSLBaseLibName: string;

procedure SetSSLBaseLibName(AValue: string);

function GetCryptoBaseLibName: string;

procedure SetCryptoBaseLibName(AValue: string);

function GetAllowLegacyLibsFallback: boolean;

procedure SetAllowLegacyLibsFallback(AValue: boolean);

function GetLibCryptoHandle: TLibHandle;

function GetLibSSLHandle: TLibHandle;

function GetLibCryptoFilePath: string;

function GetLibSSLFilePath: string;

function GetFailedToLoadList: TStrings;

function Load: Boolean;

procedure Unload;

function IsLoaded: boolean;

end;

{$ENDIF}

constructor TOpenSSLStaticLibProvider.Create;

inherited Create;

FThreadLock := TCriticalSection.Create;

FOpenSSLPath := GetEnvironmentVariable(OpenSSLLibraryPath)

end;

destructor TOpenSSLStaticLibProvider.Destroy;

if FThreadLock <> nil then FThreadLock.Free;

inherited Destroy;

end;

function TOpenSSLStaticLibProvider.GetOpenSSLPath : string;

Result := string(OpenSSL_version(OPENSSL_DIR));

end;

function TOpenSSLStaticLibProvider.GetOpenSSLVersionStr : string;

Result := string(OpenSSL_Version(OPENSSL_VERSION_CONST));

end;

function TOpenSSLStaticLibProvider.GetOpenSSLVersion : TOpenSSL_C_ULONG;

Result := OpenSSL_version_num;

end;

function OpenSSLMalloc(num: UInt32): Pointer cdecl;

Result := AllocMem(num);

end;

function OpenSSLRealloc(addr: Pointer; num: UInt32): Pointer cdecl;

Result := addr;

ReallocMem(Result, num);

end;

procedure OpenSSLFree(addr: Pointer)cdecl;

FreeMem(addr);

end;

procedure OpenSSLCryptoMallocInit;

r: Integer;

r := CRYPTO_set_mem_functions(@OpenSSLMalloc, @OpenSSLRealloc, @OpenSSLFree);

Assert(r <> 0);

end;

function TOpenSSLStaticLibProvider.GetLinkModel: TOpenSSL_LinkModel;

{$IFDEF OPENSSL_USE_SHARED_LIBRARY}

Result := lmShared;

{$ELSE}

Result := lmStatic;

{$ENDIF}

end;

function TOpenSSLStaticLibProvider.Init: boolean;

if not FInitDone then

begin

FThreadLock.Acquire;

try

{$IFDEF OPENSSL_SET_MEMORY_FUNCS}

// has to be done before anything that uses memory

OpenSSLCryptoMallocInit;

{$ENDIF}

OPENSSL_init_ssl(OPENSSL_INIT_LOAD_SSL_STRINGS or OPENSSL_INIT_ADD_ALL_CIPHERS or

OPENSSL_INIT_ADD_ALL_DIGESTS or OPENSSL_INIT_LOAD_CRYPTO_STRINGS or

OPENSSL_INIT_LOAD_CONFIG or OPENSSL_INIT_ASYNC or

OPENSSL_INIT_ENGINE_ALL_BUILTIN ,nil);

if GetOpenSSLVersion < CRYPTO_set_locking_callback_removed then

SetLegacyCallbacks;

finally

FThreadLock.Release;

end;

FInitDone := true;

end;

Result := FInitDone;

end;

function TOpenSSLDynamicLibProvider.FindLibrary(LibName , LibVersions : string;

var FilePath : string) : TLibHandle;

function DoLoadLibrary(FullLibName: string): TLibHandle;

begin

Result := SafeLoadLibrary(FullLibName, {$IFDEF WINDOWS}SEM_FAILCRITICALERRORS {$ELSE} 0 {$ENDIF});

if Result <> NilHandle then

{$if defined(FPC) and defined(UNIX)}

FilePath := fpReadLink(FullLibName);

{$else}

FilePath := FullLibName;

{$ifend}

end;

function SearchLocations(SSLPath: string): TLibHandle;

var LibVersionsList: TStringList;

i: integer;

begin

Result := NilHandle;

if SSLPath <> '' then

SSLPath := IncludeTrailingPathDelimiter(SSLPath);

if LibVersions <> '' then

begin

LibVersionsList := TStringList.Create;

try

LibVersionsList.Delimiter := DirListDelimiter;

LibVersionsList.StrictDelimiter := true;

LibVersionsList.DelimitedText := LibVersions; {Split list on delimiter}

for i := 0 to LibVersionsList.Count - 1 do

begin

Result := DoLoadLibrary(SSLPath + LibName + LibVersionsList[i]);

if Result <> NilHandle then

break;

end;

finally

LibVersionsList.Free;

end;

end

else

Result := DoLoadLibrary(SSLPath + LibName );

end;

var OpenSSLPaths: TStringList;

j: integer;

Result := NilHandle;

if OpenSSLPath = '' then

Result := SearchLocations('')

else

begin

OpenSSLPaths := TStringList.Create;

try

OpenSSLPaths.Delimiter := DirListDelimiter;

OpenSSLPaths.StrictDelimiter := true;

OpenSSLPaths.DelimitedText := OpenSSLPath;

for j := 0 to OpenSSLPaths.Count -1 do

begin

Result := SearchLocations(OpenSSLPaths[j]);

if Result <> NilHandle then

break;

end;

finally

OpenSSLPaths.Free;

end;

end;

end;

constructor TOpenSSLDynamicLibProvider.Create;

inherited Create;

FFailed := TStringList.Create();

FSSLLibVersions := DefaultLibVersions;

FSSLBaseLibName := CLibSSLBase;

FCryptoBaseLibName := CLibCryptoBase;

FAllowLegacyLibsFallback := false;

end;

destructor TOpenSSLDynamicLibProvider.Destroy;

Unload;

if FFailed <> nil then FFailed.Free;

inherited Destroy;

end;

function TOpenSSLDynamicLibProvider.GetOpenSSLPath : string;

if not IsLoaded then

Result := FOpenSSLPath

else

Result := inherited GetOpenSSLPath;

end;

function TOpenSSLDynamicLibProvider.GetOpenSSLVersionStr : string;

if not IsLoaded then

Load;

Result := inherited GetOpenSSLVersionStr;

end;

function TOpenSSLDynamicLibProvider.GetOpenSSLVersion : TOpenSSL_C_ULONG;

if not IsLoaded then

Load;

Result := inherited GetOpenSSLVersion;

end;

function TOpenSSLDynamicLibProvider.GetLinkModel: TOpenSSL_LinkModel;

Result := lmDynamic;

end;

function TOpenSSLDynamicLibProvider.Init : boolean;

Result := Load;

end;

function LoadLibCryptoFunction(const AProcName: string): Pointer;

Result := GetProcAddress(TOpenSSLDynamicLibProvider.FOpenSSLDDL.GetLibCryptoHandle,PChar(AProcName));

end;

function LoadLibSSLFunction(const AProcName: string): Pointer;

Result := GetProcAddress(TOpenSSLDynamicLibProvider.FOpenSSLDDL.GetLibSSLHandle,PChar(AProcName));

end;

procedure TOpenSSLDynamicLibProvider.SetOpenSSLPath(const Value : string);

FOpenSSLPath := Value;

end;

function TOpenSSLDynamicLibProvider.GetSSLLibVersions : string;

Result := FSSLLibVersions;

end;

procedure TOpenSSLDynamicLibProvider.SetSSLLibVersions(AValue : string);

if FSSLLibVersions <> AValue then

UnLoad;

FSSLLibVersions := AValue;

end;

function TOpenSSLDynamicLibProvider.GetSSLBaseLibName: string;

Result := FSSLBaseLibName;

end;

procedure TOpenSSLDynamicLibProvider.SetSSLBaseLibName(AValue: string);

if FSSLBaseLibName <> AValue then

UnLoad;

FSSLBaseLibName := AValue;

end;

function TOpenSSLDynamicLibProvider.GetCryptoBaseLibName: string;

Result := FCryptoBaseLibName;

end;

procedure TOpenSSLDynamicLibProvider.SetCryptoBaseLibName(AValue: string);

if FCryptoBaseLibName <> AValue then

UnLoad;

FCryptoBaseLibName := AValue;

end;

function TOpenSSLDynamicLibProvider.GetAllowLegacyLibsFallback: boolean;

Result := FAllowLegacyLibsFallback;

end;

procedure TOpenSSLDynamicLibProvider.SetAllowLegacyLibsFallback(AValue: boolean

);

if FAllowLegacyLibsFallback <> AValue then

Unload;

FAllowLegacyLibsFallback := AValue;

end;

function TOpenSSLDynamicLibProvider.GetLibCryptoHandle : TLibHandle;

if (FLibCrypto = NilHandle) and not FFailedToLoad then Load;

Result := FLibCrypto;

end;

function TOpenSSLDynamicLibProvider.GetLibSSLHandle : TLibHandle;

if (FLibSSL = NilHandle) and not FFailedToLoad then Load;

Result := FLibSSL;

end;

function TOpenSSLDynamicLibProvider.GetLibCryptoFilePath : string;

if (FLibCrypto = NilHandle) and not FFailedToLoad then Load;

Result := FLibCryptoFilePath;

end;

function TOpenSSLDynamicLibProvider.GetLibSSLFilePath : string;

if (FLibSSL = NilHandle) and not FFailedToLoad then Load;

Result := FLibSSLFilePath;

end;

function TOpenSSLDynamicLibProvider.GetFailedToLoadList : TStrings;

Result := FFailed;

end;

function TOpenSSLDynamicLibProvider.Load : Boolean;

TOpenSSL_version_num = function: TOpenSSL_C_ULONG; cdecl;

var i: integer;

OpenSSL_version_num: TOpenSSL_version_num;

SSLVersionNo: TOpenSSL_C_ULONG;

Result := not FFailedToLoad;

if not Result then

Exit;

FThreadLock.Acquire;

try

if not IsLoaded then

begin

FLibCrypto := FindLibrary(FCryptoBaseLibName + LibSuffix,FSSLLibVersions,FLibCryptoFilePath);

FLibSSL := FindLibrary(FSSLBaseLibName + LibSuffix,FSSLLibVersions,FLibSSLFilePath);

Result := not (FLibCrypto = NilHandle) and not (FLibSSL = NilHandle);

{$IFDEF WINDOWS}

if not Result and FAllowLegacyLibsFallback then

begin

{try the legacy dll names}

FLibCrypto := FindLibrary(LegacyLibCrypto,'',FLibCryptoFilePath);

FLibSSL := FindLibrary(LegacyLibssl,'',FLibSSLFilePath);

Result := not (FLibCrypto = NilHandle) and not (FLibSSL = NilHandle);

end;

{$ENDIF}

if not Result then

Exit;

{Load Version number}

OpenSSL_version_num := LoadLibCryptoFunction('OpenSSL_version_num');

if not assigned(OpenSSL_version_num) then

OpenSSL_version_num := LoadLibCryptoFunction('SSLeay');

if not assigned(OpenSSL_version_num) then

raise EOpenSSLError.Create(ROSSLCantGetSSLVersionNo);

SSLVersionNo := OpenSSL_version_num();

if SSLVersionNo < min_supported_ssl_version then {remove patch and dev flag}

raise EOpenSSLError.CreateFmt(RSOSSUnsupportedVersion,[SSLVersionNo]);

for i := 0 to FLibLoadList.Count - 1 do

TOpenSSLLoadProc(FLibLoadList[i])(SSLVersionNo,FFailed);

end;

finally

FThreadLock.Release;

end;

Result := inherited Init;

end;

procedure TOpenSSLDynamicLibProvider.Unload;

var i: integer;

FThreadLock.Acquire;

try

if IsLoaded then

begin

RemoveLegacyCallbacks;

for i := 0 to FUnLoadList.Count - 1 do

TOpenSSLUnloadProc(FUnLoadList[i]);

FFailed.Clear();

if FLibSSL <> NilHandle then

FreeLibrary(FLibSSL);

if FLibCrypto <> NilHandle then

FreeLibrary(FLibCrypto);

FLibSSL := NilHandle;

FLibCrypto := NilHandle;

end;

FFailedToLoad := false;

finally

FThreadLock.Release;

end;

end;

function TOpenSSLDynamicLibProvider.IsLoaded : boolean;

Result := (FLibCrypto <> Nilhandle) and (FLibSSL <> Nilhandle);

end;

const InitUnitDone: boolean = false;

procedure InitUnit;

if not InitUnitDone then

begin

{$IFDEF OPENSSL_STATIC_LINK_MODEL}

TOpenSSLStaticLibProvider.FOpenSSL := TOpenSSLStaticLibProvider.Create;

TOpenSSLStaticLibProvider.FOpenSSL.Init;

{$ELSE}

TOpenSSLStaticLibProvider.FOpenSSL := TOpenSSLDynamicLibProvider.Create;

TOpenSSLDynamicLibProvider.FOpenSSLDDL := TOpenSSLDynamicLibProvider.FOpenSSL as IOpenSSLDLL;

TOpenSSLDynamicLibProvider.FLibLoadList := TList.Create;

TOpenSSLDynamicLibProvider.FUnLoadList := TList.Create;

{$ENDIF};

InitUnitDone := true;

end;

end;

function GetIOpenSSL: IOpenSSL;

InitUnit;

Result := TOpenSSLStaticLibProvider.FOpenSSL;

end;

function GetIOpenSSLDDL: IOpenSSLDLL;

{$IFDEF OPENSSL_STATIC_LINK_MODEL}

Result := nil;

{$ELSE}

InitUnit;

Result := TOpenSSLDynamicLibProvider.FOpenSSLDDL;

{$ENDIF}

end;

procedure Register_SSLLoader(LoadProc : TOpenSSLLoadProc);

InitUnit;

TOpenSSLDynamicLibProvider.FLibLoadList.Add(@LoadProc);

end;

procedure Register_SSLUnloader(UnloadProc: TOpenSSLUnloadProc);

InitUnit;

TOpenSSLDynamicLibProvider.FUnLoadList.Add(@UnloadProc);

end;

InitUnit;

TOpenSSLStaticLibProvider.FOpenSSL := nil;

{$IFNDEF OPENSSL_STATIC_LINK_MODEL}

TOpenSSLDynamicLibProvider.FOpenSSLDDL := nil;

FreeAndNil(TOpenSSLDynamicLibProvider.FLibLoadList);

FreeAndNil(TOpenSSLDynamicLibProvider.FUnLoadList);

{$ENDIF}

end.