You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
355 lines
13 KiB
355 lines
13 KiB
/*
|
|
* 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] = {0};
|
|
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 = {0};
|
|
sha256_Init(&ctx);
|
|
sha256_Update(&ctx, (const uint8_t *)"\x15" "Lisk Signed Message:\n", 22);
|
|
uint8_t varint[5] = {0};
|
|
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] = {0};
|
|
uint8_t hash[32] = {0};
|
|
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] = {0};
|
|
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] = {0};
|
|
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] = {0};
|
|
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 = {0};
|
|
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] = {0};
|
|
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] = {0};
|
|
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] = {0};
|
|
char formated_fee[MAX_LISK_VALUE_SIZE] = {0};
|
|
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] = {0};
|
|
char remove_votes_txt[16] = {0};
|
|
|
|
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] = {0};
|
|
char life_time_str[14] = {0};
|
|
char min_str[8] = {0};
|
|
|
|
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);
|
|
}
|