trezor-firmware/legacy/firmware/lisk.c

/*
 * This file is part of the Trezor project, https://trezor.io/
 *
 * Copyright (C) 2018 alepop <alepooop@gmail.com>
 *
 * This library is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this library.  If not, see <http://www.gnu.org/licenses/>.
 */

#include "lisk.h"
#include "bitmaps.h"
#include "crypto.h"
#include "curves.h"
#include "fsm.h"
#include "gettext.h"
#include "layout2.h"
#include "messages.pb.h"
#include "protect.h"
#include "util.h"

void lisk_get_address_from_public_key(const uint8_t *public_key,
                                      char *address) {
  uint64_t digest[4];
  sha256_Raw(public_key, 32, (uint8_t *)digest);
  bn_format_uint64(digest[0], NULL, "L", 0, 0, false, address,
                   MAX_LISK_ADDRESS_SIZE);
}

void lisk_message_hash(const uint8_t *message, size_t message_len,
                       uint8_t hash[32]) {
  SHA256_CTX ctx;
  sha256_Init(&ctx);
  sha256_Update(&ctx, (const uint8_t *)"\x15" "Lisk Signed Message:\n", 22);
  uint8_t varint[5];
  uint32_t l = ser_length(message_len, varint);
  sha256_Update(&ctx, varint, l);
  sha256_Update(&ctx, message, message_len);
  sha256_Final(&ctx, hash);
  sha256_Raw(hash, 32, hash);
}

void lisk_sign_message(const HDNode *node, const LiskSignMessage *msg,
                       LiskMessageSignature *resp) {
  layoutSignMessage(msg->message.bytes, msg->message.size);
  if (!protectButton(ButtonRequestType_ButtonRequest_ProtectCall, false)) {
    fsm_sendFailure(FailureType_Failure_ActionCancelled, NULL);
    layoutHome();
    return;
  }

  layoutProgressSwipe(_("Signing"), 0);

  uint8_t signature[64];
  uint8_t hash[32];
  lisk_message_hash(msg->message.bytes, msg->message.size, hash);

  ed25519_sign(hash, 32, node->private_key, &node->public_key[1], signature);

  memcpy(resp->signature.bytes, signature, sizeof(signature));
  memcpy(resp->public_key.bytes, &node->public_key[1], 32);

  resp->has_signature = true;
  resp->signature.size = 64;
  resp->has_public_key = true;
  resp->public_key.size = 32;
}

bool lisk_verify_message(const LiskVerifyMessage *msg) {
  uint8_t hash[32];
  lisk_message_hash(msg->message.bytes, msg->message.size, hash);
  return 0 == ed25519_sign_open(hash, 32, msg->public_key.bytes,
                                msg->signature.bytes);
}

static void lisk_update_raw_tx(const HDNode *node, LiskSignTx *msg) {
  if (!msg->transaction.has_sender_public_key) {
    memcpy(msg->transaction.sender_public_key.bytes, &node->public_key[1], 32);
  }

  // For CastVotes transactions, recipientId should be equal to transaction
  // creator address.
  if (msg->transaction.type == LiskTransactionType_CastVotes &&
      !msg->transaction.has_recipient_id) {
    msg->transaction.has_recipient_id = true;
    lisk_get_address_from_public_key(&node->public_key[1],
                                     msg->transaction.recipient_id);
  }
}

static void lisk_hashupdate_uint32(SHA256_CTX *ctx, uint32_t value) {
  uint8_t data[4];
  write_le(data, value);
  sha256_Update(ctx, data, sizeof(data));
}

static void lisk_hashupdate_uint64_le(SHA256_CTX *ctx, uint64_t value) {
  sha256_Update(ctx, (uint8_t *)&value, sizeof(uint64_t));
}

static void lisk_hashupdate_uint64_be(SHA256_CTX *ctx, uint64_t value) {
  uint8_t data[8];
  data[0] = value >> 56;
  data[1] = value >> 48;
  data[2] = value >> 40;
  data[3] = value >> 32;
  data[4] = value >> 24;
  data[5] = value >> 16;
  data[6] = value >> 8;
  data[7] = value;
  sha256_Update(ctx, data, sizeof(data));
}

