-# We place all implementations in static libraries, and then let the
-# provider mains pilfer what they want through symbol resolution when
-# linking.
-#
-# The non-legacy implementations (libimplementations) must be made FIPS
-# agnostic as much as possible, as well as the common building blocks
-# (libcommon). The legacy implementations (liblegacy) will never be
-# part of the FIPS provider.
-#
-# If there is anything that isn't FIPS agnostic, it should be set aside
-# in its own source file, which is then included directly into other
-# static libraries geared for FIPS and non-FIPS providers, and built
-# separately.
-#
-# libcommon.a Contains common building blocks, potentially
-# needed both by non-legacy and legacy code.
-#
-# libimplementations.a Contains all non-legacy implementations.
-# liblegacy.a Contains all legacy implementaions.
-#
-# libfips.a Contains all things needed to support
-# FIPS implementations, such as code from
-# crypto/ and object files that contain
-# FIPS-specific code. FIPS_MODE is defined
-# for this library. The FIPS module uses
-# this.
-# libnonfips.a Corresponds to libfips.a, but built with
-# FIPS_MODE undefined. The default and legacy
-# providers use this.
-
-SUBDIRS=common default implementations
+# libcommon.a Contains common building blocks and other routines,
+# potentially needed by any of our providers.
+#
+# libfips.a Contains all algorithm implementations that should
+# go in the FIPS provider. The compilations for this
+# library are all done with FIPS_MODULE defined.
+#
+# liblegacy.a Contains all algorithm implementations that should
+# go into the legacy provider. The compilations for
+# this library are all done with STATIC_LEGACY defined.
+#
+# libdefault.a Contains all algorithm implementations that should
+# into the default or base provider.
+#
+# To be noted is that the FIPS provider shares source code with libcrypto,
+# which means that select source files from crypto/ are compiled for
+# libfips.a the sources from providers/implementations.
+#
+# This is how a provider module should be linked:
+#
+# -o {modulename}.so {object files...} lib{modulename}.a libcommon.a
+#
+# It is crucial that code that checks the FIPS_MODULE macro ends up in
+# libfips.a.
+# It is crucial that code that checks the STATIC_LEGACY macro ends up in
+# liblegacy.a.
+# It is recommended that code that is written for libcommon.a doesn't end
+# up depending on libfips.a, liblegacy.a or libdefault.a
+#
+# Code in providers/implementations/ should be written in such a way that
+# the OSSL_DISPATCH arrays (and preferably the majority of the actual code)
+# end up in either libfips.a, liblegacy.a or libdefault.a.
+
+SUBDIRS=common implementations
INCLUDE[../libcrypto]=common/include
# Libraries we're dealing with
$LIBCOMMON=libcommon.a
-$LIBIMPLEMENTATIONS=libimplementations.a
-$LIBLEGACY=liblegacy.a
-$LIBNONFIPS=libnonfips.a
$LIBFIPS=libfips.a
+$LIBLEGACY=liblegacy.a
+$LIBDEFAULT=libdefault.a
+LIBS{noinst}=$LIBDEFAULT $LIBCOMMON
# Enough of our implementations include prov/ciphercommon.h (present in
-# providers/common/include), which includes crypto/ciphermode_platform.h
+# providers/implementations/include), which includes crypto/*_platform.h
# (present in include), which in turn may include very internal header
# files in crypto/, so let's have a common include list for them all.
-$COMMON_INCLUDES=../crypto ../include common/include
+$COMMON_INCLUDES=../crypto ../include implementations/include common/include
INCLUDE[$LIBCOMMON]=$COMMON_INCLUDES
-INCLUDE[$LIBIMPLEMENTATIONS]=.. $COMMON_INCLUDES implementations/include
-INCLUDE[$LIBLEGACY]=$COMMON_INCLUDES implementations/include
-INCLUDE[$LIBNONFIPS]=$COMMON_INCLUDES
INCLUDE[$LIBFIPS]=.. $COMMON_INCLUDES
-DEFINE[$LIBFIPS]=FIPS_MODE
+INCLUDE[$LIBLEGACY]=.. $COMMON_INCLUDES
+INCLUDE[$LIBDEFAULT]=.. $COMMON_INCLUDES
+DEFINE[$LIBFIPS]=FIPS_MODULE
-# Weak dependencies to provide library order information.
-# We make it weak so they aren't both used always; what is
-# actually used is determined by non-weak dependencies.
-DEPEND[$LIBIMPLEMENTATIONS]{weak}=$LIBFIPS $LIBNONFIPS
-DEPEND[$LIBCOMMON]{weak}=$LIBFIPS
+# Weak dependencies to provide library order information. What is actually
+# used is determined by non-weak dependencies.
+DEPEND[$LIBCOMMON]{weak}=../libcrypto
-# Strong dependencies. This ensures that any time libimplementations
+# Strong dependencies. This ensures that any time an implementation library
# is used, libcommon gets included as well.
-DEPEND[$LIBIMPLEMENTATIONS]=$LIBCOMMON
-DEPEND[$LIBNONFIPS]=../libcrypto
-# It's tempting to make libcommon depend on ../libcrypto. However,
-# since the FIPS provider module must NOT depend on ../libcrypto, we
-# need to set that dependency up specifically for the final products
-# that use $LIBCOMMON or anything that depends on it.
-
-# Libraries common to all providers, must be built regardless
-LIBS{noinst}=$LIBCOMMON
-# Libraries that are common for all non-FIPS providers, must be built regardless
-LIBS{noinst}=$LIBNONFIPS $LIBIMPLEMENTATIONS
+# The $LIBFIPS dependency on $LIBCOMMON is extra strong, to mitigate for
+# linking problems because they are interdependent
+SOURCE[$LIBFIPS]=$LIBCOMMON
+DEPEND[$LIBLEGACY]=$LIBCOMMON
+DEPEND[$LIBDEFAULT]=$LIBCOMMON
#
# Default provider stuff
# Because the default provider is built in, it means that libcrypto must
# include all the object files that are needed (we do that indirectly,
# by using the appropriate libraries as source). Note that for shared
-# libraries, SOURCEd libraries are considered as if the where specified
+# libraries, SOURCEd libraries are considered as if they were specified
# with DEPEND.
$DEFAULTGOAL=../libcrypto
-SOURCE[$DEFAULTGOAL]=$LIBIMPLEMENTATIONS $LIBNONFIPS
-# Some legacy implementations depend on provider header files
-INCLUDE[../libcrypto]=implementations/include
+SOURCE[$DEFAULTGOAL]=$LIBDEFAULT defltprov.c
+INCLUDE[$DEFAULTGOAL]=implementations/include
-LIBS=$DEFAULTGOAL
+#
+# Base provider stuff
+#
+# Because the base provider is built in, it means that libcrypto must
+# include all of the object files that are needed, just like the default
+# provider.
+$BASEGOAL=../libcrypto
+SOURCE[$BASEGOAL]=$LIBDEFAULT baseprov.c
+INCLUDE[$BASEGOAL]=implementations/include
#
# FIPS provider stuff
# diverse build.info files. libfips.a, fips.so and their sources aren't
# built unless the proper LIBS or MODULES statement has been seen, so we
# have those and only those within a condition.
-SUBDIRS=fips
-$FIPSGOAL=fips
-DEPEND[$FIPSGOAL]=$LIBIMPLEMENTATIONS $LIBFIPS
-INCLUDE[$FIPSGOAL]=../include
-IF[{- defined $target{shared_defflag} -}]
- SOURCE[$FIPSGOAL]=fips.ld
- GENERATE[fips.ld]=../util/providers.num
-ENDIF
-
IF[{- !$disabled{fips} -}]
+ SUBDIRS=fips
+ $FIPSGOAL=fips
+
# This is the trigger to actually build the FIPS module. Without these
# statements, the final build file will not have a trace of it.
- MODULES=$FIPSGOAL
+ MODULES{fips}=$FIPSGOAL
LIBS{noinst}=$LIBFIPS
+
+ DEPEND[$FIPSGOAL]=$LIBFIPS
+ INCLUDE[$FIPSGOAL]=../include
+ DEFINE[$FIPSGOAL]=FIPS_MODULE
+ IF[{- defined $target{shared_defflag} -}]
+ SOURCE[$FIPSGOAL]=fips.ld
+ GENERATE[fips.ld]=../util/providers.num
+ ENDIF
+
+ DEPEND[|build_modules_nodep|]=fipsmodule.cnf
+ GENERATE[fipsmodule.cnf]=../util/mk-fipsmodule-cnf.pl \
+ -module $(FIPSMODULE) -section_name fips_sect -key $(FIPSKEY)
+ DEPEND[fipsmodule.cnf]=$FIPSGOAL
+
+ # Add VERSIONINFO resource for windows
+ IF[{- $config{target} =~ /^(?:Cygwin|mingw|VC-|BC-)/ -}]
+ GENERATE[fips.rc]=../util/mkrc.pl fips
+ SOURCE[$FIPSGOAL]=fips.rc
+ ENDIF
ENDIF
#
# Legacy provider stuff
#
IF[{- !$disabled{legacy} -}]
- # The legacy implementation library
- SUBDIRS=legacy
LIBS{noinst}=$LIBLEGACY
- DEPEND[$LIBLEGACY]=$LIBCOMMON $LIBNONFIPS
- # The Legacy provider
IF[{- $disabled{module} -}]
# Become built in
# In this case, we need to do the same thing a for the default provider,
# implementation specific build.info files harder to write, so we don't.
$LEGACYGOAL=../libcrypto
SOURCE[$LEGACYGOAL]=$LIBLEGACY
- DEFINE[$LIBLEGACY]=STATIC_LEGACY
DEFINE[$LEGACYGOAL]=STATIC_LEGACY
ELSE
# Become a module
# In this case, we can work with dependencies
$LEGACYGOAL=legacy
MODULES=$LEGACYGOAL
- DEPEND[$LEGACYGOAL]=$LIBLEGACY
+ DEPEND[$LEGACYGOAL]=$LIBLEGACY ../libcrypto
IF[{- defined $target{shared_defflag} -}]
SOURCE[legacy]=legacy.ld
GENERATE[legacy.ld]=../util/providers.num
ENDIF
+
+ # Add VERSIONINFO resource for windows
+ IF[{- $config{target} =~ /^(?:Cygwin|mingw|VC-|BC-)/ -}]
+ GENERATE[legacy.rc]=../util/mkrc.pl legacy
+ SOURCE[$LEGACYGOAL]=legacy.rc
+ ENDIF
+
+ SOURCE[$LIBLEGACY]=prov_running.c
ENDIF
# Common things that are valid no matter what form the Legacy provider
# takes.
- INCLUDE[$LEGACYGOAL]=../include common/include
+ SOURCE[$LEGACYGOAL]=legacyprov.c
+ INCLUDE[$LEGACYGOAL]=../include implementations/include common/include
ENDIF
+#
+# Null provider stuff
+#
+# Because the null provider is built in, it means that libcrypto must
+# include all the object files that are needed.
+$NULLGOAL=../libcrypto
+SOURCE[$NULLGOAL]=nullprov.c prov_running.c
projects / openssl.git / blobdiff