Rename cmd_version to cmd_version_openpgp

Signed-off-by: Pol Henarejos <pol.henarejos@cttc.es>

.github/workflows/codeql.yml

@@ -35,7 +35,7 @@ jobs:
         language: [ 'cpp', 'python' ]
         # CodeQL supports [ 'cpp', 'csharp', 'go', 'java', 'javascript', 'python', 'ruby' ]
         # Learn more about CodeQL language support at https://aka.ms/codeql-docs/language-support
-        mode: [ 'pico', 'esp32', 'local' ]
+        mode: [ 'pico', 'local' ]
 
     steps:
     - name: Checkout repository

.github/workflows/nightly.yml

@@ -24,7 +24,7 @@ jobs:
           PICO_SDK_PATH: ../pico-sdk
         run: |
            ./workflows/autobuild.sh pico
-           ./build_pico_openpgp.sh
+           ./build_pico_openpgp.sh --no-eddsa
            ./workflows/autobuild.sh esp32
       - name: Update nightly release
         uses: pyTooling/Actions/releaser@main

.github/workflows/test.yml

@@ -14,10 +14,10 @@ name: "Emulation and test"
 on:
   workflow_dispatch:
   push:
-    branches: [ "main", "piv" ]
+    branches: [ "main", "piv", "eddsa" ]
   pull_request:
     # The branches below must be a subset of the branches above
-    branches: [ "main", "piv" ]
+    branches: [ "main", "piv", "eddsa" ]
   schedule:
     - cron: '23 5 * * 4'
 

CMakeLists.txt

@@ -67,6 +67,7 @@ set(SOURCES ${SOURCES}
         ${CMAKE_CURRENT_LIST_DIR}/src/openpgp/cmd_keypair_gen.c
         ${CMAKE_CURRENT_LIST_DIR}/src/openpgp/cmd_reset_retry.c
         ${CMAKE_CURRENT_LIST_DIR}/src/openpgp/do.c
+        ${CMAKE_CURRENT_LIST_DIR}/src/openpgp/defs.c
 )
 
 set(USB_ITF_CCID 1)

VERSION

@@ -1 +1 @@
-Version=3.4
+Version=3.6

build_pico_openpgp.sh

@@ -1,23 +1,47 @@
 #!/bin/bash
 
 VERSION_MAJOR="3"
-VERSION_MINOR="4"
+VERSION_MINOR="6"
+NO_EDDSA=0
 SUFFIX="${VERSION_MAJOR}.${VERSION_MINOR}"
 #if ! [[ -z "${GITHUB_SHA}" ]]; then
 #    SUFFIX="${SUFFIX}.${GITHUB_SHA}"
 #fi
 