static void lisk_hashupdate_asset(SHA256_CTX *ctx, LiskTransactionType type,
                                  LiskTransactionAsset *asset) {
  switch (type) {
    case LiskTransactionType_Transfer:
      if (asset->has_data) {
        sha256_Update(ctx, (const uint8_t *)asset->data, strlen(asset->data));
      }
      break;
    case LiskTransactionType_RegisterDelegate:
      if (asset->has_delegate && asset->delegate.has_username) {
        sha256_Update(ctx, (const uint8_t *)asset->delegate.username,
                      strlen(asset->delegate.username));
      }
      break;
    case LiskTransactionType_CastVotes: {
      for (int i = 0; i < asset->votes_count; i++) {
        sha256_Update(ctx, (uint8_t *)asset->votes[i], strlen(asset->votes[i]));
      }
      break;
    }
    case LiskTransactionType_RegisterSecondPassphrase:
      if (asset->has_signature && asset->signature.has_public_key) {
        sha256_Update(ctx, asset->signature.public_key.bytes,
                      asset->signature.public_key.size);
      }
      break;
    case LiskTransactionType_RegisterMultisignatureAccount:
      if (asset->has_multisignature) {
        sha256_Update(ctx, (uint8_t *)&(asset->multisignature.min), 1);
        sha256_Update(ctx, (uint8_t *)&(asset->multisignature.life_time), 1);
        for (int i = 0; i < asset->multisignature.keys_group_count; i++) {
          sha256_Update(ctx, (uint8_t *)asset->multisignature.keys_group[i],
                        strlen(asset->multisignature.keys_group[i]));
        };
      }
      break;
    default:
      fsm_sendFailure(FailureType_Failure_DataError,
                      _("Invalid transaction type"));
      break;
  }
}

#define MAX_LISK_VALUE_SIZE 20

static void lisk_format_value(uint64_t value, char *formated_value) {
  bn_format_uint64(value, NULL, " LSK", 8, 0, false, formated_value,
                   MAX_LISK_VALUE_SIZE);
}

void lisk_sign_tx(const HDNode *node, LiskSignTx *msg, LiskSignedTx *resp) {
  lisk_update_raw_tx(node, msg);

  if (msg->has_transaction) {
    SHA256_CTX ctx;
    sha256_Init(&ctx);

    switch (msg->transaction.type) {
      case LiskTransactionType_Transfer:
        layoutRequireConfirmTx(msg->transaction.recipient_id,
                               msg->transaction.amount);
        break;
      case LiskTransactionType_RegisterDelegate:
        layoutRequireConfirmDelegateRegistration(&msg->transaction.asset);
        break;
      case LiskTransactionType_CastVotes:
        layoutRequireConfirmCastVotes(&msg->transaction.asset);
        break;
      case LiskTransactionType_RegisterSecondPassphrase:
        layoutLiskPublicKey(msg->transaction.asset.signature.public_key.bytes);
        break;
      case LiskTransactionType_RegisterMultisignatureAccount:
        layoutRequireConfirmMultisig(&msg->transaction.asset);
        break;
      default:
        fsm_sendFailure(FailureType_Failure_DataError,
                        _("Invalid transaction type"));
        layoutHome();
        break;
    }
    if (!protectButton((msg->transaction.type ==
                                LiskTransactionType_RegisterSecondPassphrase
                            ? ButtonRequestType_ButtonRequest_PublicKey
                            : ButtonRequestType_ButtonRequest_SignTx),
                       false)) {
      fsm_sendFailure(FailureType_Failure_ActionCancelled, "Signing cancelled");
      layoutHome();
      return;
    }

    layoutRequireConfirmFee(msg->transaction.fee, msg->transaction.amount);
    if (!protectButton(ButtonRequestType_ButtonRequest_ConfirmOutput, false)) {
      fsm_sendFailure(FailureType_Failure_ActionCancelled, "Signing cancelled");
      layoutHome();
      return;
    }
    layoutProgressSwipe(_("Signing transaction"), 0);

    sha256_Update(&ctx, (const uint8_t *)&msg->transaction.type, 1);

    lisk_hashupdate_uint32(&ctx, msg->transaction.timestamp);

    sha256_Update(&ctx, msg->transaction.sender_public_key.bytes, 32);

    if (msg->transaction.has_requester_public_key) {
      sha256_Update(&ctx, msg->transaction.requester_public_key.bytes,
                    msg->transaction.requester_public_key.size);
    }

    uint64_t recipient_id = 0;
    if (msg->transaction.has_recipient_id &&
        msg->transaction.recipient_id[0] != 0) {
      // parse integer from lisk address ("123L" -> 123)
      for (size_t i = 0; i < strlen(msg->transaction.recipient_id) - 1; i++) {
        if (msg->transaction.recipient_id[i] < '0' ||
            msg->transaction.recipient_id[i] > '9') {
          fsm_sendFailure(FailureType_Failure_DataError,
                          _("Invalid recipient_id"));
          layoutHome();
          return;
        }
        recipient_id *= 10;
        recipient_id += (msg->transaction.recipient_id[i] - '0');
      }
    }
    lisk_hashupdate_uint64_be(&ctx, recipient_id);
    lisk_hashupdate_uint64_le(&ctx, msg->transaction.amount);

    lisk_hashupdate_asset(&ctx, msg->transaction.type, &msg->transaction.asset);

    // if signature exist calculate second signature
    if (msg->transaction.has_signature) {
      sha256_Update(&ctx, msg->transaction.signature.bytes,
                    msg->transaction.signature.size);
    }

    uint8_t hash[32];
    sha256_Final(&ctx, hash);
    ed25519_sign(hash, 32, node->private_key, &node->public_key[1],
                 resp->signature.bytes);

    resp->has_signature = true;
    resp->signature.size = 64;
  }
}

