starlight-apk/tiny_computer
1
0
Fork 0
mirror of https://github.com/Cateners/tiny_computer.git synced 2026-05-21 08:55:48 +08:00
Code Issues Packages Projects Releases Wiki Activity

Update code to v1.0.14 (10)

Browse Source
This commit is contained in:
Caten
2024-02-29 19:35:00 +08:00
parent c2ee3b694c
commit a956d26f6d
3188 changed files with 2317293 additions and 146 deletions
Download Patch File Download Diff File Expand all files Collapse all files

18
android/extern/wolfssl/IDE/Renesas/e2studio/Projects/README vendored Normal file
View File

@@ -0,0 +1,18 @@
This is procedure how to build wolfssl and test project on Renesas e2studio.
wolfssl:
Build wolfssl.lib
test:
Get missing files
- create DUMMY project
- copy generate directory of DUMMY project under src directory of test project
- uncomment "Use SIM I/O" lines in resetprg.c
- set heap size in sbrk.h
- set stack size in stacksct.h
- replace lowlvl.src with sample project's lowlvl.src which you can download below.
https://www.renesas.com/jp/ja/software/D3012028.html
* copy lowlvl.c and lowlvl.h in sample project's above into src directory of test project too.
Build test wolfCrypt
Setting MPU: R5F565MLCxFC or R5F571MLDxFC

22
android/extern/wolfssl/IDE/Renesas/e2studio/Projects/common/strings.h vendored Normal file
View File

@@ -0,0 +1,22 @@
/* strings.h
*
* Copyright (C) 2006-2022 wolfSSL Inc.
*
* This file is part of wolfSSL.
*
* wolfSSL 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.
*
* wolfSSL 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-1335, USA
*/
int strncasecmp(const char *s1, const char * s2, unsigned int sz);

22
android/extern/wolfssl/IDE/Renesas/e2studio/Projects/common/unistd.h vendored Normal file
View File

@@ -0,0 +1,22 @@
/* unistd.h
*
* Copyright (C) 2006-2022 wolfSSL Inc.
*
* This file is part of wolfSSL.
*
* wolfSSL 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.
*
* wolfSSL 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-1335, USA
*/
/* DUMMY Header */

86
android/extern/wolfssl/IDE/Renesas/e2studio/Projects/common/user_settings.h vendored Normal file
View File

@@ -0,0 +1,86 @@
/* user_settings.h
*
* Copyright (C) 2006-2022 wolfSSL Inc.
*
* This file is part of wolfSSL.
*
* wolfSSL 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.
*
* wolfSSL 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-1335, USA
*/
#define NO_MAIN_DRIVER
#define BENCH_EMBEDDED
#define NO_WRITEV
#define WOLFSSL_USER_IO
#define NO_DEV_RANDOM
#define USE_CERT_BUFFERS_2048
#define WOLFSSL_USER_CURRTIME
#define SIZEOF_LONG_LONG 8
#define NO_WOLFSSL_DIR
#define WOLFSSL_NO_CURRDIR
#define NO_FILESYSTEM
#define WOLFSSL_LOG_PRINTF
#define WOLFSSL_HAVE_MIN
#define WOLFSSL_HAVE_MAX
#if !defined(min)
#define min(data1, data2) _builtin_min(data1, data2)
#endif
#define WOLFSSL_SMALL_STACK
#define WOLFSSL_DH_CONST
#define HAVE_TLS_EXTENSIONS
#define HAVE_SUPPORTED_CURVES
#define USER_TIME
#define XTIME time
#define USE_WOLF_SUSECONDS_T
#define USE_WOLF_TIMEVAL_T
#define WOLFSSL_USER_CURRTIME /* for benchmark */
#define TFM_TIMING_RESISTANT
#define ECC_TIMING_RESISTANT
#define WC_RSA_BLINDING
#define SINGLE_THREADED /* or define RTOS option */
#ifndef SINGLE_THREADED
/* expects use FRERRTOS */
#define FREERTOS
#endif
/* #define NO_DH */
#define HAVE_AESGCM
#define WOLFSSL_SHA512
#define HAVE_ECC
#define HAVE_CURVE25519
#define CURVE25519_SMALL
#define HAVE_ED25519
/* #define NO_WOLFSSL_STUB */
/* #define DEBUG_WOLFSSL */
/* TSIP TLS specific definitions */
#if !defined(WOLFSSL_RENESAS_TSIP)
#define OPENSSL_EXTRA
#define WOLFSSL_GENSEED_FORTEST /* Warning: define your own seed gen */
#else
#if defined(WOLFSSL_RENESAS_RX65N)
/* In the case of Static RSA and AES-CBC use */
#define HAVE_AES_CBC
/* TSIP ver 1.0.6 or lower supports only static RSA as Public-key cryptography. */
#define WOLFSSL_STATIC_RSA
/* for disabling TSIP CRYPT and TSIP TLS */
/* #define NO_RENESAS_TSIP_CRYPT */
/* for disabling only TSIP TLS-linked Common key encryption method */
/* #define NO_WOLFSSL_RENESAS_TSIP_TLS_SESSION */
#endif
#endif

