Merge pull request #194 from ARMmbed/dev/Patater/enable-use-as-submodule-only

Enable use as submodule only (no removal of non-crypto)
This commit is contained in:
Jaeden Amero 2018-11-21 12:53:12 +00:00 committed by GitHub
commit dbb83ac5f7
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
14 changed files with 109 additions and 752 deletions

14
.gitignore vendored
View file

@ -26,17 +26,3 @@ massif-*
# CMake generates *.dir/ folders for in-tree builds (used by MSVC projects), ignore all of those:
*.dir/
# Exported Mbed Crypto files
crypto/LICENSE
crypto/VERSION.txt
crypto/include/mbedcrypto/*.h
crypto/include/psa/*.h
crypto/library/*.c
crypto/programs/psa/*.c
crypto/programs/psa/*.sh
crypto/scripts
crypto/tests/scripts
crypto/tests/suites/*.data
crypto/tests/suites/*.function
mbedcrypto.tar.gz

View file

@ -24,6 +24,8 @@ ifndef WINDOWS
install: no_test
mkdir -p $(DESTDIR)/include/mbedtls
cp -rp include/mbedtls $(DESTDIR)/include
mkdir -p $(DESTDIR)/include/psa
cp -rp include/psa $(DESTDIR)/include
mkdir -p $(DESTDIR)/lib
cp -RP library/libmbedtls.* $(DESTDIR)/lib

212
README.md
View file

@ -1,187 +1,83 @@
README for Mbed TLS
===================
# Mbed Crypto library
Configuration
-------------
The Mbed cryptography library is a reference implementation of the cryptography interface of the Arm Platform Security Architecture (PSA). This is a preview release of Mbed Crypto, provided for evaluation purposes only.
Mbed TLS should build out of the box on most systems. Some platform specific options are available in the fully documented configuration file `include/mbedtls/config.h`, which is also the place where features can be selected. This file can be edited manually, or in a more programmatic way using the Perl script `scripts/config.pl` (use `--help` for usage instructions).
Mbed Crypto is distributed under the Apache License, version 2.0. See the [LICENSE](LICENSE) file for the full text of the license.
Compiler options can be set using conventional environment variables such as `CC` and `CFLAGS` when using the Make and CMake build system (see below).
## PSA cryptography API
Compiling
---------
Arm's Platform Security Architecture (PSA) is a holistic set of threat models, security analyses, hardware and firmware architecture specifications, and an open source firmware reference implementation. PSA provides a recipe, based on industry best practice, that allows security to be consistently designed in, at both a hardware and firmware level.
There are currently three active build systems used within Mbed TLS releases:
The PSA cryptography API provides access to a set of cryptographic primitives. It has a dual purpose. First, it can be used in a PSA-compliant platform to build services, such as secure boot, secure storage and secure communication. Second, it can also be used independently of other PSA components on any platform.
- GNU Make
- CMake
- Microsoft Visual Studio (Microsoft Visual Studio 2010 or later)
The design goals of the PSA cryptography API include:
The main systems used for development are CMake and GNU Make. Those systems are always complete and up-to-date. The others should reflect all changes present in the CMake and Make build system, although features may not be ported there automatically.
* The API distinguishes caller memory from internal memory, which allows the library to be implemented in an isolated space for additional security. Library calls can be implemented as direct function calls if isolation is not desired, and as remote procedure calls if isolation is desired.
* The structure of internal data is hidden to the application, which allows substituting alternative implementations at build time or run time, for example, in order to take advantage of hardware accelerators.
* All access to the keys happens through handles, which allows support for external cryptoprocessors that is transparent to applications.
* The interface to algorithms is generic, favoring algorithm agility.
* The interface is designed to be easy to use and hard to accidentally misuse.
The Make and CMake build systems create three libraries: libmbedcrypto, libmbedx509, and libmbedtls. Note that libmbedtls depends on libmbedx509 and libmbedcrypto, and libmbedx509 depends on libmbedcrypto. As a result, some linkers will expect flags to be in a specific order, for example the GNU linker wants `-lmbedtls -lmbedx509 -lmbedcrypto`. Also, when loading shared libraries using dlopen(), you'll need to load libmbedcrypto first, then libmbedx509, before you can load libmbedtls.
## Mbed Crypto implementation
### Make
Mbed Crypto is a reference implementation of the PSA cryptography API. It is written in portable C.
We require GNU Make. To build the library and the sample programs, GNU Make and a C compiler are sufficient. Some of the more advanced build targets require some Unix/Linux tools.
## Documentation
We intentionally only use a minimum of functionality in the makefiles in order to keep them as simple and independent of different toolchains as possible, to allow users to more easily move between different platforms. Users who need more features are recommended to use CMake.
Since the Mbed Crypto library is a reference implementation of the PSA cryptography API, the library's API documentation is the PSA cryptography API specification. The PSA cryptography API specification consists of the following documents:
In order to build from the source code using GNU Make, just enter at the command line:
* The [PSA Cryptography API overview](docs/PSA_Crypto_API_Overview.pdf).
* The [PSA Cryptography API detailed function reference](docs/PSA_Crypto_API_Reference.pdf), which you can also browse in [HTML format](docs/html/modules.html).
make
## Compiling
In order to run the tests, enter:
You need the following tools to build the library with the provided makefiles:
make check
* GNU Make or a build tool that CMake supports.
* A C99 toolchain (compiler, linker, archiver).
* Python 2 or Python 3 (either will work) to generate the test code.
* Perl to run the tests.
The tests need Perl to be built and run. If you don't have Perl installed, you can skip building the tests with:
If you have a C compiler, such as GCC or Clang, just run `make` in the top-level directory to build the library, a set of unit tests and some sample programs.
make no_test
To select a different compiler, set the `CC` variable to the name or path of the compiler and linker (default: `cc`), and set `AR` to a compatible archiver (default: `ar`). For example:
```
make CC=arm-linux-gnueabi-gcc AR=arm-linux-gnueabi-ar
```
The provided makefiles pass options to the compiler that assume a GCC-like command-line syntax. To use a different compiler, you may need to pass different values for `CFLAGS`, `WARNINGS_CFLAGS` and `LDFLAGS`.
You'll still be able to run a much smaller set of tests with:
To run the unit tests on the host machine, run `make test` from the top-level directory. If you are cross-compiling, copy the test executable from the `tests` directory to the target machine.
programs/test/selftest
### Compiling as a subproject
In order to build for a Windows platform, you should use `WINDOWS_BUILD=1` if the target is Windows but the build environment is Unix-like (for instance when cross-compiling, or compiling from an MSYS shell), and `WINDOWS=1` if the build environment is a Windows shell (for instance using mingw32-make) (in that case some targets will not be available).
Mbed Crypto supports being built as a subproject of Mbed TLS. Mbed TLS can use Mbed Crypto for its cryptography implementation by using Mbed Crypto as a subproject.
Setting the variable `SHARED` in your environment will build shared libraries in addition to the static libraries. Setting `DEBUG` gives you a debug build. You can override `CFLAGS` and `LDFLAGS` by setting them in your environment or on the make command line; compiler warning options may be overridden separately using `WARNING_CFLAGS`. Some directory-specific options (for example, `-I` directives) are still preserved.
From the Mbed TLS project repository, CMake can be invoked as follows to build Mbed TLS using Mbed Crypto's `libmbedcrypto`.
```
mkdir cmake
cd cmake
cmake .. -DUSE_CRYPTO_SUBMODULE=1
make -j
make test
```
Please note that setting `CFLAGS` overrides its default value of `-O2` and setting `WARNING_CFLAGS` overrides its default value (starting with `-Wall -W`), so if you just want to add some warning options to the default ones, you can do so by setting `CFLAGS=-O2 -Werror` for example. Setting `WARNING_CFLAGS` is useful when you want to get rid of its default content (for example because your compiler doesn't accept `-Wall` as an option). Directory-specific options cannot be overriden from the command line.
When building Mbed Crypto as a subproject of Mbed TLS, the Mbed TLS
configuration file (config.h) is used, and not the Mbed Crypto configuration
file.
Depending on your platform, you might run into some issues. Please check the Makefiles in `library/`, `programs/` and `tests/` for options to manually add or remove for specific platforms. You can also check [the Mbed TLS Knowledge Base](https://tls.mbed.org/kb) for articles on your platform or issue.
## Example programs
In case you find that you need to do something else as well, please let us know what, so we can add it to the [Mbed TLS Knowledge Base](https://tls.mbed.org/kb).
The `programs/` subdirectory contains sample programs that use the library. Please note that the goal of these sample programs is to demonstrate specific features of the library, and the code may need to be adapted to build a real-world application.
### CMake
## Upcoming features
In order to build the source using CMake in a separate directory (recommended), just enter at the command line:
Future releases of this library will include:
mkdir /path/to/build_dir && cd /path/to/build_dir
cmake /path/to/mbedtls_source
make
* A driver programming interface, which makes it possible to use hardware accelerators instead of the default software implementation for chosen algorithms.
* Support for external keys to be stored and manipulated exclusively in a separate cryptoprocessor.
* A configuration mechanism to compile only the algorithms you need for your application.
* A wider set of cryptographic algorithms.
In order to run the tests, enter:
make test
The test suites need Perl to be built. If you don't have Perl installed, you'll want to disable the test suites with:
cmake -DENABLE_TESTING=Off /path/to/mbedtls_source
If you disabled the test suites, but kept the programs enabled, you can still run a much smaller set of tests with:
programs/test/selftest
To configure CMake for building shared libraries, use:
cmake -DUSE_SHARED_MBEDTLS_LIBRARY=On /path/to/mbedtls_source
There are many different build modes available within the CMake buildsystem. Most of them are available for gcc and clang, though some are compiler-specific:
- `Release`. This generates the default code without any unnecessary information in the binary files.
- `Debug`. This generates debug information and disables optimization of the code.
- `Coverage`. This generates code coverage information in addition to debug information.
- `ASan`. This instruments the code with AddressSanitizer to check for memory errors. (This includes LeakSanitizer, with recent version of gcc and clang.) (With recent version of clang, this mode also instruments the code with UndefinedSanitizer to check for undefined behaviour.)
- `ASanDbg`. Same as ASan but slower, with debug information and better stack traces.
- `MemSan`. This instruments the code with MemorySanitizer to check for uninitialised memory reads. Experimental, needs recent clang on Linux/x86\_64.
- `MemSanDbg`. Same as MemSan but slower, with debug information, better stack traces and origin tracking.
- `Check`. This activates the compiler warnings that depend on optimization and treats all warnings as errors.
Switching build modes in CMake is simple. For debug mode, enter at the command line:
cmake -D CMAKE_BUILD_TYPE=Debug /path/to/mbedtls_source
To list other available CMake options, use:
cmake -LH
Note that, with CMake, you can't adjust the compiler or its flags after the
initial invocation of cmake. This means that `CC=your_cc make` and `make
CC=your_cc` will *not* work (similarly with `CFLAGS` and other variables).
These variables need to be adjusted when invoking cmake for the first time,
for example:
CC=your_cc cmake /path/to/mbedtls_source
If you already invoked cmake and want to change those settings, you need to
remove the build directory and create it again.
Note that it is possible to build in-place; this will however overwrite the
provided Makefiles (see `scripts/tmp_ignore_makefiles.sh` if you want to
prevent `git status` from showing them as modified). In order to do so, from
the Mbed TLS source directory, use:
cmake .
make
If you want to change `CC` or `CFLAGS` afterwards, you will need to remove the
CMake cache. This can be done with the following command using GNU find:
find . -iname '*cmake*' -not -name CMakeLists.txt -exec rm -rf {} +
You can now make the desired change:
CC=your_cc cmake .
make
Regarding variables, also note that if you set CFLAGS when invoking cmake,
your value of CFLAGS doesn't override the content provided by cmake (depending
on the build mode as seen above), it's merely prepended to it.
### Microsoft Visual Studio
The build files for Microsoft Visual Studio are generated for Visual Studio 2010.
The solution file `mbedTLS.sln` contains all the basic projects needed to build the library and all the programs. The files in tests are not generated and compiled, as these need a perl environment as well. However, the selftest program in `programs/test/` is still available.
Example programs
----------------
We've included example programs for a lot of different features and uses in [`programs/`](programs/README.md). Most programs only focus on a single feature or usage scenario, so keep that in mind when copying parts of the code.
Tests
-----
Mbed TLS includes an elaborate test suite in `tests/` that initially requires Perl to generate the tests files (e.g. `test\_suite\_mpi.c`). These files are generated from a `function file` (e.g. `suites/test\_suite\_mpi.function`) and a `data file` (e.g. `suites/test\_suite\_mpi.data`). The `function file` contains the test functions. The `data file` contains the test cases, specified as parameters that will be passed to the test function.
For machines with a Unix shell and OpenSSL (and optionally GnuTLS) installed, additional test scripts are available:
- `tests/ssl-opt.sh` runs integration tests for various TLS options (renegotiation, resumption, etc.) and tests interoperability of these options with other implementations.
- `tests/compat.sh` tests interoperability of every ciphersuite with other implementations.
- `tests/scripts/test-ref-configs.pl` test builds in various reduced configurations.
- `tests/scripts/key-exchanges.pl` test builds in configurations with a single key exchange enabled
- `tests/scripts/all.sh` runs a combination of the above tests, plus some more, with various build options (such as ASan, full `config.h`, etc).
Configurations
--------------
We provide some non-standard configurations focused on specific use cases in the `configs/` directory. You can read more about those in `configs/README.txt`
Porting Mbed TLS
----------------
Mbed TLS can be ported to many different architectures, OS's and platforms. Before starting a port, you may find the following Knowledge Base articles useful:
- [Porting Mbed TLS to a new environment or OS](https://tls.mbed.org/kb/how-to/how-do-i-port-mbed-tls-to-a-new-environment-OS)
- [What external dependencies does Mbed TLS rely on?](https://tls.mbed.org/kb/development/what-external-dependencies-does-mbedtls-rely-on)
- [How do I configure Mbed TLS](https://tls.mbed.org/kb/compiling-and-building/how-do-i-configure-mbedtls)
Contributing
------------
We gratefully accept bug reports and contributions from the community. There are some requirements we need to fulfill in order to be able to integrate contributions:
- All contributions, whether large or small require a Contributor's License Agreement (CLA) to be accepted. This is because source code can possibly fall under copyright law and we need your consent to share in the ownership of the copyright.
- We would ask that contributions conform to [our coding standards](https://tls.mbed.org/kb/development/mbedtls-coding-standards), and that contributions should be fully tested before submission.
- As with any open source project, contributions will be reviewed by the project team and community and may need some modifications to be accepted.
To accept the Contributors Licence Agreement (CLA), individual contributors can do this by creating an Mbed account and [accepting the online agreement here with a click through](https://os.mbed.com/contributor_agreement/). Alternatively, for contributions from corporations, or those that do not wish to create an Mbed account, a slightly different agreement can be found [here](https://www.mbed.com/en/about-mbed/contributor-license-agreements/). This agreement should be signed and returned to Arm as described in the instructions given.
### Making a Contribution
1. [Check for open issues](https://github.com/ARMmbed/mbedtls/issues) or [start a discussion](https://forums.mbed.com/c/mbed-tls) around a feature idea or a bug.
2. Fork the [Mbed TLS repository on GitHub](https://github.com/ARMmbed/mbedtls) to start making your changes. As a general rule, you should use the "development" branch as a basis.
3. Write a test which shows that the bug was fixed or that the feature works as expected.
4. Send a pull request and bug us until it gets merged and published. Contributions may need some modifications, so work with us to get your change accepted. We will include your name in the ChangeLog :)
## Feedback welcome
Arm welcomes feedback on the design of the API. If you think something could be improved, please open an issue on our Github repository. Alternatively, if you prefer to provide your feedback privately, please email us at [`mbed-crypto@arm.com`](mailto:mbed-crypto@arm.com). All feedback received by email is treated confidentially.

13
crypto/.gitignore vendored
View file

@ -1,13 +0,0 @@
*.exe
*.o
*.obj
/docs/*.pdf
/docs/html
/library/libmbedcrypto*.a
/library/libmbedcrypto*.dll
/library/libmbedcrypto*.so
/library/libmbedcrypto*.so.[0-9]*
/programs/psa/crypto_examples
/programs/psa/key_ladder_demo
/programs/psa/psa_constant_names
/tests/test_suite_*

View file

@ -1,20 +0,0 @@
.PHONY: all lib programs tests clean test
all: programs tests
lib:
$(MAKE) -C library
programs: lib
$(MAKE) -C programs
tests: lib
$(MAKE) -C tests
clean:
$(MAKE) -C library clean
$(MAKE) -C programs clean
$(MAKE) -C tests clean
test: lib tests
$(MAKE) -C tests test

View file

@ -1,66 +0,0 @@
# Mbed Crypto library
The Mbed cryptography library is a reference implementation of the cryptography interface of the Arm Platform Security Architecture (PSA). This is a preview release of Mbed Crypto, provided for evaluation purposes only.
Mbed Crypto is distributed under the Apache License, version 2.0. See the [LICENSE](LICENSE) file for the full text of the license.
## PSA cryptography API
Arm's Platform Security Architecture (PSA) is a holistic set of threat models, security analyses, hardware and firmware architecture specifications, and an open source firmware reference implementation. PSA provides a recipe, based on industry best practice, that allows security to be consistently designed in, at both a hardware and firmware level.
The PSA cryptography API provides access to a set of cryptographic primitives. It has a dual purpose. First, it can be used in a PSA-compliant platform to build services, such as secure boot, secure storage and secure communication. Second, it can also be used independently of other PSA components on any platform.
The design goals of the PSA cryptography API include:
* The API distinguishes caller memory from internal memory, which allows the library to be implemented in an isolated space for additional security. Library calls can be implemented as direct function calls if isolation is not desired, and as remote procedure calls if isolation is desired.
* The structure of internal data is hidden to the application, which allows substituting alternative implementations at build time or run time, for example, in order to take advantage of hardware accelerators.
* All access to the keys happens through handles, which allows support for external cryptoprocessors that is transparent to applications.
* The interface to algorithms is generic, favoring algorithm agility.
* The interface is designed to be easy to use and hard to accidentally misuse.
## Mbed Crypto implementation
Mbed Crypto is a reference implementation of the PSA cryptography API. It is written in portable C.
## Documentation
Since the Mbed Crypto library is a reference implementation of the PSA cryptography API, the library's API documentation is the PSA cryptography API specification. The PSA cryptography API specification consists of the following documents:
* The [PSA Cryptography API overview](docs/PSA_Crypto_API_Overview.pdf).
* The [PSA Cryptography API detailed function reference](docs/PSA_Crypto_API_Reference.pdf), which you can also browse in [HTML format](docs/html/modules.html).
## Compiling
You need the following tools to build the library with the provided makefiles:
* GNU Make.
* A C toolchain (compiler, linker, archiver).
* Python 2 or Python 3 (either will work) to generate the test code.
* Perl to run the tests.
If you have a C compiler, such as GCC or Clang, just run `make` in the top-level directory to build the library, a set of unit tests and some sample programs.
To select a different compiler, set the `CC` variable to the name or path of the compiler and linker (default: `cc`), and set `AR` to a compatible archiver (default: `ar`). For example:
```
make CC=arm-linux-gnueabi-gcc AR=arm-linux-gnueabi-ar
```
The provided makefiles pass options to the compiler that assume a GCC-like command-line syntax. To use a different compiler, you may need to pass different values for `CFLAGS`, `WARNINGS_CFLAGS` and `LDFLAGS`.
To run the unit tests on the host machine, run `make test` from the top-level directory. If you are cross-compiling, copy the test executable from the `tests` directory to the target machine.
## Example programs
The `programs/` subdirectory contains sample programs that use the library. Please note that the goal of these sample programs is to demonstrate specific features of the library, and the code may need to be adapted to build a real-world application.
## Upcoming features
Future releases of this library will include:
* A driver programming interface, which makes it possible to use hardware accelerators instead of the default software implementation for chosen algorithms.
* Support for external keys to be stored and manipulated exclusively in a separate cryptoprocessor.
* A configuration mechanism to compile only the algorithms you need for your application.
* A wider set of cryptographic algorithms.
## Feedback welcome
Arm welcomes feedback on the design of the API. If you think something could be improved, please open an issue on our Github repository. Alternatively, if you prefer to provide your feedback privately, please email us at [`mbed-crypto@arm.com`](mailto:mbed-crypto@arm.com). All feedback received by email is treated confidentially.

View file

@ -1,78 +0,0 @@
CFLAGS ?= -O2 -I../include
WARNING_CFLAGS ?= \
-Werror -Wall -Wextra \
-Wno-unused-function \
-Wno-overlength-strings \
-Wdeclaration-after-statement \
# Don't delete this line.
OBJS_CRYPTO := \
aes.o \
aesni.o \
arc4.o \
asn1parse.o \
asn1write.o \
base64.o \
bignum.o \
blowfish.o \
camellia.o \
ccm.o \
cipher.o \
cipher_wrap.o \
cmac.o \
ctr_drbg.o \
des.o \
ecdsa.o \
ecp.o \
ecp_curves.o \
entropy.o \
entropy_poll.o \
gcm.o \
hmac_drbg.o \
md.o \
md2.o \
md4.o \
md5.o \
md_wrap.o \
oid.o \
pem.o \
pk.o \
pk_wrap.o \
pkcs12.o \
pkcs5.o \
pkparse.o \
pkwrite.o \
platform.o \
platform_util.o \
psa_crypto.o \
psa_crypto_storage.o \
psa_crypto_storage_file.o \
ripemd160.o \
rsa_internal.o \
rsa.o \
sha1.o \
sha256.o \
sha512.o \
xtea.o \
# Don't delete this line.
.SILENT:
.PHONY: all static clean
all: static
static: libmbedcrypto.a
libmbedcrypto.a: $(OBJS_CRYPTO)
echo " AR $@"
$(AR) -rc $@ $(OBJS_CRYPTO)
echo " RL $@"
$(AR) -s $@
.c.o:
echo " CC $<"
$(CC) $(CFLAGS) $(WARNING_CFLAGS) -c $<
clean:
rm -f *.o libmbedcrypto.a

View file

@ -1,51 +0,0 @@
CFLAGS ?= -O2 -I../include
WARNING_CFLAGS ?= \
-Werror -Wall -Wextra \
-Wno-unused-function \
-Wno-overlength-strings \
-Wdeclaration-after-statement \
# Don't delete this line.
LDFLAGS ?= -L../library -lmbedcrypto
DEP := ../library/libmbedcrypto.a
APPS := \
psa/crypto_examples \
psa/key_ladder_demo \
psa/psa_constant_names \
# Don't delete this line.
EXTRA_GENERATED := \
psa/psa_constant_names_generated.c \
# Don't delete this line.
.SILENT:
.PHONY: all clean list
all: $(APPS)
$(DEP):
$(MAKE) -C ../library
psa/crypto_examples: psa/crypto_examples.c $(DEP)
echo " CC psa/crypto_examples.c"
$(CC) $(LOCAL_CFLAGS) $(CFLAGS) psa/crypto_examples.c $(LOCAL_LDFLAGS) $(LDFLAGS) -o $@
psa/key_ladder_demo: psa/key_ladder_demo.c $(DEP)
echo " CC psa/key_ladder_demo.c"
$(CC) $(LOCAL_CFLAGS) $(CFLAGS) psa/key_ladder_demo.c $(LOCAL_LDFLAGS) $(LDFLAGS) -o $@
psa/psa_constant_names_generated.c: ../scripts/generate_psa_constants.py ../include/psa/crypto.h
../scripts/generate_psa_constants.py
psa/psa_constant_names: psa/psa_constant_names_generated.c psa/psa_constant_names.c $(DEP)
echo " CC psa/psa_constant_names.c"
$(CC) $(LOCAL_CFLAGS) $(CFLAGS) psa/psa_constant_names.c $(LOCAL_LDFLAGS) $(LDFLAGS) -o $@
clean:
rm -f $(APPS) $(EXTRA_GENERATED)
list:
echo $(APPS)

View file

@ -1,82 +0,0 @@
CFLAGS ?= -O2 -I../include -I../library
WARNING_CFLAGS ?= \
-Werror -Wall -Wextra \
-Wno-unused-function \
-Wno-overlength-strings \
-Wdeclaration-after-statement \
# Don't delete this line.
LDFLAGS ?= -L../library -lmbedcrypto
DEP := ../library/libmbedcrypto.a
# Python executable
PYTHON ?= python
APPS := \
test_suite_psa_crypto \
test_suite_psa_crypto_metadata \
test_suite_psa_crypto_persistent_key \
test_suite_psa_crypto_storage_file \
# Don't delete this line.
# Look up for associated function files
func.test_suite_psa_crypto := test_suite_psa_crypto
func.test_suite_psa_crypto_metadata := test_suite_psa_crypto_metadata
func.test_suite_psa_crypto_persistent_key := test_suite_psa_crypto_persistent_key
func.test_suite_psa_crypto_storage_file := test_suite_psa_crypto_storage_file
.SILENT:
.PHONY: all test clean
all: $(APPS)
$(DEP):
$(MAKE) -C ../library
C_FILES := $(addsuffix .c,$(APPS))
.SECONDEXPANSION:
$(C_FILES): %.c: suites/$$(func.$$*).function suites/%.data scripts/generate_test_code.py suites/helpers.function suites/main_test.function suites/host_test.function
echo " Gen $@"
$(PYTHON) scripts/generate_test_code.py -f suites/$(func.$*).function \
-d suites/$*.data \
-t suites/main_test.function \
-p suites/host_test.function \
-s suites \
--helpers-file suites/helpers.function \
-o .
$(APPS): %: %.c $(DEP)
echo " CC $<"
$(CC) $(CFLAGS) $(WARNING_CFLAGS) $< $(LDFLAGS) -o $@
clean:
rm -rf $(APPS) *.c *.data TESTS
rm -rf data_files/ctr_drbg_seed data_files/hmac_drbg_seed data_files/mpi_write
test: $(APPS)
./test_suite_psa_crypto_metadata
./test_suite_psa_crypto
./test_suite_psa_crypto_persistent_key
./test_suite_psa_crypto_storage_file
# Create separate targets for generating embedded tests.
EMBEDDED_TESTS := $(addprefix embedded_,$(APPS))
# Generate test code for target.
.SECONDEXPANSION:
$(EMBEDDED_TESTS): embedded_%: suites/$$(func.$$*).function suites/%.data scripts/generate_test_code.py suites/helpers.function suites/main_test.function suites/target_test.function
echo " Gen ./TESTS/mbedcrypto/$*/$*.c"
$(PYTHON) scripts/generate_test_code.py -f suites/$(func.$*).function \
-d suites/$*.data \
-t suites/main_test.function \
-p suites/target_test.function \
-s suites \
--helpers-file suites/helpers.function \
-o ./TESTS/mbedcrypto/$*
gen-embedded-test: $(EMBEDDED_TESTS)

