Add files via upload

models/AuthenticationEvent.js

@@ -0,0 +1,43 @@
+const mongoose = require('mongoose');
+
+// Log authentication verification events
+const authEventSchema = new mongoose.Schema({
+    userId: {
+        type: mongoose.Schema.Types.ObjectId,
+        ref: 'User',
+        required: true
+    },
+    sessionId: String,
+    keystrokeMetrics: {
+        avgKeystrokeTime: Number,
+        stdDevKeystrokeTime: Number,
+        avgPauseTime: Number,
+        typingSpeed: Number,
+        sampleSize: Number
+    },
+    deviceInfo: {
+        deviceId: String,
+        osType: String,
+        timezone: String
+    },
+    verificationResult: {
+        status: {
+            type: String,
+            enum: ['success', 'failed', 'challenge'],
+            default: 'challenge'
+        },
+        confidenceScore: Number,
+        modelPrediction: Number,
+        matchPercentage: Number,
+        flags: [String]
+    },
+    fallbackMethod: {
+        type: String,
+        enum: ['none', 'otp', 'email_link', 'security_question'],
+        default: 'none'
+    },
+    fallbackStatus: String,
+    timestamp: { type: Date, default: Date.now }
+});
+
+module.exports = mongoose.model('AuthenticationEvent', authEventSchema);

models/BiometricProfile.js

@@ -0,0 +1,38 @@
+const mongoose = require('mongoose');
+
+// Track keystroke profiles for behavioral authentication
+const biometricProfileSchema = new mongoose.Schema({
+    userId: {
+        type: mongoose.Schema.Types.ObjectId,
+        ref: 'User',
+        required: true
+    },
+    baselineMetrics: {
+        avgKeystrokeTime: Number,
+        stdDevKeystrokeTime: Number,
+        avgPauseTime: Number,
+        typingSpeed: Number,
+        deletionRate: Number,
+        rhythmPattern: [Number]
+    },
+    deviceSignature: {
+        keyboardType: String,
+        osType: String,
+        browserAgent: String,
+        screenResolution: String,
+        timezone: String
+    },
+    status: {
+        type: String,
+        enum: ['collecting_baseline', 'active', 'suspended'],
+        default: 'collecting_baseline'
+    },
+    baselineSessionsCount: { type: Number, default: 0 },
+    baselineRequired: { type: Number, default: 5 },
+    failureCount: { type: Number, default: 0 },
+    lastVerificationFailed: Date,
+    createdAt: { type: Date, default: Date.now },
+    lastUpdated: { type: Date, default: Date.now }
+});
+
+module.exports = mongoose.model('BiometricProfile', biometricProfileSchema);

models/DeviceProfile.js

@@ -0,0 +1,32 @@
+const mongoose = require('mongoose');
+
+// Track device profiles and typing behavior per device
+const deviceProfileSchema = new mongoose.Schema({
+    userId: { type: mongoose.Schema.Types.ObjectId, ref: 'User' },
+    deviceId: String,
+
+    deviceInfo: {
+        osType: String,
+        browserAgent: String,
+        screenResolution: String,
+        timezone: String,
+        inputMethod: String
+    },
+
+    behaviorProfile: {
+        avgKeystrokeTime: Number,
+        typingSpeed: Number,
+        errorRate: Number,
+        pasteFrequency: Number
+    },
+
+    trustScore: { type: Number, default: 100 },
+    isKnownDevice: { type: Boolean, default: false },
+
+    firstSeen: Date,
+    lastSeen: Date,
+
+    createdAt: { type: Date, default: Date.now }
+});
+
+module.exports = mongoose.model('DeviceProfile', deviceProfileSchema);

models/EncryptedKeystrokeData.js