41
android/extern/wolfssl/IDE/Renesas/e2studio/Projects/common/wolfssl_dummy.c vendored Normal file
View File

@@ -0,0 +1,41 @@
/* wolfssl_dummy.c
*
* Copyright (C) 2006-2022 wolfSSL Inc.
*
* This file is part of wolfSSL.
*
* wolfSSL 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.
*
* wolfSSL 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-1335, USA
*/
typedef unsigned long time_t;
#define YEAR 2019
#define MON 5
static int tick = 0;
time_t time(time_t *t)
{
return ((YEAR-1970)*365+30*MON)*24*60*60 + tick++;
}
#include <ctype.h>
int strncasecmp(const char *s1, const char * s2, unsigned int sz)
{
for( ; sz>0; sz--)
if(toupper(s1++) != toupper(s2++))
return 1;
return 0;
}

19
android/extern/wolfssl/IDE/Renesas/e2studio/Projects/include.am vendored Normal file
View File

@@ -0,0 +1,19 @@
# vim:ft=automake
# included from Top Level Makefile.am
# All paths should be given relative to the root
EXTRA_DIST+= IDE/Renesas/e2studio/Projects/README
EXTRA_DIST+= IDE/Renesas/e2studio/Projects/wolfssl/.cproject
EXTRA_DIST+= IDE/Renesas/e2studio/Projects/wolfssl/.project
EXTRA_DIST+= IDE/Renesas/e2studio/Projects/test/.cproject
EXTRA_DIST+= IDE/Renesas/e2studio/Projects/test/.project
EXTRA_DIST+= IDE/Renesas/e2studio/Projects/test/src/test_main.c
EXTRA_DIST+= IDE/Renesas/e2studio/Projects/test/src/key_data.c
EXTRA_DIST+= IDE/Renesas/e2studio/Projects/test/src/key_data.h
EXTRA_DIST+= IDE/Renesas/e2studio/Projects/test/src/wolf_client.c
EXTRA_DIST+= IDE/Renesas/e2studio/Projects/test/src/wolf_server.c
EXTRA_DIST+= IDE/Renesas/e2studio/Projects/test/src/wolfssl_demo.h
EXTRA_DIST+= IDE/Renesas/e2studio/Projects/common/wolfssl_dummy.c
EXTRA_DIST+= IDE/Renesas/e2studio/Projects/common/strings.h
EXTRA_DIST+= IDE/Renesas/e2studio/Projects/common/unistd.h
EXTRA_DIST+= IDE/Renesas/e2studio/Projects/common/user_settings.h

166
android/extern/wolfssl/IDE/Renesas/e2studio/Projects/test/src/key_data.c vendored Normal file
View File

@@ -0,0 +1,166 @@
/* key_data.c
*
* Copyright (C) 2006-2022 wolfSSL Inc.
*
* This file is part of wolfSSL.
*
* wolfSSL 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.
*
* wolfSSL 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-1335, USA
*/
#include "key_data.h"
#ifdef WOLFSSL_RENESAS_TSIP
/* The following key data is an dummy data. */
/* Please replace them by your own data */
const st_key_block_data_t g_key_block_data =
{
/* uint8_t encrypted_session_key[R_TSIP_AES_CBC_IV_BYTE_SIZE * 2]; */
{
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
},
/* uint8_t iv[R_TSIP_AES_CBC_IV_BYTE_SIZE]; */
{
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
},
/* uint8_t encrypted_user_rsa2048_ne_key[R_TSIP_RSA2048_NE_KEY_BYTE_SIZE + 16]; */
{
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
},
};
const uint32_t s_flash[] =
{
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
};
/* ./ca-cert.der.sign, */
const unsigned char ca_cert_sig[] =
{
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00
};
const int sizeof_ca_cert_sig = sizeof(ca_cert_sig);
/* ./client-cert.der.sign, */
const unsigned char client_cert_der_sign[] =
{
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00
};
const int sizeof_client_cert_der_sign = sizeof(client_cert_der_sign);
uint32_t s_inst1[R_TSIP_SINST_WORD_SIZE] = { 0 };
uint32_t s_inst2[R_TSIP_SINST2_WORD_SIZE]= { 0 };
#endif