View file

@ -3,11 +3,16 @@ option(INSTALL_MBEDTLS_HEADERS "Install mbed TLS headers." ON)
if(INSTALL_MBEDTLS_HEADERS)
file(GLOB headers "mbedtls/*.h")
file(GLOB psa_headers "psa/*.h")
install(FILES ${headers}
DESTINATION include/mbedtls
PERMISSIONS OWNER_READ OWNER_WRITE GROUP_READ WORLD_READ)
install(FILES ${psa_headers}
DESTINATION include/psa
PERMISSIONS OWNER_READ OWNER_WRITE GROUP_READ WORLD_READ)
endif(INSTALL_MBEDTLS_HEADERS)
# Make config.h available in an out-of-source build. ssl-opt.sh requires it.

View file

@ -146,39 +146,64 @@ if(USE_STATIC_MBEDTLS_LIBRARY)
add_library(${mbedcrypto_static_target} STATIC ${src_crypto})
set_target_properties(${mbedcrypto_static_target} PROPERTIES OUTPUT_NAME mbedcrypto)
target_link_libraries(${mbedcrypto_static_target} ${libs})
target_include_directories(${mbedcrypto_static_target}
PUBLIC ${CMAKE_SOURCE_DIR}/include/
PUBLIC ${CMAKE_SOURCE_DIR}/crypto/include/)
add_library(${mbedx509_static_target} STATIC ${src_x509})
set_target_properties(${mbedx509_static_target} PROPERTIES OUTPUT_NAME mbedx509)
target_link_libraries(${mbedx509_static_target} ${libs} ${mbedcrypto_static_target})
if(USE_CRYPTO_SUBMODULE)
install(TARGETS ${mbedcrypto_static_target}
DESTINATION ${LIB_INSTALL_DIR}
PERMISSIONS OWNER_READ OWNER_WRITE OWNER_EXECUTE GROUP_READ GROUP_EXECUTE WORLD_READ WORLD_EXECUTE)
else()
add_library(${mbedx509_static_target} STATIC ${src_x509})
set_target_properties(${mbedx509_static_target} PROPERTIES OUTPUT_NAME mbedx509)
target_link_libraries(${mbedx509_static_target} ${libs} ${mbedcrypto_static_target})
add_library(${mbedtls_static_target} STATIC ${src_tls})
set_target_properties(${mbedtls_static_target} PROPERTIES OUTPUT_NAME mbedtls)
target_link_libraries(${mbedtls_static_target} ${libs} ${mbedx509_static_target})
add_library(${mbedtls_static_target} STATIC ${src_tls})
set_target_properties(${mbedtls_static_target} PROPERTIES OUTPUT_NAME mbedtls)
target_link_libraries(${mbedtls_static_target} ${libs} ${mbedx509_static_target})
install(TARGETS ${mbedtls_static_target} ${mbedx509_static_target} ${mbedcrypto_static_target}
DESTINATION ${LIB_INSTALL_DIR}
PERMISSIONS OWNER_READ OWNER_WRITE OWNER_EXECUTE GROUP_READ GROUP_EXECUTE WORLD_READ WORLD_EXECUTE)
install(TARGETS ${mbedtls_static_target} ${mbedx509_static_target} ${mbedcrypto_static_target}
DESTINATION ${LIB_INSTALL_DIR}
PERMISSIONS OWNER_READ OWNER_WRITE OWNER_EXECUTE GROUP_READ GROUP_EXECUTE WORLD_READ WORLD_EXECUTE)
endif()
endif(USE_STATIC_MBEDTLS_LIBRARY)
if(USE_SHARED_MBEDTLS_LIBRARY)
add_library(mbedcrypto SHARED ${src_crypto})
set_target_properties(mbedcrypto PROPERTIES VERSION 2.14.0 SOVERSION 3)
target_link_libraries(mbedcrypto ${libs})
target_include_directories(mbedcrypto
PUBLIC ${CMAKE_SOURCE_DIR}/include/
PUBLIC ${CMAKE_SOURCE_DIR}/crypto/include/)
add_library(mbedx509 SHARED ${src_x509})
set_target_properties(mbedx509 PROPERTIES VERSION 2.14.0 SOVERSION 0)
target_link_libraries(mbedx509 ${libs} mbedcrypto)
if(USE_CRYPTO_SUBMODULE)
install(TARGETS mbedcrypto
DESTINATION ${LIB_INSTALL_DIR}
PERMISSIONS OWNER_READ OWNER_WRITE OWNER_EXECUTE GROUP_READ GROUP_EXECUTE WORLD_READ WORLD_EXECUTE)
else()
add_library(mbedx509 SHARED ${src_x509})
set_target_properties(mbedx509 PROPERTIES VERSION 2.14.0 SOVERSION 0)
target_link_libraries(mbedx509 ${libs} mbedcrypto)
add_library(mbedtls SHARED ${src_tls})
set_target_properties(mbedtls PROPERTIES VERSION 2.14.0 SOVERSION 12)
target_link_libraries(mbedtls ${libs} mbedx509)
add_library(mbedtls SHARED ${src_tls})
set_target_properties(mbedtls PROPERTIES VERSION 2.14.0 SOVERSION 12)
target_link_libraries(mbedtls ${libs} mbedx509)
install(TARGETS mbedtls mbedx509 mbedcrypto
DESTINATION ${LIB_INSTALL_DIR}
PERMISSIONS OWNER_READ OWNER_WRITE OWNER_EXECUTE GROUP_READ GROUP_EXECUTE WORLD_READ WORLD_EXECUTE)
install(TARGETS mbedtls mbedx509 mbedcrypto
DESTINATION ${LIB_INSTALL_DIR}
PERMISSIONS OWNER_READ OWNER_WRITE OWNER_EXECUTE GROUP_READ GROUP_EXECUTE WORLD_READ WORLD_EXECUTE)
endif()
endif(USE_SHARED_MBEDTLS_LIBRARY)
add_custom_target(lib DEPENDS mbedcrypto mbedx509 mbedtls)
if(USE_STATIC_MBEDTLS_LIBRARY AND USE_SHARED_MBEDTLS_LIBRARY)
add_dependencies(lib mbedcrypto_static mbedx509_static mbedtls_static)
if(USE_CRYPTO_SUBMODULE)
add_custom_target(crypto_lib DEPENDS mbedcrypto)
if(USE_STATIC_MBEDTLS_LIBRARY AND USE_SHARED_MBEDTLS_LIBRARY)
add_dependencies(crypto_lib mbedcrypto_static)
endif()
else()
add_custom_target(lib DEPENDS mbedcrypto mbedx509 mbedtls)
if(USE_STATIC_MBEDTLS_LIBRARY AND USE_SHARED_MBEDTLS_LIBRARY)
add_dependencies(lib mbedcrypto_static mbedx509_static mbedtls_static)
endif()
endif()

