Line data    Source code

       1             : /**
       2             :  * Copyright Soramitsu Co., Ltd. All Rights Reserved.
       3             :  * SPDX-License-Identifier: Apache-2.0
       4             :  */
       5             : 
       6             : #include <ed25519/ed25519.h>
       7             : 
       8             : #include "cryptography/ed25519_sha3_impl/internal/ed25519_impl.hpp"
       9             : #include "cryptography/ed25519_sha3_impl/internal/sha3_hash.hpp"
      10             : 
      11             : namespace iroha {
      12             : 
      13             :   /**
      14             :    * Sign the message
      15             :    */
      16             :   sig_t sign(const uint8_t *msg,
      17             :              size_t msgsize,
      18             :              const pubkey_t &pub,
      19             :              const privkey_t &priv) {
      20        6462 :     sig_t sig;
      21        6462 :     ed25519_sign(reinterpret_cast<signature_t *>(sig.data()),
      22        6462 :                  msg,
      23        6462 :                  msgsize,
      24        6462 :                  reinterpret_cast<const public_key_t *>(pub.data()),
      25        6462 :                  reinterpret_cast<const private_key_t *>(priv.data()));
      26        6462 :     return sig;
      27             :   }
      28             : 
      29             :   sig_t sign(const std::string &msg,
      30             :              const pubkey_t &pub,
      31             :              const privkey_t &priv) {
      32        6461 :     return sign(
      33        6461 :         reinterpret_cast<const uint8_t *>(msg.data()), msg.size(), pub, priv);
      34             :   }
      35             : 
      36             :   /**
      37             :    * Verify signature
      38             :    */
      39             :   bool verify(const uint8_t *msg,
      40             :               size_t msgsize,
      41             :               const pubkey_t &pub,
      42             :               const sig_t &sig) {
      43       16178 :     return 1
      44       16178 :         == ed25519_verify(reinterpret_cast<const signature_t *>(sig.data()),
      45       16178 :                           msg,
      46       16178 :                           msgsize,
      47       16178 :                           reinterpret_cast<const public_key_t *>(pub.data()));
      48             :   }
      49             : 
      50             :   bool verify(const std::string &msg, const pubkey_t &pub, const sig_t &sig) {
      51       16170 :     return 1
      52       16170 :         == verify(reinterpret_cast<const uint8_t *>(msg.data()),
      53       16170 :                   msg.size(),
      54       16170 :                   pub,
      55       16170 :                   sig);
      56             :   }
      57             : 
      58             :   /**
      59             :    * Generate seed
      60             :    */
      61             :   blob_t<32> create_seed() {
      62         718 :     blob_t<32> seed;
      63         718 :     randombytes(seed.data(), seed.size());
      64         718 :     return seed;
      65             :   }
      66             : 
      67             :   /**
      68             :    * Generate 32 bytes seed based on a passphrase
      69             :    * @param passphrase
      70             :    * @return
      71             :    */
      72             :   blob_t<32> create_seed(std::string passphrase) {
      73           0 :     return sha3_256((uint8_t *)passphrase.data(), passphrase.size());
      74             :   }
      75             : 
      76             :   /**
      77             :    * Create keypair
      78             :    */
      79             :   keypair_t create_keypair(blob_t<32> seed) {
      80         718 :     keypair_t kp;
      81         718 :     kp.privkey = seed;
      82             : 
      83         718 :     ed25519_derive_public_key(
      84         718 :         reinterpret_cast<const private_key_t *>(kp.privkey.data()),
      85         718 :         reinterpret_cast<public_key_t *>(kp.pubkey.data()));
      86             : 
      87         718 :     return kp;
      88             :   }
      89             : 
      90             :   keypair_t create_keypair() {
      91           4 :     return create_keypair(create_seed());
      92             :   }
      93             : }  // namespace iroha