47
android/extern/wolfssl/IDE/Renesas/e2studio/Projects/test/src/key_data.h vendored Normal file
View File

@@ -0,0 +1,47 @@
/* key_data.h
*
* Copyright (C) 2006-2022 wolfSSL Inc.
*
* This file is part of wolfSSL.
*
* wolfSSL 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.
*
* wolfSSL 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-1335, USA
*/
#ifndef KEY_DATA_H_
#define KEY_DATA_H_
#include <wolfssl/wolfcrypt/settings.h>
#ifdef WOLFSSL_RENESAS_TSIP
#include "r_tsip_rx_if.h"
/** user key data */
typedef struct key_block_data
{
uint8_t encrypted_session_key[R_TSIP_AES_CBC_IV_BYTE_SIZE * 2];
uint8_t iv[R_TSIP_AES_CBC_IV_BYTE_SIZE];
uint8_t encrypted_user_rsa2048_ne_key[R_TSIP_RSA2048_NE_KEY_BYTE_SIZE + 16];
} st_key_block_data_t;
extern const st_key_block_data_t g_key_block_data;
extern const uint32_t s_flash[];
extern const unsigned char ca_cert_der[];
extern const int sizeof_ca_cert_der;
extern const unsigned char ca_cert_sig[];
extern const unsigned char client_cert_der_sign[];
#endif /* WOLFSSL_RENESAS_TSIP */
#endif /* KEY_DATA_H_ */

221
android/extern/wolfssl/IDE/Renesas/e2studio/Projects/test/src/test_main.c vendored Normal file
View File

