| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,87 @@ | ||
| =================== | ||
| README for PolarSSL | ||
| =================== | ||
|
|
||
| Compiling | ||
| ========= | ||
|
|
||
| There are currently three active build systems within the PolarSSL releases: | ||
|
|
||
| - Make | ||
| - CMake | ||
| - Microsoft Visual Studio | ||
|
|
||
| The main system used for development is CMake. That system is always the most up-to-date. The others should reflect all changes present in the CMake build system, but some features are not ported there by default. | ||
|
|
||
| Make | ||
| ---- | ||
|
|
||
| We intentionally only use the absolute minimum of **Make** functionality, as we have discovered that a lot of **Make** features are not supported on all different implementations of Make on different platforms. As such, the Makefiles sometimes require some handwork or `export` statements in order to work for your platform. | ||
|
|
||
| In order to build the source using Make, just enter at the command line: | ||
|
|
||
| make | ||
|
|
||
| In order to run the tests, enter: | ||
|
|
||
| make check | ||
|
|
||
| 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 PolarSSL Knowledge Base <https://polarssl.org/kb>`_ for articles on your platform or issue. | ||
|
|
||
| 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 KB. | ||
|
|
||
| CMake | ||
| ----- | ||
|
|
||
| In order to build the source using CMake, just enter at the command line: | ||
|
|
||
| cmake . | ||
|
|
||
| make | ||
|
|
||
| There are 3 different active build modes specified within the CMake buildsystem: | ||
|
|
||
| - 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. | ||
|
|
||
| Switching build modes in CMake is simple. For debug mode, enter at the command line: | ||
|
|
||
| cmake -D CMAKE_BUILD_TYPE:String="Debug" . | ||
|
|
||
| In order to run the tests, enter: | ||
|
|
||
| make test | ||
|
|
||
| Microsoft Visual Studio | ||
| ----------------------- | ||
|
|
||
| The build files for Microsoft Visual Studio are generated for Visual Studio 6.0 all future Visual Studio's should be able to open and use this older version of the build files. | ||
|
|
||
| The workspace 'polarssl.dsw' 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. | ||
|
|
||
| Example programs | ||
| ================ | ||
|
|
||
| We've included example programs for a lot of different features and uses in *programs/*. Most programs only focus on a single feature or usage scenario, so keep that in mind when copying parts of the code. | ||
|
|
||
| Tests | ||
| ===== | ||
|
|
||
| PolarSSL includes a elaborate test suite in *tests/* that initially requires Perl to generate the tests files (e.g. *test_suite_mpi.c*). These files are generates 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 template for each test function. The **data file** contains the test cases, specified as parameters that should be pushed into a template function. | ||
|
|
||
| Contributing | ||
| ============ | ||
|
|
||
| #. `Check for open issues <https://github.com/polarssl/polarssl/issues>`_ or | ||
| `start a discussion <https://polarssl.org/discussions>`_ around a feature | ||
| idea or a bug. | ||
| #. Fork the `PolarSSL repository on Github <https://github.com/polarssl/polarssl>`_ | ||
| to start making your changes. | ||
| #. Write a test which shows that the bug was fixed or that the feature works | ||
| as expected. | ||
| #. Send a pull request and bug us until it gets merged and published. We will | ||
| include your name in the ChangeLog :) |
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,11 @@ | ||
| option(INSTALL_POLARSSL_HEADERS "Install PolarSSL headers." ON) | ||
|
|
||
| if(INSTALL_POLARSSL_HEADERS) | ||
|
|
||
| file(GLOB headers "polarssl/*.h") | ||
|
|
||
| install(FILES ${headers} | ||
| DESTINATION include/polarssl | ||
| PERMISSIONS OWNER_READ OWNER_WRITE GROUP_READ WORLD_READ) | ||
|
|
||
| endif(INSTALL_POLARSSL_HEADERS) |
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,107 @@ | ||
| /** | ||
| * \file aesni.h | ||
| * | ||
| * \brief AES-NI for hardware AES acceleration on some Intel processors | ||
| * | ||
| * Copyright (C) 2013, Brainspark B.V. | ||
| * | ||
| * This file is part of PolarSSL (http://www.polarssl.org) | ||
| * Lead Maintainer: Paul Bakker <polarssl_maintainer at polarssl.org> | ||
| * | ||
| * All rights reserved. | ||
| * | ||
| * This program is free software; you can redistribute it and/or modify | ||
| * it under the terms of the GNU General Public License as published by | ||
| * the Free Software Foundation; either version 2 of the License, or | ||
| * (at your option) any later version. | ||
| * | ||
| * This program is distributed in the hope that it will be useful, | ||
| * but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | ||
| * GNU General Public License for more details. | ||
| * | ||
| * You should have received a copy of the GNU General Public License along | ||
| * with this program; if not, write to the Free Software Foundation, Inc., | ||
| * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. | ||
| */ | ||
| #ifndef POLARSSL_AESNI_H | ||
| #define POLARSSL_AESNI_H | ||
|
|
||
| #include "aes.h" | ||
|
|
||
| #define POLARSSL_AESNI_AES 0x02000000u | ||
| #define POLARSSL_AESNI_CLMUL 0x00000002u | ||
|
|
||
| #if defined(POLARSSL_HAVE_ASM) && defined(__GNUC__) && \ | ||
| ( defined(__amd64__) || defined(__x86_64__) ) && \ | ||
| ! defined(POLARSSL_HAVE_X86_64) | ||
| #define POLARSSL_HAVE_X86_64 | ||
| #endif | ||
|
|
||
| #if defined(POLARSSL_HAVE_X86_64) | ||
|
|
||
| /** | ||
| * \brief AES-NI features detection routine | ||
| * | ||
| * \param what The feature to detect | ||
| * (POLARSSL_AESNI_AES or POLARSSL_AESNI_CLMUL) | ||
| * | ||
| * \return 1 if CPU has support for the feature, 0 otherwise | ||
| */ | ||
| int aesni_supports( unsigned int what ); | ||
|
|
||
| /** | ||
| * \brief AES-NI AES-ECB block en(de)cryption | ||
| * | ||
| * \param ctx AES context | ||
| * \param mode AES_ENCRYPT or AES_DECRYPT | ||
| * \param input 16-byte input block | ||
| * \param output 16-byte output block | ||
| * | ||
| * \return 0 on success (cannot fail) | ||
| */ | ||
| int aesni_crypt_ecb( aes_context *ctx, | ||
| int mode, | ||
| const unsigned char input[16], | ||
| unsigned char output[16] ); | ||
|
|
||
| /** | ||
| * \brief GCM multiplication: c = a * b in GF(2^128) | ||
| * | ||
| * \param c Result | ||
| * \param a First operand | ||
| * \param b Second operand | ||
| * | ||
| * \note Both operands and result are bit strings interpreted as | ||
| * elements of GF(2^128) as per the GCM spec. | ||
| */ | ||
| void aesni_gcm_mult( unsigned char c[16], | ||
| const unsigned char a[16], | ||
| const unsigned char b[16] ); | ||
|
|
||
| /** | ||
| * \brief Compute decryption round keys from encryption round keys | ||
| * | ||
| * \param invkey Round keys for the equivalent inverse cipher | ||
| * \param fwdkey Original round keys (for encryption) | ||
| * \param nr Number of rounds (that is, number of round keys minus one) | ||
| */ | ||
| void aesni_inverse_key( unsigned char *invkey, | ||
| const unsigned char *fwdkey, int nr ); | ||
|
|
||
| /** | ||
| * \brief Perform key expansion (for encryption) | ||
| * | ||
| * \param rk Destination buffer where the round keys are written | ||
| * \param key Encryption key | ||
| * \param bits Key size in bits (must be 128, 192 or 256) | ||
| * | ||
| * \return 0 if successful, or POLARSSL_ERR_AES_INVALID_KEY_LENGTH | ||
| */ | ||
| int aesni_setkey_enc( unsigned char *rk, | ||
| const unsigned char *key, | ||
| size_t bits ); | ||
|
|
||
| #endif /* POLARSSL_HAVE_X86_64 */ | ||
|
|
||
| #endif /* POLARSSL_AESNI_H */ |
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,385 @@ | ||
| /** | ||
| * \file compat-1.2.h | ||
| * | ||
| * \brief Backwards compatibility header for PolarSSL-1.2 from PolarSSL-1.3 | ||
| * | ||
| * Copyright (C) 2006-2013, Brainspark B.V. | ||
| * | ||
| * This file is part of PolarSSL (http://www.polarssl.org) | ||
| * Lead Maintainer: Paul Bakker <polarssl_maintainer at polarssl.org> | ||
| * | ||
| * All rights reserved. | ||
| * | ||
| * This program is free software; you can redistribute it and/or modify | ||
| * it under the terms of the GNU General Public License as published by | ||
| * the Free Software Foundation; either version 2 of the License, or | ||
| * (at your option) any later version. | ||
| * | ||
| * This program is distributed in the hope that it will be useful, | ||
| * but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | ||
| * GNU General Public License for more details. | ||
| * | ||
| * You should have received a copy of the GNU General Public License along | ||
| * with this program; if not, write to the Free Software Foundation, Inc., | ||
| * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. | ||
| */ | ||
| #ifndef POLARSSL_COMPAT_1_2_H | ||
| #define POLARSSL_COMPAT_1_2_H | ||
|
|
||
| #include "config.h" | ||
|
|
||
| // Comment out to disable prototype change warnings | ||
| #define SHOW_PROTOTYPE_CHANGE_WARNINGS | ||
|
|
||
| #if defined(_MSC_VER) && !defined(inline) | ||
| #define inline _inline | ||
| #else | ||
| #if defined(__ARMCC_VERSION) && !defined(inline) | ||
| #define inline __inline | ||
| #endif /* __ARMCC_VERSION */ | ||
| #endif /* _MSC_VER */ | ||
|
|
||
| #if defined(_MSC_VER) | ||
| // MSVC does not support #warning | ||
| #undef SHOW_PROTOTYPE_CHANGE_WARNINGS | ||
| #endif | ||
|
|
||
| #if defined(SHOW_PROTOTYPE_CHANGE_WARNINGS) | ||
| #warning "You can disable these warnings by commenting SHOW_PROTOTYPE_CHANGE_WARNINGS in compat-1.2.h" | ||
| #endif | ||
|
|
||
| #if defined(POLARSSL_SHA256_C) | ||
| #define POLARSSL_SHA2_C | ||
| #include "sha256.h" | ||
|
|
||
| /* | ||
| * SHA-2 -> SHA-256 | ||
| */ | ||
| typedef sha256_context sha2_context; | ||
|
|
||
| static inline void sha2_starts( sha256_context *ctx, int is224 ) { | ||
| sha256_starts( ctx, is224 ); | ||
| } | ||
| static inline void sha2_update( sha256_context *ctx, const unsigned char *input, | ||
| size_t ilen ) { | ||
| sha256_update( ctx, input, ilen ); | ||
| } | ||
| static inline void sha2_finish( sha256_context *ctx, unsigned char output[32] ) { | ||
| sha256_finish( ctx, output ); | ||
| } | ||
| static inline int sha2_file( const char *path, unsigned char output[32], int is224 ) { | ||
| return sha256_file( path, output, is224 ); | ||
| } | ||
| static inline void sha2( const unsigned char *input, size_t ilen, | ||
| unsigned char output[32], int is224 ) { | ||
| sha256( input, ilen, output, is224 ); | ||
| } | ||
| static inline void sha2_hmac_starts( sha256_context *ctx, const unsigned char *key, | ||
| size_t keylen, int is224 ) { | ||
| sha256_hmac_starts( ctx, key, keylen, is224 ); | ||
| } | ||
| static inline void sha2_hmac_update( sha256_context *ctx, const unsigned char *input, size_t ilen ) { | ||
| sha256_hmac_update( ctx, input, ilen ); | ||
| } | ||
| static inline void sha2_hmac_finish( sha256_context *ctx, unsigned char output[32] ) { | ||
| sha256_hmac_finish( ctx, output ); | ||
| } | ||
| static inline void sha2_hmac_reset( sha256_context *ctx ) { | ||
| sha256_hmac_reset( ctx ); | ||
| } | ||
| static inline void sha2_hmac( const unsigned char *key, size_t keylen, | ||
| const unsigned char *input, size_t ilen, | ||
| unsigned char output[32], int is224 ) { | ||
| sha256_hmac( key, keylen, input, ilen, output, is224 ); | ||
| } | ||
| static inline int sha2_self_test( int verbose ) { | ||
| return sha256_self_test( verbose ); | ||
| } | ||
| #endif /* POLARSSL_SHA256_C */ | ||
|
|
||
| #if defined(POLARSSL_SHA512_C) | ||
| #define POLARSSL_SHA4_C | ||
| #include "sha512.h" | ||
|
|
||
| /* | ||
| * SHA-4 -> SHA-512 | ||
| */ | ||
| typedef sha512_context sha4_context; | ||
|
|
||
| static inline void sha4_starts( sha512_context *ctx, int is384 ) { | ||
| sha512_starts( ctx, is384 ); | ||
| } | ||
| static inline void sha4_update( sha512_context *ctx, const unsigned char *input, | ||
| size_t ilen ) { | ||
| sha512_update( ctx, input, ilen ); | ||
| } | ||
| static inline void sha4_finish( sha512_context *ctx, unsigned char output[64] ) { | ||
| sha512_finish( ctx, output ); | ||
| } | ||
| static inline int sha4_file( const char *path, unsigned char output[64], int is384 ) { | ||
| return sha512_file( path, output, is384 ); | ||
| } | ||
| static inline void sha4( const unsigned char *input, size_t ilen, | ||
| unsigned char output[32], int is384 ) { | ||
| sha512( input, ilen, output, is384 ); | ||
| } | ||
| static inline void sha4_hmac_starts( sha512_context *ctx, const unsigned char *key, | ||
| size_t keylen, int is384 ) { | ||
| sha512_hmac_starts( ctx, key, keylen, is384 ); | ||
| } | ||
| static inline void sha4_hmac_update( sha512_context *ctx, const unsigned char *input, size_t ilen ) { | ||
| sha512_hmac_update( ctx, input, ilen ); | ||
| } | ||
| static inline void sha4_hmac_finish( sha512_context *ctx, unsigned char output[64] ) { | ||
| sha512_hmac_finish( ctx, output ); | ||
| } | ||
| static inline void sha4_hmac_reset( sha512_context *ctx ) { | ||
| sha512_hmac_reset( ctx ); | ||
| } | ||
| static inline void sha4_hmac( const unsigned char *key, size_t keylen, | ||
| const unsigned char *input, size_t ilen, | ||
| unsigned char output[64], int is384 ) { | ||
| sha512_hmac( key, keylen, input, ilen, output, is384 ); | ||
| } | ||
| static inline int sha4_self_test( int verbose ) { | ||
| return sha512_self_test( verbose ); | ||
| } | ||
| #endif /* POLARSSL_SHA512_C */ | ||
|
|
||
| #if defined(POLARSSL_CIPHER_C) | ||
| #if defined(SHOW_PROTOTYPE_CHANGE_WARNINGS) | ||
| #warning "cipher_reset() prototype changed. Manual change required if used" | ||
| #endif | ||
| #endif | ||
|
|
||
| #if defined(POLARSSL_RSA_C) | ||
| #define SIG_RSA_RAW POLARSSL_MD_NONE | ||
| #define SIG_RSA_MD2 POLARSSL_MD_MD2 | ||
| #define SIG_RSA_MD4 POLARSSL_MD_MD4 | ||
| #define SIG_RSA_MD5 POLARSSL_MD_MD5 | ||
| #define SIG_RSA_SHA1 POLARSSL_MD_SHA1 | ||
| #define SIG_RSA_SHA224 POLARSSL_MD_SHA224 | ||
| #define SIG_RSA_SHA256 POLARSSL_MD_SHA256 | ||
| #define SIG_RSA_SHA384 POLARSSL_MD_SHA384 | ||
| #define SIG_RSA_SHA512 POLARSSL_MD_SHA512 | ||
| #if defined(SHOW_PROTOTYPE_CHANGE_WARNINGS) | ||
| #warning "rsa_pkcs1_verify() prototype changed. Manual change required if used" | ||
| #warning "rsa_pkcs1_decrypt() prototype changed. Manual change required if used" | ||
| #endif | ||
| #endif | ||
|
|
||
| #if defined(POLARSSL_DHM_C) | ||
| #if defined(SHOW_PROTOTYPE_CHANGE_WARNINGS) | ||
| #warning "dhm_calc_secret() prototype changed. Manual change required if used" | ||
| #endif | ||
| #endif | ||
|
|
||
| #if defined(POLARSSL_GCM_C) | ||
| #if defined(SHOW_PROTOTYPE_CHANGE_WARNINGS) | ||
| #warning "gcm_init() prototype changed. Manual change required if used" | ||
| #endif | ||
| #endif | ||
|
|
||
| #if defined(POLARSSL_SSL_CLI_C) | ||
| #if defined(SHOW_PROTOTYPE_CHANGE_WARNINGS) | ||
| #warning "ssl_set_own_cert() prototype changed. Change to ssl_set_own_cert_rsa(). Manual change required if used" | ||
| #endif | ||
| #endif | ||
|
|
||
| #if defined(POLARSSL_X509_USE_C) || defined(POLARSSL_X509_CREATE_C) | ||
| #include "x509.h" | ||
|
|
||
| #define POLARSSL_ERR_X509_CERT_INVALID_FORMAT POLARSSL_ERR_X509_INVALID_FORMAT | ||
| #define POLARSSL_ERR_X509_CERT_INVALID_VERSION POLARSSL_ERR_X509_INVALID_VERSION | ||
| #define POLARSSL_ERR_X509_CERT_INVALID_ALG POLARSSL_ERR_X509_INVALID_ALG | ||
| #define POLARSSL_ERR_X509_CERT_UNKNOWN_SIG_ALG POLARSSL_ERR_X509_UNKNOWN_SIG_ALG | ||
| #define POLARSSL_ERR_X509_CERT_INVALID_NAME POLARSSL_ERR_X509_INVALID_NAME | ||
| #define POLARSSL_ERR_X509_CERT_INVALID_DATE POLARSSL_ERR_X509_INVALID_DATE | ||
| #define POLARSSL_ERR_X509_CERT_INVALID_EXTENSIONS POLARSSL_ERR_X509_INVALID_EXTENSIONS | ||
| #define POLARSSL_ERR_X509_CERT_SIG_MISMATCH POLARSSL_ERR_X509_SIG_MISMATCH | ||
| #define POLARSSL_ERR_X509_CERT_INVALID_SIGNATURE POLARSSL_ERR_X509_INVALID_SIGNATURE | ||
| #define POLARSSL_ERR_X509_CERT_INVALID_SERIAL POLARSSL_ERR_X509_INVALID_SERIAL | ||
| #define POLARSSL_ERR_X509_CERT_UNKNOWN_VERSION POLARSSL_ERR_X509_UNKNOWN_VERSION | ||
|
|
||
| static inline int x509parse_serial_gets( char *buf, size_t size, const x509_buf *serial ) { | ||
| return x509_serial_gets( buf, size, serial ); | ||
| } | ||
| static inline int x509parse_dn_gets( char *buf, size_t size, const x509_name *dn ) { | ||
| return x509_dn_gets( buf, size, dn ); | ||
| } | ||
| static inline int x509parse_time_expired( const x509_time *time ) { | ||
| return x509_time_expired( time ); | ||
| } | ||
| #endif /* POLARSSL_X509_USE_C || POLARSSL_X509_CREATE_C */ | ||
|
|
||
| #if defined(POLARSSL_X509_CRT_PARSE_C) | ||
| #define POLARSSL_X509_PARSE_C | ||
| #include "x509_crt.h" | ||
| typedef x509_crt x509_cert; | ||
|
|
||
| static inline int x509parse_crt_der( x509_cert *chain, const unsigned char *buf, | ||
| size_t buflen ) { | ||
| return x509_crt_parse_der( chain, buf, buflen ); | ||
| } | ||
| static inline int x509parse_crt( x509_cert *chain, const unsigned char *buf, size_t buflen ) { | ||
| return x509_crt_parse( chain, buf, buflen ); | ||
| } | ||
| static inline int x509parse_crtfile( x509_cert *chain, const char *path ) { | ||
| return x509_crt_parse_file( chain, path ); | ||
| } | ||
| static inline int x509parse_crtpath( x509_cert *chain, const char *path ) { | ||
| return x509_crt_parse_path( chain, path ); | ||
| } | ||
| static inline int x509parse_cert_info( char *buf, size_t size, const char *prefix, | ||
| const x509_cert *crt ) { | ||
| return x509_crt_info( buf, size, prefix, crt ); | ||
| } | ||
| static inline int x509parse_verify( x509_cert *crt, x509_cert *trust_ca, | ||
| x509_crl *ca_crl, const char *cn, int *flags, | ||
| int (*f_vrfy)(void *, x509_cert *, int, int *), | ||
| void *p_vrfy ) { | ||
| return x509_crt_verify( crt, trust_ca, ca_crl, cn, flags, f_vrfy, p_vrfy ); | ||
| } | ||
| static inline int x509parse_revoked( const x509_cert *crt, const x509_crl *crl ) { | ||
| return x509_crt_revoked( crt, crl ); | ||
| } | ||
| static inline void x509_free( x509_cert *crt ) { | ||
| x509_crt_free( crt ); | ||
| } | ||
| #endif /* POLARSSL_X509_CRT_PARSE_C */ | ||
|
|
||
| #if defined(POLARSSL_X509_CRL_PARSE_C) | ||
| #define POLARSSL_X509_PARSE_C | ||
| #include "x509_crl.h" | ||
| static inline int x509parse_crl( x509_crl *chain, const unsigned char *buf, size_t buflen ) { | ||
| return x509_crl_parse( chain, buf, buflen ); | ||
| } | ||
| static inline int x509parse_crlfile( x509_crl *chain, const char *path ) { | ||
| return x509_crl_parse_file( chain, path ); | ||
| } | ||
| static inline int x509parse_crl_info( char *buf, size_t size, const char *prefix, | ||
| const x509_crl *crl ) { | ||
| return x509_crl_info( buf, size, prefix, crl ); | ||
| } | ||
| #endif /* POLARSSL_X509_CRL_PARSE_C */ | ||
|
|
||
| #if defined(POLARSSL_X509_CSR_PARSE_C) | ||
| #define POLARSSL_X509_PARSE_C | ||
| #include "x509_csr.h" | ||
| static inline int x509parse_csr( x509_csr *csr, const unsigned char *buf, size_t buflen ) { | ||
| return x509_csr_parse( csr, buf, buflen ); | ||
| } | ||
| static inline int x509parse_csrfile( x509_csr *csr, const char *path ) { | ||
| return x509_csr_parse_file( csr, path ); | ||
| } | ||
| static inline int x509parse_csr_info( char *buf, size_t size, const char *prefix, | ||
| const x509_csr *csr ) { | ||
| return x509_csr_info( buf, size, prefix, csr ); | ||
| } | ||
| #endif /* POLARSSL_X509_CSR_PARSE_C */ | ||
|
|
||
| #if defined(POLARSSL_SSL_TLS_C) | ||
| #include "ssl_ciphersuites.h" | ||
|
|
||
| #define ssl_default_ciphersuites ssl_list_ciphersuites() | ||
| #endif | ||
|
|
||
| #if defined(POLARSSL_PK_PARSE_C) && defined(POLARSSL_RSA_C) | ||
| #include "rsa.h" | ||
| #include "pk.h" | ||
|
|
||
| #define POLARSSL_ERR_X509_PASSWORD_MISMATCH POLARSSL_ERR_PK_PASSWORD_MISMATCH | ||
| #define POLARSSL_ERR_X509_KEY_INVALID_FORMAT POLARSSL_ERR_PK_KEY_INVALID_FORMAT | ||
| #define POLARSSL_ERR_X509_UNKNOWN_PK_ALG POLARSSL_ERR_PK_UNKNOWN_PK_ALG | ||
| #define POLARSSL_ERR_X509_CERT_INVALID_PUBKEY POLARSSL_ERR_PK_INVALID_PUBKEY | ||
|
|
||
| #if defined(POLARSSL_FS_IO) | ||
| static inline int x509parse_keyfile( rsa_context *rsa, const char *path, | ||
| const char *pwd ) { | ||
| int ret; | ||
| pk_context pk; | ||
| pk_init( &pk ); | ||
| ret = pk_parse_keyfile( &pk, path, pwd ); | ||
| if( ret == 0 && ! pk_can_do( &pk, POLARSSL_PK_RSA ) ) | ||
| ret = POLARSSL_ERR_PK_TYPE_MISMATCH; | ||
| if( ret == 0 ) | ||
| rsa_copy( rsa, pk_rsa( pk ) ); | ||
| else | ||
| rsa_free( rsa ); | ||
| pk_free( &pk ); | ||
| return( ret ); | ||
| } | ||
| static inline int x509parse_public_keyfile( rsa_context *rsa, const char *path ) { | ||
| int ret; | ||
| pk_context pk; | ||
| pk_init( &pk ); | ||
| ret = pk_parse_public_keyfile( &pk, path ); | ||
| if( ret == 0 && ! pk_can_do( &pk, POLARSSL_PK_RSA ) ) | ||
| ret = POLARSSL_ERR_PK_TYPE_MISMATCH; | ||
| if( ret == 0 ) | ||
| rsa_copy( rsa, pk_rsa( pk ) ); | ||
| else | ||
| rsa_free( rsa ); | ||
| pk_free( &pk ); | ||
| return( ret ); | ||
| } | ||
| #endif /* POLARSSL_FS_IO */ | ||
|
|
||
| static inline int x509parse_key( rsa_context *rsa, const unsigned char *key, | ||
| size_t keylen, | ||
| const unsigned char *pwd, size_t pwdlen ) { | ||
| int ret; | ||
| pk_context pk; | ||
| pk_init( &pk ); | ||
| ret = pk_parse_key( &pk, key, keylen, pwd, pwdlen ); | ||
| if( ret == 0 && ! pk_can_do( &pk, POLARSSL_PK_RSA ) ) | ||
| ret = POLARSSL_ERR_PK_TYPE_MISMATCH; | ||
| if( ret == 0 ) | ||
| rsa_copy( rsa, pk_rsa( pk ) ); | ||
| else | ||
| rsa_free( rsa ); | ||
| pk_free( &pk ); | ||
| return( ret ); | ||
| } | ||
|
|
||
| static inline int x509parse_public_key( rsa_context *rsa, | ||
| const unsigned char *key, size_t keylen ) | ||
| { | ||
| int ret; | ||
| pk_context pk; | ||
| pk_init( &pk ); | ||
| ret = pk_parse_public_key( &pk, key, keylen ); | ||
| if( ret == 0 && ! pk_can_do( &pk, POLARSSL_PK_RSA ) ) | ||
| ret = POLARSSL_ERR_PK_TYPE_MISMATCH; | ||
| if( ret == 0 ) | ||
| rsa_copy( rsa, pk_rsa( pk ) ); | ||
| else | ||
| rsa_free( rsa ); | ||
| pk_free( &pk ); | ||
| return( ret ); | ||
| } | ||
| #endif /* POLARSSL_PK_PARSE_C && POLARSSL_RSA_C */ | ||
|
|
||
| #if defined(POLARSSL_PK_WRITE_C) && defined(POLARSSL_RSA_C) | ||
| #include "pk.h" | ||
| static inline int x509_write_pubkey_der( unsigned char *buf, size_t len, rsa_context *rsa ) { | ||
| int ret; | ||
| pk_context ctx; | ||
| if( ( ret = pk_init_ctx( &ctx, pk_info_from_type( POLARSSL_PK_RSA ) ) ) != 0 ) return( ret ); | ||
| if( ( ret = rsa_copy( pk_rsa( ctx ), rsa ) ) != 0 ) return( ret ); | ||
| ret = pk_write_pubkey_der( &ctx, buf, len ); | ||
| pk_free( &ctx ); | ||
| return( ret ); | ||
| } | ||
| static inline int x509_write_key_der( unsigned char *buf, size_t len, rsa_context *rsa ) { | ||
| int ret; | ||
| pk_context ctx; | ||
| if( ( ret = pk_init_ctx( &ctx, pk_info_from_type( POLARSSL_PK_RSA ) ) ) != 0 ) return( ret ); | ||
| if( ( ret = rsa_copy( pk_rsa( ctx ), rsa ) ) != 0 ) return( ret ); | ||
| ret = pk_write_key_der( &ctx, buf, len ); | ||
| pk_free( &ctx ); | ||
| return( ret ); | ||
| } | ||
| #endif /* POLARSSL_PK_WRITE_C && POLARSSL_RSA_C */ | ||
| #endif /* compat-1.2.h */ |
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,215 @@ | ||
| /** | ||
| * \file ecdh.h | ||
| * | ||
| * \brief Elliptic curve Diffie-Hellman | ||
| * | ||
| * Copyright (C) 2006-2013, Brainspark B.V. | ||
| * | ||
| * This file is part of PolarSSL (http://www.polarssl.org) | ||
| * Lead Maintainer: Paul Bakker <polarssl_maintainer at polarssl.org> | ||
| * | ||
| * All rights reserved. | ||
| * | ||
| * This program is free software; you can redistribute it and/or modify | ||
| * it under the terms of the GNU General Public License as published by | ||
| * the Free Software Foundation; either version 2 of the License, or | ||
| * (at your option) any later version. | ||
| * | ||
| * This program is distributed in the hope that it will be useful, | ||
| * but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | ||
| * GNU General Public License for more details. | ||
| * | ||
| * You should have received a copy of the GNU General Public License along | ||
| * with this program; if not, write to the Free Software Foundation, Inc., | ||
| * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. | ||
| */ | ||
| #ifndef POLARSSL_ECDH_H | ||
| #define POLARSSL_ECDH_H | ||
|
|
||
| #include "ecp.h" | ||
|
|
||
| #ifdef __cplusplus | ||
| extern "C" { | ||
| #endif | ||
|
|
||
| /** | ||
| * When importing from an EC key, select if it is our key or the peer's key | ||
| */ | ||
| typedef enum | ||
| { | ||
| POLARSSL_ECDH_OURS, | ||
| POLARSSL_ECDH_THEIRS, | ||
| } ecdh_side; | ||
|
|
||
| /** | ||
| * \brief ECDH context structure | ||
| */ | ||
| typedef struct | ||
| { | ||
| ecp_group grp; /*!< ellipitic curve used */ | ||
| mpi d; /*!< our secret value */ | ||
| ecp_point Q; /*!< our public value */ | ||
| ecp_point Qp; /*!< peer's public value */ | ||
| mpi z; /*!< shared secret */ | ||
| int point_format; /*!< format for point export */ | ||
| ecp_point Vi; /*!< blinding value (for later) */ | ||
| ecp_point Vf; /*!< un-blinding value (for later) */ | ||
| mpi _d; /*!< previous d */ | ||
| } | ||
| ecdh_context; | ||
|
|
||
| /** | ||
| * \brief Generate a public key | ||
| * | ||
| * \param grp ECP group | ||
| * \param d Destination MPI (secret exponent) | ||
| * \param Q Destination point (public key) | ||
| * \param f_rng RNG function | ||
| * \param p_rng RNG parameter | ||
| * | ||
| * \return 0 if successful, | ||
| * or a POLARSSL_ERR_ECP_XXX or POLARSSL_MPI_XXX error code | ||
| */ | ||
| int ecdh_gen_public( ecp_group *grp, mpi *d, ecp_point *Q, | ||
| int (*f_rng)(void *, unsigned char *, size_t), | ||
| void *p_rng ); | ||
|
|
||
| /** | ||
| * \brief Compute shared secret | ||
| * | ||
| * \param grp ECP group | ||
| * \param z Destination MPI (shared secret) | ||
| * \param Q Public key from other party | ||
| * \param d Our secret exponent | ||
| * \param f_rng RNG function (see notes) | ||
| * \param p_rng RNG parameter | ||
| * | ||
| * \return 0 if successful, | ||
| * or a POLARSSL_ERR_ECP_XXX or POLARSSL_MPI_XXX error code | ||
| * | ||
| * \note If f_rng is not NULL, it is used to implement | ||
| * countermeasures against potential elaborate timing | ||
| * attacks, see \c ecp_mul() for details. | ||
| */ | ||
| int ecdh_compute_shared( ecp_group *grp, mpi *z, | ||
| const ecp_point *Q, const mpi *d, | ||
| int (*f_rng)(void *, unsigned char *, size_t), | ||
| void *p_rng ); | ||
|
|
||
| /** | ||
| * \brief Initialize context | ||
| * | ||
| * \param ctx Context to initialize | ||
| */ | ||
| void ecdh_init( ecdh_context *ctx ); | ||
|
|
||
| /** | ||
| * \brief Free context | ||
| * | ||
| * \param ctx Context to free | ||
| */ | ||
| void ecdh_free( ecdh_context *ctx ); | ||
|
|
||
| /** | ||
| * \brief Setup and write the ServerKeyExhange parameters | ||
| * | ||
| * \param ctx ECDH context | ||
| * \param olen number of chars written | ||
| * \param buf destination buffer | ||
| * \param blen length of buffer | ||
| * \param f_rng RNG function | ||
| * \param p_rng RNG parameter | ||
| * | ||
| * \note This function assumes that ctx->grp has already been | ||
| * properly set (for example using ecp_use_known_dp). | ||
| * | ||
| * \return 0 if successful, or an POLARSSL_ERR_ECP_XXX error code | ||
| */ | ||
| int ecdh_make_params( ecdh_context *ctx, size_t *olen, | ||
| unsigned char *buf, size_t blen, | ||
| int (*f_rng)(void *, unsigned char *, size_t), | ||
| void *p_rng ); | ||
|
|
||
| /** | ||
| * \brief Parse the ServerKeyExhange parameters | ||
| * | ||
| * \param ctx ECDH context | ||
| * \param buf pointer to start of input buffer | ||
| * \param end one past end of buffer | ||
| * | ||
| * \return 0 if successful, or an POLARSSL_ERR_ECP_XXX error code | ||
| */ | ||
| int ecdh_read_params( ecdh_context *ctx, | ||
| const unsigned char **buf, const unsigned char *end ); | ||
|
|
||
| /** | ||
| * \brief Setup an ECDH context from an EC key | ||
| * | ||
| * \param ctx ECDH constext to set | ||
| * \param key EC key to use | ||
| * \param side Is it our key (1) or the peer's key (0) ? | ||
| * | ||
| * \return 0 if successful, or an POLARSSL_ERR_ECP_XXX error code | ||
| */ | ||
| int ecdh_get_params( ecdh_context *ctx, const ecp_keypair *key, | ||
| ecdh_side side ); | ||
|
|
||
| /** | ||
| * \brief Setup and export the client's public value | ||
| * | ||
| * \param ctx ECDH context | ||
| * \param olen number of bytes actually written | ||
| * \param buf destination buffer | ||
| * \param blen size of destination buffer | ||
| * \param f_rng RNG function | ||
| * \param p_rng RNG parameter | ||
| * | ||
| * \return 0 if successful, or an POLARSSL_ERR_ECP_XXX error code | ||
| */ | ||
| int ecdh_make_public( ecdh_context *ctx, size_t *olen, | ||
| unsigned char *buf, size_t blen, | ||
| int (*f_rng)(void *, unsigned char *, size_t), | ||
| void *p_rng ); | ||
|
|
||
| /** | ||
| * \brief Parse and import the client's public value | ||
| * | ||
| * \param ctx ECDH context | ||
| * \param buf start of input buffer | ||
| * \param blen length of input buffer | ||
| * | ||
| * \return 0 if successful, or an POLARSSL_ERR_ECP_XXX error code | ||
| */ | ||
| int ecdh_read_public( ecdh_context *ctx, | ||
| const unsigned char *buf, size_t blen ); | ||
|
|
||
| /** | ||
| * \brief Derive and export the shared secret | ||
| * | ||
| * \param ctx ECDH context | ||
| * \param olen number of bytes written | ||
| * \param buf destination buffer | ||
| * \param blen buffer length | ||
| * \param f_rng RNG function, see notes for \c ecdh_compute_shared() | ||
| * \param p_rng RNG parameter | ||
| * | ||
| * \return 0 if successful, or an POLARSSL_ERR_ECP_XXX error code | ||
| */ | ||
| int ecdh_calc_secret( ecdh_context *ctx, size_t *olen, | ||
| unsigned char *buf, size_t blen, | ||
| int (*f_rng)(void *, unsigned char *, size_t), | ||
| void *p_rng ); | ||
|
|
||
| /** | ||
| * \brief Checkup routine | ||
| * | ||
| * \return 0 if successful, or 1 if the test failed | ||
| */ | ||
| int ecdh_self_test( int verbose ); | ||
|
|
||
| #ifdef __cplusplus | ||
| } | ||
| #endif | ||
|
|
||
| #endif |
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,234 @@ | ||
| /** | ||
| * \file ecdsa.h | ||
| * | ||
| * \brief Elliptic curve DSA | ||
| * | ||
| * Copyright (C) 2006-2013, Brainspark B.V. | ||
| * | ||
| * This file is part of PolarSSL (http://www.polarssl.org) | ||
| * Lead Maintainer: Paul Bakker <polarssl_maintainer at polarssl.org> | ||
| * | ||
| * All rights reserved. | ||
| * | ||
| * This program is free software; you can redistribute it and/or modify | ||
| * it under the terms of the GNU General Public License as published by | ||
| * the Free Software Foundation; either version 2 of the License, or | ||
| * (at your option) any later version. | ||
| * | ||
| * This program is distributed in the hope that it will be useful, | ||
| * but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | ||
| * GNU General Public License for more details. | ||
| * | ||
| * You should have received a copy of the GNU General Public License along | ||
| * with this program; if not, write to the Free Software Foundation, Inc., | ||
| * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. | ||
| */ | ||
| #ifndef POLARSSL_ECDSA_H | ||
| #define POLARSSL_ECDSA_H | ||
|
|
||
| #include "ecp.h" | ||
|
|
||
| #if defined(POLARSSL_ECDSA_DETERMINISTIC) | ||
| #include "polarssl/md.h" | ||
| #endif | ||
|
|
||
| /** | ||
| * \brief ECDSA context structure | ||
| * | ||
| * \note Purposefully begins with the same members as struct ecp_keypair. | ||
| */ | ||
| typedef struct | ||
| { | ||
| ecp_group grp; /*!< ellipitic curve used */ | ||
| mpi d; /*!< secret signature key */ | ||
| ecp_point Q; /*!< public signature key */ | ||
| mpi r; /*!< first integer from signature */ | ||
| mpi s; /*!< second integer from signature */ | ||
| } | ||
| ecdsa_context; | ||
|
|
||
| #ifdef __cplusplus | ||
| extern "C" { | ||
| #endif | ||
|
|
||
| /** | ||
| * \brief Compute ECDSA signature of a previously hashed message | ||
| * | ||
| * \param grp ECP group | ||
| * \param r First output integer | ||
| * \param s Second output integer | ||
| * \param d Private signing key | ||
| * \param buf Message hash | ||
| * \param blen Length of buf | ||
| * \param f_rng RNG function | ||
| * \param p_rng RNG parameter | ||
| * | ||
| * \return 0 if successful, | ||
| * or a POLARSSL_ERR_ECP_XXX or POLARSSL_MPI_XXX error code | ||
| */ | ||
| int ecdsa_sign( ecp_group *grp, mpi *r, mpi *s, | ||
| const mpi *d, const unsigned char *buf, size_t blen, | ||
| int (*f_rng)(void *, unsigned char *, size_t), void *p_rng ); | ||
|
|
||
| #if defined(POLARSSL_ECDSA_DETERMINISTIC) | ||
| /** | ||
| * \brief Compute ECDSA signature of a previously hashed message | ||
| * (deterministic version) | ||
| * | ||
| * \param grp ECP group | ||
| * \param r First output integer | ||
| * \param s Second output integer | ||
| * \param d Private signing key | ||
| * \param buf Message hash | ||
| * \param blen Length of buf | ||
| * \param md_alg MD algorithm used to hash the message | ||
| * | ||
| * \return 0 if successful, | ||
| * or a POLARSSL_ERR_ECP_XXX or POLARSSL_MPI_XXX error code | ||
| */ | ||
| int ecdsa_sign_det( ecp_group *grp, mpi *r, mpi *s, | ||
| const mpi *d, const unsigned char *buf, size_t blen, | ||
| md_type_t md_alg ); | ||
| #endif | ||
|
|
||
| /** | ||
| * \brief Verify ECDSA signature of a previously hashed message | ||
| * | ||
| * \param grp ECP group | ||
| * \param buf Message hash | ||
| * \param blen Length of buf | ||
| * \param Q Public key to use for verification | ||
| * \param r First integer of the signature | ||
| * \param s Second integer of the signature | ||
| * | ||
| * \return 0 if successful, | ||
| * POLARSSL_ERR_ECP_BAD_INPUT_DATA if signature is invalid | ||
| * or a POLARSSL_ERR_ECP_XXX or POLARSSL_MPI_XXX error code | ||
| */ | ||
| int ecdsa_verify( ecp_group *grp, | ||
| const unsigned char *buf, size_t blen, | ||
| const ecp_point *Q, const mpi *r, const mpi *s); | ||
|
|
||
| /** | ||
| * \brief Compute ECDSA signature and write it to buffer, | ||
| * serialized as defined in RFC 4492 page 20. | ||
| * (Not thread-safe to use same context in multiple threads) | ||
| * | ||
| * \param ctx ECDSA context | ||
| * \param hash Message hash | ||
| * \param hlen Length of hash | ||
| * \param sig Buffer that will hold the signature | ||
| * \param slen Length of the signature written | ||
| * \param f_rng RNG function | ||
| * \param p_rng RNG parameter | ||
| * | ||
| * \note The "sig" buffer must be at least as large as twice the | ||
| * size of the curve used, plus 7 (eg. 71 bytes if a 256-bit | ||
| * curve is used). | ||
| * | ||
| * \return 0 if successful, | ||
| * or a POLARSSL_ERR_ECP, POLARSSL_ERR_MPI or | ||
| * POLARSSL_ERR_ASN1 error code | ||
| */ | ||
| int ecdsa_write_signature( ecdsa_context *ctx, | ||
| const unsigned char *hash, size_t hlen, | ||
| unsigned char *sig, size_t *slen, | ||
| int (*f_rng)(void *, unsigned char *, size_t), | ||
| void *p_rng ); | ||
|
|
||
| #if defined(POLARSSL_ECDSA_DETERMINISTIC) | ||
| /** | ||
| * \brief Compute ECDSA signature and write it to buffer, | ||
| * serialized as defined in RFC 4492 page 20. | ||
| * Deterministic version, RFC 6979. | ||
| * (Not thread-safe to use same context in multiple threads) | ||
| * | ||
| * \param ctx ECDSA context | ||
| * \param hash Message hash | ||
| * \param hlen Length of hash | ||
| * \param sig Buffer that will hold the signature | ||
| * \param slen Length of the signature written | ||
| * \param md_alg MD algorithm used to hash the message | ||
| * | ||
| * \note The "sig" buffer must be at least as large as twice the | ||
| * size of the curve used, plus 7 (eg. 71 bytes if a 256-bit | ||
| * curve is used). | ||
| * | ||
| * \return 0 if successful, | ||
| * or a POLARSSL_ERR_ECP, POLARSSL_ERR_MPI or | ||
| * POLARSSL_ERR_ASN1 error code | ||
| */ | ||
| int ecdsa_write_signature_det( ecdsa_context *ctx, | ||
| const unsigned char *hash, size_t hlen, | ||
| unsigned char *sig, size_t *slen, | ||
| md_type_t md_alg ); | ||
| #endif | ||
|
|
||
| /** | ||
| * \brief Read and verify an ECDSA signature | ||
| * | ||
| * \param ctx ECDSA context | ||
| * \param hash Message hash | ||
| * \param hlen Size of hash | ||
| * \param sig Signature to read and verify | ||
| * \param slen Size of sig | ||
| * | ||
| * \return 0 if successful, | ||
| * POLARSSL_ERR_ECP_BAD_INPUT_DATA if signature is invalid | ||
| * or a POLARSSL_ERR_ECP or POLARSSL_ERR_MPI error code | ||
| */ | ||
| int ecdsa_read_signature( ecdsa_context *ctx, | ||
| const unsigned char *hash, size_t hlen, | ||
| const unsigned char *sig, size_t slen ); | ||
|
|
||
| /** | ||
| * \brief Generate an ECDSA keypair on the given curve | ||
| * | ||
| * \param ctx ECDSA context in which the keypair should be stored | ||
| * \param gid Group (elliptic curve) to use. One of the various | ||
| * POLARSSL_ECP_DP_XXX macros depending on configuration. | ||
| * \param f_rng RNG function | ||
| * \param p_rng RNG parameter | ||
| * | ||
| * \return 0 on success, or a POLARSSL_ERR_ECP code. | ||
| */ | ||
| int ecdsa_genkey( ecdsa_context *ctx, ecp_group_id gid, | ||
| int (*f_rng)(void *, unsigned char *, size_t), void *p_rng ); | ||
|
|
||
| /** | ||
| * \brief Set an ECDSA context from an EC key pair | ||
| * | ||
| * \param ctx ECDSA context to set | ||
| * \param key EC key to use | ||
| * | ||
| * \return 0 on success, or a POLARSSL_ERR_ECP code. | ||
| */ | ||
| int ecdsa_from_keypair( ecdsa_context *ctx, const ecp_keypair *key ); | ||
|
|
||
| /** | ||
| * \brief Initialize context | ||
| * | ||
| * \param ctx Context to initialize | ||
| */ | ||
| void ecdsa_init( ecdsa_context *ctx ); | ||
|
|
||
| /** | ||
| * \brief Free context | ||
| * | ||
| * \param ctx Context to free | ||
| */ | ||
| void ecdsa_free( ecdsa_context *ctx ); | ||
|
|
||
| /** | ||
| * \brief Checkup routine | ||
| * | ||
| * \return 0 if successful, or 1 if the test failed | ||
| */ | ||
| int ecdsa_self_test( int verbose ); | ||
|
|
||
| #ifdef __cplusplus | ||
| } | ||
| #endif | ||
|
|
||
| #endif |