Qualify conservative attestation freshness boundaries on cloud Linux
Rust development slice / linux (push) Failing after 6s
Rust development slice / linux (push) Failing after 6s
This commit is contained in:
@@ -395,11 +395,7 @@ impl Verifier {
|
||||
.interrupt_ns
|
||||
.checked_sub(evidence.received.interrupt_ns)
|
||||
.ok_or_else(|| anyhow::anyhow!("TIME_COUNTER"))?;
|
||||
ensure!(
|
||||
elapsed <= MAX_RTT_NS && age <= MAX_RECEIVED_AGE_NS,
|
||||
"TIME_STALE_RESPONSE"
|
||||
);
|
||||
// Include every local capture budget conservatively, never RTT/2.
|
||||
// Include every local capture/timer budget conservatively, never RTT/2.
|
||||
let delta = evidence
|
||||
.begin
|
||||
.capture_error_ns
|
||||
@@ -407,6 +403,19 @@ impl Verifier {
|
||||
.and_then(|d| d.checked_add(checked.capture_error_ns))
|
||||
.ok_or_else(|| anyhow::anyhow!("TIME_ERROR_OVERFLOW"))?;
|
||||
ensure!(delta <= MAX_CAPTURE_ERROR_NS, "TIME_CAPTURE_BUDGET");
|
||||
// Use the same full qualified uncertainty for freshness as for UTC-U.
|
||||
// The begin budget is deliberately overcounted for receive age: no
|
||||
// endpoint or timer-underread allowance can disappear at either gate.
|
||||
let upper_elapsed = elapsed
|
||||
.checked_add(delta)
|
||||
.ok_or_else(|| anyhow::anyhow!("TIME_ERROR_OVERFLOW"))?;
|
||||
let upper_age = age
|
||||
.checked_add(delta)
|
||||
.ok_or_else(|| anyhow::anyhow!("TIME_ERROR_OVERFLOW"))?;
|
||||
ensure!(
|
||||
upper_elapsed <= MAX_RTT_NS && upper_age <= MAX_RECEIVED_AGE_NS,
|
||||
"TIME_STALE_RESPONSE"
|
||||
);
|
||||
ensure!(
|
||||
p.source_sync_age_ns
|
||||
.checked_add(elapsed)
|
||||
@@ -622,8 +631,8 @@ mod tests {
|
||||
let next_reply = reply(&next, &key, server);
|
||||
let later = v.check_evidence(&evidence, sample(110_000_000)).unwrap();
|
||||
assert!(later.upper_utc_ns() > initial.upper_utc_ns());
|
||||
assert!(v.check_evidence(&evidence, sample(170_000_000)).is_ok());
|
||||
assert!(v.check_evidence(&evidence, sample(171_000_000)).is_err());
|
||||
assert!(v.check_evidence(&evidence, sample(167_000_000)).is_ok());
|
||||
assert!(v.check_evidence(&evidence, sample(167_000_001)).is_err());
|
||||
assert_eq!(
|
||||
v.pending_nonce.as_deref(),
|
||||
Some(next.request().nonce.as_str())
|
||||
@@ -645,8 +654,62 @@ mod tests {
|
||||
Ok(sample(1_250_000_000))
|
||||
})
|
||||
.unwrap();
|
||||
assert!(v.check_evidence(&evidence, sample(1_300_000_000)).is_ok());
|
||||
assert!(v.check_evidence(&evidence, sample(1_300_000_001)).is_err());
|
||||
assert!(v.check_evidence(&evidence, sample(1_297_000_000)).is_ok());
|
||||
assert!(v.check_evidence(&evidence, sample(1_297_000_001)).is_err());
|
||||
}
|
||||
#[test]
|
||||
fn challenge_freshness_includes_all_capture_budgets_at_one_second() {
|
||||
// Unequal budgets make omission of any one endpoint observable. These
|
||||
// are fixture inputs, never installation calibration or measurements.
|
||||
let delta = 31_000_000;
|
||||
for excess in [0, 1] {
|
||||
let (mut v, key, server) = fixture(context(Role::Agent));
|
||||
let mut begin = sample(0);
|
||||
begin.capture_error_ns = 7_000_000;
|
||||
let c = v.begin(begin).unwrap();
|
||||
let signed = reply(&c, &key, server);
|
||||
let mut received = sample(MAX_RTT_NS - delta - 1_000_000);
|
||||
received.capture_error_ns = 11_000_000;
|
||||
let mut checked = sample(MAX_RTT_NS - delta + excess);
|
||||
checked.capture_error_ns = 13_000_000;
|
||||
let result = v.finish_evidence(c, &signed, received, || Ok(checked));
|
||||
assert!(v.pending_nonce.is_none());
|
||||
if excess == 0 {
|
||||
let (evidence, _) = result.unwrap();
|
||||
assert!(v.check_evidence(&evidence, checked).is_ok());
|
||||
let mut later = sample(MAX_RTT_NS - delta + 1);
|
||||
later.capture_error_ns = checked.capture_error_ns;
|
||||
assert!(v.check_evidence(&evidence, later).is_err());
|
||||
} else {
|
||||
assert_eq!(result.err().unwrap().to_string(), "TIME_STALE_RESPONSE");
|
||||
}
|
||||
}
|
||||
}
|
||||
#[test]
|
||||
fn receive_freshness_includes_all_capture_budgets_at_one_hundred_ms() {
|
||||
let delta = 31_000_000;
|
||||
for excess in [0, 1] {
|
||||
let (mut v, key, server) = fixture(context(Role::SystemHelper));
|
||||
let mut begin = sample(0);
|
||||
begin.capture_error_ns = 7_000_000;
|
||||
let c = v.begin(begin).unwrap();
|
||||
let signed = reply(&c, &key, server);
|
||||
let mut received = sample(50_000_000);
|
||||
received.capture_error_ns = 11_000_000;
|
||||
let mut checked = sample(50_000_000 + MAX_RECEIVED_AGE_NS - delta + excess);
|
||||
checked.capture_error_ns = 13_000_000;
|
||||
let result = v.finish_evidence(c, &signed, received, || Ok(checked));
|
||||
assert!(v.pending_nonce.is_none());
|
||||
if excess == 0 {
|
||||
let (evidence, _) = result.unwrap();
|
||||
assert!(v.check_evidence(&evidence, checked).is_ok());
|
||||
let mut later = sample(50_000_000 + MAX_RECEIVED_AGE_NS - delta + 1);
|
||||
later.capture_error_ns = checked.capture_error_ns;
|
||||
assert!(v.check_evidence(&evidence, later).is_err());
|
||||
} else {
|
||||
assert_eq!(result.err().unwrap().to_string(), "TIME_STALE_RESPONSE");
|
||||
}
|
||||
}
|
||||
}
|
||||
#[test]
|
||||
fn held_evidence_cannot_cross_verifier_epoch_or_discontinuity() {
|
||||
|
||||
@@ -0,0 +1,321 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Frozen eight conservative freshness contract units only; no updater service or Apply.
|
||||
|
||||
Prepare copies the independently reviewed snapshot locally. Execute is one
|
||||
root-only Cloud-VM fixture run. After any lost reply read the original case;
|
||||
never execute it again or substitute another binary/source generation.
|
||||
"""
|
||||
import argparse
|
||||
import base64
|
||||
import hashlib
|
||||
import inspect
|
||||
import json
|
||||
import os
|
||||
from pathlib import Path
|
||||
import stat
|
||||
import uuid
|
||||
|
||||
import windows_msi_runtime_acceptance as support
|
||||
|
||||
ROOT = Path(__file__).resolve().parents[1]
|
||||
ACCESS_ROOT = ROOT.parent / 'rust-discovery'
|
||||
QUALIFICATION = ROOT / 'devstate/windows-signed-clock/freshness-qualification-af7a9fb3-0460-4ddc-b682-39931accd249'
|
||||
STATE = ROOT / 'devstate/time-attestation-freshness-linux'
|
||||
PROFILE = 'rmm.time-attestation.eight-conservative-freshness-units.v1'
|
||||
RECEIPT_SHA = '6a624ee9b795ce67d80a91536ba242835be9757a2f502d2d9fbc545532e1b560'
|
||||
INPUTS_SHA = 'e85271e4ec92b8fe05ebdf779206214366ac0e25f8083a4bb13bdd5828c3daa2'
|
||||
BINARY_SHA = '8c1b47a892d8e0afe8d8cd47cfcbd150240fe771be13e990f8bbe161d18f5e21'
|
||||
BINARY_BYTES = 1554688
|
||||
SOURCE_SHA = '807cac064b00760d9131dc2a44d01ad9770a3660f4acd5f8d2948bb0f9234d08'
|
||||
TESTS = ['tests::challenge_freshness_includes_all_capture_budgets_at_one_second', 'tests::discontinuity_invalidates_outstanding_and_requires_new_challenge', 'tests::foreign_reply_cannot_reenable_an_older_own_challenge', 'tests::held_evidence_cannot_cross_verifier_epoch_or_discontinuity', 'tests::held_evidence_expires_without_renewal_and_preserves_pending_refresh', 'tests::receive_freshness_includes_all_capture_budgets_at_one_hundred_ms', 'tests::signed_roundtrip_uses_entire_rtt_and_strict_deadline_interval', 'tests::tampering_wrong_role_nonce_key_and_delays_never_open']
|
||||
AGENT_SHA = '0a7ad6eefaefda79ee80b6a41b2df904e9e7f50ae6ebeed01b98c25b6ce5c06f'
|
||||
HELPER_SHA = '79442727c3ba31cda02a8bc0e67481f14db9f39fc07520a880a90b64f10f1eaf'
|
||||
|
||||
|
||||
def sha(raw):
|
||||
return hashlib.sha256(raw).hexdigest()
|
||||
|
||||
|
||||
def save_local(path, value):
|
||||
support.save(path, value)
|
||||
fd = os.open(path.parent, os.O_RDONLY | os.O_DIRECTORY | os.O_NOFOLLOW)
|
||||
try:
|
||||
os.fsync(fd)
|
||||
finally:
|
||||
os.close(fd)
|
||||
|
||||
|
||||
def copy_exact(source, destination, digest, size):
|
||||
metadata = source.lstat()
|
||||
support.require(stat.S_ISREG(metadata.st_mode) and metadata.st_nlink == 1
|
||||
and metadata.st_uid in (0, os.getuid()) and not metadata.st_mode & 0o002
|
||||
and metadata.st_size == size and size <= 2 * 1024 * 1024, 'bounded regular frozen input')
|
||||
raw = source.read_bytes()
|
||||
support.require(sha(raw) == digest, 'frozen snapshot input hash')
|
||||
destination.parent.mkdir(mode=0o700, parents=True, exist_ok=True)
|
||||
support.private(destination.parent, True)
|
||||
fd = os.open(destination, os.O_CREAT | os.O_EXCL | os.O_NOFOLLOW | os.O_WRONLY, 0o600)
|
||||
with os.fdopen(fd, 'wb') as stream:
|
||||
stream.write(raw); stream.flush(); os.fsync(stream.fileno())
|
||||
fd = os.open(destination.parent, os.O_RDONLY | os.O_DIRECTORY | os.O_NOFOLLOW)
|
||||
try:
|
||||
os.fsync(fd)
|
||||
finally:
|
||||
os.close(fd)
|
||||
|
||||
|
||||
def verify_case(folder):
|
||||
value = support.load(folder / 'manifest.json')
|
||||
support.require(value['profile'] == PROFILE and value['tests'] == TESTS
|
||||
and value['runner_sha256'] == sha(Path(__file__).read_bytes())
|
||||
and value['receipt_sha256'] == RECEIPT_SHA and value['binary_sha256'] == BINARY_SHA
|
||||
and value['binary_bytes'] == BINARY_BYTES, 'same original reviewed manifest')
|
||||
support.require(sha((folder / 'receipt.json').read_bytes()) == RECEIPT_SHA
|
||||
and sha((folder / 'inputs.json').read_bytes()) == INPUTS_SHA, 'original qualification provenance')
|
||||
source = support.load(folder / 'inputs.json')
|
||||
support.require(len(source) == 202 and source == value['source_files'], 'exact frozen 202 qualification inputs')
|
||||
for item in source:
|
||||
path = Path(item['path'])
|
||||
support.require(not path.is_absolute() and '..' not in path.parts, 'fixed snapshot relative path')
|
||||
file = folder / 'source' / path
|
||||
support.private(file)
|
||||
support.require(file.stat().st_size == item['bytes'] and sha(file.read_bytes()) == item['sha256'], 'retained source freeze')
|
||||
support.require([item for item in source if item['path']=='crates/time-attestation/src/lib.rs']
|
||||
== [dict(path='crates/time-attestation/src/lib.rs', bytes=28154, sha256=SOURCE_SHA)], 'exact conservative freshness codec source')
|
||||
binary = folder / 'time-contract-tests'; support.private(binary)
|
||||
support.require(binary.stat().st_size == BINARY_BYTES and sha(binary.read_bytes()) == BINARY_SHA, 'original qualified test bytes')
|
||||
for path, digest in value['transport_sources'].items():
|
||||
support.require(sha((ROOT / path).read_bytes()) == digest, 'original strict transport source')
|
||||
return value
|
||||
|
||||
|
||||
def remote(p):
|
||||
import base64
|
||||
import hashlib
|
||||
import json
|
||||
import os
|
||||
from pathlib import Path
|
||||
import selectors
|
||||
import signal
|
||||
import stat
|
||||
import subprocess
|
||||
import time
|
||||
import uuid
|
||||
|
||||
def require(ok, message):
|
||||
if not ok:
|
||||
raise RuntimeError(message)
|
||||
|
||||
def enc(value):
|
||||
return json.dumps(value, sort_keys=True, separators=(',', ':')).encode()
|
||||
|
||||
def create(path, raw, mode=0o600):
|
||||
fd = os.open(path, os.O_WRONLY | os.O_CREAT | os.O_EXCL | os.O_NOFOLLOW, mode)
|
||||
with os.fdopen(fd, 'wb') as stream:
|
||||
stream.write(raw); stream.flush(); os.fsync(stream.fileno())
|
||||
fd = os.open(path.parent, os.O_DIRECTORY | os.O_RDONLY | os.O_NOFOLLOW)
|
||||
try:
|
||||
os.fsync(fd)
|
||||
finally:
|
||||
os.close(fd)
|
||||
|
||||
def run(args, timeout=20):
|
||||
# Keep the owned group leader unreaped until its entire group has been
|
||||
# cleaned up. Its PID therefore cannot be recycled before killpg.
|
||||
child = subprocess.Popen(args, stdin=subprocess.DEVNULL, stdout=subprocess.PIPE,
|
||||
stderr=subprocess.PIPE, start_new_session=True,
|
||||
env={'PATH': '/usr/bin:/bin', 'LC_ALL': 'C', 'HOME': '/nonexistent'})
|
||||
selector = selectors.DefaultSelector()
|
||||
buffers = {'stdout': bytearray(), 'stderr': bytearray()}
|
||||
deadline = time.monotonic() + timeout
|
||||
try:
|
||||
for stream, name in ((child.stdout, 'stdout'), (child.stderr, 'stderr')):
|
||||
os.set_blocking(stream.fileno(), False); selector.register(stream, selectors.EVENT_READ, name)
|
||||
while True:
|
||||
require(time.monotonic() < deadline, 'owned native command timeout; read original case only')
|
||||
for key, _ in selector.select(0.02):
|
||||
raw = os.read(key.fileobj.fileno(), 4096)
|
||||
if raw:
|
||||
buffers[key.data].extend(raw)
|
||||
require(len(buffers[key.data]) <= 65536, 'bounded native output')
|
||||
else:
|
||||
selector.unregister(key.fileobj)
|
||||
ended = os.waitid(os.P_PID, child.pid, os.WEXITED | os.WNOHANG | os.WNOWAIT)
|
||||
if ended is not None:
|
||||
# Child remains a zombie until finally: no PID/group reuse.
|
||||
os.killpg(child.pid, signal.SIGKILL)
|
||||
for key in list(selector.get_map().values()):
|
||||
while True:
|
||||
try:
|
||||
raw = os.read(key.fileobj.fileno(), 4096)
|
||||
except BlockingIOError:
|
||||
break
|
||||
if not raw:
|
||||
break
|
||||
buffers[key.data].extend(raw)
|
||||
require(len(buffers[key.data]) <= 65536, 'bounded native output')
|
||||
code = ended.si_status if ended.si_code == os.CLD_EXITED else -ended.si_status
|
||||
return code, bytes(buffers['stdout']), bytes(buffers['stderr'])
|
||||
finally:
|
||||
os.killpg(child.pid, signal.SIGKILL)
|
||||
child.wait()
|
||||
selector.close(); child.stdout.close(); child.stderr.close()
|
||||
|
||||
def metadata_identity(value):
|
||||
return (value.st_dev, value.st_ino, value.st_uid, value.st_gid, value.st_mode,
|
||||
value.st_nlink, value.st_size, value.st_mtime_ns, value.st_ctime_ns)
|
||||
|
||||
def hashed(path, maximum, process_image=False):
|
||||
fd = os.open(path, os.O_RDONLY | os.O_CLOEXEC | (0 if process_image else os.O_NOFOLLOW))
|
||||
with os.fdopen(fd, 'rb') as stream:
|
||||
before = os.fstat(stream.fileno()); require(stat.S_ISREG(before.st_mode) and before.st_size <= maximum, 'bounded witness file')
|
||||
digest = hashlib.sha256(); total = 0
|
||||
while True:
|
||||
raw = stream.read(32768)
|
||||
if not raw:
|
||||
break
|
||||
total += len(raw); require(total <= maximum, 'bounded witness hash'); digest.update(raw)
|
||||
after = os.fstat(stream.fileno())
|
||||
require(metadata_identity(before) == metadata_identity(after) and total == before.st_size, 'stable witness hash')
|
||||
return before, digest.hexdigest()
|
||||
|
||||
def witness():
|
||||
out = {'boot_id': Path('/proc/sys/kernel/random/boot_id').read_text().strip(), 'services': {}, 'files': {}}
|
||||
release = dict(line.split('=', 1) for line in Path('/etc/os-release').read_text().splitlines() if '=' in line)
|
||||
require(release.get('ID', '').strip('"') == 'ubuntu' and release.get('VERSION_ID', '').strip('"') == '24.04', 'fixed native Ubuntu24.04')
|
||||
out['os'] = {'id': 'ubuntu', 'version': '24.04', 'machine': os.uname().machine, 'kernel': os.uname().release}
|
||||
for name, uid, binary in (
|
||||
('rmm-agent-remote.service', 993, p['agent_sha256']),
|
||||
('rmm-helper-cloud.service', 0, p['helper_sha256']),
|
||||
('rmm-full-maintenance-helper.service', 0, p['helper_sha256'])):
|
||||
code, stdout, _ = run(['/usr/bin/systemctl', 'show', name, '-p', 'ActiveState', '-p', 'MainPID', '-p', 'UnitFileState', '-p', 'InvocationID'])
|
||||
require(code == 0, 'existing service read')
|
||||
service = dict(line.split('=', 1) for line in stdout.decode().splitlines())
|
||||
pid = int(service['MainPID']); require(service['ActiveState'] == 'active' and pid > 1, 'three existing services active')
|
||||
proc = Path('/proc', str(pid)); birth = (proc / 'stat').read_text().rsplit(') ', 1)[1].split()[19]
|
||||
ids = {line.split(':')[0]: line.split()[1:] for line in (proc / 'status').read_text().splitlines() if line.startswith(('Uid:', 'Gid:'))}
|
||||
metadata, image = hashed(proc / 'exe', 256 * 1024 * 1024, process_image=True)
|
||||
current = (proc / 'exe').stat()
|
||||
require(ids['Uid'] == [str(uid)] * 4 and ids['Gid'] == ['984'] * 4 and image == binary
|
||||
and (metadata.st_dev, metadata.st_ino) == (current.st_dev, current.st_ino)
|
||||
and (proc / 'stat').read_text().rsplit(') ', 1)[1].split()[19] == birth, 'current generation/account/image')
|
||||
out['services'][name] = dict(service, birth=birth, image=image, ids=ids)
|
||||
code, stdout, _ = run(['/usr/bin/systemctl', 'show', 'rmm-apt-helper.service', '-p', 'ActiveState', '-p', 'UnitFileState'])
|
||||
apt = dict(line.split('=', 1) for line in stdout.decode().splitlines())
|
||||
require(code == 0 and apt == {'ActiveState': 'inactive', 'UnitFileState': 'disabled'}, 'APT remains closed')
|
||||
out['apt'] = apt
|
||||
for name in ('/etc/rmm-remote/helper-general.json', '/etc/rmm-remote/helper-full-maintenance.json',
|
||||
'/etc/rmm-remote/full-maintenance-helper-proof.json', '/etc/systemd/system/rmm-full-maintenance-helper.service'):
|
||||
path = Path(name); metadata = path.lstat()
|
||||
require(not path.is_symlink() and stat.S_ISREG(metadata.st_mode) and metadata.st_uid == 0
|
||||
and not metadata.st_mode & 0o022 and metadata.st_nlink == 1, 'protected known control')
|
||||
current, digest = hashed(path, 65536)
|
||||
require(metadata_identity(current) == metadata_identity(metadata), 'same known control file')
|
||||
out['files'][name] = [metadata.st_dev, metadata.st_ino, metadata.st_uid, metadata.st_gid, metadata.st_mode,
|
||||
metadata.st_size, metadata.st_mtime_ns, metadata.st_ctime_ns, digest]
|
||||
for name in ('/var/lib/rmm-helper/consumption.sqlite', '/var/lib/rmm-helper/executor.lock',
|
||||
'/var/lib/rmm-agent-remote/journal.sqlite', '/var/lib/rmm-agent-remote/consumption.sqlite'):
|
||||
path = Path(name); metadata = path.lstat()
|
||||
require(not path.is_symlink() and stat.S_ISREG(metadata.st_mode) and metadata.st_nlink == 1, 'existing state identity')
|
||||
out['files'][name] = [metadata.st_dev, metadata.st_ino, metadata.st_uid, metadata.st_gid, metadata.st_mode]
|
||||
return out
|
||||
|
||||
require(os.geteuid() == 0 and os.uname().machine == 'x86_64', 'fixed Cloud Linux root contract fixtures')
|
||||
ident = str(uuid.UUID(p['id'])); require(ident == p['id'], 'canonical original case')
|
||||
folder = Path('/var/tmp') / ('rmm-time-freshness-units-linux-' + ident)
|
||||
if p['action'] == 'read':
|
||||
metadata = folder.lstat()
|
||||
require(stat.S_ISDIR(metadata.st_mode) and not folder.is_symlink() and metadata.st_uid == 0
|
||||
and stat.S_IMODE(metadata.st_mode) == 0o700, 'own original case only')
|
||||
intent = json.loads((folder / 'intent.json').read_bytes())
|
||||
require(all(intent.get(key) == value for key,value in p.items() if key != 'action'), 'same original read binding')
|
||||
result = folder / 'result.json'
|
||||
return {'read_only': True, 'id': ident, 'entered': (folder / 'entered.json').exists(),
|
||||
'result': json.loads(result.read_bytes()) if result.exists() else None, 'current_witness': witness()}
|
||||
require(p['action'] == 'execute', 'one fixed time contract action')
|
||||
os.umask(0o077); folder.mkdir(mode=0o700)
|
||||
create(folder / 'intent.json', enc({key: value for key, value in p.items() if key != 'binary_b64'}))
|
||||
require(len(p['binary_b64']) == 2072920, 'bounded binary transfer')
|
||||
raw = base64.b64decode(p['binary_b64'], validate=True)
|
||||
require(len(raw) == 1554688 and hashlib.sha256(raw).hexdigest() == p['binary_sha256'], 'fixed eight-unit binary')
|
||||
binary = folder / 'time-contract-tests'; create(binary, raw, 0o700)
|
||||
before = witness(); create(folder / 'before.json', enc(before))
|
||||
command = ['/usr/bin/setpriv', '--reuid=0', '--regid=0', '--clear-groups', '--no-new-privs', str(binary)]
|
||||
code, stdout, stderr = run(command + ['--list', '--format', 'terse'])
|
||||
create(folder / 'list.stdout', stdout); create(folder / 'list.stderr', stderr)
|
||||
require(code == 0 and stderr == b'', 'native list succeeded')
|
||||
lines = stdout.decode().splitlines()
|
||||
require(len(lines) == 8 and all(line.endswith(': test') for line in lines) and sorted(line[:-6] for line in lines if line.endswith(': test')) == p['tests'], 'exact eight tests before any run')
|
||||
create(folder / 'entered.json', enc({'id': ident, 'run_once': True, 'time_ns': time.time_ns()}))
|
||||
code, stdout, stderr = run(command + ['--test-threads=1', '--nocapture'])
|
||||
create(folder / 'run.stdout', stdout); create(folder / 'run.stderr', stderr)
|
||||
after = witness(); create(folder / 'after.json', enc(after))
|
||||
require(before == after and code == 0 and stderr == b''
|
||||
and b'8 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out' in stdout
|
||||
and all((b'test ' + name.encode() + b' ... ok') in stdout for name in p['tests']), 'eight native units and retained target state')
|
||||
receipt = dict(id=ident, profile=p['profile'], passed=8, ignored=0, filtered=0, execution_uid=0, tests=p['tests'],
|
||||
before=before, after=after, binary_sha256=p['binary_sha256'], source_receipt_sha256=p['receipt_sha256'],
|
||||
source_manifest_sha256=p['manifest_sha256'], stdout_sha256=hashlib.sha256(stdout).hexdigest(),
|
||||
no_rmm_jobs=True, no_apply=True, no_service_control=True)
|
||||
create(folder / 'result.json', enc(receipt)); return receipt
|
||||
|
||||
|
||||
def main():
|
||||
parser = argparse.ArgumentParser(description=__doc__)
|
||||
parser.add_argument('action', choices=('prepare', 'execute', 'read')); parser.add_argument('--case')
|
||||
args = parser.parse_args(); os.umask(0o077)
|
||||
STATE.mkdir(mode=0o700, parents=True, exist_ok=True); support.private(STATE, True)
|
||||
if args.action == 'prepare':
|
||||
support.require(args.case is None, 'prepare one new local case')
|
||||
receipt_path = QUALIFICATION / 'receipt.json'; support.private(receipt_path)
|
||||
support.require(sha(receipt_path.read_bytes()) == RECEIPT_SHA, 'independently reviewed source receipt')
|
||||
receipt = support.load(receipt_path); original = support.load(QUALIFICATION / 'inputs.json')
|
||||
support.require(sha((QUALIFICATION / 'inputs.json').read_bytes()) == INPUTS_SHA
|
||||
and receipt['inputs_sha256'] == INPUTS_SHA and len(original) == 202
|
||||
and receipt['source_sha256'] == SOURCE_SHA
|
||||
and receipt['checks']['local_units'] == dict(passed=8,failed=0,ignored=0,filtered=0,complete_test_list=TESTS)
|
||||
and receipt['native_target_execution'] is False and receipt['calibration_created'] is False,
|
||||
'reviewed eight-codec-test qualification')
|
||||
ident = str(uuid.uuid4()); folder = STATE / ident; folder.mkdir(mode=0o700)
|
||||
copy_exact(receipt_path, folder / 'receipt.json', RECEIPT_SHA, receipt_path.stat().st_size)
|
||||
copy_exact(QUALIFICATION / 'inputs.json', folder / 'inputs.json', INPUTS_SHA, (QUALIFICATION / 'inputs.json').stat().st_size)
|
||||
paths = set()
|
||||
for item in original:
|
||||
path = Path(item['path'])
|
||||
support.require(not path.is_absolute() and '..' not in path.parts and str(path) not in paths, 'unique fixed frozen input')
|
||||
paths.add(str(path)); copy_exact(QUALIFICATION / 'source' / path, folder / 'source' / path, item['sha256'], item['bytes'])
|
||||
binary = QUALIFICATION / 'freshness-contract-tests'
|
||||
support.require(receipt['binary'] == dict(filename='freshness-contract-tests', bytes=BINARY_BYTES,
|
||||
sha256=BINARY_SHA, mode='0500', nlink=1), 'fixed original linked artifact')
|
||||
copy_exact(binary, folder / 'time-contract-tests', BINARY_SHA, BINARY_BYTES)
|
||||
transports = {path: sha((ROOT / path).read_bytes()) for path in ('deploy/windows_msi_runtime_acceptance.py', 'deploy/vm_access_check.py')}
|
||||
save_local(folder / 'manifest.json', dict(id=ident, profile=PROFILE, runner_sha256=sha(Path(__file__).read_bytes()),
|
||||
receipt_sha256=RECEIPT_SHA, binary_sha256=BINARY_SHA, binary_bytes=BINARY_BYTES,
|
||||
source_files=original, tests=TESTS, transport_sources=transports))
|
||||
verify_case(folder)
|
||||
print(json.dumps({'id': ident, 'prepared_locally': True})); return
|
||||
support.require(args.case is not None, 'original --case required')
|
||||
ident = str(uuid.UUID(args.case)); support.require(ident == args.case, 'same canonical original case')
|
||||
folder = STATE / ident; support.private(folder, True); verify_case(folder)
|
||||
payload = dict(id=ident, action=args.action, profile=PROFILE, tests=TESTS, binary_sha256=BINARY_SHA,
|
||||
receipt_sha256=RECEIPT_SHA, manifest_sha256=sha((folder / 'manifest.json').read_bytes()),
|
||||
agent_sha256=AGENT_SHA, helper_sha256=HELPER_SHA)
|
||||
if args.action == 'execute':
|
||||
save_local(folder / 'execute-entered.json', {'once': True, 'no_retry': True})
|
||||
payload['binary_b64'] = base64.b64encode((folder / 'time-contract-tests').read_bytes()).decode()
|
||||
code = 'import json\n' + inspect.getsource(remote) + '\nprint(json.dumps(remote(' + repr(payload) + ')))\n'
|
||||
response = support.transport(support.access_settings(ACCESS_ROOT, 'linux'), 'python3 -', code.encode(), folder)
|
||||
save_local(folder / (args.action + '-' + str(uuid.uuid4()) + '.json'), response)
|
||||
if args.action == 'read' and response['result'] is not None:
|
||||
support.require(response['result']['source_manifest_sha256'] == sha((folder / 'manifest.json').read_bytes())
|
||||
and response['result']['source_receipt_sha256'] == RECEIPT_SHA
|
||||
and response['result']['binary_sha256'] == BINARY_SHA and response['result']['tests'] == TESTS
|
||||
and response['result']['passed'] == 8 and response['result']['ignored'] == 0 and response['result']['filtered'] == 0
|
||||
and response['result']['before'] == response['result']['after']
|
||||
and response['current_witness'] == response['result']['after'], 'same-case retained native result')
|
||||
print(json.dumps({'id': ident, 'action': args.action, 'passed': response.get('passed'),
|
||||
'complete': response.get('result') is not None if args.action == 'read' else True, 'read_only': args.action == 'read'}))
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
main()
|
||||
@@ -1,5 +1,11 @@
|
||||
# Übergabe — Linux-MVP abgeschlossen, Windows wird fortgesetzt
|
||||
|
||||
**Konservative Zeitfrische nativ Linux bestanden:** acht Guards im Originalfall
|
||||
4072ed8d,8PASS/0Filter, separater Read mit erhaltenen Runtimezeugen.
|
||||
[Belege und neue gebaute Windowskandidaten](time-attestation-freshness-results.md).
|
||||
[Konkrete fehlende Plattformqualifikation](windows-signed-clock-calibration-assessment.md)
|
||||
bleibt offen; keine Kalibrierungszahl oder Windowswirkung erfunden.
|
||||
|
||||
**Reale Peer-Zeitqualitätsprobe fehlgeschlagen:** neuer Fallteilf37040c5,
|
||||
Exit1/kein Sample; separater Read bestätigt unveränderte Runtime-/Chronyzeugen.
|
||||
[Ergebnis](server-time-source-probe-peer-acceptance.md). Namespace bleibt
|
||||
|
||||
@@ -0,0 +1,40 @@
|
||||
# Signierter Zeitvergleich: konservative Frischegrenzen
|
||||
|
||||
Stand2026-11-15: enger Quellfix und lokale Qualifikation abgeschlossen; tatsächlicher Cloud-Linux-Nachweis und neuer Windows-Kandidatenlink folgen separat durch Root. Keine Kalibrierungswerte, Schlüssel oder Zielkonfiguration wurden erzeugt. Die ursprüngliche [Kalibrierungsbewertung](windows-signed-clock-calibration-assessment.md) bleibt unverändert erhalten; ihr zusätzlicher Frischebefund wird durch diesen neuen Schnitt behoben. Die fehlende tatsächliche Plattformqualifikation bleibt offen.
|
||||
|
||||
`Verifier::evidence_interval` prüft die Frische nun unter Einbezug derselben bereits vorhandenen qualifizierten Capture-/Timerunsicherheit, die auch die UTC-Obergrenze verwendet. Es gilt weiterhin `delta = error_begin + error_receive + error_check <= 50ms`. Neu müssen `elapsed + delta <= 1s` und `age + delta <= 100ms` sein; ganzzahlige Additionen sind überlaufgeprüft. Für das Empfangsalter ist der Beginnfehler bewusst zusätzlich mitgezählt. Diese Überzählung ist konservativ und verhindert eine neue nicht belegte feinere Fehlerallokation. Server-U und Quellalter verwenden weiterhin nur `elapsed + delta`, keine doppelte Addition. Ein Belegrefresh oder eine spätere Nutzung verlängert keine Grenze.
|
||||
|
||||
Zwei neue Boundarytests verwenden bewusst ungleiche **Fixturewerte** von7/11/13ms (Summe31ms), keine Messungen oder installierbaren Kalibrierungen. Erstverifikation und spätere Eigennutzung akzeptieren die jeweils exakt erreichte obere Frischegrenze und verweigern einen weiteren Nanosekundenwert, obwohl die rohe Timerdifferenz noch innerhalb der bisherigen nominalen Grenze läge. Die bestehende Sequenz für gehaltene Evidenz, offenen Folgechallenge und fehlende Verlängerung wurde an dieselbe konservative Grenze angepasst. Originalrequest, Codec-/Signaturdomäne, Wirebytes, Schlüsselrollen und unabhängige Signaturprüfung bleiben unverändert.
|
||||
|
||||
Tatsächlicher lokaler Fall `freshness-qualification-af7a9fb3-0460-4ddc-b682-39931accd249`: vollständige202 Compilerinputs, Manifest-SHA256 `e85271e4ec92b8fe05ebdf779206214366ac0e25f8083a4bb13bdd5828c3daa2`; Codecquelle `807cac064b00760d9131dc2a44d01ad9770a3660f4acd5f8d2948bb0f9234d08`. Offline-Docker ohne Netzwerk, Quellen nur lesbar und eigene private Buildausgaben. Rustfmt, Crate-Alltargets-Clippy mit `-D warnings` und Linux-Release-Link PASS. Alle acht vorhandenen/neuen Codec-Guards tatsächlich lokal PASS:0failed/ignored/filtered.
|
||||
|
||||
Der erste Compilerlauf dieses Falles scheiterte an verlorenen Ausführungsrechten kopierter Cache-Buildskripte. Der originale Fehlerlog und Exit101 sind erhalten. Nach Wiederherstellung ausschließlich der ursprünglichen Execbits im eigenen neuen Cache wurden dieselben eingefrorenen Quellen erfolgreich separat geprüft. Kein Sourcefehler unterdrückt und kein historischer Beleg umgedeutet.
|
||||
|
||||
Standalone-ELF `freshness-contract-tests`,1554688Bytes, SHA256 `8c1b47a892d8e0afe8d8cd47cfcbd150240fe771be13e990f8bbe161d18f5e21`, Modus0500 und genau ein Hardlink. Receipt-SHA256 `6a624ee9b795ce67d80a91536ba242835be9757a2f502d2d9fbc545532e1b560`. Vollständige Liste und Logs liegen im privaten Fall. **Geplant, nicht ausgeführt:** unabhängiger Quellreview, tatsächliche Cloud-Linux-Ausführung und separater Originalfall-Lesebeleg, danach neuer Windows-Paarlink mit diesem Codec. Die früheren Windowskandidaten `e7ba…`/`e71b…` enthalten diesen Fix noch nicht und werden nicht als aktueller Fixkandidat ausgegeben.
|
||||
|
||||
## Neuer vorbereiteter Native-Runner und Windowslink
|
||||
|
||||
`deploy/time_freshness_linux_acceptance.py` (SHA256 `276b86c5ae19d5acfa4ff9f6b80534cdf05afcec9b126a5c14d9037f4386861e`) bindet den aktuellen achtteiligen Codec-Testlauf an exakt diesen202-Input-Freeze, Receipt und ELF. Alle acht vollständigen Namen müssen vor Ausführung passen; keine Filter oder Skips. Der vorbereitete lokale Fall ist `4072ed8d-c157-460c-bc3b-cb31ddb1a1b8`, Manifest `c02e7c645cf5eaf9bff8146b94e94fd4cb925e3e996310495a80ec4b0972092c`. Python-AST, lokale Vorbereitung und erneute Fallvalidierung PASS. Die bestehenden tatsächlichen Linuxruntime-Witnesses und der auf die eigene Prozessgruppe begrenzte Runner wurden bytegleich aus dem vorherigen Evidence-Operator übernommen. Noch keine Zielausführung durch diesen Agenten; nach verlorener Antwort ausschließlich Originalfall lesen.
|
||||
|
||||
Danach tatsächlich separat gebaut: Windows-GNU-Releasepaar aus demselben unveränderten202-Input-Freeze, Fall `freshness-candidate-link-917425d6-412b-4f70-a7db-bc02de6b9b2a`. Link Exit0 (16.86s), Netzwerk aus, Quellen nur lesbar, keine Credentials-Mounts; ausschließlich die beiden Produktbinärdateien. Alle Quellen vorher/nachher gehasht identisch. Neuer Receipt `2abf7fe56633e68864469de2ff9ded21888301bdc737e53211d024cfd044e22e`; Buildlog `416834c6ac9abbfba4ea13cbb86ab78bbf078eabc15512bcae3825816ee58e09`.
|
||||
|
||||
| Neuer Kandidat | Bytes | SHA256 |
|
||||
| --- | ---: | --- |
|
||||
| Agent | 22244878 | `751657ee873c4f4d013abc4ea6daaa4641fea2fe55838fb1c701e6a71b57c192` |
|
||||
| SYSTEM-Helper | 13055259 | `acf1e3f3b1609a97e0d5e88a43a421bed530a09a236bfc0dec1b1abbb22d4413` |
|
||||
|
||||
Beide Übergabedateien sind AMD64-PEs, Modus0500, jeweils genau ein Hardlink. Das frühere Kandidatenpaar bleibt unverändert erhalten. Kein VM-Deploy, keine Änderung vorhandener Indizes, PKI, DB-/Lockdateien oder Konfiguration und keine Clockgateaktivierung. Der neue Cross-Link ersetzt weder die tatsächliche Linux-First-Ausführung noch die native Windowsabnahme und liefert keine Kalibrierung.
|
||||
|
||||
## Tatsächlich auf der Cloud-Linux-VM bestanden
|
||||
|
||||
Originalfall `4072ed8d-c157-460c-bc3b-cb31ddb1a1b8`: vollständige acht
|
||||
Testnamen vor Ausführung geprüft, anschließend8PASS/0failed/ignored/filtered
|
||||
als UID0. Execute-Receipt
|
||||
`4e17db56039e45657b145c91b951f81c5a2327af7bc2754369e5be2b69cce943`.
|
||||
Der separate lesende Originalrückabruf bestätigte das gebundene Ergebnis und
|
||||
die unveränderten aktuellen Cloud-Runtimezeugen; Readreceipt
|
||||
`8c885f79986b6046d2dfce08984b1eaae3716880fc03726eaa6aeb84ba5795fb`.
|
||||
Unabhängiger Quellenreview ebenfalls ohne konkreten Blocker abgeschlossen.
|
||||
Keine RMM-Aufträge, Servicekontrolle, Schlüssel-/Policyänderungen oder echte
|
||||
Server-/Windows-Zeitbereitschaft daraus ableiten. Plattformkalibrierung und
|
||||
tatsächlicher signierter Austausch bleiben zusätzlich offen.
|
||||
@@ -0,0 +1,51 @@
|
||||
# Windows: fehlende numerische Timerqualifikation
|
||||
|
||||
Stand 2026-11-15, Spezifikation1.22. Ergebnis dieser Quellenprüfung: **Mit den bisher vorhandenen Nachweisen lässt sich kein qualifizierter positiver `base_error_ns` erzeugen.** Kein Kalibrierungsproducer, keine provisionierte Zeitkonfiguration und keine Gatefreischaltung wurden daraus gebaut. Dies ist eine präzise fehlende Voraussetzung, keine Behauptung, Windowszeit sei grundsätzlich unqualifizierbar.
|
||||
|
||||
## Was tatsächlich zu begrenzen ist
|
||||
|
||||
UTC-Autorität kommt aus dem unabhängig signierten Serverbeleg, nicht aus einem behaupteten lokalen W32Time-Sync. Die eigene Windows-Wallclock wird gegen das gesamte daraus gebildete Intervall geprüft. Ihr unbekannter UTC-Offset ist deshalb nicht der fehlende Kalibrierungswert.
|
||||
|
||||
Im eingefrorenen Kandidaten `e7ba4730…`/`e71be671…` erfasst `raw_capture` die feste Folge Interrupt-before, Unbiased-before, Wallclock, Unbiased-after, Interrupt-after. `bracket_sample` bildet den gemessenen Interruptbracket in Nanosekunden und addiert `base_error_ns`. Die unveränderte lokale Konfiguration verlangt einen positiven Grundwert von höchstens10ms und genau eine imagegebundene Qualifikation je Agent-/SYSTEM-Rolle.
|
||||
|
||||
Der gemeinsame Verifier verwendet den vollen lokal gemessenen Interruptabstand `R`, nicht `R/2`. Seine drei Capturebudgets werden zu `delta` addiert (höchstens50ms); `delta` vergrößert die obere Server-UTC-Grenze und das geprüfte Quellalter. Damit ein solcher oberer UTC-Endpunkt konservativ ist, muss dieses Budget insbesondere eine mögliche **Unterzählung** des lokalen Intervalls und die Zuordnung der eigenen Wallclock in ihren Capturebracket decken. Die 100ns-Darstellung allein belegt diese Schranke nicht.
|
||||
|
||||
## Offizielle API-Verträge und ihre Grenze
|
||||
|
||||
Microsoft beschreibt `GetSystemTimePreciseAsFileTime` als UTC-Systemzeit mit höchstmöglicher Präzision unter1µs; Intervallmessungen werden getrennt behandelt. Daraus folgt kein belegter UTC-Offset dieses Gasts. [Microsoft: GetSystemTimePreciseAsFileTime](https://learn.microsoft.com/en-us/windows/win32/api/sysinfoapi/nf-sysinfoapi-getsystemtimepreciseasfiletime).
|
||||
|
||||
`QueryInterruptTimePrecise` liefert 100ns-Einheiten und liest den Timer direkt. Der auf derselben Seite genannte typische Systemtickbereich beschreibt die gröbere nichtpräzise Variante, keine garantierte numerische Fehlerschranke dieses Precise-Getters auf unserer VM. [Microsoft: QueryInterruptTimePrecise](https://learn.microsoft.com/en-us/windows/win32/api/realtimeapiset/nf-realtimeapiset-queryinterrupttimeprecise).
|
||||
|
||||
`QueryUnbiasedInterruptTimePrecise` lässt Schlaf-/Hibernatezeit aus und liefert ebenfalls präzisere direkte Timerwerte. Seine Dokumentation liefert keinen numerischen maximalen Frequenzfehler dieses Gasts. [Microsoft: QueryUnbiasedInterruptTimePrecise](https://learn.microsoft.com/en-us/windows/win32/api/realtimeapiset/nf-realtimeapiset-queryunbiasedinterrupttimeprecise).
|
||||
|
||||
Der dokumentierte Kernelgetter `KeQueryInterruptTimePrecise` nennt Mikrosekundengenauigkeit gegenüber der Systeminterruptzeit. Der Kandidat ruft diesen Kernel-DDI nicht auf; daraus darf kein nicht dokumentierter numerischer Vertrag für alle drei Usermode-Getter, ihre gemeinsame Zuordnung und den realen Gastoszillator abgeleitet werden. [Microsoft: KeQueryInterruptTimePrecise](https://learn.microsoft.com/en-us/windows-hardware/drivers/ddi/wdm/nf-wdm-kequeryinterrupttimeprecise).
|
||||
|
||||
Microsoft trennt in der QPC-Grundlage Auflösung, Zugriffspräzision, Frequenzgenauigkeit und Stabilität. Hersteller-/Hardwaretoleranzen bestimmen den Frequenzfehler; typische Beispiele sind keine zugesicherte Obergrenze. Die QPC-Frequenz ist zudem nicht notwendig die physische Oszillatorfrequenz. Für Gäste setzt Microsoft einen korrekt implementierten Hypervisor voraus. Ein Wechsel zu QPC oder ein zusätzlicher QPC-Vergleich allein beseitigt die fehlende numerische Plattformschranke daher nicht. [Microsoft: High-resolution time stamps, insbesondere Virtualization und Low-level hardware clock characteristics](https://learn.microsoft.com/en-us/windows/win32/sysinfo/acquiring-high-resolution-time-stamps).
|
||||
|
||||
Auch der Hyper-V-Referenzzählervertrag liefert keine universelle numerische SI-Genauigkeitsgrenze. Er beschreibt konstante Referenzrate und weist auf Zählerstillstand während bestimmter Save-/Suspendzustände hin. Das ist ein Gegenbeispiel gegen die pauschale Ableitung eines physikalischen Bounds allein aus „virtueller konstanter Timer“, kein Befund über den tatsächlich verwendeten Hypervisor dieser VM. [Microsoft: TLFS Timers](https://learn.microsoft.com/en-us/virtualization/hyper-v-on-windows/tlfs/timers).
|
||||
|
||||
## Warum die vorhandenen realen Rohmessungen nicht reichen
|
||||
|
||||
Root hat beide festen Rollen tatsächlich mit128 Captures geprüft. Diese Belege bleiben unverändert gültige Beobachtungen ihres Brackets und der internen Zählerdifferenzen. Sie enthalten aber keine unabhängige numerisch begrenzte Referenz für die reale Zählrate. Ein gemeinsamer langsamer Oszillator oder eine gemeinsame Virtualisierungsabweichung kann Wallclock-, Interrupt- und Unbiasedwerte zugleich betreffen; interne Übereinstimmung schließt das nicht aus. Aus einem endlichen beobachteten Maximum folgt auch keine Obergrenze für einen folgenden Capture.
|
||||
|
||||
Ein zusätzlicher Schlaf-/Busywait-Test oder ein Vergleich mit `Instant`/Stopwatch würde keinen unabhängigen Maßstab schaffen. Ein tatsächlich signierter Serververgleich kann vergangene Messpunkte eingrenzen; ohne begrenzte Änderung/Stabilität der lokalen Zählrate liefert er allein noch keine garantierte zukünftige Timerfehlerschranke. Eine empirische Qualifikation darf diese fehlende Annahme nicht still durch einen Sicherheitsfaktor ersetzen.
|
||||
|
||||
## Kleinste Ergänzung innerhalb des vorhandenen Vertrags
|
||||
|
||||
Erforderlich ist ein belastbarer aktueller Plattformnachweis, der unter der bereits erlaubten OS-/Hypervisor-Vertrauensannahme mindestens folgende Größen begrenzt: mögliche Timer-Unterzählung über den gesamten kurzen Belegzeitraum; diskrete/API-interne Zuordnungsfehler der verwendeten Getter; sowie den gültigen Betriebskontext einschließlich Pause/Restore/Migration. Das kann ein zur tatsächlichen Plattform passender dokumentierter Hersteller-/Virtualisierungsvertrag oder eine unabhängige Referenzqualifikation **mit explizit begrenzter Stabilitätsannahme und Gültigkeit** sein. Ein geratenes ppm-Limit oder bloßes Modell-/Featureflag genügt nicht. Hypervisorzugang wird hier nicht als neue Produktvoraussetzung eingeführt; derzeit fehlt der Nachweis für diesen konkreten Gast.
|
||||
|
||||
Rechnerisch: Wenn ein belegter relativer Unterzählungsbound `0 <= rho < 1` und ein belegter additiver Endpunktfehler `q` die Ungleichung `R_measured >= (1-rho)*R_real - q` garantieren, folgt `R_real <= (R_measured+q)/(1-rho)`. Für den gesamten zulässigen Bereich muss die daraus resultierende Unterzählung konservativ in `delta` Platz finden. Read-/Wallclock-Zuordnung und Rundung kommen zusätzlich hinzu. Rollenbelegte Bracketmessungen liefern dann die tatsächlich beobachteten Werte, die laufende Implementierung verwirft übergroße Brackets selbst; der dokumentierte Basiswert darf keines dieser nicht erfassten Fehlerglieder auslassen. Ergebnis und Qualifikationsreferenz müssen an **die exakten** Produktimages und die tatsächlichen Rollen gebunden werden, nicht allein an den früheren Diagnose-EXE-Hash.
|
||||
|
||||
Erst mit diesen Eingangsnachweisen ist ein enger Producer sinnvoll: ausschließlich kontrollierte originale Rollenbelege plus nachprüfbarer Plattformvertrag, ganzzahlige aufgerundete Rechnung, Budgetprüfung, genaue Provenienz und imagegebundene Ausgabe. Solange ein Glied fehlt, erzeugt er keine `Calibration`. Ein Producer, der jetzt lediglich eine beliebige Zahl aus diesen Rohdaten berechnet, wäre eine Scheinqualifikation; deshalb wurde er nicht implementiert.
|
||||
|
||||
## Zusätzlicher Frischebefund am unveränderten Verifier
|
||||
|
||||
`evidence_interval` prüft derzeit `elapsed <= 1s` und `age <= 100ms` auf den rohen Interruptdifferenzen. Erst danach wird `delta` für UTC-Obergrenze und Quellalter verwendet. Das sind damit zunächst nominelle OS-Zählergrenzen. **Falls** der geforderte Timerbound auch physikalische Unterzählung beinhaltet, müssen dessen konservative oberen Intervallwerte ebenso vor diesen Frischegrenzen liegen; eine bloße Addition zu UTC-U reicht dann nicht. Eine mögliche enge Umsetzung nach Festlegung des Fehlervertrags ist ein jeweils konservatives `upper_elapsed <= 1s` und `upper_age <= 100ms`. Überbreite Verwendung des gesamten `delta` wäre konservativ, muss aber technisch zur Endpunkt-/Fehlerallokation passen.
|
||||
|
||||
Dies ist ein gezielt gemeldeter offener Sourcebefund, kein hier ausgeführter Fix. Der bereits qualifizierte Codec, Wirebytes, 202-Eingaben-Snapshot und beide Kandidaten blieben unverändert. Eine Umdefinition der Grenzen zu nominellen statt konservativ begrenzten Zeitintervallen wäre eine ausdrückliche Vertragsänderung, keine zulässige stille Kalibrierungsentscheidung.
|
||||
|
||||
## Ausgeführt und offen
|
||||
|
||||
Tatsächlich ausgeführt: offizielle Microsoft-Primärquellen gelesen, Capture-/Codec-/Loaderpfad im vorhandenen Quellcode geprüft und diese Bewertung dokumentiert. Keine neue VM-Diagnose, keine Ziel-/Gitaktion, keine Schlüssel gelesen, keine Werte erzeugt, keine Tests oder Builds wiederholt. Die Linux-first- und Windows-Roh-/Runtimebelege werden dadurch nicht rückwirkend verändert.
|
||||
|
||||
Nächster notwendiger Schritt ist die Entscheidung über einen konkret belegbaren numerischen Plattform-/Fehlervertrag, anschließend dessen enge Rollen-/Imagequalifikation und der dazu passende Frischecheck. Bis dahin bleiben Zeitpins/Kalibrierung und Windowswirkungen gesperrt. Die separate tatsächliche Serverquellqualität bleibt zusätzlich erforderlich.
|
||||
Reference in New Issue
Block a user