@@ -0,0 +1,221 @@
/* test_main.c
*
* Copyright (C) 2006-2022 wolfSSL Inc.
*
* This file is part of wolfSSL.
*
* wolfSSL 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.
*
* wolfSSL 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-1335, USA
*/
//#include "typedefine.h"
#ifdef __cplusplus
//#include <ios> // Remove the comment when you use ios
//_SINT ios_base::Init::init_cnt; // Remove the comment when you use ios
#endif
#include "stdio.h"
#include "stdint.h"
#include <wolfssl/wolfcrypt/settings.h>
#include "wolfssl/wolfcrypt/types.h"
#include "wolfssl_demo.h"
void main(void);
#ifdef __cplusplus
extern "C" {
void abort(void);
}
#endif
#if defined(TLS_CLIENT) || defined(TLS_SERVER)
#include "r_t4_itcpip.h"
#include "r_sys_time_rx_if.h"
#include "Pin.h"
#define T4_WORK_SIZE (14800)
static UW tcpudp_work[(T4_WORK_SIZE / 4) + 1];
#if defined(WOLFSSL_RENESAS_TSIP)
#include "key_data.h"
#include <wolfssl/wolfcrypt/port/Renesas/renesas-tsip-crypt.h>
extern const st_key_block_data_t g_key_block_data;
#endif
#endif
static long tick;
static void timeTick(void *pdata)
{
tick++;
}
typedef struct func_args {
int argc;
char** argv;
int return_code;
} func_args;
void wolfcrypt_test(func_args args);
int benchmark_test(void *args);
double current_time(int reset)
{
if(reset) tick = 0 ;
return ((double)tick/FREQ) ;
}
#if defined(TLS_CLIENT) || defined(TLS_SERVER)
int SetTsiptlsKey()
{
#if defined(WOLFSSL_RENESAS_TSIP) && defined(TLS_CLIENT)
tsip_inform_cert_sign((const byte *)ca_cert_sig);
tsip_inform_user_keys((byte*)&g_key_block_data.encrypted_session_key,
(byte*)&g_key_block_data.iv,
(byte*)&g_key_block_data.encrypted_user_rsa2048_ne_key);
#elif defined(WOLFSSL_RENESAS_TSIP) && defined(TLS_SERVER)
tsip_inform_cert_sign((const byte *)client_cert_der_sign);
tsip_inform_user_keys((byte*)&g_key_block_data.encrypted_session_key,
(byte*)&g_key_block_data.iv,
(byte*)&g_key_block_data.encrypted_user_rsa2048_ne_key);
#endif
return 0;
}
int Open_tcp( )
{
ER ercd;
W size;
sys_time_err_t sys_ercd;
char ver[128];
/* cast from uint8_t to char* */
strcpy(ver, (char*)R_t4_version.library);
sys_ercd = R_SYS_TIME_Open();
if (sys_ercd != SYS_TIME_SUCCESS) {
printf("ERROR : R_SYS_TIME_Open() failed\n");
return -1;
}
R_Pins_Create();
/* start LAN controller */
ercd = lan_open();
/* initialize TCP/IP */
size = tcpudp_get_ramsize();
if (size > (sizeof(tcpudp_work))) {
printf("size > (sizeof(tcpudp_work))!\n");
return -1;
}
ercd = tcpudp_open(tcpudp_work);
if (ercd != E_OK) {
printf("ERROR : tcpudp_open failed\n");
return -1;
}
return 0;
}
void Close_tcp()
{
/* end TCP/IP */
tcpudp_close();
lan_close();
R_SYS_TIME_Close();
}
#endif
void main(void)
{
(void)timeTick;
#if defined(CRYPT_TEST) || defined(BENCHMARK)
#if defined(CRYPT_TEST)
int ret;
func_args args = { 0 };
if ((ret = wolfCrypt_Init()) != 0) {
printf("wolfCrypt_Init failed %d\n", ret);
}
printf("Start wolfCrypt Test\n");
wolfcrypt_test(args);
printf("End wolfCrypt Test\n");
if ((ret = wolfCrypt_Cleanup()) != 0) {
printf("wolfCrypt_Cleanup failed %d\n", ret);
}
#endif
#if defined(BENCHMARK)
#include "r_cmt_rx_if.h"
uint32_t channel;
R_CMT_CreatePeriodic(FREQ, &timeTick, &channel);
printf("Start wolfCrypt Benchmark\n");
benchmark_test(NULL);
printf("End wolfCrypt Benchmark\n");
#endif
#elif defined(TLS_CLIENT)
#if defined(WOLFSSL_RENESAS_TSIP)
const char* cipherlist[] = {
/* NULL */
"AES128-SHA",
"AES128-SHA256",
"AES256-SHA",
"AES256-SHA256"
};
const int cipherlist_sz = 4;
#else
const char* cipherlist[] = { NULL };
const int cipherlist_sz = 0;
#endif
int i = 0;
Open_tcp();
#if defined(WOLFSSL_RENESAS_TSIP)
SetTsiptlsKey();
#endif
do {
if(cipherlist_sz > 0 ) printf("cipher : %s\n", cipherlist[i]);
wolfSSL_TLS_client_init(cipherlist[i]);
wolfSSL_TLS_client();
i++;
} while (i < cipherlist_sz);
Close_tcp();
#elif defined(TLS_SERVER)
Open_tcp();
#if defined(WOLFSSL_RENESAS_TSIP)
SetTsiptlsKey();
#endif
wolfSSL_TLS_server_init();
wolfSSL_TLS_server();
Close_tcp();
#endif
}
#ifdef __cplusplus
void abort(void)
{
}
#endif

205
android/extern/wolfssl/IDE/Renesas/e2studio/Projects/test/src/wolf_client.c vendored Normal file
View File

