Inside Bitcoin

251        if (opcode == Instruction::RETURN) {
252            // There should not be any RETURN immediately after a DEFAULT (could be combined into just RETURN)
253            if (prevopcode == Instruction::DEFAULT) return false;
254            uint32_t asn = DecodeASN(pos, asmap);
255            if (asn == INVALID) return false; // ASN straddles EOF
256            if (jumps.empty()) {
257                // Nothing to execute anymore
258                if (endpos - pos > 7) return false; // Excessive padding
259                while (pos != endpos) {
260                    if (ConsumeBitLE(pos, asmap)) return false; // Nonzero padding bit
261                }
262                return true; // Sanely reached EOF
263            } else {
264                // Continue by pretending we jumped to the next instruction
265                if (pos != jumps.back().first) return false; // Unreachable code
266                bits = jumps.back().second; // Restore the number of bits we would have had left after this jump
267                jumps.pop_back();
268                prevopcode = Instruction::JUMP;
269            }
270        } else if (opcode == Instruction::JUMP) {
271            uint32_t jump = DecodeJump(pos, asmap);
272            if (jump == INVALID) return false; // Jump offset straddles EOF
273            if (int64_t{jump} > static_cast<int64_t>(endpos - pos)) return false; // Jump out of range
274            if (bits == 0) return false; // Consuming bits past the end of the input
275            --bits;
276            uint32_t jump_offset = pos + jump;
277            if (!jumps.empty() && jump_offset >= jumps.back().first) return false; // Intersecting jumps
278            jumps.emplace_back(jump_offset, bits);  // Queue jump target for validation
279            prevopcode = Instruction::JUMP;
280        } else if (opcode == Instruction::MATCH) {
281            uint32_t match = DecodeMatch(pos, asmap);
282            if (match == INVALID) return false; // Match bits straddle EOF
283            int matchlen = std::bit_width(match) - 1;
284            if (prevopcode != Instruction::MATCH) had_incomplete_match = false;
285            // Within a sequence of matches only at most one should be incomplete
286            if (matchlen < 8 && had_incomplete_match) return false;
287            had_incomplete_match = (matchlen < 8);
288            if (bits < matchlen) return false; // Consuming bits past the end of the input
289            bits -= matchlen;
290            prevopcode = Instruction::MATCH;
291        } else if (opcode == Instruction::DEFAULT) {
292            // There should not be two successive DEFAULTs (they could be combined into one)
293            if (prevopcode == Instruction::DEFAULT) return false;
294            uint32_t asn = DecodeASN(pos, asmap);
295            if (asn == INVALID) return false; // ASN straddles EOF
296            prevopcode = Instruction::DEFAULT;
297        } else {
298            return false; // Instruction straddles EOF
299        }
300    }
301    return false; // Reached EOF without RETURN instruction
302}
303
304/**
305 * Provides a safe interface for validating ASMap data before use.
306 * Returns true if the data is valid for 128 bits long inputs.
307 */
308bool CheckStandardAsmap(const std::span<const std::byte> data)
309{
310    if (!SanityCheckAsmap(data, 128)) {
311        LogWarning("Sanity check of asmap data failed\n");
312        return false;
313    }
314    return true;
315}
316
317/**
318 * Loads an ASMap file from disk and validates it.
319 */
320std::vector<std::byte> DecodeAsmap(fs::path path)
321{
322    FILE *filestr = fsbridge::fopen(path, "rb");
323    AutoFile file{filestr};
324    if (file.IsNull()) {
325        LogWarning("Failed to open asmap file from disk");
326        return {};
327    }
328    int64_t length{file.size()};
329    LogInfo("Opened asmap file %s (%d bytes) from disk", fs::quoted(fs::PathToString(path)), length);
330
331    // Read entire file into memory
332    std::vector<std::byte> buffer(length);
333    file.read(buffer);
334
335    if (!CheckStandardAsmap(buffer)) {
336        LogWarning("Sanity check of asmap file %s failed", fs::quoted(fs::PathToString(path)));
337        return {};
338    }
339
340    return buffer;
341}
342
343/**
344 * Computes SHA256 hash of ASMap data for versioning and consistency checks.
345 */
346uint256 AsmapVersion(const std::span<const std::byte> data)
347{
348    if (data.empty()) return {};
349
350    HashWriter asmap_hasher;
351    asmap_hasher << data;
352    return asmap_hasher.GetSHA256();
353}
354