providers/build.info

   1 # We place all implementations in static libraries, and then let the
   2 # provider mains pilfer what they want through symbol resolution when
   3 # linking.
   4 #
   5 # The non-legacy implementations (libimplementations) must be made FIPS
   6 # agnostic as much as possible, as well as the common building blocks
   7 # (libcommon).  The legacy implementations (liblegacy) will never be
   8 # part of the FIPS provider.
   9 #
  10 # If there is anything that isn't FIPS agnostic, it should be set aside
  11 # in its own source file, which is then included directly into other
  12 # static libraries geared for FIPS and non-FIPS providers, and built
  13 # separately.
  14 #
  15 # libcommon.a           Contains common building blocks, potentially
  16 #                       needed both by non-legacy and legacy code.
  17 #
  18 # libimplementations.a  Contains all non-legacy implementations.
  19 # liblegacy.a           Contains all legacy implementations.
  20 #
  21 # libfips.a             Contains all things needed to support
  22 #                       FIPS implementations, such as code from
  23 #                       crypto/ and object files that contain
  24 #                       FIPS-specific code.  FIPS_MODULE is defined
  25 #                       for this library.  The FIPS module uses
  26 #                       this.
  27 # libnonfips.a          Corresponds to libfips.a, but built with
  28 #                       FIPS_MODULE undefined.  The default and legacy
  29 #                       providers use this.
  30 #
  31 # This is how different provider modules should be linked:
  32 #
  33 # FIPS:
  34 #     -o fips.so {object files...} libimplementations.a libcommon.a libfips.a
  35 # Non-FIPS:
  36 #     -o module.so {object files...} libimplementations.a libcommon.a libnonfips.a
  37 #
  38 # It is crucial that code that checks for the FIPS_MODULE macro end up in
  39 # libfips.a and libnonfips.a, never in libcommon.a.
  40 # It is crucial that such code is written so libfips.a and libnonfips.a doesn't
  41 # end up depending on libimplementations.a or libcommon.a.
  42 # It is crucial that such code is written so libcommon.a doesn't end up
  43 # depending on libimplementations.a.
  44 #
  45 # Code in providers/implementations/ should be written in such a way that the
  46 # OSSL_DISPATCH arrays (and preferably the majority of the actual code) ends
  47 # up in either libimplementations.a or liblegacy.a.
  48 # If need be, write an abstraction layer in separate source files and make them
  49 # libfips.a / libnonfips.a sources.
  50
  51 SUBDIRS=common implementations
  52
  53 INCLUDE[../libcrypto]=common/include
  54
  55 # Libraries we're dealing with
  56 $LIBCOMMON=libcommon.a
  57 $LIBIMPLEMENTATIONS=libimplementations.a
  58 $LIBLEGACY=liblegacy.a
  59 $LIBNONFIPS=libnonfips.a
  60 $LIBFIPS=libfips.a
  61
  62 # Enough of our implementations include prov/ciphercommon.h (present in
  63 # providers/implementations/include), which includes crypto/*_platform.h
  64 # (present in include), which in turn may include very internal header
  65 # files in crypto/, so let's have a common include list for them all.
  66 $COMMON_INCLUDES=../crypto ../include implementations/include common/include
  67
  68 INCLUDE[$LIBCOMMON]=$COMMON_INCLUDES
  69 INCLUDE[$LIBIMPLEMENTATIONS]=.. $COMMON_INCLUDES
  70 INCLUDE[$LIBLEGACY]=.. $COMMON_INCLUDES
  71 INCLUDE[$LIBNONFIPS]=.. $COMMON_INCLUDES
  72 INCLUDE[$LIBFIPS]=.. $COMMON_INCLUDES
  73 DEFINE[$LIBFIPS]=FIPS_MODULE
  74
  75 # Weak dependencies to provide library order information.
  76 # We make it weak so they aren't both used always; what is
  77 # actually used is determined by non-weak dependencies.
  78 DEPEND[$LIBIMPLEMENTATIONS]{weak}=$LIBFIPS $LIBNONFIPS
  79 DEPEND[$LIBCOMMON]{weak}=$LIBFIPS
  80
  81 # Strong dependencies.  This ensures that any time libimplementations
  82 # is used, libcommon gets included as well.
  83 DEPEND[$LIBIMPLEMENTATIONS]=$LIBCOMMON
  84 DEPEND[$LIBNONFIPS]=../libcrypto
  85 # It's tempting to make libcommon depend on ../libcrypto.  However,
  86 # since the FIPS provider module must NOT depend on ../libcrypto, we
  87 # need to set that dependency up specifically for the final products
  88 # that use $LIBCOMMON or anything that depends on it.
  89
  90 # Libraries common to all providers, must be built regardless
  91 LIBS{noinst}=$LIBCOMMON
  92 # Libraries that are common for all non-FIPS providers, must be built regardless
  93 LIBS{noinst}=$LIBNONFIPS $LIBIMPLEMENTATIONS
  94
  95 #
  96 # Default provider stuff
  97 #
  98 # Because the default provider is built in, it means that libcrypto must
  99 # include all the object files that are needed (we do that indirectly,
 100 # by using the appropriate libraries as source).  Note that for shared
 101 # libraries, SOURCEd libraries are considered as if the where specified
 102 # with DEPEND.
 103 $DEFAULTGOAL=../libcrypto
 104 SOURCE[$DEFAULTGOAL]=$LIBIMPLEMENTATIONS $LIBNONFIPS
 105 SOURCE[$DEFAULTGOAL]=defltprov.c
 106 # Some legacy implementations depend on provider header files
 107 INCLUDE[$DEFAULTGOAL]=implementations/include
 108
 109 LIBS=$DEFAULTGOAL
 110
 111 #
 112 # Base provider stuff
 113 #
 114 # Because the base provider is built in, it means that libcrypto
 115 # must include all of the object files that are needed.
 116 $BASEGOAL=../libcrypto
 117 SOURCE[$BASEGOAL]=$LIBIMPLEMENTATIONS $LIBNONFIPS
 118 SOURCE[$BASEGOAL]=baseprov.c
 119 INCLUDE[$BASEGOAL]=implementations/include
 120
 121 #
 122 # FIPS provider stuff
 123 #
 124 # We define it this way to ensure that configdata.pm will have all the
 125 # necessary information even if we don't build the module.  This will allow
 126 # us to make all kinds of checks on the source, based on what we specify in
 127 # diverse build.info files.  libfips.a, fips.so and their sources aren't
 128 # built unless the proper LIBS or MODULES statement has been seen, so we
 129 # have those and only those within a condition.
 130 SUBDIRS=fips
 131 $FIPSGOAL=fips
 132 DEPEND[$FIPSGOAL]=$LIBIMPLEMENTATIONS $LIBFIPS
 133 INCLUDE[$FIPSGOAL]=../include
 134 DEFINE[$FIPSGOAL]=FIPS_MODULE
 135 IF[{- defined $target{shared_defflag} -}]
 136   SOURCE[$FIPSGOAL]=fips.ld
 137   GENERATE[fips.ld]=../util/providers.num
 138 ENDIF
 139
 140 IF[{- !$disabled{fips} -}]
 141   # This is the trigger to actually build the FIPS module.  Without these
 142   # statements, the final build file will not have a trace of it.
 143   MODULES{fips}=$FIPSGOAL
 144   LIBS{noinst}=$LIBFIPS
 145 ENDIF
 146
 147 #
 148 # Legacy provider stuff
 149 #
 150 IF[{- !$disabled{legacy} -}]
 151   # The legacy implementation library
 152   LIBS{noinst}=$LIBLEGACY
 153   DEPEND[$LIBLEGACY]=$LIBCOMMON $LIBNONFIPS
 154
 155   # The Legacy provider
 156   IF[{- $disabled{module} -}]
 157     # Become built in
 158     # In this case, we need to do the same thing a for the default provider,
 159     # and make the liblegacy object files end up in libcrypto.  We could also
 160     # just say that for the built-in legacy, we put the source directly in
 161     # libcrypto instead of going via liblegacy, but that makes writing the
 162     # implementation specific build.info files harder to write, so we don't.
 163     $LEGACYGOAL=../libcrypto
 164     SOURCE[$LEGACYGOAL]=$LIBLEGACY
 165     DEFINE[$LIBLEGACY]=STATIC_LEGACY
 166     DEFINE[$LEGACYGOAL]=STATIC_LEGACY
 167   ELSE
 168     # Become a module
 169     # In this case, we can work with dependencies
 170     $LEGACYGOAL=legacy
 171     MODULES=$LEGACYGOAL
 172     DEPEND[$LEGACYGOAL]=$LIBLEGACY
 173     IF[{- defined $target{shared_defflag} -}]
 174       SOURCE[legacy]=legacy.ld
 175       GENERATE[legacy.ld]=../util/providers.num
 176     ENDIF
 177   ENDIF
 178
 179   # Common things that are valid no matter what form the Legacy provider
 180   # takes.
 181   SOURCE[$LEGACYGOAL]=legacyprov.c
 182   INCLUDE[$LEGACYGOAL]=../include implementations/include common/include
 183 ENDIF
 184
 185 #
 186 # Null provider stuff
 187 #
 188 # Because the null provider is built in, it means that libcrypto must
 189 # include all the object files that are needed.
 190 $NULLGOAL=../libcrypto
 191 SOURCE[$NULLGOAL]=nullprov.c prov_running.c
 192
 193 SOURCE[$LIBNONFIPS]=prov_running.c