@@ -0,0 +1,205 @@
/* wolf_client.c
*
* Copyright (C) 2006-2022 wolfSSL Inc.
*
* This file is part of wolfSSL.
*
* wolfSSL 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.
*
* wolfSSL 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-1335, USA
*/
#include <stdio.h>
#include <string.h>
#include "r_t4_itcpip.h"
#include "wolfssl/wolfcrypt/settings.h"
#include "wolfssl/ssl.h"
#include "wolfssl/certs_test.h"
#include "key_data.h"
#define SIMPLE_TLSSEVER_IP "192.168.1.45"
#define SIMPLE_TLSSERVER_PORT "11111"
ER t4_tcp_callback(ID cepid, FN fncd , VP p_parblk);
uint32_t g_encrypted_root_public_key[140];
static WOLFSSL_CTX *client_ctx;
static int my_IORecv(WOLFSSL* ssl, char* buff, int sz, void* ctx)
{
int ret;
ID cepid;
if(ctx != NULL)
cepid = *(ID *)ctx;
else
return WOLFSSL_CBIO_ERR_GENERAL;
ret = tcp_rcv_dat(cepid, buff, sz, TMO_FEVR);
if(ret > 0)
return ret;
else
return WOLFSSL_CBIO_ERR_GENERAL;
}
static int my_IOSend(WOLFSSL* ssl, char* buff, int sz, void* ctx)
{
int ret;
ID cepid;
if(ctx != NULL)
cepid = *(ID *)ctx;
else
return WOLFSSL_CBIO_ERR_GENERAL;
ret = tcp_snd_dat(cepid, buff, sz, TMO_FEVR);
if(ret == sz)
return ret;
else
return WOLFSSL_CBIO_ERR_GENERAL;
}
static int getIPaddr(char *arg)
{
int a1, a2, a3, a4;
if(sscanf(arg, "%d.%d.%d.%d", &a1, &a2, &a3, &a4) == 4)
return (a1 << 24) | (a2 << 16) | (a3 << 8) | a4;
else return 0;
}
static int getPort(char *arg)
{
int port;
if(sscanf(arg, "%d", &port) == 1)
return port;
else return 0;
}
void wolfSSL_TLS_client_init(const char* cipherlist)
{
#ifndef NO_FILESYSTEM
#ifdef USE_ECC_CERT
char *cert = "./certs/ca-ecc-cert.pem";
#else
char *cert = "./certs/ca-cert.pem";
#endif
#else
#ifdef USE_ECC_CERT
const unsigned char *cert = ca_ecc_der_256;
#define SIZEOF_CERT sizeof_ca_ecc_der_256
#else
const unsigned char *cert = ca_cert_der_2048;
#define SIZEOF_CERT sizeof_ca_cert_der_2048
#endif
#endif
wolfSSL_Init();
#ifdef DEBUG_WOLFSSL
wolfSSL_Debugging_ON();
#endif
/* Create and initialize WOLFSSL_CTX */
if ((client_ctx = wolfSSL_CTX_new(wolfTLSv1_2_client_method_ex((void *)NULL))) == NULL) {
printf("ERROR: failed to create WOLFSSL_CTX\n");
return;
}
#if !defined(NO_FILESYSTEM)
if (wolfSSL_CTX_load_verify_locations(client_ctx, cert, 0) != SSL_SUCCESS) {
printf("ERROR: can't load \"%s\"\n", cert);
return NULL;
}
#else
if (wolfSSL_CTX_load_verify_buffer(client_ctx, cert, SIZEOF_CERT, SSL_FILETYPE_ASN1) != SSL_SUCCESS){
printf("ERROR: can't load certificate data\n");
return;
}
#endif
/* Register callbacks */
wolfSSL_SetIORecv(client_ctx, my_IORecv);
wolfSSL_SetIOSend(client_ctx, my_IOSend);
/* use specific cipher */
if (cipherlist != NULL && wolfSSL_CTX_set_cipher_list(client_ctx, cipherlist) != WOLFSSL_SUCCESS) {
wolfSSL_CTX_free(client_ctx); client_ctx = NULL;
printf("client can't set cipher list 1");
}
}
void wolfSSL_TLS_client( )
{
ID cepid = 1;
ER ercd;
int ret;
WOLFSSL_CTX *ctx = (WOLFSSL_CTX *)client_ctx;
WOLFSSL *ssl;
#define BUFF_SIZE 256
static const char sendBuff[]= "Hello Server\n" ;
char rcvBuff[BUFF_SIZE] = {0};
static T_IPV4EP my_addr = { 0, 0 };
T_IPV4EP dst_addr;
if((dst_addr.ipaddr = getIPaddr(SIMPLE_TLSSEVER_IP)) == 0){
printf("ERROR: IP address\n");
return;
}
if((dst_addr.portno = getPort(SIMPLE_TLSSERVER_PORT)) == 0){
printf("ERROR: IP address\n");
return;
}
if((ercd = tcp_con_cep(cepid, &my_addr, &dst_addr, TMO_FEVR)) != E_OK) {
printf("ERROR TCP Connect: %d\n", ercd);
return;
}
if((ssl = wolfSSL_new(ctx)) == NULL) {
printf("ERROR wolfSSL_new: %d\n", wolfSSL_get_error(ssl, 0));
return;
}
/* set callback context */
wolfSSL_SetIOReadCtx(ssl, (void *)&cepid);
wolfSSL_SetIOWriteCtx(ssl, (void *)&cepid);
if(wolfSSL_connect(ssl) != SSL_SUCCESS) {
printf("ERROR SSL connect: %d\n", wolfSSL_get_error(ssl, 0));
return;
}
if (wolfSSL_write(ssl, sendBuff, strlen(sendBuff)) != strlen(sendBuff)) {
printf("ERROR SSL write: %d\n", wolfSSL_get_error(ssl, 0));
return;
}
if ((ret=wolfSSL_read(ssl, rcvBuff, BUFF_SIZE)) < 0) {
printf("ERROR SSL read: %d\n", wolfSSL_get_error(ssl, 0));
return;
}
rcvBuff[ret] = '\0' ;
printf("Received: %s\n", rcvBuff);
/* frees all data before client termination */
wolfSSL_free(ssl);
wolfSSL_CTX_free(ctx);
wolfSSL_Cleanup();
tcp_sht_cep(cepid);
tcp_cls_cep(cepid, TMO_FEVR);
return;
}

