FP ID: ${displayedFingerprint?.split('').map((x: string, i: number) => {
return `${x}`
}).join('')}${isTracing ? `[${timeseries}]` : ''}
`)
}, 300)
const toLocaleStr = (str: string) => {
const date = new Date(str)
const dateString = date.toLocaleDateString()
const timeString = date.toLocaleTimeString()
return `${dateString}, ${timeString}`
}
const {
switchCountPointGain,
errorsPointGain,
trashPointGain,
liesPointGain,
tracedPointGain,
measuredPointGain,
supervisedPointGain,
shadowBitsPointGain,
grade,
} = JSON.parse(scoreData)
const computePoints = (x) => {
return `
fingerprints renewed ${
new Date(renewedDateString).toLocaleDateString()
}
${resistanceId}
Browser
trust score:
${score}% ${grade}
visits: ${visits} ${
supervised > 0 ? `[supervised] ${computePoints(supervisedPointGain)}` : ''
}
first: ${toLocaleStr(firstVisit)}
alive: ${((hours) => {
const format = (n) => {
const fixed = n.toFixed(1)
const shouldMakeNumberWhole = /\.0/.test(fixed)
return shouldMakeNumberWhole ? n.toFixed() : fixed
}
return (
hours > 48 ? `${format(hours/24)} days` : `${format(hours)} hrs`
)
})(persistence)} ${
traced > 0 ? `[traced] ${computePoints(tracedPointGain)}` : ''
}
auto-delete in
shadow: ${!shadowBits ? '0' : shadowBits.toFixed(5)} ${computePoints(shadowBitsPointGain)}
${
!shadowBits ? '' : `${hashMini(shadow)}`
}
${styleChunks(getChunks(shadow.split(''), 8))}
${trashHTML(fp, computePoints(trashPointGain))}
${liesHTML(fp, computePoints(liesPointGain))}
${errorsHTML(fp, computePoints(errorsPointGain))}
session (${''+loads}):${initial} ${computePoints(measuredPointGain)}
revisions (${''+revisedKeys.length}): ${
!revisedKeys.length ? 'none' : modal(
`creep-revisions`,
revisedKeys.join('
'),
hashMini(revisedKeys),
)
}
loose fp (${''+switchCount}):${hashSlice(fpHash)} ${computePoints(switchCountPointGain)}
bot: ${bot.toFixed(2)}:${botLevel}:${botHash}
idle min-max: ${timeHoursIdleMin}-${timeHoursIdleMax} hrs
performance benchmark: ${benchmark.toFixed(2)} ms
${
signature ?
`
` :
`
`
}
`
patch(visitorElem, html`${template}`, () => {
// show self destruct time
const el = document.getElementById('auto-delete')
const arrivalTime = +new Date
const showTime = () => {
requestAnimationFrame(showTime)
const hoursInMs = 36e5
const day = hoursInMs * 24
const destructionDate = +new Date(+new Date-(day*30))
const hoursTillSelfDestruct = Math.abs(arrivalTime - destructionDate) / hoursInMs/24
// @ts-ignore
return el.style.setProperty(
'--auto-delete-time',
`'${hoursTillSelfDestruct.toFixed(8)}'`,
)
}
showTime()
// listen to form signature if not already signed
if (signature) {
return
}
const form = document.getElementById('signature')
// @ts-ignore
form.addEventListener('submit', async (event) => {
event.preventDefault()
// @ts-ignore
const input = document.getElementById('signature-input').value
const submit = confirm(`Are you sure? This cannot be undone.\n\nsignature: ${input}`)
if (!submit) {
return
}
const signatureRequest = `https://creepjs-api.web.app/sign?id=${creepHash}&signature=${input}`
// animate out
// @ts-ignore
form.classList.remove('fade-right-in')
// @ts-ignore
form.classList.add('fade-down-out')
// fetch/animate in
return fetch(signatureRequest)
.then((response) => response.json())
.then((data) => {
return setTimeout(() => {
patch(form, html`
`)
return console.log('Signed: ', JSON.stringify(data, null, '\t'))
}, 300)
})
.catch((error) => {
patch(form, html`
`)
return console.error('Error!', error.message)
})
})
})
const {
maths,
consoleErrors,
htmlElementVersion,
windowFeatures,
// css,
clientRects,
offlineAudioContext,
resistance,
canvas2d,
canvasWebgl,
screen: screenFp,
fonts,
voices,
svg,
media,
} = fp || {}
// const { computedStyle, system } = css || {}
const isTorBrowser = resistance.privacy == 'Tor Browser'
const isRFP = resistance.privacy == 'Firefox'
// const isBravePrivacy = resistance.privacy == 'Brave'
const screenMetrics = (
!screenFp || screenFp.lied || isRFP || isTorBrowser ? 'undefined' :
`${screenFp.width}x${screenFp.height}`
)
const {
compressorGainReduction: gain,
sampleSum,
floatFrequencyDataSum: freqSum,
floatTimeDomainDataSum: timeSum,
values: audioValues,
} = offlineAudioContext || {}
const valuesHash = hashMini(audioValues)
const audioMetrics = `${sampleSum}_${gain}_${freqSum}_${timeSum}_${valuesHash}`
const getBestGPUModel = ({ canvasWebgl, workerScope }) => {
const gpuHasGoodConfidence = (data) => {
return (
(data.gpu || {}).confidence &&
(data.gpu.confidence != 'low')
)
}
if (!canvasWebgl || canvasWebgl.parameterOrExtensionLie) {
return 'undefined'
} else if (workerScope && gpuHasGoodConfidence(workerScope)) {
return workerScope.webglRenderer
} else if (canvasWebgl && !canvasWebgl.parameterOrExtensionLie && gpuHasGoodConfidence(canvasWebgl)) {
return ''+((canvasWebgl.parameters || {}).UNMASKED_RENDERER_WEBGL)
}
return 'undefined'
}
const gpuModel = getBestGPUModel({ canvasWebgl, workerScope: fp.workerScope })
let RAW_BODY // store so we can access el
if (!shouldLock) {
// get data from session
// @ts-ignore
let decryptionData = window.sessionStorage && JSON.parse(sessionStorage.getItem('decryptionData'))
const targetMetrics = [
'canvas2d',
'canvasWebgl',
'clientRects',
'consoleErrors',
'css',
'cssMedia',
'fonts',
'htmlElementVersion',
'maths',
'media',
'navigator',
'offlineAudioContext',
'resistance',
'screen',
'svg',
'timezone',
'voices',
'windowFeatures',
'workerScope',
/* disregard metrics not in samples:
capturedErrors,
features,
headless,
intl,
lies,
trash,
*/
]
const { revisedKeysFromPreviousLoad } = computeSession({
fingerprint: fp,
computePreviousLoadRevision: true,
})
// @ts-ignore
const sessionFingerprintRevision = targetMetrics.filter((x) => revisedKeysFromPreviousLoad.includes(x))
const revisionLen = sessionFingerprintRevision.length
// fetch data
const requireNewDecryptionFetch = !decryptionData || revisionLen
console.log(`${revisionLen} revisions: fetching prediction data from ${requireNewDecryptionFetch ? 'server' : 'session'}...`)
if (requireNewDecryptionFetch) {
const sender = {
e: ({
// this just allows us to keep using Math.PI ** -100 results in the database for consistency
80: 1.9275814160560204e-50,
58: 1.9275814160560185e-50,
77: 1.9275814160560206e-50,
} as Record
)[ENGINE_IDENTIFIER] || 0,
l: +new Date('7/1/1113'),
}
const { userAgent, userAgentData } = fp.workerScope || {}
const { platformVersion: fontPlatformVersion } = fp.fonts || {}
const restoredUA = getUserAgentRestored({ userAgent, userAgentData, fontPlatformVersion })
const windows11UA = attemptWindows11UserAgent({
userAgent,
userAgentData,
fontPlatformVersion,
})
const workerScopeUserAgent = restoredUA || windows11UA
if (restoredUA && (restoredUA != userAgent)) {
console.log(`corrected: ${workerScopeUserAgent}`)
}
// cipher
RAW_BODY = {
stackBytes,
tmSum,
sender: `${sender.e}_${sender.l}`,
isTorBrowser,
isRFP,
isBrave,
resistanceId: resistance.$hash,
mathId: maths.$hash,
errorId: consoleErrors.$hash,
htmlId: htmlElementVersion.$hash,
winId: windowFeatures.$hash,
styleId: styleHash,
styleSystemId: styleSystemHash,
emojiId: (
!clientRects || clientRects.lied ? null :
clientRects.domrectSystemSum
),
domRectId: (
!clientRects || clientRects.lied ? null : domRectHash
),
svgId: (
!svg || svg.lied ? null : svg.svgrectSystemSum
),
mimeTypesId: (
!media || media.lied ? null : mimeTypesHash
),
audioId: (
!offlineAudioContext ||
offlineAudioContext.lied ? null : audioMetrics
),
canvasId: (
!canvas2d || canvas2d.lied ? null :
canvas2dImageHash
),
canvasPaintId: (
!canvas2d || canvas2d.lied ? null :
canvas2dPaintHash
),
canvasTextId: (
!canvas2d || canvas2d.lied ? null :
canvas2dTextHash
),
canvasEmojiId: (
!canvas2d || canvas2d.lied ? null :
canvas2dEmojiHash
),
textMetricsId: (
!canvas2d ||
canvas2d.liedTextMetrics ||
((+canvas2d.textMetricsSystemSum) == 0) ? null :
canvas2d.textMetricsSystemSum
),
webglId: (
!canvasWebgl || (canvas2d || {}).lied || canvasWebgl.lied ? null :
canvasWebglImageHash
),
gpuId: (
!canvasWebgl || canvasWebgl.parameterOrExtensionLie ? null :
canvasWebglParametersHash
),
gpu: gpuModel,
fontsId: !fonts || fonts.lied ? null : fonts.$hash,
voicesId: !voices || voices.lied ? null : voices.$hash,
screenId: screenMetrics,
deviceOfTimezoneId: deviceOfTimezoneHash,
ua: workerScopeUserAgent,
}
const secret = await cipher(RAW_BODY)
decryptionData = await fetch('https://creepjs-api.web.app/decrypt', {
method: 'POST',
headers: {
'Accept': 'application/json, text/plain, */*',
'Content-Type': 'application/json',
},
body: JSON.stringify(secret),
})
.then((res) => {
if (res.ok) return res.json()
status = `${res.status}:${res.statusText.toLocaleLowerCase()}`
return res
})
.catch((error) => {
console.error(error)
predictionErrorPatch(error)
return
})
if (decryptionData && window.sessionStorage) {
sessionStorage.setItem('decryptionData', JSON.stringify(decryptionData))
}
}
// Crowd-Blending Score
const crowdMap: Record = {
windowVersion: RAW_BODY?.winId,
jsRuntime: RAW_BODY?.mathId,
jsEngine: RAW_BODY?.errorId,
htmlVersion: RAW_BODY?.htmlId,
styleVersion: RAW_BODY?.styleId,
resistance: RAW_BODY?.resistanceId,
styleSystem: RAW_BODY?.styleSystemId,
emojiSystem: RAW_BODY?.emojiId,
domRectSystem: RAW_BODY?.domRectId,
svgSystem: RAW_BODY?.svgId,
mimeTypesSystem: RAW_BODY?.mimeTypesId,
audioSystem: RAW_BODY?.audioId,
canvasSystem: RAW_BODY?.canvasId,
canvasPaintSystem: RAW_BODY?.canvasPaintId,
canvasTextSystem: RAW_BODY?.canvasTextId,
canvasEmojiSystem: RAW_BODY?.canvasEmojiId,
textMetricsSystem: RAW_BODY?.textMetricsId,
webglSystem: RAW_BODY?.webglId,
gpuSystem: RAW_BODY?.gpuId,
gpuModelSystem: RAW_BODY?.gpu,
fontsSystem: RAW_BODY?.fontsId,
voicesSystem: RAW_BODY?.voicesId,
screenSystem: RAW_BODY?.screenId,
deviceOfTimezone: RAW_BODY?.deviceOfTimezoneId,
}
const scoreKeys = Object.keys(crowdMap)
const decryptionDataScores = Object.keys(crowdMap).reduce((acc, key) => {
const { score } = decryptionData[key] || {}
const reporters = (
score == 36 ? 1 :
score == 84 ? 2 :
score == 96 ? 3 :
score == 100 ? 4 :
0
)
// @ts-ignore
acc.metrics = [...(acc.metrics||[]), { key, score: (score||0), reporters }]
// @ts-ignore
acc.scores = [...(acc.scores||[]), (score||0)]
return acc
}, {})
// @ts-ignore
const { metrics: scoreMetrics } = decryptionDataScores
const scoreMetricsMap = Object.keys(scoreMetrics).reduce((acc, key) => {
const scoreMetricData = scoreMetrics[key]
const { score, reporters } = scoreMetricData
acc[scoreMetricData.key] = { score, reporters }
return acc
}, {} as Record)
// Generate Trace Fingerprint
const traceId = !RAW_BODY ? null : await hashify(
scoreKeys.reduce((acc, key) => {
const hasGoodScore = scoreMetricsMap[key].score > 90
if (hasGoodScore) {
acc.push(String(crowdMap[key]))
}
return acc
}, [] as string[]),
)
// @ts-ignore
const blockedOrOpenlyPoisonedMetric = decryptionDataScores.scores.includes(0)
// @ts-ignore
const validScores = decryptionDataScores.scores.filter((n) => !!n)
const crowdBlendingScoreMin = Math.min(...(validScores.length ? validScores : [0]))
const crowdBlendingScore = (
blockedOrOpenlyPoisonedMetric ? (0.75 * crowdBlendingScoreMin) :
crowdBlendingScoreMin
)
console.groupCollapsed(`Crowd-Blending Score: ${crowdBlendingScore}%`)
console.table(scoreMetricsMap)
console.groupEnd()
if (crowdBlendingScore != fpCrowdBlendingScore) {
console.log(`updating crowd-blending score from ${fpCrowdBlendingScore} to ${crowdBlendingScore}`)
const scoreRequest = `https://creepjs-api.web.app/score-crowd-blending?id=${creepHash}&crowdBlendingScore=${crowdBlendingScore}&traceId=${traceId}&stackBytes=${stackBytes}&tmSum=${tmSum}`
fetch(scoreRequest)
.catch((error) => console.error('Failed Score Request', error))
}
renderPrediction({ decryptionData, crowdBlendingScore })
}
const { samples: decryptionSamples, samplesDidLoadFromSession } = await getSamples() || {}
const cleanGPUString = (x: string) => !x ? x : (''+x).replace(/\//g, '')
const {
window: winSamples,
math: mathSamples,
error: errorSamples,
html: htmlSamples,
style: styleSamples,
resistance: resistanceSamples,
styleVersion: styleVersionSamples,
emoji: emojiSamples,
domRect: domRectSamples,
svg: svgSamples,
mimeTypes: mimeTypesSamples,
audio: audioSamples,
canvas: canvasSamples,
canvasPaint: canvasPaintSamples,
canvasText: canvasTextSamples,
canvasEmoji: canvasEmojiSamples,
textMetrics: textMetricsSamples,
webgl: webglSamples,
fonts: fontsSamples,
voices: voicesSamples,
screen: screenSamples,
gpu: gpuSamples,
gpuModel: gpuModelSamples,
deviceOfTimezone: deviceOfTimezoneSamples,
} = decryptionSamples || {}
if (shouldLock && !decryptionSamples) {
predictionErrorPatch('Failed prediction fetch')
}
if (shouldLock && decryptionSamples) {
// Perform Dragon Fire Magic
const decryptionData = {
windowVersion: getPrediction({ hash: (windowFeatures || {}).$hash, data: winSamples }),
jsRuntime: getPrediction({ hash: (maths || {}).$hash, data: mathSamples }),
jsEngine: getPrediction({ hash: (consoleErrors || {}).$hash, data: errorSamples }),
htmlVersion: getPrediction({ hash: (htmlElementVersion || {}).$hash, data: htmlSamples }),
styleVersion: getPrediction({ hash: styleHash, data: styleVersionSamples }),
styleSystem: getPrediction({ hash: styleSystemHash, data: styleSamples }),
resistance: getPrediction({ hash: (resistance || {}).$hash, data: resistanceSamples }),
emojiSystem: getPrediction({
hash: (clientRects || {}).domrectSystemSum,
data: emojiSamples,
}),
domRectSystem: getPrediction({ hash: domRectHash, data: domRectSamples }),
svgSystem: getPrediction({
hash: (svg || {}).svgrectSystemSum,
data: svgSamples,
}),
mimeTypesSystem: getPrediction({ hash: mimeTypesHash, data: mimeTypesSamples }),
audioSystem: getPrediction({ hash: audioMetrics, data: audioSamples }),
canvasSystem: getPrediction({ hash: canvas2dImageHash, data: canvasSamples }),
canvasPaintSystem: getPrediction({ hash: canvas2dPaintHash, data: canvasPaintSamples }),
canvasTextSystem: getPrediction({ hash: canvas2dTextHash, data: canvasTextSamples }),
canvasEmojiSystem: getPrediction({ hash: canvas2dEmojiHash, data: canvasEmojiSamples }),
textMetricsSystem: getPrediction({
hash: (canvas2d || {}).textMetricsSystemSum,
data: textMetricsSamples,
}),
webglSystem: getPrediction({ hash: canvasWebglImageHash, data: webglSamples }),
gpuSystem: getPrediction({ hash: canvasWebglParametersHash, data: gpuSamples }),
gpuModelSystem: getPrediction({ hash: cleanGPUString(gpuModel), data: gpuModelSamples }),
fontsSystem: getPrediction({ hash: (fonts || {}).$hash, data: fontsSamples }),
voicesSystem: getPrediction({ hash: (voices || {}).$hash, data: voicesSamples }),
screenSystem: getPrediction({ hash: screenMetrics, data: screenSamples }),
deviceOfTimezone: getPrediction({ hash: deviceOfTimezoneHash, data: deviceOfTimezoneSamples }),
}
// @ts-ignore
renderPrediction({ decryptionData, bot: true })
}
// render entropy notes
if (decryptionSamples) {
const getEntropy = (hash, data) => {
let classTotal = 0
const metricTotal = Object.keys(data)
.reduce((acc, key) => acc+= data[key].length, 0)
const decryption = Object.keys(data).find((key) => data[key].find((item) => {
if ((item.id == hash) && (item.reporterTrustScore > 36)) {
const trustedSamples = data[key].filter((sample) => {
return (sample.reporterTrustScore > 36)
})
classTotal = trustedSamples.length
return true
}
return false
}))
return {
classTotal,
decryption,
metricTotal,
}
}
const entropyHash: Record = {
window: (windowFeatures || {}).$hash,
math: (maths || {}).$hash,
error: (consoleErrors || {}).$hash,
html: (htmlElementVersion || {}).$hash,
style: styleSystemHash,
resistance: (resistance || {}).$hash,
styleVersion: styleHash,
emoji: (clientRects || {}).domrectSystemSum,
domRect: domRectHash,
svg: (svg || {}).svgrectSystemSum,
mimeTypes: mimeTypesHash,
audio: audioMetrics,
canvas: canvas2dImageHash,
canvasPaint: canvas2dPaintHash,
canvasText: canvas2dTextHash,
canvasEmoji: canvas2dEmojiHash,
textMetrics: (canvas2d || {}).textMetricsSystemSum,
webgl: canvasWebglImageHash,
fonts: (fonts || {}).$hash,
voices: (voices || {}).$hash,
screen: screenMetrics,
gpu: canvasWebglParametersHash,
gpuModel,
deviceOfTimezone: deviceOfTimezoneHash,
}
const entropyDescriptors: Record = {
window: 'window object',
math: 'engine math runtime',
error: 'engine console errors',
html: 'html element',
style: 'system styles',
resistance: 'resistance patterns',
styleVersion: 'computed styles',
emoji: 'domrect emojis',
domRect: 'domrect metrics',
svg: 'svg emojis',
mimeTypes: 'media mimeTypes',
audio: 'audio metrics',
canvas: 'canvas image',
canvasPaint: 'canvas paint',
canvasText: 'canvas text',
canvasEmoji: 'canvas emoji',
textMetrics: 'textMetrics',
webgl: 'webgl image',
fonts: 'system fonts',
voices: 'voices',
screen: 'screen metrics',
gpu: 'webgl parameters',
gpuModel: 'webgl renderer',
deviceOfTimezone: 'device of timezone',
}
Object.keys(decryptionSamples).forEach((key, i) => {
const hash = (
key == 'gpuModel' ? cleanGPUString(decodeURIComponent(entropyHash[key])) :
entropyHash[key]
)
const {
classTotal,
decryption,
// metricTotal,
} = getEntropy(hash, decryptionSamples[key])
const el = document.getElementById(`${key}-entropy`)
const deviceMetric = (
(key == 'screen') || (key == 'fonts') || (key == 'gpuModel') || (key == 'deviceOfTimezone')
)
const uniquePercent = !classTotal ? 0 : (1/classTotal)*100
const signal = (
uniquePercent == 0 ? 'entropy-unknown' :
uniquePercent < 1 ? 'entropy-high' :
uniquePercent > 10 ? 'entropy-low' :
''
)
const animate = samplesDidLoadFromSession ? '' : `style="animation: fade-up .3s ${100*i}ms ease both;"`
return patch(el, html`
${(uniquePercent).toFixed(2)}%
`)
})
}
return renderSamples(decryptionSamples, { fp, styleSystemHash })
}).catch((error) => {
fetchVisitorDataTimer('Error fetching visitor data')
const el = document.getElementById('browser-detection')
console.error('Error!', error.message)
if (!el) {
return
}
const loader = document.getElementById('loader')
loader && patch(loader, html`
${status}:API access denied
`)
return patch(el, html`
${status}:API access denied
`)
})
})
}()