[Ethereum] How to implement cryptographic algorithms in smart contracts

cryptographyecdsaserpentsolidity

I need to implement cryptographic algorithms such as AESCCM and elliptic curve algorithms (ECDSA, ECIES) within a smart contract. Is there any implementation of such algorithms in Solidity or Serpent?

Or is there is any way to integrate Python code (or other language) within Serpent for example (there many cryptographic libraries in Python)?

Or any other suggestions on how can I implement those algorithms?

Best Answer

This library is a good starting point: https://github.com/HarryR/solcrypto

As Richard points out symmetric key crypto and private key operation are rarely sensible in a smart contract as the smart contract has no privacy. However public key operations like checking signatures, proofs and hashes can be very useful and got more efficient with the addition of the elliptic curve precompiled contracts in Byzantium.

Related Solutions

Solidity – How Was Solidity Conceived and What Design Tradeoffs Were Made?

There's some explanation in the original design proposal here: https://t.co/An1ZpRSu7O .

Basically, it was meant to use some OOP features to provide a convenient abstraction for contracts. Objects' data could be arbitrarily complex through its mapping mechanism. The original design included the ability to specify (and therefore optimise) that mapping. For objects' functions, I leveraged the then-new Ethereum contract ABI specification to synthesise something familiar to OOP practitioners. The introduction of the constant function marker was also quite nice, since it allowed an optimised way of inspecting object state with Solidity logic.

It was meant to be a sophisticated tool for developing contracts that could ultimately give both developers and users good information on what the code did. To help this along, I devised NatSpec, a contract-friendly documentation format, and made that a first-class citizen in Solidity. I also proposed a formal proofing language subset (not yet implemented) in order to maximise the kinds of correctness guarantees that could be made.

I introduced events as a first class citizen into the Solidity language in order to provide a nice abstraction for LOGs similar in form to function calls. Inspiration for that came from the Qt meta-object system's "signals".

One later feature that Christian R. and I figured out together was function modifiers; that allows attributes placed as part of a function signature to make some modifications to the apparent function body. Being a very declarative means of expression, it's an idiom that falls nicely into the contract-oriented programming space.

Solidity – Proper Way to Implement ‘Buyable’ ERC721 Tokens

So I ended up going with a solution that used my contract as an intermediate third party. The flow goes as follows:

The seller approves the contract address to act on their behalf.
Then, when the buyer wants to buy the token, the contract transfers the token from the buyer to the seller, and transfers the payment as well

Something along the lines of:

function setForSale(uint256 _tokenId) external {
    address owner = ownerOf(_tokenId);

    require(isValidToken(_tokenId));
    require(owner == msg.sender || authorized[owner][msg.sender]);

    allowance[_tokenId] = address(this);
    tokensForSale.push(_tokenId);
    // set the sale price etc

    emit Approval(owner, address(this), _tokenId);
}

function buy(uint256 _tokenId) external payable {
    address buyer = msg.sender;
    uint payedPrice = msg.value;

    require(isValidToken(_tokenId));
    require(getApproved(_tokenId) == address(this));
    // require payedPrice >= salePrice

    // pay the seller
    // remove token from tokensForSale

    transferFrom(ownerOf(_tokenId), buyer, _tokenId);
}

Obviously you can do this with a third-party contract, but I found this easy and fairly straightforward using the given interface.

Best Answer

Related Solutions

Solidity – How Was Solidity Conceived and What Design Tradeoffs Were Made?

Solidity – Proper Way to Implement ‘Buyable’ ERC721 Tokens

Related Topic