203
android/extern/wolfssl/IDE/Renesas/e2studio/Projects/test/src/wolf_server.c vendored Normal file
View File

@@ -0,0 +1,203 @@
/* wolf_server.c
*
* Copyright (C) 2006-2022 wolfSSL Inc.
*
* This file is part of wolfSSL.
*
* wolfSSL 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.
*
* wolfSSL 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-1335, USA
*/
#include <stdio.h>
#include <string.h>
#include "r_t4_itcpip.h"
#include "wolfssl/wolfcrypt/settings.h"
#include "wolfssl/ssl.h"
#include "wolfssl/certs_test.h"
#include "wolfssl_demo.h"
static WOLFSSL_CTX *server_ctx;
static byte doCliCertCheck;
static int my_IORecv(WOLFSSL* ssl, char* buff, int sz, void* ctx)
{
int ret;
ID cepid;
if(ctx != NULL)
cepid = *(ID *)ctx;
else
return WOLFSSL_CBIO_ERR_GENERAL;
ret = tcp_rcv_dat(cepid, buff, sz, TMO_FEVR);
if(ret == sz)
return ret;
else
return WOLFSSL_CBIO_ERR_GENERAL;
}
static int my_IOSend(WOLFSSL* ssl, char* buff, int sz, void* ctx)
{
int ret;
ID cepid;
if(ctx != NULL)
cepid = *(ID *)ctx;
else
return WOLFSSL_CBIO_ERR_GENERAL;
ret = tcp_snd_dat(cepid, buff, sz, TMO_FEVR);
if(ret == sz)
return ret;
else
return WOLFSSL_CBIO_ERR_GENERAL;
}
void wolfSSL_TLS_server_init(byte doClientCheck)
{
int ret;
#ifndef NO_FILESYSTEM
#ifdef USE_ECC_CERT
char *cert = "./certs/server-ecc-cert.pem";
char *key = "./certs/server-ecc-key.pem";
#else
char *cert = "./certs/server-cert.pem";
char *key = "./certs/server-key.pem";
#endif
char *clientCert = "./certs/client-cert.pem";
#else
#ifdef USE_ECC_CERT
char *cert = serv_ecc_der_256;
int sizeof_cert = sizeof_serv_ecc_der_256;
char *cert = serv_ecc_key_der_256;
int sizeof_key = sizeof_serv_ecc_key_der_256;
#else
const unsigned char *cert = server_cert_der_2048;
#define sizeof_cert sizeof_server_cert_der_2048
const unsigned char *key = server_key_der_2048;
#define sizeof_key sizeof_server_key_der_2048
const unsigned char *clientCert = client_cert_der_2048;
#define sizeof_clicert sizeof_client_cert_der_2048
#endif
#endif
wolfSSL_Init();
#ifdef DEBUG_WOLFSSL
wolfSSL_Debugging_ON();
#endif
/* Create and initialize WOLFSSL_CTX */
if ((server_ctx = wolfSSL_CTX_new(wolfSSLv23_server_method_ex((void *)NULL)))
== NULL) {
printf("ERROR: failed to create WOLFSSL_CTX\n");
return;
}
#if !defined(NO_FILESYSTEM)
ret = wolfSSL_CTX_use_certificate_file(server_ctx, cert, 0);
#else
ret = wolfSSL_CTX_use_certificate_buffer(server_ctx, cert,
sizeof_cert, SSL_FILETYPE_ASN1);
#endif
if (ret != SSL_SUCCESS) {
printf("Error %d loading server-cert!\n", ret);
return;
}
/* Load server key into WOLFSSL_CTX */
#if !defined(NO_FILESYSTEM)
ret = wolfSSL_CTX_use_PrivateKey_file(server_ctx, key, 0);
#else
ret = wolfSSL_CTX_use_PrivateKey_buffer(server_ctx, key, sizeof_key,
SSL_FILETYPE_ASN1);
#endif
if (ret != SSL_SUCCESS) {
printf("Error %d loading server-key!\n", ret);
return;
}
#if defined(WOLFSSL_RENESAS_TSIP)
doCliCertCheck = 1;
#endif
if (doCliCertCheck) {
wolfSSL_CTX_set_verify(server_ctx, WOLFSSL_VERIFY_PEER |
WOLFSSL_VERIFY_FAIL_IF_NO_PEER_CERT, 0);
#if !defined(NO_FILESYSTEM)
if (wolfSSL_CTX_load_verify_locations(server_ctx, clientCert, 0)
!= WOLFSSL_SUCCESS)
#else
if (wolfSSL_CTX_load_verify_buffer(server_ctx, clientCert,
sizeof_clicert,
SSL_FILETYPE_ASN1) != SSL_SUCCESS)
#endif
printf("can't load ca file, Please run from wolfSSL home dir\n");
}
/* Register callbacks */
wolfSSL_SetIORecv(server_ctx, my_IORecv);
wolfSSL_SetIOSend(server_ctx, my_IOSend);
}
void wolfSSL_TLS_server( )
{
ID cepid = 1;
ID repid = 1;
ER ercd;
WOLFSSL_CTX *ctx = (WOLFSSL_CTX *)server_ctx;
WOLFSSL *ssl;
int len;
#define BUFF_SIZE 256
char buff[BUFF_SIZE];
T_IPV4EP dst_addr = {0, 0};
if((ercd = tcp_acp_cep(cepid, repid, &dst_addr, TMO_FEVR)) != E_OK) {
printf("ERROR TCP Accept: %d\n", ercd);
return;
}
if((ssl = wolfSSL_new(ctx)) == NULL) {
printf("ERROR: failed wolfSSL_new\n");
return;
}
wolfSSL_SetIOReadCtx(ssl, (void *)&cepid);
wolfSSL_SetIOWriteCtx(ssl, (void *)&cepid);
if (wolfSSL_accept(ssl) < 0) {
printf("ERROR: SSL Accept(%d)\n", wolfSSL_get_error(ssl, 0));
return;
}
if ((len = wolfSSL_read(ssl, buff, sizeof(buff) - 1)) < 0) {
printf("ERROR: SSL Read(%d)\n", wolfSSL_get_error(ssl, 0));
return;
}
buff[len] = '\0';
printf("Received: %s\n", buff);
if (wolfSSL_write(ssl, buff, len) != len) {
printf("ERROR: SSL Write(%d)\n", wolfSSL_get_error(ssl, 0));
return;
}
wolfSSL_free(ssl);
tcp_sht_cep(cepid);
}