@@ -0,0 +1,27 @@
+const mongoose = require('mongoose');
+
+// Store encrypted keystroke data for privacy
+const encryptedKeystrokeSchema = new mongoose.Schema({
+    userId: { type: mongoose.Schema.Types.ObjectId, ref: 'User' },
+    sessionId: { type: mongoose.Schema.Types.ObjectId, ref: 'Text' },
+
+    encryptedData: {
+        iv: String,
+        encryptedData: String,
+        authTag: String
+    },
+
+    anonymizedMetrics: {
+        avgKeystrokeTime: Number,
+        stdDevKeystrokeTime: Number,
+        pauseFrequency: Number
+    },
+
+    encryptionTimestamp: Date,
+    dataEncryptionEnabled: { type: Boolean, default: true },
+    userConsent: { type: Boolean, default: true },
+
+    createdAt: { type: Date, default: Date.now }
+});
+
+module.exports = mongoose.model('EncryptedKeystrokeData', encryptedKeystrokeSchema);

models/PasteDetectionLog.js

@@ -0,0 +1,55 @@
+const mongoose = require('mongoose');
+
+// Track paste and AI-generated content detection
+const pasteDetectionLogSchema = new mongoose.Schema({
+    userId: { type: mongoose.Schema.Types.ObjectId, ref: 'User' },
+    textSessionId: { type: mongoose.Schema.Types.ObjectId, ref: 'Text' },
+
+    detectionResults: [{
+        segmentId: String,
+        startPosition: Number,
+        endPosition: Number,
+        segmentText: String,
+        keystrokeAnalysis: {
+            hasKeystrokeIntervals: Boolean,
+            isInstantAppearance: Boolean,
+            uniformityScore: Number,
+            variationCv: Number,
+            expectedIntervals: Number,
+            actualIntervals: Number
+        },
+        linguisticMarkers: {
+            vocabularyShift: Number,
+            sentenceComplexity: Number,
+            punctuationConsistency: Number,
+            grammarAnomalies: [String]
+        },
+        aiConfidenceScore: Number,
+        pasteConfidenceScore: Number,
+        verdict: {
+            type: String,
+            enum: ['human_typed', 'pasted', 'ai_generated', 'uncertain'],
+            default: 'uncertain'
+        },
+        flags: [String]
+    }],
+
+    summaryAnalysis: {
+        totalSegments: Number,
+        pastedSegments: Number,
+        significantPastedSegments: Number,
+        trivialPastedSegments: Number,
+        ignoredPastedSegments: Number,
+        aiSegments: Number,
+        mixedContentDetected: Boolean,
+        suspicionLevel: {
+            type: String,
+            enum: ['low', 'medium', 'high'],
+            default: 'low'
+        }
+    },
+
+    timestamp: { type: Date, default: Date.now }
+});
+
+module.exports = mongoose.model('PasteDetectionLog', pasteDetectionLogSchema);

models/Report.js

@@ -0,0 +1,45 @@
+const mongoose = require('mongoose');
+const crypto = require('crypto');
+
+// Generate and manage shareable verification reports
+const reportSchema = new mongoose.Schema({
+    userId: { type: mongoose.Schema.Types.ObjectId, ref: 'User' },
+    textSessionId: { type: mongoose.Schema.Types.ObjectId, ref: 'Text' },
+
+    reportContent: {
+        title: String,
+        summary: String,
+        trustScore: Number,
+        analysisDate: Date,
+        findings: [{
+            category: String,
+            result: String,
+            confidence: Number
+        }]
+    },
+
+    sharingToken: { type: String, unique: true },
+    isPublic: { type: Boolean, default: false },
+    expiresAt: Date,
+    accessControl: {
+        allowVerification: { type: Boolean, default: true },
+        restrictedViewers: [String]
+    },
+
+    viewCount: { type: Number, default: 0 },
+    viewLog: [{
+        timestamp: Date,
+        viewerIP: String
+    }],
+
+    createdAt: { type: Date, default: Date.now }
+});
+
+// Auto-generate secure token before saving
+reportSchema.pre('save', function() {
+    if (!this.sharingToken) {
+        this.sharingToken = crypto.randomBytes(32).toString('hex');
+    }
+});
+
+module.exports = mongoose.model('Report', reportSchema);

models/SessionTrustScore.js

