{ "address": "0xD0ADDcc2C6d49c04296A331bf2A07E269f88A287", "transactionHash": "0x6c2a5374fe0c8937e33dcd5d8f849a896be171f43b41426317865691471575f5", "abi": [ { "inputs": [ { "internalType": "bytes", "name": "key", "type": "bytes" }, { "internalType": "bytes", "name": "data", "type": "bytes" }, { "internalType": "bytes", "name": "sig", "type": "bytes" } ], "name": "verify", "outputs": [ { "internalType": "bool", "name": "", "type": "bool" } ], "stateMutability": "view", "type": "function" } ], "transactionHash": "0x6c2a5374fe0c8937e33dcd5d8f849a896be171f43b41426317865691471575f5", "receipt": { "to": null, "from": "0xa303ddC620aa7d1390BACcc8A495508B183fab59", "contractAddress": "0xD0ADDcc2C6d49c04296A331bf2A07E269f88A287", "transactionIndex": 2, "gasUsed": "803850", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "blockHash": "0xd48a9db2d8f755de1d5ce4a92a97e54563fcbfaff260b704c2299c254c8fd27e", "transactionHash": "0x6c2a5374fe0c8937e33dcd5d8f849a896be171f43b41426317865691471575f5", "logs": [], "blockNumber": 6469094, "cumulativeGasUsed": "1214094", "status": 1, "byzantium": true }, "args": [], "solcInputHash": "7948b60c3b601df824761a337a51d661", "metadata": "{\"compiler\":{\"version\":\"0.8.4+commit.c7e474f2\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"key\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"sig\",\"type\":\"bytes\"}],\"name\":\"verify\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"}],\"devdoc\":{\"details\":\"Implements the DNSSEC RSASHA1 algorithm.\",\"kind\":\"dev\",\"methods\":{},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"version\":1}},\"settings\":{\"compilationTarget\":{\"contracts/dnssec-oracle/algorithms/RSASHA1Algorithm.sol\":\"RSASHA1Algorithm\"},\"evmVersion\":\"istanbul\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":10000},\"remappings\":[]},\"sources\":{\"@ensdomains/solsha1/contracts/SHA1.sol\":{\"content\":\"pragma solidity ^0.8.4;\\n\\nlibrary SHA1 {\\n event Debug(bytes32 x);\\n\\n function sha1(bytes memory data) internal pure returns(bytes20 ret) {\\n assembly {\\n // Get a safe scratch location\\n let scratch := mload(0x40)\\n\\n // Get the data length, and point data at the first byte\\n let len := mload(data)\\n data := add(data, 32)\\n\\n // Find the length after padding\\n let totallen := add(and(add(len, 1), 0xFFFFFFFFFFFFFFC0), 64)\\n switch lt(sub(totallen, len), 9)\\n case 1 { totallen := add(totallen, 64) }\\n\\n let h := 0x6745230100EFCDAB890098BADCFE001032547600C3D2E1F0\\n\\n function readword(ptr, off, count) -> result {\\n result := 0\\n if lt(off, count) {\\n result := mload(add(ptr, off))\\n count := sub(count, off)\\n if lt(count, 32) {\\n let mask := not(sub(exp(256, sub(32, count)), 1))\\n result := and(result, mask)\\n }\\n }\\n }\\n\\n for { let i := 0 } lt(i, totallen) { i := add(i, 64) } {\\n mstore(scratch, readword(data, i, len))\\n mstore(add(scratch, 32), readword(data, add(i, 32), len))\\n\\n // If we loaded the last byte, store the terminator byte\\n switch lt(sub(len, i), 64)\\n case 1 { mstore8(add(scratch, sub(len, i)), 0x80) }\\n\\n // If this is the last block, store the length\\n switch eq(i, sub(totallen, 64))\\n case 1 { mstore(add(scratch, 32), or(mload(add(scratch, 32)), mul(len, 8))) }\\n\\n // Expand the 16 32-bit words into 80\\n for { let j := 64 } lt(j, 128) { j := add(j, 12) } {\\n let temp := xor(xor(mload(add(scratch, sub(j, 12))), mload(add(scratch, sub(j, 32)))), xor(mload(add(scratch, sub(j, 56))), mload(add(scratch, sub(j, 64)))))\\n temp := or(and(mul(temp, 2), 0xFFFFFFFEFFFFFFFEFFFFFFFEFFFFFFFEFFFFFFFEFFFFFFFEFFFFFFFEFFFFFFFE), and(div(temp, 0x80000000), 0x0000000100000001000000010000000100000001000000010000000100000001))\\n mstore(add(scratch, j), temp)\\n }\\n for { let j := 128 } lt(j, 320) { j := add(j, 24) } {\\n let temp := xor(xor(mload(add(scratch, sub(j, 24))), mload(add(scratch, sub(j, 64)))), xor(mload(add(scratch, sub(j, 112))), mload(add(scratch, sub(j, 128)))))\\n temp := or(and(mul(temp, 4), 0xFFFFFFFCFFFFFFFCFFFFFFFCFFFFFFFCFFFFFFFCFFFFFFFCFFFFFFFCFFFFFFFC), and(div(temp, 0x40000000), 0x0000000300000003000000030000000300000003000000030000000300000003))\\n mstore(add(scratch, j), temp)\\n }\\n\\n let x := h\\n let f := 0\\n let k := 0\\n for { let j := 0 } lt(j, 80) { j := add(j, 1) } {\\n switch div(j, 20)\\n case 0 {\\n // f = d xor (b and (c xor d))\\n f := xor(div(x, 0x100000000000000000000), div(x, 0x10000000000))\\n f := and(div(x, 0x1000000000000000000000000000000), f)\\n f := xor(div(x, 0x10000000000), f)\\n k := 0x5A827999\\n }\\n case 1{\\n // f = b xor c xor d\\n f := xor(div(x, 0x1000000000000000000000000000000), div(x, 0x100000000000000000000))\\n f := xor(div(x, 0x10000000000), f)\\n k := 0x6ED9EBA1\\n }\\n case 2 {\\n // f = (b and c) or (d and (b or c))\\n f := or(div(x, 0x1000000000000000000000000000000), div(x, 0x100000000000000000000))\\n f := and(div(x, 0x10000000000), f)\\n f := or(and(div(x, 0x1000000000000000000000000000000), div(x, 0x100000000000000000000)), f)\\n k := 0x8F1BBCDC\\n }\\n case 3 {\\n // f = b xor c xor d\\n f := xor(div(x, 0x1000000000000000000000000000000), div(x, 0x100000000000000000000))\\n f := xor(div(x, 0x10000000000), f)\\n k := 0xCA62C1D6\\n }\\n // temp = (a leftrotate 5) + f + e + k + w[i]\\n let temp := and(div(x, 0x80000000000000000000000000000000000000000000000), 0x1F)\\n temp := or(and(div(x, 0x800000000000000000000000000000000000000), 0xFFFFFFE0), temp)\\n temp := add(f, temp)\\n temp := add(and(x, 0xFFFFFFFF), temp)\\n temp := add(k, temp)\\n temp := add(div(mload(add(scratch, mul(j, 4))), 0x100000000000000000000000000000000000000000000000000000000), temp)\\n x := or(div(x, 0x10000000000), mul(temp, 0x10000000000000000000000000000000000000000))\\n x := or(and(x, 0xFFFFFFFF00FFFFFFFF000000000000FFFFFFFF00FFFFFFFF), mul(or(and(div(x, 0x4000000000000), 0xC0000000), and(div(x, 0x400000000000000000000), 0x3FFFFFFF)), 0x100000000000000000000))\\n }\\n\\n h := and(add(h, x), 0xFFFFFFFF00FFFFFFFF00FFFFFFFF00FFFFFFFF00FFFFFFFF)\\n }\\n ret := mul(or(or(or(or(and(div(h, 0x100000000), 0xFFFFFFFF00000000000000000000000000000000), and(div(h, 0x1000000), 0xFFFFFFFF000000000000000000000000)), and(div(h, 0x10000), 0xFFFFFFFF0000000000000000)), and(div(h, 0x100), 0xFFFFFFFF00000000)), and(h, 0xFFFFFFFF)), 0x1000000000000000000000000)\\n }\\n }\\n}\\n\",\"keccak256\":\"0x746d9b85de197afbc13182cbe4ba4f7917f19594e07c655d6a0c85fdf7460a8a\"},\"contracts/dnssec-oracle/BytesUtils.sol\":{\"content\":\"pragma solidity ^0.8.4;\\n\\nlibrary BytesUtils {\\n /*\\n * @dev Returns the keccak-256 hash of a byte range.\\n * @param self The byte string to hash.\\n * @param offset The position to start hashing at.\\n * @param len The number of bytes to hash.\\n * @return The hash of the byte range.\\n */\\n function keccak(bytes memory self, uint offset, uint len) internal pure returns (bytes32 ret) {\\n require(offset + len <= self.length);\\n assembly {\\n ret := keccak256(add(add(self, 32), offset), len)\\n }\\n }\\n\\n\\n /*\\n * @dev Returns a positive number if `other` comes lexicographically after\\n * `self`, a negative number if it comes before, or zero if the\\n * contents of the two bytes are equal.\\n * @param self The first bytes to compare.\\n * @param other The second bytes to compare.\\n * @return The result of the comparison.\\n */\\n function compare(bytes memory self, bytes memory other) internal pure returns (int) {\\n return compare(self, 0, self.length, other, 0, other.length);\\n }\\n\\n /*\\n * @dev Returns a positive number if `other` comes lexicographically after\\n * `self`, a negative number if it comes before, or zero if the\\n * contents of the two bytes are equal. Comparison is done per-rune,\\n * on unicode codepoints.\\n * @param self The first bytes to compare.\\n * @param offset The offset of self.\\n * @param len The length of self.\\n * @param other The second bytes to compare.\\n * @param otheroffset The offset of the other string.\\n * @param otherlen The length of the other string.\\n * @return The result of the comparison.\\n */\\n function compare(bytes memory self, uint offset, uint len, bytes memory other, uint otheroffset, uint otherlen) internal pure returns (int) {\\n uint shortest = len;\\n if (otherlen < len)\\n shortest = otherlen;\\n\\n uint selfptr;\\n uint otherptr;\\n\\n assembly {\\n selfptr := add(self, add(offset, 32))\\n otherptr := add(other, add(otheroffset, 32))\\n }\\n for (uint idx = 0; idx < shortest; idx += 32) {\\n uint a;\\n uint b;\\n assembly {\\n a := mload(selfptr)\\n b := mload(otherptr)\\n }\\n if (a != b) {\\n // Mask out irrelevant bytes and check again\\n uint mask;\\n if (shortest > 32) {\\n mask = type(uint256).max;\\n } else {\\n mask = ~(2 ** (8 * (32 - shortest + idx)) - 1);\\n }\\n int diff = int(a & mask) - int(b & mask);\\n if (diff != 0)\\n return diff;\\n }\\n selfptr += 32;\\n otherptr += 32;\\n }\\n\\n return int(len) - int(otherlen);\\n }\\n\\n /*\\n * @dev Returns true if the two byte ranges are equal.\\n * @param self The first byte range to compare.\\n * @param offset The offset into the first byte range.\\n * @param other The second byte range to compare.\\n * @param otherOffset The offset into the second byte range.\\n * @param len The number of bytes to compare\\n * @return True if the byte ranges are equal, false otherwise.\\n */\\n function equals(bytes memory self, uint offset, bytes memory other, uint otherOffset, uint len) internal pure returns (bool) {\\n return keccak(self, offset, len) == keccak(other, otherOffset, len);\\n }\\n\\n /*\\n * @dev Returns true if the two byte ranges are equal with offsets.\\n * @param self The first byte range to compare.\\n * @param offset The offset into the first byte range.\\n * @param other The second byte range to compare.\\n * @param otherOffset The offset into the second byte range.\\n * @return True if the byte ranges are equal, false otherwise.\\n */\\n function equals(bytes memory self, uint offset, bytes memory other, uint otherOffset) internal pure returns (bool) {\\n return keccak(self, offset, self.length - offset) == keccak(other, otherOffset, other.length - otherOffset);\\n }\\n\\n /*\\n * @dev Compares a range of 'self' to all of 'other' and returns True iff\\n * they are equal.\\n * @param self The first byte range to compare.\\n * @param offset The offset into the first byte range.\\n * @param other The second byte range to compare.\\n * @return True if the byte ranges are equal, false otherwise.\\n */\\n function equals(bytes memory self, uint offset, bytes memory other) internal pure returns (bool) {\\n return self.length >= offset + other.length && equals(self, offset, other, 0, other.length);\\n }\\n\\n /*\\n * @dev Returns true if the two byte ranges are equal.\\n * @param self The first byte range to compare.\\n * @param other The second byte range to compare.\\n * @return True if the byte ranges are equal, false otherwise.\\n */\\n function equals(bytes memory self, bytes memory other) internal pure returns(bool) {\\n return self.length == other.length && equals(self, 0, other, 0, self.length);\\n }\\n\\n /*\\n * @dev Returns the 8-bit number at the specified index of self.\\n * @param self The byte string.\\n * @param idx The index into the bytes\\n * @return The specified 8 bits of the string, interpreted as an integer.\\n */\\n function readUint8(bytes memory self, uint idx) internal pure returns (uint8 ret) {\\n return uint8(self[idx]);\\n }\\n\\n /*\\n * @dev Returns the 16-bit number at the specified index of self.\\n * @param self The byte string.\\n * @param idx The index into the bytes\\n * @return The specified 16 bits of the string, interpreted as an integer.\\n */\\n function readUint16(bytes memory self, uint idx) internal pure returns (uint16 ret) {\\n require(idx + 2 <= self.length);\\n assembly {\\n ret := and(mload(add(add(self, 2), idx)), 0xFFFF)\\n }\\n }\\n\\n /*\\n * @dev Returns the 32-bit number at the specified index of self.\\n * @param self The byte string.\\n * @param idx The index into the bytes\\n * @return The specified 32 bits of the string, interpreted as an integer.\\n */\\n function readUint32(bytes memory self, uint idx) internal pure returns (uint32 ret) {\\n require(idx + 4 <= self.length);\\n assembly {\\n ret := and(mload(add(add(self, 4), idx)), 0xFFFFFFFF)\\n }\\n }\\n\\n /*\\n * @dev Returns the 32 byte value at the specified index of self.\\n * @param self The byte string.\\n * @param idx The index into the bytes\\n * @return The specified 32 bytes of the string.\\n */\\n function readBytes32(bytes memory self, uint idx) internal pure returns (bytes32 ret) {\\n require(idx + 32 <= self.length);\\n assembly {\\n ret := mload(add(add(self, 32), idx))\\n }\\n }\\n\\n /*\\n * @dev Returns the 32 byte value at the specified index of self.\\n * @param self The byte string.\\n * @param idx The index into the bytes\\n * @return The specified 32 bytes of the string.\\n */\\n function readBytes20(bytes memory self, uint idx) internal pure returns (bytes20 ret) {\\n require(idx + 20 <= self.length);\\n assembly {\\n ret := and(mload(add(add(self, 32), idx)), 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF000000000000000000000000)\\n }\\n }\\n\\n /*\\n * @dev Returns the n byte value at the specified index of self.\\n * @param self The byte string.\\n * @param idx The index into the bytes.\\n * @param len The number of bytes.\\n * @return The specified 32 bytes of the string.\\n */\\n function readBytesN(bytes memory self, uint idx, uint len) internal pure returns (bytes32 ret) {\\n require(len <= 32);\\n require(idx + len <= self.length);\\n assembly {\\n let mask := not(sub(exp(256, sub(32, len)), 1))\\n ret := and(mload(add(add(self, 32), idx)), mask)\\n }\\n }\\n\\n function memcpy(uint dest, uint src, uint len) private pure {\\n // Copy word-length chunks while possible\\n for (; len >= 32; len -= 32) {\\n assembly {\\n mstore(dest, mload(src))\\n }\\n dest += 32;\\n src += 32;\\n }\\n\\n // Copy remaining bytes\\n unchecked {\\n uint mask = (256 ** (32 - len)) - 1;\\n assembly {\\n let srcpart := and(mload(src), not(mask))\\n let destpart := and(mload(dest), mask)\\n mstore(dest, or(destpart, srcpart))\\n }\\n }\\n }\\n\\n /*\\n * @dev Copies a substring into a new byte string.\\n * @param self The byte string to copy from.\\n * @param offset The offset to start copying at.\\n * @param len The number of bytes to copy.\\n */\\n function substring(bytes memory self, uint offset, uint len) internal pure returns(bytes memory) {\\n require(offset + len <= self.length);\\n\\n bytes memory ret = new bytes(len);\\n uint dest;\\n uint src;\\n\\n assembly {\\n dest := add(ret, 32)\\n src := add(add(self, 32), offset)\\n }\\n memcpy(dest, src, len);\\n\\n return ret;\\n }\\n\\n // Maps characters from 0x30 to 0x7A to their base32 values.\\n // 0xFF represents invalid characters in that range.\\n bytes constant base32HexTable = hex'00010203040506070809FFFFFFFFFFFFFF0A0B0C0D0E0F101112131415161718191A1B1C1D1E1FFFFFFFFFFFFFFFFFFFFF0A0B0C0D0E0F101112131415161718191A1B1C1D1E1F';\\n\\n /**\\n * @dev Decodes unpadded base32 data of up to one word in length.\\n * @param self The data to decode.\\n * @param off Offset into the string to start at.\\n * @param len Number of characters to decode.\\n * @return The decoded data, left aligned.\\n */\\n function base32HexDecodeWord(bytes memory self, uint off, uint len) internal pure returns(bytes32) {\\n require(len <= 52);\\n\\n uint ret = 0;\\n uint8 decoded;\\n for(uint i = 0; i < len; i++) {\\n bytes1 char = self[off + i];\\n require(char >= 0x30 && char <= 0x7A);\\n decoded = uint8(base32HexTable[uint(uint8(char)) - 0x30]);\\n require(decoded <= 0x20);\\n if(i == len - 1) {\\n break;\\n }\\n ret = (ret << 5) | decoded;\\n }\\n\\n uint bitlen = len * 5;\\n if(len % 8 == 0) {\\n // Multiple of 8 characters, no padding\\n ret = (ret << 5) | decoded;\\n } else if(len % 8 == 2) {\\n // Two extra characters - 1 byte\\n ret = (ret << 3) | (decoded >> 2);\\n bitlen -= 2;\\n } else if(len % 8 == 4) {\\n // Four extra characters - 2 bytes\\n ret = (ret << 1) | (decoded >> 4);\\n bitlen -= 4;\\n } else if(len % 8 == 5) {\\n // Five extra characters - 3 bytes\\n ret = (ret << 4) | (decoded >> 1);\\n bitlen -= 1;\\n } else if(len % 8 == 7) {\\n // Seven extra characters - 4 bytes\\n ret = (ret << 2) | (decoded >> 3);\\n bitlen -= 3;\\n } else {\\n revert();\\n }\\n\\n return bytes32(ret << (256 - bitlen));\\n }\\n}\",\"keccak256\":\"0x83315df2e54c74451577c70da2c267c3459802b08b9aeec6516302eee70f796e\"},\"contracts/dnssec-oracle/algorithms/Algorithm.sol\":{\"content\":\"pragma solidity ^0.8.4;\\n\\n/**\\n* @dev An interface for contracts implementing a DNSSEC (signing) algorithm.\\n*/\\ninterface Algorithm {\\n /**\\n * @dev Verifies a signature.\\n * @param key The public key to verify with.\\n * @param data The signed data to verify.\\n * @param signature The signature to verify.\\n * @return True iff the signature is valid.\\n */\\n function verify(bytes calldata key, bytes calldata data, bytes calldata signature) external virtual view returns (bool);\\n}\\n\",\"keccak256\":\"0x51d6251568844e435f58952354abe8c8c8e978ab40ecb0bbb2f5bd767838b3a7\"},\"contracts/dnssec-oracle/algorithms/ModexpPrecompile.sol\":{\"content\":\"pragma solidity ^0.8.4;\\n\\nlibrary ModexpPrecompile {\\n /**\\n * @dev Computes (base ^ exponent) % modulus over big numbers.\\n */\\n function modexp(bytes memory base, bytes memory exponent, bytes memory modulus) internal view returns (bool success, bytes memory output) {\\n bytes memory input = abi.encodePacked(\\n uint256(base.length),\\n uint256(exponent.length),\\n uint256(modulus.length),\\n base,\\n exponent,\\n modulus\\n );\\n\\n output = new bytes(modulus.length);\\n\\n assembly {\\n success := staticcall(gas(), 5, add(input, 32), mload(input), add(output, 32), mload(modulus))\\n }\\n }\\n}\\n\",\"keccak256\":\"0xe3d689d14cf0294f433f4e14cdd8feab8d542e5b8342c911d5c7cb518170e2b1\"},\"contracts/dnssec-oracle/algorithms/RSASHA1Algorithm.sol\":{\"content\":\"pragma solidity ^0.8.4;\\n\\nimport \\\"./Algorithm.sol\\\";\\nimport \\\"../BytesUtils.sol\\\";\\nimport \\\"./RSAVerify.sol\\\";\\nimport \\\"@ensdomains/solsha1/contracts/SHA1.sol\\\";\\n\\n/**\\n* @dev Implements the DNSSEC RSASHA1 algorithm.\\n*/\\ncontract RSASHA1Algorithm is Algorithm {\\n using BytesUtils for *;\\n\\n function verify(bytes calldata key, bytes calldata data, bytes calldata sig) external override view returns (bool) {\\n bytes memory exponent;\\n bytes memory modulus;\\n\\n uint16 exponentLen = uint16(key.readUint8(4));\\n if (exponentLen != 0) {\\n exponent = key.substring(5, exponentLen);\\n modulus = key.substring(exponentLen + 5, key.length - exponentLen - 5);\\n } else {\\n exponentLen = key.readUint16(5);\\n exponent = key.substring(7, exponentLen);\\n modulus = key.substring(exponentLen + 7, key.length - exponentLen - 7);\\n }\\n\\n // Recover the message from the signature\\n bool ok;\\n bytes memory result;\\n (ok, result) = RSAVerify.rsarecover(modulus, exponent, sig);\\n\\n // Verify it ends with the hash of our data\\n return ok && SHA1.sha1(data) == result.readBytes20(result.length - 20);\\n }\\n}\\n\",\"keccak256\":\"0x4d3b4b7873785b2d1806faa3fc31aca7b5897b1ae69b1224f6a12d06e295939e\"},\"contracts/dnssec-oracle/algorithms/RSAVerify.sol\":{\"content\":\"pragma solidity ^0.8.4;\\n\\nimport \\\"../BytesUtils.sol\\\";\\nimport \\\"./ModexpPrecompile.sol\\\";\\n\\nlibrary RSAVerify {\\n /**\\n * @dev Recovers the input data from an RSA signature, returning the result in S.\\n * @param N The RSA public modulus.\\n * @param E The RSA public exponent.\\n * @param S The signature to recover.\\n * @return True if the recovery succeeded.\\n */\\n function rsarecover(bytes memory N, bytes memory E, bytes memory S) internal view returns (bool, bytes memory) {\\n return ModexpPrecompile.modexp(S, E, N);\\n }\\n}\\n\",\"keccak256\":\"0xc630e4d296e2d7bd2b968f8a9a8df629fef5161e10ffae9973e045900741cfe4\"}},\"version\":1}", "bytecode": "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", "deployedBytecode": "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", "devdoc": { "details": "Implements the DNSSEC RSASHA1 algorithm.", "kind": "dev", "methods": {}, "version": 1 }, "userdoc": { "kind": "user", "methods": {}, "version": 1 }, "storageLayout": { "storage": [], "types": null } }