48
android/extern/wolfssl/IDE/Renesas/e2studio/Projects/test/src/wolfssl_demo.h vendored Normal file
View File

@@ -0,0 +1,48 @@
/* wolfssl_demo.h
*
* Copyright (C) 2006-2022 wolfSSL Inc.
*
* This file is part of wolfSSL.
*
* wolfSSL 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.
*
* wolfSSL 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-1335, USA
*/
#ifndef WOLFSSL_DEMO_H_
#define WOLFSSL_DEMO_H_
#define FREQ 10000 /* Hz */
/* Enable wolfcrypt test */
/* can be enabled with benchmark test */
/* #define CRYPT_TEST */
/* Enable benchmark */
/* can be enabled with cyrpt test */
/* #define BENCHMARK */
/* Enable TLS client */
/* cannot enable with other definition */
/* #define TLS_CLIENT */
/* Enable TLS server */
/* cannot enable with other definition */
/* #define TLS_SERVER */
void wolfSSL_TLS_client_init();
void wolfSSL_TLS_client();
void wolfSSL_TLS_server_init();
void wolfSSL_TLS_server();
#endif /* WOLFSSL_DEMO_H_ */

52
android/extern/wolfssl/IDE/Renesas/e2studio/Projects/tools/generate_rsa_keypair.sh vendored Normal file
View File

@@ -0,0 +1,52 @@
#!/bin/bash
function usage(){
cat << _EOT_
Usage :
$0 [-g] [-]
Description:
Generate 2048 bit Rsa key pair and Display modulus and public exponent
Options:
-g generate rsa key pair, default on
-s only show modulus and public exponent
_EOT_
exit 1
}
FLAG_G="on"
FLAG_S="off"
while getopts gsh OPT
do
case $OPT in
g)
FLAG_G="on"
;;
s)
FLAG_S="on"
FLAG_G="off"
;;
h)
usage
;;
\?)
usage
;;
esac
done
if [ $FLAG_G = "on" ]; then
# generate 2048bit Rsa private key
openssl genrsa 2048 2> /dev/null > private-key.pem
# expose public key
openssl rsa -in private-key.pem -pubout -out public-key.pem 2> /dev/null
fi
if [ $FLAG_S = "on" ]; then
# display modulus and exponent
openssl rsa -modulus < private-key.pem 2>/dev/null | grep Modulus=
openssl rsa -text < private-key.pem 2> /dev/null | grep publicExponent
fi

