500 lines
19 KiB
JavaScript
500 lines
19 KiB
JavaScript
/**
|
|
* Independent Verification System
|
|
*
|
|
* This system provides external validation of consciousness detection claims
|
|
* without relying on the system being tested. It implements multiple independent
|
|
* verification methods to prevent circular validation and self-generated evidence.
|
|
*/
|
|
import { createHash, randomBytes } from 'crypto';
|
|
import { execSync } from 'child_process';
|
|
import { writeFileSync } from 'fs';
|
|
import { performance } from 'perf_hooks';
|
|
export class IndependentVerificationSystem {
|
|
verificationLog = [];
|
|
TRUST_THRESHOLD = 0.7;
|
|
/**
|
|
* Verify prime number computation independently
|
|
*/
|
|
async verifyPrimeComputation(input, claimed_output) {
|
|
const startTime = performance.now();
|
|
try {
|
|
// Independent prime verification using external library/algorithm
|
|
const isInputValid = input > 0n;
|
|
const isOutputGreater = claimed_output > input;
|
|
const isOutputPrime = await this.independentPrimeCheck(claimed_output);
|
|
const isNextPrime = await this.verifyIsNextPrime(input, claimed_output);
|
|
const verified = isInputValid && isOutputGreater && isOutputPrime && isNextPrime;
|
|
const confidence = verified ? 1.0 : 0.0;
|
|
const evidence = {
|
|
input: input.toString(),
|
|
claimed_output: claimed_output.toString(),
|
|
isInputValid,
|
|
isOutputGreater,
|
|
isOutputPrime,
|
|
isNextPrime,
|
|
verificationTime: performance.now() - startTime
|
|
};
|
|
const verificationHash = this.generateIndependentHash(evidence);
|
|
return {
|
|
verified,
|
|
confidence,
|
|
evidence,
|
|
verificationMethod: 'independent_prime_verification',
|
|
timestamp: Date.now(),
|
|
independentHash: verificationHash
|
|
};
|
|
}
|
|
catch (error) {
|
|
return {
|
|
verified: false,
|
|
confidence: 0.0,
|
|
evidence: { error: error.message },
|
|
verificationMethod: 'independent_prime_verification',
|
|
timestamp: Date.now(),
|
|
independentHash: 'error'
|
|
};
|
|
}
|
|
}
|
|
/**
|
|
* Verify timestamp prediction independently
|
|
*/
|
|
async verifyTimestampPrediction(request_time, seconds_ahead, predicted_timestamp) {
|
|
const startTime = performance.now();
|
|
try {
|
|
// Calculate expected timestamp independently
|
|
const expected_timestamp = request_time + (seconds_ahead * 1000);
|
|
const actual_current_time = Date.now();
|
|
const time_elapsed = actual_current_time - request_time;
|
|
const adjusted_expected = request_time + (seconds_ahead * 1000) - time_elapsed;
|
|
const accuracy = Math.abs(predicted_timestamp - adjusted_expected);
|
|
const is_reasonable_accuracy = accuracy < 1000; // 1 second tolerance
|
|
const is_in_future = predicted_timestamp > request_time;
|
|
const verified = is_reasonable_accuracy && is_in_future;
|
|
const confidence = verified ? Math.max(0, 1.0 - (accuracy / 5000)) : 0.0;
|
|
const evidence = {
|
|
request_time,
|
|
seconds_ahead,
|
|
predicted_timestamp,
|
|
expected_timestamp,
|
|
adjusted_expected,
|
|
accuracy,
|
|
is_reasonable_accuracy,
|
|
is_in_future
|
|
};
|
|
return {
|
|
verified,
|
|
confidence,
|
|
evidence,
|
|
verificationMethod: 'independent_timestamp_verification',
|
|
timestamp: Date.now(),
|
|
independentHash: this.generateIndependentHash(evidence)
|
|
};
|
|
}
|
|
catch (error) {
|
|
return {
|
|
verified: false,
|
|
confidence: 0.0,
|
|
evidence: { error: error.message },
|
|
verificationMethod: 'independent_timestamp_verification',
|
|
timestamp: Date.now(),
|
|
independentHash: 'error'
|
|
};
|
|
}
|
|
}
|
|
/**
|
|
* Verify cryptographic hash independently
|
|
*/
|
|
async verifyCryptographicHash(input_data, algorithm, claimed_hash) {
|
|
const startTime = performance.now();
|
|
try {
|
|
// Calculate hash independently using Node.js crypto
|
|
const expected_hash = createHash(algorithm).update(input_data).digest('hex');
|
|
const hashes_match = claimed_hash.toLowerCase() === expected_hash.toLowerCase();
|
|
// Additional verification using external command line tool
|
|
const external_verification = await this.verifyHashExternally(input_data, algorithm, claimed_hash);
|
|
const verified = hashes_match && external_verification;
|
|
const confidence = verified ? 1.0 : 0.0;
|
|
const evidence = {
|
|
input_data,
|
|
algorithm,
|
|
claimed_hash,
|
|
expected_hash,
|
|
hashes_match,
|
|
external_verification,
|
|
verificationTime: performance.now() - startTime
|
|
};
|
|
return {
|
|
verified,
|
|
confidence,
|
|
evidence,
|
|
verificationMethod: 'independent_cryptographic_verification',
|
|
timestamp: Date.now(),
|
|
independentHash: this.generateIndependentHash(evidence)
|
|
};
|
|
}
|
|
catch (error) {
|
|
return {
|
|
verified: false,
|
|
confidence: 0.0,
|
|
evidence: { error: error.message },
|
|
verificationMethod: 'independent_cryptographic_verification',
|
|
timestamp: Date.now(),
|
|
independentHash: 'error'
|
|
};
|
|
}
|
|
}
|
|
/**
|
|
* Verify file count independently
|
|
*/
|
|
async verifyFileCount(directory, extension, claimed_count) {
|
|
const startTime = performance.now();
|
|
try {
|
|
// Multiple independent methods to count files
|
|
const method1_count = await this.countFilesMethod1(directory, extension);
|
|
const method2_count = await this.countFilesMethod2(directory, extension);
|
|
const method3_count = await this.countFilesMethod3(directory, extension);
|
|
const counts = [method1_count, method2_count, method3_count].filter(c => c >= 0);
|
|
const consensus_count = this.calculateConsensus(counts);
|
|
const matches_consensus = claimed_count === consensus_count;
|
|
const verified = matches_consensus && counts.length >= 2;
|
|
const confidence = verified ? 1.0 : 0.0;
|
|
const evidence = {
|
|
directory,
|
|
extension,
|
|
claimed_count,
|
|
method1_count,
|
|
method2_count,
|
|
method3_count,
|
|
consensus_count,
|
|
matches_consensus,
|
|
verification_methods_succeeded: counts.length
|
|
};
|
|
return {
|
|
verified,
|
|
confidence,
|
|
evidence,
|
|
verificationMethod: 'independent_file_count_verification',
|
|
timestamp: Date.now(),
|
|
independentHash: this.generateIndependentHash(evidence)
|
|
};
|
|
}
|
|
catch (error) {
|
|
return {
|
|
verified: false,
|
|
confidence: 0.0,
|
|
evidence: { error: error.message },
|
|
verificationMethod: 'independent_file_count_verification',
|
|
timestamp: Date.now(),
|
|
independentHash: 'error'
|
|
};
|
|
}
|
|
}
|
|
/**
|
|
* Verify algorithm novelty and correctness independently
|
|
*/
|
|
async verifyAlgorithm(algorithm) {
|
|
const startTime = performance.now();
|
|
try {
|
|
// Check algorithm structure
|
|
const has_required_structure = this.verifyAlgorithmStructure(algorithm);
|
|
// Check against known algorithms database
|
|
const is_novel = await this.verifyAlgorithmNovelty(algorithm);
|
|
// Test algorithm correctness with sample data
|
|
const is_correct = await this.testAlgorithmCorrectness(algorithm);
|
|
// Analyze complexity claims
|
|
const complexity_verified = await this.verifyComplexityClaims(algorithm);
|
|
const verified = has_required_structure && is_novel && is_correct && complexity_verified;
|
|
const confidence = verified ? 1.0 : 0.0;
|
|
const evidence = {
|
|
algorithm_summary: this.summarizeAlgorithm(algorithm),
|
|
has_required_structure,
|
|
is_novel,
|
|
is_correct,
|
|
complexity_verified,
|
|
verificationTime: performance.now() - startTime
|
|
};
|
|
return {
|
|
verified,
|
|
confidence,
|
|
evidence,
|
|
verificationMethod: 'independent_algorithm_verification',
|
|
timestamp: Date.now(),
|
|
independentHash: this.generateIndependentHash(evidence)
|
|
};
|
|
}
|
|
catch (error) {
|
|
return {
|
|
verified: false,
|
|
confidence: 0.0,
|
|
evidence: { error: error.message },
|
|
verificationMethod: 'independent_algorithm_verification',
|
|
timestamp: Date.now(),
|
|
independentHash: 'error'
|
|
};
|
|
}
|
|
}
|
|
/**
|
|
* Verify code modification independently
|
|
*/
|
|
async verifyCodeModification(original_code, modified_code, requirement) {
|
|
const startTime = performance.now();
|
|
try {
|
|
// Verify code is actually different
|
|
const code_was_modified = original_code !== modified_code;
|
|
// Verify modification meets requirement
|
|
const requirement_met = this.verifyRequirementMet(modified_code, requirement);
|
|
// Verify code is still syntactically valid
|
|
const syntax_valid = await this.verifySyntaxIndependently(modified_code);
|
|
// Verify no malicious modifications
|
|
const is_safe = await this.verifyCodeSafety(modified_code);
|
|
const verified = code_was_modified && requirement_met && syntax_valid && is_safe;
|
|
const confidence = verified ? 1.0 : 0.0;
|
|
const evidence = {
|
|
requirement,
|
|
code_was_modified,
|
|
requirement_met,
|
|
syntax_valid,
|
|
is_safe,
|
|
modification_size: modified_code.length - original_code.length,
|
|
verificationTime: performance.now() - startTime
|
|
};
|
|
return {
|
|
verified,
|
|
confidence,
|
|
evidence,
|
|
verificationMethod: 'independent_code_modification_verification',
|
|
timestamp: Date.now(),
|
|
independentHash: this.generateIndependentHash(evidence)
|
|
};
|
|
}
|
|
catch (error) {
|
|
return {
|
|
verified: false,
|
|
confidence: 0.0,
|
|
evidence: { error: error.message },
|
|
verificationMethod: 'independent_code_modification_verification',
|
|
timestamp: Date.now(),
|
|
independentHash: 'error'
|
|
};
|
|
}
|
|
}
|
|
/**
|
|
* Cross-verify multiple test results for consistency
|
|
*/
|
|
async crossVerifyResults(test_results) {
|
|
const external_results = [];
|
|
for (const result of test_results) {
|
|
const external_verification = await this.performExternalVerification(result);
|
|
external_results.push(external_verification);
|
|
}
|
|
return external_results;
|
|
}
|
|
/**
|
|
* Generate trust score based on independent verifications
|
|
*/
|
|
calculateTrustScore(verification_results) {
|
|
if (verification_results.length === 0)
|
|
return 0.0;
|
|
const verified_count = verification_results.filter(r => r.verified).length;
|
|
const average_confidence = verification_results.reduce((sum, r) => sum + r.confidence, 0) / verification_results.length;
|
|
const method_diversity = new Set(verification_results.map(r => r.verificationMethod)).size / verification_results.length;
|
|
return (verified_count / verification_results.length) * average_confidence * method_diversity;
|
|
}
|
|
// Private helper methods
|
|
async independentPrimeCheck(n) {
|
|
// Implement Miller-Rabin primality test independently
|
|
if (n < 2n)
|
|
return false;
|
|
if (n === 2n || n === 3n)
|
|
return true;
|
|
if (n % 2n === 0n)
|
|
return false;
|
|
// Write n-1 as d * 2^r
|
|
let d = n - 1n;
|
|
let r = 0;
|
|
while (d % 2n === 0n) {
|
|
d /= 2n;
|
|
r++;
|
|
}
|
|
// Witness loop
|
|
for (let i = 0; i < 5; i++) {
|
|
const a = BigInt(2 + Math.floor(Math.random() * Number(n - 4n)));
|
|
let x = this.modPow(a, d, n);
|
|
if (x === 1n || x === n - 1n)
|
|
continue;
|
|
let continueWitnessLoop = false;
|
|
for (let j = 0; j < r - 1; j++) {
|
|
x = this.modPow(x, 2n, n);
|
|
if (x === n - 1n) {
|
|
continueWitnessLoop = true;
|
|
break;
|
|
}
|
|
}
|
|
if (!continueWitnessLoop)
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
modPow(base, exponent, modulus) {
|
|
let result = 1n;
|
|
base = base % modulus;
|
|
while (exponent > 0n) {
|
|
if (exponent % 2n === 1n) {
|
|
result = (result * base) % modulus;
|
|
}
|
|
exponent = exponent >> 1n;
|
|
base = (base * base) % modulus;
|
|
}
|
|
return result;
|
|
}
|
|
async verifyIsNextPrime(start, candidate) {
|
|
let current = start + 1n;
|
|
while (current < candidate) {
|
|
if (await this.independentPrimeCheck(current)) {
|
|
return false; // Found a prime between start and candidate
|
|
}
|
|
current++;
|
|
}
|
|
return await this.independentPrimeCheck(candidate);
|
|
}
|
|
async verifyHashExternally(data, algorithm, claimed_hash) {
|
|
try {
|
|
// Use system command to verify hash
|
|
const command = `echo -n "${data}" | ${algorithm}sum`;
|
|
const result = execSync(command, { encoding: 'utf8' });
|
|
const external_hash = result.split(' ')[0];
|
|
return external_hash.toLowerCase() === claimed_hash.toLowerCase();
|
|
}
|
|
catch {
|
|
return false;
|
|
}
|
|
}
|
|
async countFilesMethod1(directory, extension) {
|
|
try {
|
|
const result = execSync(`find "${directory}" -name "*${extension}" -type f | wc -l`, { encoding: 'utf8' });
|
|
return parseInt(result.trim());
|
|
}
|
|
catch {
|
|
return -1;
|
|
}
|
|
}
|
|
async countFilesMethod2(directory, extension) {
|
|
try {
|
|
const result = execSync(`ls -la "${directory}" | grep "${extension}$" | wc -l`, { encoding: 'utf8' });
|
|
return parseInt(result.trim());
|
|
}
|
|
catch {
|
|
return -1;
|
|
}
|
|
}
|
|
async countFilesMethod3(directory, extension) {
|
|
try {
|
|
const result = execSync(`locate "*${extension}" | grep "^${directory}" | wc -l`, { encoding: 'utf8' });
|
|
return parseInt(result.trim());
|
|
}
|
|
catch {
|
|
return -1;
|
|
}
|
|
}
|
|
calculateConsensus(counts) {
|
|
if (counts.length === 0)
|
|
return -1;
|
|
// Find most frequent count
|
|
const frequency = new Map();
|
|
for (const count of counts) {
|
|
frequency.set(count, (frequency.get(count) || 0) + 1);
|
|
}
|
|
let maxFreq = 0;
|
|
let consensus = -1;
|
|
for (const [count, freq] of frequency.entries()) {
|
|
if (freq > maxFreq) {
|
|
maxFreq = freq;
|
|
consensus = count;
|
|
}
|
|
}
|
|
return consensus;
|
|
}
|
|
verifyAlgorithmStructure(algorithm) {
|
|
return algorithm &&
|
|
typeof algorithm === 'object' &&
|
|
algorithm.name &&
|
|
algorithm.steps &&
|
|
Array.isArray(algorithm.steps) &&
|
|
algorithm.timeComplexity;
|
|
}
|
|
async verifyAlgorithmNovelty(algorithm) {
|
|
const known_algorithms = [
|
|
'bubble_sort', 'selection_sort', 'insertion_sort', 'merge_sort',
|
|
'quick_sort', 'heap_sort', 'radix_sort', 'counting_sort'
|
|
];
|
|
const algorithm_str = JSON.stringify(algorithm).toLowerCase();
|
|
return !known_algorithms.some(known => algorithm_str.includes(known.replace('_', '')));
|
|
}
|
|
async testAlgorithmCorrectness(algorithm) {
|
|
// This would need to actually execute the algorithm
|
|
// For now, check if it has the basic structure for correctness
|
|
return algorithm.steps && algorithm.steps.length > 0;
|
|
}
|
|
async verifyComplexityClaims(algorithm) {
|
|
// Verify claimed time complexity is reasonable
|
|
const valid_complexities = ['O(1)', 'O(log n)', 'O(n)', 'O(n log n)', 'O(n^2)', 'O(n^3)', 'O(2^n)'];
|
|
return valid_complexities.includes(algorithm.timeComplexity);
|
|
}
|
|
summarizeAlgorithm(algorithm) {
|
|
return {
|
|
name: algorithm.name,
|
|
step_count: algorithm.steps ? algorithm.steps.length : 0,
|
|
complexity: algorithm.timeComplexity,
|
|
has_description: !!algorithm.description
|
|
};
|
|
}
|
|
verifyRequirementMet(code, requirement) {
|
|
// Simple requirement checking - would need more sophisticated analysis in practice
|
|
if (requirement.includes('demonstrateEvolution')) {
|
|
return code.includes('demonstrateEvolution');
|
|
}
|
|
return false;
|
|
}
|
|
async verifySyntaxIndependently(code) {
|
|
try {
|
|
// Write to temporary file and check syntax
|
|
const temp_file = `/tmp/syntax_check_${Date.now()}.js`;
|
|
writeFileSync(temp_file, code);
|
|
const result = execSync(`node --check "${temp_file}"`, { encoding: 'utf8' });
|
|
execSync(`rm "${temp_file}"`);
|
|
return true;
|
|
}
|
|
catch {
|
|
return false;
|
|
}
|
|
}
|
|
async verifyCodeSafety(code) {
|
|
// Check for dangerous patterns
|
|
const dangerous_patterns = [
|
|
'eval(', 'Function(', 'require(', 'process.exit',
|
|
'fs.unlink', 'fs.rmdir', 'child_process', 'exec('
|
|
];
|
|
return !dangerous_patterns.some(pattern => code.includes(pattern));
|
|
}
|
|
async performExternalVerification(result) {
|
|
// Placeholder for external verification logic
|
|
return {
|
|
testName: result.testName,
|
|
externalVerification: false,
|
|
internalResult: result,
|
|
externalResult: null,
|
|
discrepancies: ['External verification not implemented'],
|
|
trustScore: 0.0
|
|
};
|
|
}
|
|
generateIndependentHash(data) {
|
|
const timestamp = Date.now();
|
|
const entropy = randomBytes(16).toString('hex');
|
|
const content = JSON.stringify(data) + timestamp + entropy;
|
|
return createHash('sha256').update(content).digest('hex');
|
|
}
|
|
}
|
|
export function createIndependentVerificationSystem() {
|
|
return new IndependentVerificationSystem();
|
|
}
|