Ethereum: How are SIGHASH flags encoded into a signature?
** Ethereum: How are sighing flags codified in a signature?
In Ethereum, signatures are used to pro -owners and the author of the Blockchain transactions. One of the key components that allow this is
Signature hash algorithm) . In this article, we will deepen how the sighing flags are encoded in a signature.
What are the sighing flags?
Suspine flags allow the signatory to control which parts of the transaction they want to sign and check. These flags allow a more efficient use of memory and calculation resources in the Ethereum network. A signature
is created by the hashing of input data with the public key, followed by the hashing of the result with the private key.
Codification of sighing flags in a signature
When a signatory wants to extract certain parts of the transaction to sign, it must encode its sigh into a unique idique that can be used for verification. This is achieved by extracting the necessary field from the entry data and then harassing it with the private key.
Suppose we work with an example of a simple transaction:
`Solidity
Pragma solidity ^0.8.0;
Simplansction contract {
Sendmoney function (addresses recipient, sum UNT) public {
// Entry: Shipment, recipient and transfer amount
Bytes32 _inputs = abi.encodepacked (sender, recipient, amount);
// codifies sighing flags (on_checksig)
Sigh [] memory _flags = new sigh [_ inputs.length];
for (uint i = 0; i <_inputs.length; i ++) {
_Flags [i] = sighash (_inputs [i]);
}
// hash input data with private key
Bytes32 _Datahash = abi.encodePack (_ inputs, msg.sender);
// hash the result with the public key (on_checksig)
Bytes32 _sighsh = keccak256 (abi.ennodepacked (_datahash, _flags));
// sign the hash of signature with private key
Bytes32 _sig;
if (msg.sender == address (0)) {
Assembly {
_sig: = sha3_256 (MEMO: = abi.encodePacked (_sighsh))
}
} Else {
_sig: = keccak256 (abi.encodepacked (_sighsh));
}
// check the signature
Request (msg.sendender == owner, "invalid signature");
}
}
In this example, we encode the sighing flags in a unique identifier using theabi. We also get rid of the input data with the private key to create the hash value.
Coding of the sigh pavilion **
ARRAY `_Flags contain an element by flag, which is a
structure
which includes information as follows:
- 0x1 (On_Checksig): Extract the non-standard argument from each signature it evaluates.
- Other flags (eg on_checksigify, on_checksigsig): Provides additional verification options.
By encoding the thesis flags in a unique identifier using the_Sighasha, we can check if the correct part of the transaction has been signed and verified.
Conclusion
In this article, I explored the way in which the sighing flags are encoded in a signature in Ethereum. Understanding how these flags work, you will be better equipped to optimize your code for better network performance. Remember to always follow the best practices when working with cryptography and hash functions.