View file

@ -5,7 +5,8 @@ CFLAGS ?= -O2
WARNING_CFLAGS ?= -Wall -W -Wdeclaration-after-statement
LDFLAGS ?=
LOCAL_CFLAGS = $(WARNING_CFLAGS) -I../include -D_FILE_OFFSET_BITS=64
CRYPTO_INCLUDES ?= -I../include
LOCAL_CFLAGS = $(WARNING_CFLAGS) $(CRYPTO_INCLUDES) -D_FILE_OFFSET_BITS=64
LOCAL_LDFLAGS =
ifdef DEBUG

View file

@ -1,239 +0,0 @@
###########################################################################
#
# Copyright (c) 2018, ARM Limited, All Rights Reserved
# SPDX-License-Identifier: Apache-2.0
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
###########################################################################
#
# Use this file to export an Mbed Crypto release tarball as follows, from the
# top level of the mbedtls repo:
#
# 1) make -f scripts/mbed_crypto.make
#
.PHONY: all clean FORCE
all: mbedcrypto.tar.gz
#
# Crypto-necessary library files
#
LIB_FILES := \
aes.c \
aesni.c \
arc4.c \
asn1parse.c \
asn1write.c \
base64.c \
bignum.c \
blowfish.c \
camellia.c \
ccm.c \
cipher.c \
cipher_wrap.c \
cmac.c \
ctr_drbg.c \
des.c \
ecdsa.c \
ecp.c \
ecp_curves.c \
entropy.c \
entropy_poll.c \
gcm.c \
hmac_drbg.c \
md.c \
md2.c \
md4.c \
md5.c \
md_wrap.c \
oid.c \
pem.c \
pk.c \
pk_wrap.c \
pkcs12.c \
pkcs5.c \
pkparse.c \
pkwrite.c \
platform.c \
platform_util.c \
psa_crypto.c \
psa_crypto_storage.h \
psa_crypto_storage.c \
psa_crypto_storage_backend.h \
psa_crypto_storage_file.c \
ripemd160.c \
rsa_internal.c \
rsa.c \
sha1.c \
sha256.c \
sha512.c \
xtea.c \
# Don't delete this line.
#
# Crypto-necessary include files
#
INC_FILES := \
mbedcrypto/aes.h \
mbedcrypto/aesni.h \
mbedcrypto/arc4.h \
mbedcrypto/asn1.h \
mbedcrypto/asn1write.h \
mbedcrypto/base64.h \
mbedcrypto/bignum.h \
mbedcrypto/blowfish.h \
mbedcrypto/bn_mul.h \
mbedcrypto/camellia.h \
mbedcrypto/ccm.h \
mbedcrypto/certs.h \
mbedcrypto/check_config.h \
mbedcrypto/cipher.h \
mbedcrypto/cipher_internal.h \
mbedcrypto/cmac.h \
mbedcrypto/config.h \
mbedcrypto/ctr_drbg.h \
mbedcrypto/des.h \
mbedcrypto/ecdsa.h \
mbedcrypto/ecp.h \
mbedcrypto/ecp_internal.h \
mbedcrypto/entropy.h \
mbedcrypto/entropy_poll.h \
mbedcrypto/error.h \
mbedcrypto/gcm.h \
mbedcrypto/hmac_drbg.h \
mbedcrypto/md.h \
mbedcrypto/md2.h \
mbedcrypto/md4.h \
mbedcrypto/md5.h \
mbedcrypto/md_internal.h \
mbedcrypto/oid.h \
mbedcrypto/pem.h \
mbedcrypto/pk.h \
mbedcrypto/pk_internal.h \
mbedcrypto/pkcs11.h \
mbedcrypto/pkcs12.h \
mbedcrypto/pkcs5.h \
mbedcrypto/platform.h \
mbedcrypto/platform_util.h \
mbedcrypto/ripemd160.h \
mbedcrypto/rsa.h \
mbedcrypto/rsa_internal.h \
mbedcrypto/sha1.h \
mbedcrypto/sha256.h \
mbedcrypto/sha512.h \
mbedcrypto/threading.h \
mbedcrypto/xtea.h \
psa/crypto.h \
psa/crypto_extra.h \
psa/crypto_platform.h \
psa/crypto_sizes.h \
psa/crypto_struct.h \
# Don't delete this line.
TEST_FILES := \
tests/scripts/generate_test_code.py \
tests/scripts/mbedtls_test.py \
tests/scripts/test_generate_test_code.py \
tests/scripts/run-test-suites.pl \
tests/suites/helpers.function \
tests/suites/host_test.function \
tests/suites/main_test.function \
tests/suites/target_test.function \
tests/suites/test_suite_psa_crypto.data \
tests/suites/test_suite_psa_crypto.function \
tests/suites/test_suite_psa_crypto_hash.data \
tests/suites/test_suite_psa_crypto_hash.function \
tests/suites/test_suite_psa_crypto_metadata.data \
tests/suites/test_suite_psa_crypto_metadata.function \
tests/suites/test_suite_psa_crypto_persistent_key.data \
tests/suites/test_suite_psa_crypto_persistent_key.function \
tests/suites/test_suite_psa_crypto_storage_file.data \
tests/suites/test_suite_psa_crypto_storage_file.function \
# Don't delete this line.
OTHER_FILES := \
LICENSE \
VERSION.txt \
programs/psa/crypto_examples.c \
programs/psa/key_ladder_demo.c \
programs/psa/key_ladder_demo.sh \
programs/psa/psa_constant_names.c \
scripts/config.pl \
scripts/generate_psa_constants.py \
# Don't delete this line.
# Prepend destination directory
LIB_FILES := $(addprefix crypto/library/,$(LIB_FILES))
INC_FILES := $(addprefix crypto/include/,$(INC_FILES))
TEST_FILES := $(addprefix crypto/,$(TEST_FILES))
OTHER_FILES := $(addprefix crypto/,$(OTHER_FILES))
define rename_mbedcrypto
@sed -i -e 's/Mbed TLS/Mbed Crypto/g' $(1)
@sed -i -e 's/mbed TLS/Mbed Crypto/g' $(1)
@sed -i -e 's/MBEDTLS_/MBEDCRYPTO_/g' $(1)
@sed -i -e 's/mbedtls/mbedcrypto/g' $(1)
@sed -i -e 's/MbedTls/MbedCrypto/g' $(1)
@sed -i -e 's/include\/mbedtls/include\/mbedcrypto/g' $(1)
endef
crypto/include/mbedcrypto/config.h: configs/config-psa-crypto.h
@echo $@
@mkdir -p $(dir $@)
@cp $< $@
@#Rename the file in the comments
@sed -i -e 's/config-psa-crypto.h/config.h/g' $@
$(call rename_mbedcrypto,$@)
crypto/tests/data_files/%: tests/data_files/%
@echo $@
@mkdir -p $(dir $@)
@cp $< $@
@#Don't rename things inside data files
crypto/include/mbedcrypto/%.h: include/mbedtls/%.h
@echo $@
@mkdir -p $(dir $@)
@cp $< $@
$(call rename_mbedcrypto,$@)
crypto/LICENSE: apache-2.0.txt
@echo $@
@mkdir -p $(dir $@)
@cp $< $@
@#Don't rename anything in the license
crypto/%: %
@echo $@
@mkdir -p $(dir $@)
@cp $< $@
$(call rename_mbedcrypto,$@)
crypto/VERSION.txt: FORCE
@git describe --tags --abbrev=12 --dirty --always > $@
mbedcrypto.tar.gz: $(LIB_FILES) $(INC_FILES) $(TEST_FILES) $(OTHER_FILES)
@echo $@
@tar czf mbedcrypto.tar.gz crypto
clean:
@echo clean
@rm -rf mbedcrypto.tar.gz \
$(LIB_FILES) $(INC_FILES) $(TEST_FILES) $(OTHER_FILES)
FORCE:
# vi: ft=make

View file

@ -440,15 +440,6 @@ msg "test: doxygen warnings" # ~ 3s
cleanup
record_status tests/scripts/doxygen.sh
msg "test: Mbed Crypto exporter " # ~ 30s
cleanup
make -f scripts/mbed_crypto.make
cd crypto
make test
make clean
cd ..
make -f scripts/mbed_crypto.make clean
################################################################
#### Build and test many configurations and targets