// Layouts
void layoutLiskPublicKey(const uint8_t *pubkey) {
  const char **str = split_message_hex(pubkey, 32);
  layoutDialogSwipe(&bmp_icon_question, NULL, _("Continue"), NULL,
                    _("Public Key:"), str[0], str[1], str[2], str[3], NULL);
}

void layoutLiskVerifyAddress(const char *address) {
  const char **str =
      split_message((const uint8_t *)address, strlen(address), 10);
  layoutDialogSwipe(&bmp_icon_info, _("Cancel"), _("Confirm"),
                    _("Confirm address?"), _("Message signed by:"), str[0],
                    str[1], NULL, NULL, NULL);
}

void layoutRequireConfirmTx(char *recipient_id, uint64_t amount) {
  char formated_amount[MAX_LISK_VALUE_SIZE];
  const char **str =
      split_message((const uint8_t *)recipient_id, strlen(recipient_id), 16);
  lisk_format_value(amount, formated_amount);
  layoutDialogSwipe(&bmp_icon_question, _("Cancel"), _("Confirm"), NULL,
                    _("Confirm sending"), formated_amount, _("to:"), str[0],
                    str[1], NULL);
}

void layoutRequireConfirmFee(uint64_t fee, uint64_t amount) {
  char formated_amount[MAX_LISK_VALUE_SIZE];
  char formated_fee[MAX_LISK_VALUE_SIZE];
  lisk_format_value(amount, formated_amount);
  lisk_format_value(fee, formated_fee);
  layoutDialogSwipe(&bmp_icon_question, _("Cancel"), _("Confirm"), NULL,
                    _("Confirm transaction"), formated_amount, _("fee:"),
                    formated_fee, NULL, NULL);
}

void layoutRequireConfirmDelegateRegistration(LiskTransactionAsset *asset) {
  if (asset->has_delegate && asset->delegate.has_username) {
    const char **str = split_message((const uint8_t *)asset->delegate.username,
                                     strlen(asset->delegate.username), 20);
    layoutDialogSwipe(&bmp_icon_question, _("Cancel"), _("Confirm"), NULL,
                      _("Confirm transaction"), _("Do you really want to"),
                      _("register a delegate?"), str[0], str[1], NULL);
  }
}

void layoutRequireConfirmCastVotes(LiskTransactionAsset *asset) {
  uint8_t plus = 0;
  uint8_t minus = 0;
  char add_votes_txt[13];
  char remove_votes_txt[16];

  for (int i = 0; i < asset->votes_count; i++) {
    if (asset->votes[i][0] == '+') {
      plus += 1;
    } else {
      minus += 1;
    }
  }

  bn_format_uint64(plus, "Add ", NULL, 0, 0, false, add_votes_txt,
                   sizeof(add_votes_txt));
  bn_format_uint64(minus, "Remove ", NULL, 0, 0, false, remove_votes_txt,
                   sizeof(remove_votes_txt));

  layoutDialogSwipe(&bmp_icon_question, _("Cancel"), _("Confirm"), NULL,
                    _("Confirm transaction"), add_votes_txt, remove_votes_txt,
                    NULL, NULL, NULL);
}

void layoutRequireConfirmMultisig(LiskTransactionAsset *asset) {
  char keys_group_str[25];
  char life_time_str[14];
  char min_str[8];

  bn_format_uint64(asset->multisignature.keys_group_count,
                   "Keys group length: ", NULL, 0, 0, false, keys_group_str,
                   sizeof(keys_group_str));
  bn_format_uint64(asset->multisignature.life_time, "Life time: ", NULL, 0, 0,
                   false, life_time_str, sizeof(life_time_str));
  bn_format_uint64(asset->multisignature.min, "Min: ", NULL, 0, 0, false,
                   min_str, sizeof(min_str));

  layoutDialogSwipe(&bmp_icon_question, _("Cancel"), _("Confirm"), NULL,
                    _("Confirm transaction"), keys_group_str, life_time_str,
                    min_str, NULL, NULL);
}