89
android/extern/wolfssl/IDE/Renesas/e2studio/Projects/tools/genhexbuf.pl vendored Normal file
View File

@@ -0,0 +1,89 @@
#!/usr/bin/perl
# genhexbuf.pl
# Copyright (C) 2020 wolfSSL Inc.
#
use strict;
use warnings;
# ---- SCRIPT SETTINGS -------------------------------------------------------
# output C header file to write cert/key buffers to
my $outputFile = "certs_sig_data.h";
# rsa keys and certs to be converted
my @fileList = (
# please add your der file and name of the data for C language
# der file name name of the data
#[ "./yourder.der", "your_der_name_in_C" ],
[ "./ca-cert.der", "ca_cert_der" ],
[ "./ca-cert.der.sign", "ca_cert_der_sign" ],
);
# ----------------------------------------------------------------------------
my $num = @fileList;
# open our output file, "+>" creates and/or truncates
open OUT_FILE, "+>", $outputFile or die $!;
print OUT_FILE "/* certs_sig_data.h */\n\n";
print OUT_FILE "#ifndef WOLFSSL_CERTS_SIG_DATA_H\n";
print OUT_FILE "#define WOLFSSL_CERTS_SIG_DATA_H\n\n";
# convert and print 1024-bit cert/keys
for (my $i = 0; $i < $num; $i++) {
my $fname = $fileList[$i][0];
my $sname = $fileList[$i][1];
print OUT_FILE "/* $fname, */\n";
print OUT_FILE "static const unsigned char $sname\[] =\n";
print OUT_FILE "{\n";
file_to_hex($fname);
print OUT_FILE "};\n";
print OUT_FILE "static const int sizeof_$sname = sizeof($sname);\n\n";
}
print OUT_FILE "#endif /* WOLFSSL_CERTS_SIG_DATA_H */\n\n";
# print file as hex, comma-separated, as needed by C buffer
sub file_to_hex {
my $fileName = $_[0];
open my $fp, "<", $fileName or die $!;
binmode($fp);
my $fileLen = -s $fileName;
my $byte;
for (my $i = 0, my $j = 1; $i < $fileLen; $i++, $j++)
{
if ($j == 1) {
print OUT_FILE " ";
}
if ($j != 1) {
print OUT_FILE " ";
}
read($fp, $byte, 1) or die "Error reading $fileName";
my $output = sprintf("0x%02X", ord($byte));
print OUT_FILE $output;
if ($i != ($fileLen - 1)) {
print OUT_FILE ",";
}
if ($j == 10) {
$j = 0;
print OUT_FILE "\n";
}
}
print OUT_FILE "\n";
close($fp);
}

34
android/extern/wolfssl/IDE/Renesas/e2studio/Projects/tools/rsa_pss_sign.sh vendored Normal file
View File

@@ -0,0 +1,34 @@
#!/bin/bash
SIGOPT=rsa_padding_mode:pss
SIGOPT2=rsa_pss_saltlen:-1
function usage() {
cat <<_EOT_
Usage:
$0 <pri key> <pub key> <file name>
pri key : private key for sign/verify
pub key : public key for sign/verify
file name : file name to be signed
_EOT_
exit 1
}
if [ $# -ne 3 ]; then
usage
fi
# $1 private key for sign/verify
# $2 public key for verify
# $3 file for sign/verify
openssl dgst -sha256 -sign $1 -sigopt $SIGOPT -sigopt $SIGOPT2 -out $3.sign $3
echo verify by private key
openssl dgst -sha256 -prverify $1 -sigopt $SIGOPT -sigopt $SIGOPT2 -signature $3.sign $3
echo verifiy by public key
openssl dgst -sha256 -verify $2 -sigopt $SIGOPT -sigopt $SIGOPT2 -signature $3.sign $3

0
android/extern/wolfssl/IDE/Renesas/e2studio/Projects/wolfssl/src/.gitkeep vendored Normal file
View File

0
android/extern/wolfssl/IDE/Renesas/e2studio/Projects/wolfssl/wolfcrypt/src/.gitkeep vendored Normal file
View File