Line data    Source code

       1             : /**
       2             :  * Copyright Soramitsu Co., Ltd. All Rights Reserved.
       3             :  * SPDX-License-Identifier: Apache-2.0
       4             :  */
       5             : 
       6             : #include "validators/protobuf/proto_transaction_validator.hpp"
       7             : 
       8             : #include "validators/validators_common.hpp"
       9             : 
      10             : namespace shared_model {
      11             :   namespace validation {
      12             : 
      13             :     void validatePublicKey(const std::string &public_key,
      14             :                            ReasonsGroupType &reason) {
      15        5571 :       if (not validateHexString(public_key)) {
      16           5 :         reason.second.emplace_back("Public key is not in hex format");
      17           5 :       }
      18        5567 :     }
      19             : 
      20             :     Answer validateProtoTx(const iroha::protocol::Transaction &transaction) {
      21        8593 :       Answer answer;
      22        8593 :       std::string tx_reason_name = "Protobuf Transaction";
      23        8651 :       ReasonsGroupType reason(tx_reason_name, GroupedReasons());
      24       29751 :       for (const auto &command :
      25        8683 :            transaction.payload().reduced_payload().commands()) {
      26       20803 :         switch (command.command_case()) {
      27             :           case iroha::protocol::Command::COMMAND_NOT_SET: {
      28           1 :             reason.second.emplace_back("Undefined command is found");
      29           1 :             answer.addReason(std::move(reason));
      30           1 :             return answer;
      31             :           }
      32             :           case iroha::protocol::Command::kAddSignatory: {
      33        1261 :             const auto &as = command.add_signatory();
      34        1261 :             validatePublicKey(as.public_key(), reason);
      35        1266 :             break;
      36             :           }
      37             :           case iroha::protocol::Command::kCreateAccount: {
      38        4119 :             const auto &ca = command.create_account();
      39        4119 :             validatePublicKey(ca.public_key(), reason);
      40        4170 :             break;
      41             :           }
      42             :           case iroha::protocol::Command::kRemoveSignatory: {
      43         128 :             const auto &rs = command.remove_signatory();
      44         128 :             validatePublicKey(rs.public_key(), reason);
      45         125 :             break;
      46             :           }
      47             :           case iroha::protocol::Command::kAddPeer: {
      48           2 :             const auto &ap = command.add_peer();
      49           2 :             validatePublicKey(ap.peer().peer_key(), reason);
      50           2 :             break;
      51             :           }
      52             :           case iroha::protocol::Command::kCreateRole: {
      53        3458 :             const auto &cr = command.create_role();
      54        3478 :             bool all_permissions_valid = std::all_of(
      55        3458 :                 cr.permissions().begin(),
      56        3473 :                 cr.permissions().end(),
      57             :                 [](const auto &perm) {
      58        6598 :                   return iroha::protocol::RolePermission_IsValid(perm);
      59             :                 });
      60        3478 :             if (not all_permissions_valid) {
      61           1 :               reason.second.emplace_back("Invalid role permission");
      62           1 :             }
      63        3471 :             break;
      64             :           }
      65             :           case iroha::protocol::Command::kGrantPermission: {
      66         371 :             if (not iroha::protocol::GrantablePermission_IsValid(
      67         369 :                     command.grant_permission().permission())) {
      68           1 :               reason.second.emplace_back("Invalid grantable permission");
      69           1 :             }
      70         370 :             break;
      71             :           }
      72             :           case iroha::protocol::Command::kRevokePermission: {
      73         143 :             if (not iroha::protocol::GrantablePermission_IsValid(
      74         144 :                     command.revoke_permission().permission())) {
      75           1 :               reason.second.emplace_back("Invalid grantable permission");
      76           1 :             }
      77         142 :             break;
      78             :           }
      79             :           default:
      80       11310 :             break;
      81             :         }
      82             :       }
      83        8810 :       if (not reason.second.empty()) {
      84           8 :         answer.addReason(std::move(reason));
      85           8 :       }
      86        8809 :       return answer;
      87        8794 :     }
      88             : 
      89             :     Answer ProtoTransactionValidator::validate(
      90             :         const iroha::protocol::Transaction &tx) const {
      91        8723 :       return validateProtoTx(tx);
      92             :     }
      93             :   }  // namespace validation
      94             : }  // namespace shared_model