Reverse engineer anything with agents, from app behavior down to native binaries.
TypeScript agent-skillsai-agentsbinary-analysisclaude-codeclicodexcordisdecompilerdeveloper-toolsdshdsh-pluginghidrahopperllmmcpmodel-context-protocolreareverse-engineeringstatic-analysistouhou
#pragma once
#include <cstdint>
#include <utility>
namespace rea {
// A failed CloseHandle and a later liveness probe are not one atomic fact.
// Another thread can reuse the numeric value before GetHandleInformation
// runs, so an Open result does not prove the probed object is still ours.
// After a failed close, drop the value only when the probe says it is gone.
// Otherwise keep it and do not call CloseHandle again.
enum class HandleLiveness { Open, NotInTable, Unavailable };
enum class HandleCloseDisposition {
Released,
TerminalInvalid,
Unconfirmed,
};
struct CloseAttempt {
bool succeeded = false;
std::uint32_t error = 0;
};
struct LivenessProbe {
HandleLiveness liveness = HandleLiveness::Unavailable;
std::uint32_t error = 0;
};
struct HandleCloseDecision {
HandleCloseDisposition disposition = HandleCloseDisposition::Released;
bool clearValue = false;
bool retryClose = false;
std::uint32_t closeError = 0;
std::uint32_t evidenceError = 0;
};
inline HandleCloseDecision decideOwnedHandleClose(bool closeSucceeded,
std::uint32_t closeError,
LivenessProbe evidence) {
if (closeSucceeded)
return {HandleCloseDisposition::Released, true, false, 0, 0};
switch (evidence.liveness) {
case HandleLiveness::Open:
case HandleLiveness::Unavailable:
return {HandleCloseDisposition::Unconfirmed, false, false, closeError,
evidence.error};
case HandleLiveness::NotInTable:
return {HandleCloseDisposition::TerminalInvalid, true, false, closeError,
evidence.error};
}
return {HandleCloseDisposition::Unconfirmed, false, false, closeError,
evidence.error};
}
// One current value plus at most one parked replacement. Close and liveness
// are injected so this gate can be tested without a kernel handle table.
template <class T>
class OwnedHandle {
public:
explicit OwnedHandle(T invalid) noexcept
: invalid_(invalid), value_(invalid), extra_(invalid) {}
OwnedHandle(const OwnedHandle&) = delete;
OwnedHandle& operator=(const OwnedHandle&) = delete;
OwnedHandle(OwnedHandle&& other) noexcept
: invalid_(other.invalid_),
value_(std::exchange(other.value_, other.invalid_)),
extra_(std::exchange(other.extra_, other.invalid_)),
blockValue_(std::exchange(other.blockValue_, false)),
blockExtra_(std::exchange(other.blockExtra_, false)) {}
OwnedHandle& operator=(OwnedHandle&&) = delete;
T get() const noexcept { return value_; }
T invalid() const noexcept { return invalid_; }
bool valid() const noexcept { return value_ != invalid_; }
bool fullyReleased() const noexcept {
return value_ == invalid_ && extra_ == invalid_;
}
bool closeBlocked() const noexcept { return blockValue_; }
// Install a value into an empty slot. A live owner uses reset.
bool park(T value, bool blockClose) noexcept {
if (value == invalid_) return true;
if (value_ == invalid_) {
value_ = value;
blockValue_ = blockClose;
return true;
}
if (extra_ == invalid_) {
extra_ = value;
blockExtra_ = blockClose;
return true;
}
return false;
}
struct Slots {
T value;
T extra;
bool blockValue;
bool blockExtra;
};
Slots take() noexcept {
Slots slots{value_, extra_, blockValue_, blockExtra_};
value_ = invalid_;
extra_ = invalid_;
blockValue_ = false;
blockExtra_ = false;
return slots;
}
template <class Close, class Probe>
HandleCloseDecision release(Close&& close, Probe&& probe) noexcept {
HandleCloseDecision last{HandleCloseDisposition::Released, true, false, 0, 0};
for (;;) {
if (value_ == invalid_) {
if (extra_ == invalid_) return last;
value_ = extra_;
blockValue_ = blockExtra_;
extra_ = invalid_;
blockExtra_ = false;
}
last = finalizeSlot(value_, blockValue_, close, probe);
if (value_ != invalid_) return last;
}
}
// Close the current owner. On an unconfirmed close, keep it and park `next`
// instead of overwriting the numeric value. `sink` receives a value that
// does not fit in the parked slot; it must retain that exact value.
template <class Close, class Probe, class Sink>
void reset(T next, Close&& close, Probe&& probe, Sink&& sink) noexcept {
release(close, probe);
if (!fullyReleased()) {
if (next != invalid_ && next != value_ && next != extra_ && !park(next, false))
sink(next, false);
return;
}
value_ = next;
blockValue_ = false;
}
// Last-resort detach. Release once, then hand any surviving values to `sink`
// without a second close of a value whose liveness is not Open.
template <class Close, class Probe, class Sink>
void abandon(Close&& close, Probe&& probe, Sink&& sink) noexcept {
release(close, probe);
if (value_ != invalid_) sink(value_, blockValue_);
if (extra_ != invalid_) sink(extra_, blockExtra_);
value_ = invalid_;
extra_ = invalid_;
blockValue_ = false;
blockExtra_ = false;
}
private:
T invalid_;
T value_;
T extra_;
bool blockValue_ = false;
bool blockExtra_ = false;
template <class Close, class Probe>
HandleCloseDecision finalizeSlot(T& slot, bool& block, Close&& close,
Probe&& probe) noexcept {
if (slot == invalid_)
return {HandleCloseDisposition::Released, true, false, 0, 0};
if (block) {
const LivenessProbe evidence = probe(slot);
if (evidence.liveness == HandleLiveness::NotInTable) {
slot = invalid_;
block = false;
return {HandleCloseDisposition::TerminalInvalid, true, false, 0,
evidence.error};
}
// Open or unreadable: the number stays close-blocked. Closing it could
// release an object that reused the value.
return {HandleCloseDisposition::Unconfirmed, false, false, 0,
evidence.error};
}
const CloseAttempt attempt = close(slot);
if (attempt.succeeded) {
slot = invalid_;
block = false;
return {HandleCloseDisposition::Released, true, false, 0, 0};
}
const LivenessProbe evidence = probe(slot);
const HandleCloseDecision decision =
decideOwnedHandleClose(false, attempt.error, evidence);
if (decision.clearValue) {
slot = invalid_;
block = false;
} else {
block = !decision.retryClose;
}
return decision;
}
};
} // namespace rea