-rm -rf release/*
+if [[ $1 == "--no-eddsa" ]]; then
+    NO_EDDSA=1
+    echo "Skipping EDDSA build"
+fi
+
 mkdir -p build_release
 mkdir -p release
+mkdir -p release_eddsa
+rm -rf -- release/*
+if [[ $NO_EDDSA -eq 0 ]]; then
+    rm -rf -- release_eddsa/*
+fi
 cd build_release
+
 PICO_SDK_PATH="${PICO_SDK_PATH:-../../pico-sdk}"
 board_dir=${PICO_SDK_PATH}/src/boards/include/boards
 for board in "$board_dir"/*
 do
-    board_name="$(basename -- $board .h)"
+    board_name="$(basename -- "$board" .h)"
-    rm -rf *
+    rm -rf -- ./*
-    PICO_SDK_PATH="${PICO_SDK_PATH}" cmake .. -DPICO_BOARD=$board_name
+    PICO_SDK_PATH="${PICO_SDK_PATH}" cmake .. -DPICO_BOARD=$board_name -DSECURE_BOOT_PKEY=../../ec_private_key.pem
     make -j`nproc`
     mv pico_openpgp.uf2 ../release/pico_openpgp_$board_name-$SUFFIX.uf2
 done
+
+# Build with EDDSA
+
+if [[ $NO_EDDSA -eq 0 ]]; then
+    for board in "$board_dir"/*
+    do
+        board_name="$(basename -- "$board" .h)"
+        rm -rf -- ./*
+        PICO_SDK_PATH="${PICO_SDK_PATH}" cmake .. -DPICO_BOARD=$board_name -DSECURE_BOOT_PKEY=../../ec_private_key.pem -DENABLE_EDDSA=1
+        make -j`nproc`
+        mv pico_openpgp.uf2 ../release_eddsa/pico_openpgp_$board_name-$SUFFIX-eddsa1.uf2
+    done
+fi

src/openpgp/CMakeLists.txt

@@ -1,6 +1,6 @@
 idf_component_register(
     SRCS ${SOURCES}
-    INCLUDE_DIRS . ../../pico-keys-sdk/src ../../pico-keys-sdk/src/fs ../../pico-keys-sdk/src/rng ../../pico-keys-sdk/src/usb
+    INCLUDE_DIRS . ../../pico-keys-sdk/src ../../pico-keys-sdk/src/fs ../../pico-keys-sdk/src/rng ../../pico-keys-sdk/src/usb ../../pico-keys-sdk/tinycbor/src
     REQUIRES bootloader_support esp_partition esp_tinyusb zorxx__neopixel mbedtls efuse
 )
 idf_component_set_property(${COMPONENT_NAME} WHOLE_ARCHIVE ON)

src/openpgp/cmd_change_pin.c

@@ -29,6 +29,10 @@ int cmd_change_pin() {
     }
     uint8_t pin_len = file_get_data(pw)[0];
     uint16_t r = 0;
+    r = check_pin(pw, apdu.data, pin_len);
+    if (r != 0x9000) {
+        return r;
+    }
     if ((r = load_dek()) != PICOKEY_OK) {
         return SW_EXEC_ERROR();
     }
@@ -38,10 +42,6 @@ int cmd_change_pin() {
             dek[IV_SIZE + i] ^= otp_key_1[i];
         }
     }
-    r = check_pin(pw, apdu.data, pin_len);
-    if (r != 0x9000) {
-        return r;
-    }
     uint8_t dhash[33];
     dhash[0] = apdu.nc - pin_len;
     double_hash_pin(apdu.data + pin_len, apdu.nc - pin_len, dhash + 1);

src/openpgp/cmd_import_data.c

@@ -156,8 +156,8 @@ int cmd_import_data() {
             return SW_EXEC_ERROR();
         }
     }
-    else if (algo[0] == ALGO_ECDSA || algo[0] == ALGO_ECDH) {
+    else if (algo[0] == ALGO_ECDSA || algo[0] == ALGO_ECDH || algo[0] == ALGO_EDDSA) {
-        mbedtls_ecdsa_context ecdsa;
+        mbedtls_ecp_keypair ecdsa;
         if (p[1] == NULL || len[1] == 0) {
             return SW_WRONG_DATA();
         }
@@ -165,7 +165,7 @@ int cmd_import_data() {
         if (gid == MBEDTLS_ECP_DP_NONE) {
             return SW_FUNC_NOT_SUPPORTED();
         }
-        mbedtls_ecdsa_init(&ecdsa);
+        mbedtls_ecp_keypair_init(&ecdsa);
         if (gid == MBEDTLS_ECP_DP_CURVE25519) {
             mbedtls_ecp_group_load(&ecdsa.grp, gid);
             r = mbedtls_mpi_read_binary(&ecdsa.d, p[1], len[1]);
@@ -174,17 +174,25 @@ int cmd_import_data() {
             r = mbedtls_ecp_read_key(gid, &ecdsa, p[1], len[1]);
         }
         if (r != 0) {
-            mbedtls_ecdsa_free(&ecdsa);
+            mbedtls_ecp_keypair_free(&ecdsa);
             return SW_EXEC_ERROR();
         }
-        r = mbedtls_ecp_mul(&ecdsa.grp, &ecdsa.Q, &ecdsa.d, &ecdsa.grp.G, random_gen, NULL);
+#ifdef MBEDTLS_EDDSA_C
+        if (ecdsa.grp.id == MBEDTLS_ECP_DP_ED25519) {
+            r = mbedtls_ecp_point_edwards(&ecdsa.grp, &ecdsa.Q, &ecdsa.d, random_gen, NULL);
+        }
+        else
+#endif
+        {
+            r = mbedtls_ecp_mul(&ecdsa.grp, &ecdsa.Q, &ecdsa.d, &ecdsa.grp.G, random_gen, NULL);
+        }
         if (r != 0) {
-            mbedtls_ecdsa_free(&ecdsa);
+            mbedtls_ecp_keypair_free(&ecdsa);
             return SW_EXEC_ERROR();
         }
         r = store_keys(&ecdsa, ALGO_ECDSA, fid, true);
         make_ecdsa_response(&ecdsa);
-        mbedtls_ecdsa_free(&ecdsa);
+        mbedtls_ecp_keypair_free(&ecdsa);
         if (r != PICOKEY_OK) {
             return SW_EXEC_ERROR();
         }

src/openpgp/cmd_internal_aut.c

@@ -37,7 +37,7 @@ int cmd_internal_aut() {
     if (!ef) {
         return SW_REFERENCE_NOT_FOUND();
     }
-    if (wait_button_pressed(EF_UIF_AUT) == true) {
+    if (wait_button_pressed_fid(EF_UIF_AUT) == true) {
         return SW_SECURE_MESSAGE_EXEC_ERROR();
     }
     int r = PICOKEY_OK;
@@ -57,17 +57,17 @@ int cmd_internal_aut() {
         }
         res_APDU_size = olen;
     }
-    else if (algo[0] == ALGO_ECDH || algo[0] == ALGO_ECDSA) {
+    else if (algo[0] == ALGO_ECDH || algo[0] == ALGO_ECDSA || algo[0] == ALGO_EDDSA) {
-        mbedtls_ecdsa_context ctx;
+        mbedtls_ecp_keypair ctx;
-        mbedtls_ecdsa_init(&ctx);
+        mbedtls_ecp_keypair_init(&ctx);
         r = load_private_key_ecdsa(&ctx, ef, true);
         if (r != PICOKEY_OK) {
-            mbedtls_ecdsa_free(&ctx);
+            mbedtls_ecp_keypair_free(&ctx);
             return SW_EXEC_ERROR();
         }
         size_t olen = 0;
         r = ecdsa_sign(&ctx, apdu.data, apdu.nc, res_APDU, &olen);
-        mbedtls_ecdsa_free(&ctx);
+        mbedtls_ecp_keypair_free(&ctx);
         if (r != 0) {
             return SW_EXEC_ERROR();
         }

src/openpgp/cmd_keypair_gen.c

@@ -76,23 +76,23 @@ int cmd_keypair_gen() {
                 return SW_EXEC_ERROR();
             }
         }
-        else if (algo[0] == ALGO_ECDH || algo[0] == ALGO_ECDSA) {
+        else if (algo[0] == ALGO_ECDH || algo[0] == ALGO_ECDSA || algo[0] == ALGO_EDDSA) {
             printf("KEYPAIR ECDSA\r\n");
             mbedtls_ecp_group_id gid = get_ec_group_id_from_attr(algo + 1, algo_len - 1);
             if (gid == MBEDTLS_ECP_DP_NONE) {
                 return SW_FUNC_NOT_SUPPORTED();
             }
-            mbedtls_ecdsa_context ecdsa;
+            mbedtls_ecp_keypair ecdsa;
-            mbedtls_ecdsa_init(&ecdsa);
+            mbedtls_ecp_keypair_init(&ecdsa);
             uint8_t index = 0;
             r = mbedtls_ecdsa_genkey(&ecdsa, gid, random_gen, &index);
             if (r != 0) {
-                mbedtls_ecdsa_free(&ecdsa);
+                mbedtls_ecp_keypair_free(&ecdsa);
                 return SW_EXEC_ERROR();
             }
             r = store_keys(&ecdsa, algo[0], fid, true);
             make_ecdsa_response(&ecdsa);
-            mbedtls_ecdsa_free(&ecdsa);
+            mbedtls_ecp_keypair_free(&ecdsa);
             if (r != PICOKEY_OK) {
                 return SW_EXEC_ERROR();
             }

src/openpgp/cmd_pso.c

@@ -66,7 +66,7 @@ int cmd_pso() {
     if (!ef) {
         return SW_REFERENCE_NOT_FOUND();
     }
-    if (wait_button_pressed(pk_fid == EF_PK_SIG ? EF_UIF_SIG : EF_UIF_DEC) == true) {
+    if (wait_button_pressed_fid(pk_fid == EF_PK_SIG ? EF_UIF_SIG : EF_UIF_DEC) == true) {
         return SW_SECURE_MESSAGE_EXEC_ERROR();
     }
     int r = PICOKEY_OK;
@@ -137,18 +137,18 @@ int cmd_pso() {
             res_APDU_size = olen;
         }
     }
-    else if (algo[0] == ALGO_ECDH || algo[0] == ALGO_ECDSA) {
+    else if (algo[0] == ALGO_ECDH || algo[0] == ALGO_ECDSA || algo[0] == ALGO_EDDSA) {
         if (P1(apdu) == 0x9E && P2(apdu) == 0x9A) {
-            mbedtls_ecdsa_context ctx;
+            mbedtls_ecp_keypair ctx;
-            mbedtls_ecdsa_init(&ctx);
+            mbedtls_ecp_keypair_init(&ctx);
             r = load_private_key_ecdsa(&ctx, ef, true);
             if (r != PICOKEY_OK) {
-                mbedtls_ecdsa_free(&ctx);
+                mbedtls_ecp_keypair_free(&ctx);
                 return SW_EXEC_ERROR();
             }
             size_t olen = 0;
             r = ecdsa_sign(&ctx, apdu.data, apdu.nc, res_APDU, &olen);
-            mbedtls_ecdsa_free(&ctx);
+            mbedtls_ecp_keypair_free(&ctx);
             if (r != 0) {
                 return SW_EXEC_ERROR();
             }

src/openpgp/cmd_terminate_df.c

@@ -32,6 +32,6 @@ int cmd_terminate_df() {
         return SW_WRONG_LENGTH();
     }
     initialize_flash(true);
-    scan_files();
+    scan_files_openpgp();
     return SW_OK();
 }

src/openpgp/cmd_version.c

@@ -18,7 +18,7 @@
 #include "openpgp.h"
 #include "version.h"
 
-int cmd_version() {
+int cmd_version_openpgp() {
     res_APDU[res_APDU_size++] = PIPGP_VERSION_MAJOR;
     res_APDU[res_APDU_size++] = PIPGP_VERSION_MINOR;
     res_APDU[res_APDU_size++] = 0x0;

src/openpgp/defs.c

@@ -0,0 +1,20 @@
+/*
+ * This file is part of the Pico OpenPGP distribution (https://github.com/polhenarejos/pico-openpgp).
+ * Copyright (c) 2022 Pol Henarejos.
+ *
+ * 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, version 3.
+ *
+ * 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "openpgp.h"
+
+uint8_t PICO_PRODUCT = 3;

src/openpgp/do.c

@@ -275,6 +275,12 @@ const uint8_t algorithm_attr_cv25519[] = {
     0x2b, 0x06, 0x01, 0x04, 0x01, 0x97, 0x55, 0x01, 0x05, 0x01
 };
 
+const uint8_t algorithm_attr_ed25519[] = {
+    10,
+    ALGO_EDDSA,
+    0x2b, 0x06, 0x01, 0x04, 0x01, 0xda, 0x47, 0x0f, 0x01
+};
+
 int parse_algo(const uint8_t *algo, uint16_t tag) {
     res_APDU[res_APDU_size++] = tag & 0xff;
     memcpy(res_APDU + res_APDU_size, algo, algo[0] + 1);
@@ -300,6 +306,7 @@ int parse_algoinfo(const file_t *f, int mode) {
         datalen += parse_algo(algorithm_attr_bp256r1, EF_ALGO_SIG);
         datalen += parse_algo(algorithm_attr_bp384r1, EF_ALGO_SIG);
         datalen += parse_algo(algorithm_attr_bp512r1, EF_ALGO_SIG);
+        datalen += parse_algo(algorithm_attr_ed25519, EF_ALGO_SIG);
 
         datalen += parse_algo(algorithm_attr_rsa1k, EF_ALGO_DEC);
         datalen += parse_algo(algorithm_attr_rsa2k, EF_ALGO_DEC);
@@ -326,6 +333,7 @@ int parse_algoinfo(const file_t *f, int mode) {
         datalen += parse_algo(algorithm_attr_bp256r1, EF_ALGO_AUT);
         datalen += parse_algo(algorithm_attr_bp384r1, EF_ALGO_AUT);
         datalen += parse_algo(algorithm_attr_bp512r1, EF_ALGO_AUT);
+        datalen += parse_algo(algorithm_attr_ed25519, EF_ALGO_AUT);
         uint16_t lpdif = res_APDU + res_APDU_size - lp - 2;
         *lp++ = lpdif >> 8;
         *lp++ = lpdif & 0xff;

src/openpgp/do.h

@@ -26,3 +26,4 @@ extern const uint8_t algorithm_attr_cv25519[];
 extern const uint8_t algorithm_attr_x448[];
 extern const uint8_t algorithm_attr_rsa2k[];
 extern const uint8_t algorithm_attr_rsa4096[];
+extern const uint8_t algorithm_attr_ed25519[];

src/openpgp/openpgp.c

@@ -30,8 +30,9 @@
 #include "ccid/ccid.h"
 #include "otp.h"
 #include "do.h"
-
+#ifdef MBEDTLS_EDDSA_C
-uint8_t PICO_PRODUCT = 3;
+#include "mbedtls/eddsa.h"
+#endif
 
 bool has_pw1 = false;
 bool has_pw2 = false;
@@ -64,7 +65,7 @@ int openpgp_process_apdu();
 
 extern uint32_t board_button_read(void);
 
-bool wait_button_pressed(uint16_t fid) {
+bool wait_button_pressed_fid(uint16_t fid) {
     uint32_t val = EV_PRESS_BUTTON;
 #ifndef ENABLE_EMULATION
     file_t *ef = search_by_fid(fid, NULL, SPECIFY_ANY);
@@ -96,7 +97,7 @@ void select_file(file_t *pe) {
     }
 }
 
-void scan_files() {
+void scan_files_openpgp() {
     scan_flash();
     file_t *ef;
     if ((ef = search_by_fid(EF_FULL_AID, NULL, SPECIFY_ANY))) {
@@ -285,7 +286,7 @@ void init_openpgp() {
     algo_aut = EF_ALGO_PRIV3;
     pk_dec = EF_PK_DEC;
     pk_aut = EF_PK_AUT;
-    scan_files();
+    scan_files_openpgp();
     //cmd_select();
 }
 
@@ -488,8 +489,8 @@ int store_keys(void *key_ctx, int type, uint16_t key_id, bool use_kek) {
         mbedtls_mpi_write_binary(&rsa->P, kdata, key_size / 2);
         mbedtls_mpi_write_binary(&rsa->Q, kdata + key_size / 2, key_size / 2);
     }
-    else if (type == ALGO_ECDSA || type == ALGO_ECDH) {
+    else if (type == ALGO_ECDSA || type == ALGO_ECDH || type == ALGO_EDDSA) {
-        mbedtls_ecdsa_context *ecdsa = (mbedtls_ecdsa_context *) key_ctx;
+        mbedtls_ecp_keypair *ecdsa = (mbedtls_ecp_keypair *) key_ctx;
         size_t olen = 0;
         kdata[0] = ecdsa->grp.id & 0xff;
         mbedtls_ecp_write_key_ext(ecdsa, &olen, kdata + 1, sizeof(kdata) - 1);
@@ -558,7 +559,7 @@ int load_private_key_rsa(mbedtls_rsa_context *ctx, file_t *fkey, bool use_dek) {
     return PICOKEY_OK;
 }
 
-int load_private_key_ecdsa(mbedtls_ecdsa_context *ctx, file_t *fkey, bool use_dek) {
+int load_private_key_ecdsa(mbedtls_ecp_keypair *ctx, file_t *fkey, bool use_dek) {
     int key_size = file_get_size(fkey);
     uint8_t kdata[67]; //Worst case, 521 bit + 1byte
     memcpy(kdata, file_get_data(fkey), key_size);
@@ -568,11 +569,19 @@ int load_private_key_ecdsa(mbedtls_ecdsa_context *ctx, file_t *fkey, bool use_de
     mbedtls_ecp_group_id gid = kdata[0];
     int r = mbedtls_ecp_read_key(gid, ctx, kdata + 1, key_size - 1);
     if (r != 0) {
-        mbedtls_ecdsa_free(ctx);
+        mbedtls_ecp_keypair_free(ctx);
         return PICOKEY_EXEC_ERROR;
     }
     mbedtls_platform_zeroize(kdata, sizeof(kdata));
-    r = mbedtls_ecp_mul(&ctx->grp, &ctx->Q, &ctx->d, &ctx->grp.G, random_gen, NULL);
+#ifdef MBEDTLS_EDDSA_C
+    if (ctx->grp.id == MBEDTLS_ECP_DP_ED25519) {
+        r = mbedtls_ecp_point_edwards(&ctx->grp, &ctx->Q, &ctx->d, random_gen, NULL);
+    }
+    else
+#endif
+    {
+        r = mbedtls_ecp_mul(&ctx->grp, &ctx->Q, &ctx->d, &ctx->grp.G, random_gen, NULL);
+    }
     if (r != 0) {
         mbedtls_ecdsa_free(ctx);
         return PICOKEY_EXEC_ERROR;
@@ -617,6 +626,11 @@ mbedtls_ecp_group_id get_ec_group_id_from_attr(const uint8_t *algo, size_t algo_
     else if (memcmp(algorithm_attr_x448 + 2, algo, algo_len) == 0) {
         return MBEDTLS_ECP_DP_CURVE448;
     }
+#ifdef MBEDTLS_EDDSA_C
+    else if (memcmp(algorithm_attr_ed25519 + 2, algo, algo_len) == 0) {
+        return MBEDTLS_ECP_DP_ED25519;
+    }
+#endif
     return MBEDTLS_ECP_DP_NONE;
 }
 
@@ -635,7 +649,7 @@ void make_rsa_response(mbedtls_rsa_context *rsa) {
     put_uint16_t_be(res_APDU_size - 5, res_APDU + 3);
 }
 
-void make_ecdsa_response(mbedtls_ecdsa_context *ecdsa) {
+void make_ecdsa_response(mbedtls_ecp_keypair *ecdsa) {
     uint8_t pt[MBEDTLS_ECP_MAX_PT_LEN];
     size_t plen = 0;
     mbedtls_ecp_point_write_binary(&ecdsa->grp,
@@ -728,23 +742,33 @@ int rsa_sign(mbedtls_rsa_context *ctx,
     return r;
 }
 
-int ecdsa_sign(mbedtls_ecdsa_context *ctx,
+int ecdsa_sign(mbedtls_ecp_keypair *ctx,
                const uint8_t *data,
                size_t data_len,
                uint8_t *out,
                size_t *out_len) {
-    mbedtls_mpi ri, si;
+
-    mbedtls_mpi_init(&ri);
+    int r = 0;
-    mbedtls_mpi_init(&si);
+#ifdef MBEDTLS_EDDSA_C
-    int r = mbedtls_ecdsa_sign(&ctx->grp, &ri, &si, &ctx->d, data, data_len, random_gen, NULL);
+    if (ctx->grp.id == MBEDTLS_ECP_DP_ED25519) {
-    if (r == 0) {
+        r = mbedtls_eddsa_write_signature(ctx, data, data_len, out, 64, out_len, MBEDTLS_EDDSA_PURE, NULL, 0, random_gen, NULL);
-        size_t plen = (ctx->grp.nbits + 7) / 8;
+    }
-        mbedtls_mpi_write_binary(&ri, out, plen);
+    else
-        mbedtls_mpi_write_binary(&si, out + plen, plen);
+#endif
-        *out_len = 2 * plen;
+    {
+        mbedtls_mpi ri, si;
+        mbedtls_mpi_init(&ri);
+        mbedtls_mpi_init(&si);
+        r = mbedtls_ecdsa_sign(&ctx->grp, &ri, &si, &ctx->d, data, data_len, random_gen, NULL);
+        if (r == 0) {
+            size_t plen = (ctx->grp.nbits + 7) / 8;
+            mbedtls_mpi_write_binary(&ri, out, plen);
+            mbedtls_mpi_write_binary(&si, out + plen, plen);
+            *out_len = 2 * plen;
+        }
+        mbedtls_mpi_free(&ri);
+        mbedtls_mpi_free(&si);
     }
-    mbedtls_mpi_free(&ri);
-    mbedtls_mpi_free(&si);
     return r;
 }
 
@@ -754,7 +778,7 @@ extern int cmd_get_next_data();
 extern int cmd_put_data();
 extern int cmd_verify();
 extern int cmd_select_data();
-extern int cmd_version();
+extern int cmd_version_openpgp();
 extern int cmd_import_data();
 extern int cmd_change_pin();
 extern int cmd_mse();
@@ -799,7 +823,7 @@ static const cmd_t cmds[] = {
     { INS_INTERNAL_AUT, cmd_internal_aut },
     { INS_MSE, cmd_mse },
     { INS_IMPORT_DATA, cmd_import_data },
-    { INS_VERSION, cmd_version },
+    { INS_VERSION, cmd_version_openpgp },
     { INS_SELECT_DATA, cmd_select_data },
     { INS_GET_NEXT_DATA, cmd_get_next_data },
     { 0x00, 0x0 }

src/openpgp/openpgp.h

@@ -59,6 +59,7 @@ extern int pin_reset_retries(const file_t *pin, bool force);
 #define ALGO_RSA        0x01
 #define ALGO_ECDH       0x12
 #define ALGO_ECDSA      0x13
+#define ALGO_EDDSA      0x16
 #define ALGO_AES        0x70
 #define ALGO_AES_128    0x71
 #define ALGO_AES_192    0x72
@@ -71,8 +72,8 @@ extern int check_pin(const file_t *pin, const uint8_t *data, size_t len);
 extern mbedtls_ecp_group_id get_ec_group_id_from_attr(const uint8_t *algo, size_t algo_len);
 extern int reset_sig_count();
 extern uint16_t algo_dec, algo_aut, pk_dec, pk_aut;
-extern bool wait_button_pressed(uint16_t fid);
+extern bool wait_button_pressed_fid(uint16_t fid);
-extern void scan_files();
+extern void scan_files_openpgp();
 extern int load_aes_key(uint8_t *aes_key, file_t *fkey);
 extern int inc_sig_count();
 extern int dek_encrypt(uint8_t *data, size_t len);

src/openpgp/version.h

@@ -29,7 +29,7 @@
 #define PIV_VERSION_MINOR (PIV_VERSION & 0xff)
 
 
-#define PIPGP_VERSION 0x0304
+#define PIPGP_VERSION 0x0306
 
 #define PIPGP_VERSION_MAJOR ((PIPGP_VERSION >> 8) & 0xff)
 #define PIPGP_VERSION_MINOR (PIPGP_VERSION & 0xff)

tests/build-in-docker.sh

@@ -3,5 +3,5 @@
 source tests/docker_env.sh
 #run_in_docker rm -rf CMakeFiles
 run_in_docker mkdir -p build_in_docker
-run_in_docker -w "$PWD/build_in_docker" cmake -DENABLE_EMULATION=1 ..
+run_in_docker -w "$PWD/build_in_docker" cmake -DENABLE_EMULATION=1 -DENABLE_EDDSA=1 ..
 run_in_docker -w "$PWD/build_in_docker" make -j ${NUM_PROC}