Momentum-Apps/flipbip/lib/crypto/nem.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 "options.h"

#if USE_NEM

#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;
}

#endif // USE_NEM