mirror of
https://github.com/trezor/trezor-firmware.git
synced 2024-12-04 21:48:17 +00:00
508 lines
17 KiB
C
508 lines
17 KiB
C
/**
|
|
* Copyright (c) 2017 Saleem Rashid
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining
|
|
* a copy of this software and associated documentation files (the "Software"),
|
|
* to deal in the Software without restriction, including without limitation
|
|
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
|
* and/or sell copies of the Software, and to permit persons to whom the
|
|
* Software is furnished to do so, subject to the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be included
|
|
* in all copies or substantial portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, E1PRESS
|
|
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
|
|
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES
|
|
* OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
|
|
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
|
|
* OTHER DEALINGS IN THE SOFTWARE.
|
|
*/
|
|
|
|
#include "nem.h"
|
|
|
|
#include <string.h>
|
|
|
|
#include "base32.h"
|
|
#include "ed25519-donna/ed25519-keccak.h"
|
|
#include "memzero.h"
|
|
#include "ripemd160.h"
|
|
#include "sha3.h"
|
|
|
|
#define CAN_WRITE(NEEDED) ((ctx->offset + (NEEDED)) <= ctx->size)
|
|
|
|
#define SERIALIZE_U32(DATA) \
|
|
do { \
|
|
if (!nem_write_u32(ctx, (DATA))) return false; \
|
|
} while (0)
|
|
#define SERIALIZE_U64(DATA) \
|
|
do { \
|
|
if (!nem_write_u64(ctx, (DATA))) return false; \
|
|
} while (0)
|
|
#define SERIALIZE_TAGGED(DATA, LENGTH) \
|
|
do { \
|
|
if (!nem_write_tagged(ctx, (DATA), (LENGTH))) return false; \
|
|
} while (0)
|
|
|
|
const char *nem_network_name(uint8_t network) {
|
|
switch (network) {
|
|
case NEM_NETWORK_MAINNET:
|
|
return "NEM Mainnet";
|
|
case NEM_NETWORK_TESTNET:
|
|
return "NEM Testnet";
|
|
case NEM_NETWORK_MIJIN:
|
|
return "Mijin";
|
|
default:
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
static inline bool nem_write_checked(nem_transaction_ctx *ctx,
|
|
const uint8_t *data, uint32_t length) {
|
|
if (!CAN_WRITE(length)) {
|
|
return false;
|
|
}
|
|
|
|
memcpy(&ctx->buffer[ctx->offset], data, length);
|
|
ctx->offset += length;
|
|
return true;
|
|
}
|
|
|
|
static inline bool nem_write_u32(nem_transaction_ctx *ctx, uint32_t data) {
|
|
if (!CAN_WRITE(4)) {
|
|
return false;
|
|
}
|
|
|
|
ctx->buffer[ctx->offset++] = (data >> 0) & 0xff;
|
|
ctx->buffer[ctx->offset++] = (data >> 8) & 0xff;
|
|
ctx->buffer[ctx->offset++] = (data >> 16) & 0xff;
|
|
ctx->buffer[ctx->offset++] = (data >> 24) & 0xff;
|
|
|
|
return true;
|
|
}
|
|
|
|
static inline bool nem_write_u64(nem_transaction_ctx *ctx, uint64_t data) {
|
|
SERIALIZE_U32((data >> 0) & 0xffffffff);
|
|
SERIALIZE_U32((data >> 32) & 0xffffffff);
|
|
|
|
return true;
|
|
}
|
|
|
|
static inline bool nem_write_tagged(nem_transaction_ctx *ctx,
|
|
const uint8_t *data, uint32_t length) {
|
|
SERIALIZE_U32(length);
|
|
|
|
return nem_write_checked(ctx, data, length);
|
|
}
|
|
|
|
static inline bool nem_write_mosaic_str(nem_transaction_ctx *ctx,
|
|
const char *name, const char *value) {
|
|
uint32_t name_length = strlen(name);
|
|
uint32_t value_length = strlen(value);
|
|
|
|
SERIALIZE_U32(sizeof(uint32_t) + name_length + sizeof(uint32_t) +
|
|
value_length);
|
|
SERIALIZE_TAGGED((const uint8_t *)name, name_length);
|
|
SERIALIZE_TAGGED((const uint8_t *)value, value_length);
|
|
|
|
return true;
|
|
}
|
|
|
|
static inline bool nem_write_mosaic_bool(nem_transaction_ctx *ctx,
|
|
const char *name, bool value) {
|
|
return nem_write_mosaic_str(ctx, name, value ? "true" : "false");
|
|
}
|
|
|
|
static inline bool nem_write_mosaic_u64(nem_transaction_ctx *ctx,
|
|
const char *name, uint64_t value) {
|
|
char buffer[21] = {0};
|
|
|
|
if (bn_format_uint64(value, NULL, NULL, 0, 0, false, 0, buffer,
|
|
sizeof(buffer)) == 0) {
|
|
return false;
|
|
}
|
|
|
|
return nem_write_mosaic_str(ctx, name, buffer);
|
|
}
|
|
|
|
void nem_get_address_raw(const ed25519_public_key public_key, uint8_t version,
|
|
uint8_t *address) {
|
|
uint8_t hash[SHA3_256_DIGEST_LENGTH] = {0};
|
|
|
|
/* 1. Perform 256-bit Sha3 on the public key */
|
|
keccak_256(public_key, sizeof(ed25519_public_key), hash);
|
|
|
|
/* 2. Perform 160-bit Ripemd of hash resulting from step 1. */
|
|
ripemd160(hash, SHA3_256_DIGEST_LENGTH, &address[1]);
|
|
|
|
/* 3. Prepend version byte to Ripemd hash (either 0x68 or 0x98) */
|
|
address[0] = version;
|
|
|
|
/* 4. Perform 256-bit Sha3 on the result, take the first four bytes as a
|
|
* checksum */
|
|
keccak_256(address, 1 + RIPEMD160_DIGEST_LENGTH, hash);
|
|
|
|
/* 5. Concatenate output of step 3 and the checksum from step 4 */
|
|
memcpy(&address[1 + RIPEMD160_DIGEST_LENGTH], hash, 4);
|
|
|
|
memzero(hash, sizeof(hash));
|
|
}
|
|
|
|
bool nem_get_address(const ed25519_public_key public_key, uint8_t version,
|
|
char *address) {
|
|
uint8_t pubkeyhash[NEM_ADDRESS_SIZE_RAW] = {0};
|
|
|
|
nem_get_address_raw(public_key, version, pubkeyhash);
|
|
|
|
char *ret = base32_encode(pubkeyhash, sizeof(pubkeyhash), address,
|
|
NEM_ADDRESS_SIZE + 1, BASE32_ALPHABET_RFC4648);
|
|
|
|
memzero(pubkeyhash, sizeof(pubkeyhash));
|
|
return (ret != NULL);
|
|
}
|
|
|
|
bool nem_validate_address_raw(const uint8_t *address, uint8_t network) {
|
|
if (!nem_network_name(network) || address[0] != network) {
|
|
return false;
|
|
}
|
|
|
|
uint8_t hash[SHA3_256_DIGEST_LENGTH] = {0};
|
|
|
|
keccak_256(address, 1 + RIPEMD160_DIGEST_LENGTH, hash);
|
|
bool valid = (memcmp(&address[1 + RIPEMD160_DIGEST_LENGTH], hash, 4) == 0);
|
|
|
|
memzero(hash, sizeof(hash));
|
|
return valid;
|
|
}
|
|
|
|
bool nem_validate_address(const char *address, uint8_t network) {
|
|
uint8_t pubkeyhash[NEM_ADDRESS_SIZE_RAW] = {0};
|
|
|
|
if (strlen(address) != NEM_ADDRESS_SIZE) {
|
|
return false;
|
|
}
|
|
|
|
uint8_t *ret = base32_decode(address, NEM_ADDRESS_SIZE, pubkeyhash,
|
|
sizeof(pubkeyhash), BASE32_ALPHABET_RFC4648);
|
|
bool valid = (ret != NULL) && nem_validate_address_raw(pubkeyhash, network);
|
|
|
|
memzero(pubkeyhash, sizeof(pubkeyhash));
|
|
return valid;
|
|
}
|
|
|
|
void nem_transaction_start(nem_transaction_ctx *ctx,
|
|
const ed25519_public_key public_key, uint8_t *buffer,
|
|
size_t size) {
|
|
memcpy(ctx->public_key, public_key, sizeof(ctx->public_key));
|
|
|
|
ctx->buffer = buffer;
|
|
ctx->offset = 0;
|
|
ctx->size = size;
|
|
}
|
|
|
|
size_t nem_transaction_end(nem_transaction_ctx *ctx,
|
|
const ed25519_secret_key private_key,
|
|
ed25519_signature signature) {
|
|
if (private_key != NULL && signature != NULL) {
|
|
ed25519_sign_keccak(ctx->buffer, ctx->offset, private_key, signature);
|
|
}
|
|
|
|
return ctx->offset;
|
|
}
|
|
|
|
bool nem_transaction_write_common(nem_transaction_ctx *ctx, uint32_t type,
|
|
uint32_t version, uint32_t timestamp,
|
|
const ed25519_public_key signer, uint64_t fee,
|
|
uint32_t deadline) {
|
|
SERIALIZE_U32(type);
|
|
SERIALIZE_U32(version);
|
|
SERIALIZE_U32(timestamp);
|
|
SERIALIZE_TAGGED(signer, sizeof(ed25519_public_key));
|
|
SERIALIZE_U64(fee);
|
|
SERIALIZE_U32(deadline);
|
|
|
|
return true;
|
|
}
|
|
|
|
bool nem_transaction_create_transfer(nem_transaction_ctx *ctx, uint8_t network,
|
|
uint32_t timestamp,
|
|
const ed25519_public_key signer,
|
|
uint64_t fee, uint32_t deadline,
|
|
const char *recipient, uint64_t amount,
|
|
const uint8_t *payload, uint32_t length,
|
|
bool encrypted, uint32_t mosaics) {
|
|
if (!signer) {
|
|
signer = ctx->public_key;
|
|
}
|
|
|
|
if (!payload) {
|
|
length = 0;
|
|
}
|
|
|
|
bool ret =
|
|
nem_transaction_write_common(ctx, NEM_TRANSACTION_TYPE_TRANSFER,
|
|
(uint32_t)network << 24 | (mosaics ? 2 : 1),
|
|
timestamp, signer, fee, deadline);
|
|
if (!ret) return false;
|
|
|
|
SERIALIZE_TAGGED((const uint8_t *)recipient, NEM_ADDRESS_SIZE);
|
|
SERIALIZE_U64(amount);
|
|
|
|
if (length) {
|
|
SERIALIZE_U32(sizeof(uint32_t) + sizeof(uint32_t) + length);
|
|
SERIALIZE_U32(encrypted ? 0x02 : 0x01);
|
|
SERIALIZE_TAGGED(payload, length);
|
|
} else {
|
|
SERIALIZE_U32(0);
|
|
}
|
|
|
|
if (mosaics) {
|
|
SERIALIZE_U32(mosaics);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool nem_transaction_write_mosaic(nem_transaction_ctx *ctx,
|
|
const char *namespace, const char *mosaic,
|
|
uint64_t quantity) {
|
|
size_t namespace_length = strlen(namespace);
|
|
size_t mosaic_length = strlen(mosaic);
|
|
size_t identifier_length =
|
|
sizeof(uint32_t) + namespace_length + sizeof(uint32_t) + mosaic_length;
|
|
|
|
SERIALIZE_U32(sizeof(uint32_t) + sizeof(uint64_t) + identifier_length);
|
|
SERIALIZE_U32(identifier_length);
|
|
SERIALIZE_TAGGED((const uint8_t *)namespace, namespace_length);
|
|
SERIALIZE_TAGGED((const uint8_t *)mosaic, mosaic_length);
|
|
SERIALIZE_U64(quantity);
|
|
|
|
return true;
|
|
}
|
|
|
|
bool nem_transaction_create_multisig(nem_transaction_ctx *ctx, uint8_t network,
|
|
uint32_t timestamp,
|
|
const ed25519_public_key signer,
|
|
uint64_t fee, uint32_t deadline,
|
|
const nem_transaction_ctx *inner) {
|
|
if (!signer) {
|
|
signer = ctx->public_key;
|
|
}
|
|
|
|
bool ret = nem_transaction_write_common(ctx, NEM_TRANSACTION_TYPE_MULTISIG,
|
|
(uint32_t)network << 24 | 1,
|
|
timestamp, signer, fee, deadline);
|
|
if (!ret) return false;
|
|
|
|
SERIALIZE_TAGGED(inner->buffer, inner->offset);
|
|
|
|
return true;
|
|
}
|
|
|
|
bool nem_transaction_create_multisig_signature(
|
|
nem_transaction_ctx *ctx, uint8_t network, uint32_t timestamp,
|
|
const ed25519_public_key signer, uint64_t fee, uint32_t deadline,
|
|
const nem_transaction_ctx *inner) {
|
|
if (!signer) {
|
|
signer = ctx->public_key;
|
|
}
|
|
|
|
bool ret = nem_transaction_write_common(
|
|
ctx, NEM_TRANSACTION_TYPE_MULTISIG_SIGNATURE, (uint32_t)network << 24 | 1,
|
|
timestamp, signer, fee, deadline);
|
|
if (!ret) return false;
|
|
|
|
char address[NEM_ADDRESS_SIZE + 1] = {0};
|
|
nem_get_address(inner->public_key, network, address);
|
|
|
|
uint8_t hash[SHA3_256_DIGEST_LENGTH] = {0};
|
|
keccak_256(inner->buffer, inner->offset, hash);
|
|
|
|
SERIALIZE_U32(sizeof(uint32_t) + SHA3_256_DIGEST_LENGTH);
|
|
SERIALIZE_TAGGED(hash, SHA3_256_DIGEST_LENGTH);
|
|
SERIALIZE_TAGGED((const uint8_t *)address, NEM_ADDRESS_SIZE);
|
|
|
|
return true;
|
|
}
|
|
|
|
bool nem_transaction_create_provision_namespace(
|
|
nem_transaction_ctx *ctx, uint8_t network, uint32_t timestamp,
|
|
const ed25519_public_key signer, uint64_t fee, uint32_t deadline,
|
|
const char *namespace, const char *parent, const char *rental_sink,
|
|
uint64_t rental_fee) {
|
|
if (!signer) {
|
|
signer = ctx->public_key;
|
|
}
|
|
|
|
bool ret = nem_transaction_write_common(
|
|
ctx, NEM_TRANSACTION_TYPE_PROVISION_NAMESPACE,
|
|
(uint32_t)network << 24 | 1, timestamp, signer, fee, deadline);
|
|
if (!ret) return false;
|
|
|
|
if (parent) {
|
|
SERIALIZE_TAGGED((const uint8_t *)rental_sink, NEM_ADDRESS_SIZE);
|
|
SERIALIZE_U64(rental_fee);
|
|
SERIALIZE_TAGGED((const uint8_t *)namespace, strlen(namespace));
|
|
SERIALIZE_TAGGED((const uint8_t *)parent, strlen(parent));
|
|
} else {
|
|
SERIALIZE_TAGGED((const uint8_t *)rental_sink, NEM_ADDRESS_SIZE);
|
|
SERIALIZE_U64(rental_fee);
|
|
SERIALIZE_TAGGED((const uint8_t *)namespace, strlen(namespace));
|
|
SERIALIZE_U32(0xffffffff);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool nem_transaction_create_mosaic_creation(
|
|
nem_transaction_ctx *ctx, uint8_t network, uint32_t timestamp,
|
|
const ed25519_public_key signer, uint64_t fee, uint32_t deadline,
|
|
const char *namespace, const char *mosaic, const char *description,
|
|
uint32_t divisibility, uint64_t supply, bool mutable_supply,
|
|
bool transferable, uint32_t levy_type, uint64_t levy_fee,
|
|
const char *levy_address, const char *levy_namespace,
|
|
const char *levy_mosaic, const char *creation_sink, uint64_t creation_fee) {
|
|
if (!signer) {
|
|
signer = ctx->public_key;
|
|
}
|
|
|
|
bool ret = nem_transaction_write_common(
|
|
ctx, NEM_TRANSACTION_TYPE_MOSAIC_CREATION, (uint32_t)network << 24 | 1,
|
|
timestamp, signer, fee, deadline);
|
|
if (!ret) return false;
|
|
|
|
size_t namespace_length = strlen(namespace);
|
|
size_t mosaic_length = strlen(mosaic);
|
|
size_t identifier_length =
|
|
sizeof(uint32_t) + namespace_length + sizeof(uint32_t) + mosaic_length;
|
|
|
|
// This length will be rewritten later on
|
|
nem_transaction_ctx state = {0};
|
|
memcpy(&state, ctx, sizeof(state));
|
|
|
|
SERIALIZE_U32(0);
|
|
SERIALIZE_TAGGED(signer, sizeof(ed25519_public_key));
|
|
SERIALIZE_U32(identifier_length);
|
|
SERIALIZE_TAGGED((const uint8_t *)namespace, namespace_length);
|
|
SERIALIZE_TAGGED((const uint8_t *)mosaic, mosaic_length);
|
|
SERIALIZE_TAGGED((const uint8_t *)description, strlen(description));
|
|
SERIALIZE_U32(4); // Number of properties
|
|
|
|
if (!nem_write_mosaic_u64(ctx, "divisibility", divisibility)) return false;
|
|
if (!nem_write_mosaic_u64(ctx, "initialSupply", supply)) return false;
|
|
if (!nem_write_mosaic_bool(ctx, "supplyMutable", mutable_supply))
|
|
return false;
|
|
if (!nem_write_mosaic_bool(ctx, "transferable", transferable)) return false;
|
|
|
|
if (levy_type) {
|
|
size_t levy_namespace_length = strlen(levy_namespace);
|
|
size_t levy_mosaic_length = strlen(levy_mosaic);
|
|
size_t levy_identifier_length = sizeof(uint32_t) + levy_namespace_length +
|
|
sizeof(uint32_t) + levy_mosaic_length;
|
|
|
|
SERIALIZE_U32(sizeof(uint32_t) + sizeof(uint32_t) + NEM_ADDRESS_SIZE +
|
|
sizeof(uint32_t) + levy_identifier_length + sizeof(uint64_t));
|
|
SERIALIZE_U32(levy_type);
|
|
SERIALIZE_TAGGED((const uint8_t *)levy_address, NEM_ADDRESS_SIZE);
|
|
SERIALIZE_U32(levy_identifier_length);
|
|
SERIALIZE_TAGGED((const uint8_t *)levy_namespace, levy_namespace_length);
|
|
SERIALIZE_TAGGED((const uint8_t *)levy_mosaic, levy_mosaic_length);
|
|
SERIALIZE_U64(levy_fee);
|
|
} else {
|
|
SERIALIZE_U32(0);
|
|
}
|
|
|
|
// Rewrite length
|
|
nem_write_u32(&state, ctx->offset - state.offset - sizeof(uint32_t));
|
|
|
|
SERIALIZE_TAGGED((const uint8_t *)creation_sink, NEM_ADDRESS_SIZE);
|
|
SERIALIZE_U64(creation_fee);
|
|
|
|
return true;
|
|
}
|
|
|
|
bool nem_transaction_create_mosaic_supply_change(
|
|
nem_transaction_ctx *ctx, uint8_t network, uint32_t timestamp,
|
|
const ed25519_public_key signer, uint64_t fee, uint32_t deadline,
|
|
const char *namespace, const char *mosaic, uint32_t type, uint64_t delta) {
|
|
if (!signer) {
|
|
signer = ctx->public_key;
|
|
}
|
|
|
|
bool ret = nem_transaction_write_common(
|
|
ctx, NEM_TRANSACTION_TYPE_MOSAIC_SUPPLY_CHANGE,
|
|
(uint32_t)network << 24 | 1, timestamp, signer, fee, deadline);
|
|
if (!ret) return false;
|
|
|
|
size_t namespace_length = strlen(namespace);
|
|
size_t mosaic_length = strlen(mosaic);
|
|
size_t identifier_length =
|
|
sizeof(uint32_t) + namespace_length + sizeof(uint32_t) + mosaic_length;
|
|
|
|
SERIALIZE_U32(identifier_length);
|
|
SERIALIZE_TAGGED((const uint8_t *)namespace, namespace_length);
|
|
SERIALIZE_TAGGED((const uint8_t *)mosaic, mosaic_length);
|
|
SERIALIZE_U32(type);
|
|
SERIALIZE_U64(delta);
|
|
|
|
return true;
|
|
}
|
|
|
|
bool nem_transaction_create_aggregate_modification(
|
|
nem_transaction_ctx *ctx, uint8_t network, uint32_t timestamp,
|
|
const ed25519_public_key signer, uint64_t fee, uint32_t deadline,
|
|
uint32_t modifications, bool relative_change) {
|
|
if (!signer) {
|
|
signer = ctx->public_key;
|
|
}
|
|
|
|
bool ret = nem_transaction_write_common(
|
|
ctx, NEM_TRANSACTION_TYPE_AGGREGATE_MODIFICATION,
|
|
(uint32_t)network << 24 | (relative_change ? 2 : 1), timestamp, signer,
|
|
fee, deadline);
|
|
if (!ret) return false;
|
|
|
|
SERIALIZE_U32(modifications);
|
|
|
|
return true;
|
|
}
|
|
|
|
bool nem_transaction_write_cosignatory_modification(
|
|
nem_transaction_ctx *ctx, uint32_t type,
|
|
const ed25519_public_key cosignatory) {
|
|
SERIALIZE_U32(sizeof(uint32_t) + sizeof(uint32_t) +
|
|
sizeof(ed25519_public_key));
|
|
SERIALIZE_U32(type);
|
|
SERIALIZE_TAGGED(cosignatory, sizeof(ed25519_public_key));
|
|
|
|
return true;
|
|
}
|
|
|
|
bool nem_transaction_write_minimum_cosignatories(nem_transaction_ctx *ctx,
|
|
int32_t relative_change) {
|
|
SERIALIZE_U32(sizeof(uint32_t));
|
|
SERIALIZE_U32((uint32_t)relative_change);
|
|
|
|
return true;
|
|
}
|
|
|
|
bool nem_transaction_create_importance_transfer(
|
|
nem_transaction_ctx *ctx, uint8_t network, uint32_t timestamp,
|
|
const ed25519_public_key signer, uint64_t fee, uint32_t deadline,
|
|
uint32_t mode, const ed25519_public_key remote) {
|
|
if (!signer) {
|
|
signer = ctx->public_key;
|
|
}
|
|
|
|
bool ret = nem_transaction_write_common(
|
|
ctx, NEM_TRANSACTION_TYPE_IMPORTANCE_TRANSFER,
|
|
(uint32_t)network << 24 | 1, timestamp, signer, fee, deadline);
|
|
if (!ret) return false;
|
|
|
|
SERIALIZE_U32(mode);
|
|
SERIALIZE_TAGGED(remote, sizeof(ed25519_public_key));
|
|
|
|
return true;
|
|
}
|