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        5192 :     sig_t sig;
      21        5192 :     ed25519_sign(reinterpret_cast<signature_t *>(sig.data()),
      22        5192 :                  msg,
      23        5192 :                  msgsize,
      24        5192 :                  reinterpret_cast<const public_key_t *>(pub.data()),
      25        5192 :                  reinterpret_cast<const private_key_t *>(priv.data()));
      26        5192 :     return sig;
      27             :   }
      28             : 
      29             :   sig_t sign(const std::string &msg,
      30             :              const pubkey_t &pub,
      31             :              const privkey_t &priv) {
      32        5190 :     return sign(
      33        5190 :         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        4653 :     return 1
      44        4653 :         == ed25519_verify(reinterpret_cast<const signature_t *>(sig.data()),
      45        4653 :                           msg,
      46        4653 :                           msgsize,
      47        4653 :                           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        4652 :     return 1
      52        4652 :         == verify(reinterpret_cast<const uint8_t *>(msg.data()),
      53        4652 :                   msg.size(),
      54        4652 :                   pub,
      55        4652 :                   sig);
      56             :   }
      57             : 
      58             :   /**
      59             :    * Generate seed
      60             :    */
      61             :   blob_t<32> create_seed() {
      62        2778 :     blob_t<32> seed;
      63        2778 :     randombytes(seed.data(), seed.size());
      64        2778 :     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        2780 :     keypair_t kp;
      81        2780 :     kp.privkey = seed;
      82             : 
      83        2780 :     ed25519_derive_public_key(
      84        2780 :         reinterpret_cast<const private_key_t *>(kp.privkey.data()),
      85        2780 :         reinterpret_cast<public_key_t *>(kp.pubkey.data()));
      86             : 
      87        2780 :     return kp;
      88             :   }
      89             : 
      90             :   keypair_t create_keypair() {
      91           4 :     return create_keypair(create_seed());
      92             :   }
      93             : }  // namespace iroha