@@ -0,0 +1,32 @@
+const mongoose = require('mongoose');
+
+// Real-time session trust score tracking
+const sessionTrustScoreSchema = new mongoose.Schema({
+    userId: { type: mongoose.Schema.Types.ObjectId, ref: 'User' },
+    textSessionId: { type: mongoose.Schema.Types.ObjectId, ref: 'Text' },
+
+    scoreHistory: [{
+        timestamp: Date,
+        score: Number,
+        factors: {
+            keystrokeBehavior: Number,
+            pasteDetection: Number,
+            aiLikelihood: Number,
+            anomalyScore: Number,
+            devicesConsistency: Number
+        }
+    }],
+
+    currentScore: Number,
+    riskLevel: { type: String, enum: ['low', 'medium', 'high'] },
+
+    warnings: [{
+        timestamp: Date,
+        message: String,
+        severity: String
+    }],
+
+    createdAt: { type: Date, default: Date.now }
+});
+
+module.exports = mongoose.model('SessionTrustScore', sessionTrustScoreSchema);

models/Text.js

@@ -0,0 +1,71 @@
+const mongoose = require('mongoose');
+
+const textSchema = new mongoose.Schema({
+    userId: {
+        type: mongoose.Schema.Types.ObjectId,
+        ref: 'User'
+    },
+    content: String,
+    startTime: Date,
+    endTime: Date,
+    duration: Number,
+    pasteCount: Number,
+    pastedTextLength: Number,
+    totalKeystrokes: Number,
+    sessionMetrics: {
+        avgKeystrokeTime: Number,
+        stdDevKeystrokeTime: Number,
+        avgPauseTime: Number,
+        longestPause: Number,
+        pauseCount: Number,
+        deletionCount: Number,
+        focusLossCount: Number,
+        revisionCount: Number,
+        typingSpeed: Number,
+        errorRate: Number,
+        pasteRatio: Number,
+        sampleSize: Number,
+        rhythmPattern: [Number]
+    },
+    linguisticMetrics: {
+        wordCount: Number,
+        sentenceCount: Number,
+        paragraphCount: Number,
+        vocabularyDiversity: Number,
+        averageSentenceLength: Number
+    },
+    deviceSnapshot: {
+        deviceId: String,
+        osType: String,
+        browserAgent: String,
+        screenResolution: String,
+        timezone: String,
+        inputMethod: String
+    },
+    analysisSummary: {
+        pasteVerdict: String,
+        aiVerdict: String,
+        trustScore: Number,
+        riskLevel: String,
+        biometricStatus: String,
+        deviceTrustScore: Number,
+        reportToken: String
+    },
+    artifactRefs: {
+        authenticationEventId: String,
+        deviceProfileId: String,
+        biometricProfileId: String,
+        pasteLogId: String,
+        writingVersionId: String,
+        encryptedTelemetryId: String,
+        trustScoreId: String,
+        reportId: String
+    },
+    createdAt: {
+        type: Date,
+        default: Date.now
+    }
+
+});
+
+module.exports = mongoose.model('Text', textSchema);

models/User.js

@@ -0,0 +1,9 @@
+const mongoose = require('mongoose');
+
+const userSchema = new mongoose.Schema({
+    username: String,
+    email: String,
+    password: String
+});
+
+module.exports = mongoose.model('User', userSchema);

models/WritingVersion.js

@@ -0,0 +1,32 @@
+const mongoose = require('mongoose');
+
+// Track writing versions and keystroke replay data
+const writingVersionSchema = new mongoose.Schema({
+    userId: { type: mongoose.Schema.Types.ObjectId, ref: 'User' },
+    textSessionId: { type: mongoose.Schema.Types.ObjectId, ref: 'Text' },
+
+    versions: [{
+        versionNumber: Number,
+        timestamp: Date,
+        content: String,
+        characterCount: Number,
+        changesSinceLast: {
+            inserted: Number,
+            deleted: Number,
+            modified: Number
+        }
+    }],
+
+    keystrokeReplay: [{
+        timestamp: Number,
+        type: { type: String, enum: ['keystroke', 'delete', 'paste'] },
+        character: String,
+        text: String,
+        position: Number,
+        interval: Number
+    }],
+
+    createdAt: { type: Date, default: Date.now }
+});
+
+module.exports = mongoose.model('WritingVersion', writingVersionSchema);