Hi
                                                          Thillai,
                                                          
                                                          
                                                          Upon
                                                          closer
                                                          examination of
                                                          the logs you
                                                          sent, it
                                                          appears that
                                                          the code
                                                          execution flow
                                                          in both cases
                                                          is not the
                                                          same, and the
                                                          errors
                                                          encountered
                                                          are of a
                                                          different
                                                          nature.
                                                          
                                                          
                                                          My
                                                          previous
                                                          message was
                                                          based on Use
                                                          Case 10, which
                                                          seems to
                                                          correspond to
                                                          a transaction
                                                          involving two
                                                          readings of
                                                          the SFI=14h
                                                          file. However,
                                                          the log for
                                                          this case does
                                                          not display
                                                          DEBUG level
                                                          traces, which
                                                          would be very
                                                          helpful for a
                                                          more in-depth
                                                          analysis.
                                                          
                                                          
                                                          On the
                                                          other hand,
                                                          the log for
                                                          Use Case 4
                                                          does show
                                                          DEBUG traces,
                                                          but here the
                                                          transaction
                                                          concludes with
                                                          an
                                                          "Unauthorized
                                                          key error."
                                                          This specific
                                                          error suggests
                                                          that the card
                                                          you are using
                                                          requires a
                                                          particular
                                                          configuration
                                                          to specify the
                                                          key KIF value
                                                          that is not
                                                          provided by
                                                          this
                                                          particular
                                                          card.
                                                          
                                                          
                                                          Based on
                                                          the JSON file
                                                          generated by
                                                          the card
                                                          analysis tool,
                                                          the KIF value
                                                          to be used for
                                                          this AID  is
                                                          0xFF. In the
                                                          context of the
                                                          Use Case 4
                                                          code, this
                                                          would
                                                          translate to
                                                          an adjustment
                                                          within the
                                                          `initSecuritySetting()`
                                                          method,
                                                          similar to the
                                                          following:
                                                          
                                                          
                                                          private static void initSecuritySetting() {
                                                          
                                                           LegacySam sam =
selectSam(samReader);
                                                          
symmetricCryptoSecuritySetting =
                                                          
                                                          
                                                          
                                                           calypsoCardApiFactory
                                                          
                                                          
                                                          
                                                          
                                                          
                                                           .createSymmetricCryptoSecuritySetting(
                                                          
                                                          
                                                          
                                                          
                                                          
                                                          
                                                          
                                                          
LegacySamExtensionService.getInstance()
                                                          
                                                          
                                                          
                                                          
                                                          
                                                          
                                                          
                                                          
                                                          
                                                          
.getLegacySamApiFactory()
                                                          
                                                          
                                                          
                                                          
                                                          
                                                          
                                                          
                                                          
                                                          
.createSymmetricCryptoCardTransactionManagerFactory(samReader, sam))
                                                          
                                                          
                                                          
                                                          
                                                          
                                                          
                                                          
                                                          
                                                           .assignDefaultKif(PERSONALIZATION,
                                                          (byte) 0xFF)
                                                          
                                                          
                                                          
                                                          
                                                           .assignDefaultKif(LOAD, (byte) 0xFF)
                                                          
                                                          
                                                          
                                                          
                                                           .assignDefaultKif(DEBIT, (byte) 0xFF);
                                                          
                                                          
                                                          
                                                           }
                                                          
                                                          
                                                          Could you
                                                          please try
                                                          implementing
                                                          this change in
                                                          your Use Case
                                                          4 code and
                                                          observe if it
                                                          resolves the
                                                          "Unauthorized
                                                          key error"? 
                                                          Regarding
                                                          use case 10, I
                                                          would need
                                                          more logs to
                                                          help you. But
                                                          the previous
                                                          configuration
                                                          with 0xFF
                                                          should also
                                                          apply here!
                                                          
                                                          
                                                          Best
                                                          regards,
                                                          
                                                          
                                                          Jean-Pierre
                                                          Fortune
                                                          Keyple-Dev Team