Line data    Source code

       1             : /**
       2             :  * Copyright Soramitsu Co., Ltd. All Rights Reserved.
       3             :  * SPDX-License-Identifier: Apache-2.0
       4             :  */
       5             : 
       6             : #include <boost/optional.hpp>
       7             : 
       8             : #include "backend/protobuf/transaction.hpp"
       9             : #include "backend/protobuf/util.hpp"
      10             : #include "bindings/client_api.hpp"
      11             : #include "common/bind.hpp"
      12             : #include "cryptography/crypto_provider/crypto_signer.hpp"
      13             : #include "cryptography/ed25519_sha3_impl/internal/sha3_hash.hpp"
      14             : #include "validators/default_validator.hpp"
      15             : 
      16             : namespace shared_model {
      17             :   namespace bindings {
      18             : 
      19             :     std::string convert(const Blob &blob) {
      20           0 :       return std::string(blob.begin(), blob.end());
      21             :     }
      22             : 
      23             :     template <typename Proto>
      24             :     boost::optional<Proto> get(const std::string &blob) {
      25           0 :       Proto proto;
      26           0 :       if (proto.ParseFromString(blob)) {
      27           0 :         return proto;
      28             :       }
      29           0 :       return {};
      30           0 :     }
      31             : 
      32             :     using namespace iroha;
      33             :     void validateTransaction(const Blob &b) {
      34           0 :       auto blob = convert(b);
      35             :       auto s = get<iroha::protocol::Transaction>(blob) | [](auto tx) {
      36           0 :         static validation::DefaultSignedTransactionValidator val;
      37           0 :         return boost::make_optional(
      38           0 :             val.validate(proto::Transaction(tx)).reason());
      39           0 :       };
      40           0 :       if (s) {
      41           0 :         auto &r = s.value();
      42           0 :         if (r == "") {
      43             :           return;
      44             :         }
      45           0 :         throw std::invalid_argument(r);
      46             :       }
      47           0 :       throw std::invalid_argument("unknown object");
      48           0 :     }
      49             : 
      50             :     void validateQuery(const Blob &b) {
      51           0 :       auto blob = convert(b);
      52             :       auto s = get<iroha::protocol::Query>(blob) | [](auto qry) {
      53           0 :         static validation::DefaultSignedQueryValidator val;
      54           0 :         return boost::make_optional(val.validate(proto::Query(qry)).reason());
      55           0 :       };
      56           0 :       if (s) {
      57           0 :         auto &r = s.value();
      58           0 :         if (r == "") {
      59             :           return;
      60             :         }
      61           0 :         throw std::invalid_argument(r);
      62             :       }
      63           0 :       throw std::invalid_argument("unknown object");
      64           0 :     }
      65             : 
      66             :     Blob signTransaction(const Blob &b, const crypto::Keypair &key) {
      67           0 :       auto blob = convert(b);
      68             :       auto s = get<iroha::protocol::Transaction>(blob) | [&key](auto tx) {
      69             :         auto signature =
      70           0 :             crypto::CryptoSigner<>::sign(proto::makeBlob(tx.payload()), key);
      71             : 
      72           0 :         auto sig = tx.add_signatures();
      73           0 :         sig->set_signature(crypto::toBinaryString(signature));
      74           0 :         sig->set_public_key(crypto::toBinaryString(key.publicKey()));
      75           0 :         return boost::make_optional(tx);
      76           0 :       };
      77           0 :       if (s) {
      78           0 :         return proto::makeBlob(s.value()).blob();
      79             :       }
      80           0 :       throw std::invalid_argument("unknown object");
      81           0 :     }
      82             : 
      83             :     Blob signQuery(const Blob &b, const crypto::Keypair &key) {
      84           0 :       auto blob = convert(b);
      85             :       auto s = get<iroha::protocol::Query>(blob) | [&key](auto qry) {
      86             :         auto signature =
      87           0 :             crypto::CryptoSigner<>::sign(proto::makeBlob(qry.payload()), key);
      88             : 
      89           0 :         auto sig = qry.mutable_signature();
      90           0 :         sig->set_signature(crypto::toBinaryString(signature));
      91           0 :         sig->set_public_key(crypto::toBinaryString(key.publicKey()));
      92           0 :         return boost::make_optional(qry);
      93           0 :       };
      94           0 :       if (s) {
      95           0 :         return proto::makeBlob(s.value()).blob();
      96             :       }
      97           0 :       throw std::invalid_argument("unknown object");
      98           0 :     }
      99             : 
     100             :     Blob hashTransaction(const Blob &b) {
     101           0 :       auto blob = convert(b);
     102             :       auto s = get<iroha::protocol::Transaction>(blob) | [](auto tx) {
     103           0 :         auto pl = proto::makeBlob(tx.payload());
     104           0 :         return boost::make_optional(
     105           0 :             sha3_256(pl.blob().data(), pl.blob().size()));
     106           0 :       };
     107           0 :       if (s) {
     108           0 :         return Blob(s->begin(), s->end());
     109             :       }
     110           0 :       throw std::invalid_argument("unknown object");
     111           0 :     }
     112             : 
     113             :     Blob hashQuery(const Blob &b) {
     114           0 :       auto blob = convert(b);
     115             :       auto s = get<iroha::protocol::Query>(blob) | [](auto qry) {
     116           0 :         auto pl = proto::makeBlob(qry.payload());
     117           0 :         return boost::make_optional(
     118           0 :             sha3_256(pl.blob().data(), pl.blob().size()));
     119           0 :       };
     120           0 :       if (s) {
     121           0 :         return Blob(s->begin(), s->end());
     122             :       }
     123           0 :       throw std::invalid_argument("unknown object");
     124           0 :     }
     125             : 
     126             :     interface::types::HashType utxReducedHash(
     127             :         const shared_model::proto::UnsignedWrapper<
     128             :             shared_model::proto::Transaction> &utx) {
     129           0 :       return utx.reducedHash();
     130             :     }
     131             :   }  // namespace bindings
     132             : }  // namespace shared_model