Building a Library for Cryptographic Operations in Solidity

By Alessandro D.P.3 min readMarch 29, 2026

Overview of Cryptographic Functions

Cryptographic functions are essential in smart contracts for tasks such as verifying identities, ensuring data integrity, and creating unique identifiers. The library we will create will include functions for:

Hashing data using SHA-256
Verifying ECDSA signatures
Generating random numbers (using block properties)

Setting Up the Library

First, let’s create a new Solidity file named CryptoLib.sol. This file will contain our cryptographic functions.

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

library CryptoLib {
    // Hashing function
    function hashData(bytes memory data) internal pure returns (bytes32) {
        return keccak256(data);
    }

    // Signature verification function
    function verifySignature(
        bytes32 messageHash,
        bytes memory signature,
        address signer
    ) internal pure returns (bool) {
        return recoverSigner(messageHash, signature) == signer;
    }

    // Function to recover the signer from a signature
    function recoverSigner(bytes32 messageHash, bytes memory signature)
        internal
        pure
        returns (address)
    {
        (bytes32 r, bytes32 s, uint8 v) = splitSignature(signature);
        return ecrecover(messageHash, v, r, s);
    }

    // Split the signature into r, s, and v
    function splitSignature(bytes memory sig)
        internal
        pure
        returns (bytes32 r, bytes32 s, uint8 v)
    {
        require(sig.length == 65, "Invalid signature length");
        assembly {
            r := mload(add(sig, 32))
            s := mload(add(sig, 64))
            v := byte(0, mload(add(sig, 96)))
        }
    }
}

Using the Library in a Smart Contract

Now that we have our library defined, let’s create a smart contract that utilizes the CryptoLib library. This contract will demonstrate how to hash data and verify signatures.

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

import "./CryptoLib.sol";

contract CryptoExample {
    using CryptoLib for *;

    event DataHashed(bytes32 indexed hash);
    event SignatureVerified(bool success);

    // Function to hash data
    function hashInputData(string memory input) public {
        bytes32 hash = input.hashData();
        emit DataHashed(hash);
    }

    // Function to verify a signature
    function verifyInputSignature(
        string memory input,
        bytes memory signature
    ) public {
        bytes32 messageHash = keccak256(abi.encodePacked(input));
        bool isVerified = messageHash.verifySignature(signature, msg.sender);
        emit SignatureVerified(isVerified);
    }
}

Best Practices for Cryptographic Operations

Use Established Libraries: While building your own cryptographic library can be educational, always prefer well-established libraries like OpenZeppelin when deploying production-grade contracts to minimize security risks.

Gas Efficiency: Cryptographic operations can be gas-intensive. Optimize your functions to reduce gas costs, especially in public-facing smart contracts.

Data Privacy: Be cautious about the data you hash or sign. Avoid including sensitive information directly in transactions, as blockchain data is public.

Testing: Thoroughly test your cryptographic functions. Use tools like Truffle or Hardhat to ensure your library behaves as expected under various conditions.

Summary of Functions

Function Name	Description	Return Type
`hashData`	Computes the SHA-256 hash of the input data	`bytes32`
`verifySignature`	Verifies if a signature corresponds to a given message hash and signer	`bool`
`recoverSigner`	Recovers the signer address from a signature	`address`
`splitSignature`	Splits a signature into r, s, and v components	`bytes32, bytes32, uint8`

Conclusion

Creating a cryptographic library in Solidity enhances the security and functionality of your smart contracts. By encapsulating common cryptographic operations, you can ensure that your contracts are both secure and maintainable. Remember to adhere to best practices and leverage existing libraries when appropriate.