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

Enable use as submodule only (no removal of non-crypto)

.gitignore

@@ -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

Makefile

@@ -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

README.md

@@ -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
+The design goals of the PSA cryptography API include:
--   CMake
--   Microsoft Visual Studio (Microsoft Visual Studio 2010 or later)
 
-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
+* A driver programming interface, which makes it possible to use hardware accelerators instead of the default software implementation for chosen algorithms.
-    cmake /path/to/mbedtls_source
+* Support for external keys to be stored and manipulated exclusively in a separate cryptoprocessor.
-    make
+* 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:
+## Feedback welcome
-
-    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 Contributor’s 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 :)
 
+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.

crypto/.gitignore

@@ -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_*

crypto/Makefile

@@ -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

crypto/README.md

@@ -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.

crypto/library/Makefile

@@ -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

crypto/programs/Makefile

@@ -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)

crypto/tests/Makefile

@@ -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)

include/CMakeLists.txt

@@ -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.

library/CMakeLists.txt

@@ -146,7 +146,15 @@ 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/)
 
+    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})
@@ -158,13 +166,22 @@ if(USE_STATIC_MBEDTLS_LIBRARY)
         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/)
 
+    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)
@@ -176,9 +193,17 @@ if(USE_SHARED_MBEDTLS_LIBRARY)
         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_CRYPTO_SUBMODULE)
-if(USE_STATIC_MBEDTLS_LIBRARY AND USE_SHARED_MBEDTLS_LIBRARY)
+    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()

library/Makefile

@@ -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

scripts/mbed_crypto.make

@@ -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

tests/scripts/all.sh

@@ -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