zoeissleeping/impost
1
0
Fork 0
Code Issues 2 Pull Requests Actions Packages Projects Releases Wiki Activity

Compare commits

base: zoeissleeping:kctf
Branches Tags
zoeissleeping:trunk zoeissleeping:benchmarking zoeissleeping:kctf
..
compare: zoeissleeping:benchmarking
Branches Tags
zoeissleeping:trunk zoeissleeping:benchmarking zoeissleeping:kctf

2 Commits
kctf ... benchmarki

Author SHA1 Message Date
Zoe
d0f4936b84 further benchmarking stuff 2025-11-28 14:53:06 -06:00
Zoe
e16383e9b9 Implement algorithm switching 
This commit implements every algorithm I have played with so far. It also allows for you to switch which algorithm you want to use at runtime.
 2025-11-25 18:09:17 +00:00
31 changed files with 1608 additions and 1120 deletions
Expand all files Collapse all files

8
README.md
View File

@@ -3,9 +3,9 @@
Impost /ˈimˌpōst/ _noun_ a tax or compulsory payment
Impost is a PoW anti-spam solution, or for short, a PoW captcha. Instead of
spying on your users and using heavy captchas, Impost uses PoW to impose a cost
on sending requests. To a single user, this is a negligable few seconds, but at
scale, it can be a significant deterrent to spam.
spying on your users and using heavy, bloated captchas, Impost uses PoW to
impose a cost on sending requests. To a single user, this is a negligable few
seconds, but at scale, it can be a significant deterrent to spam.
This is the impost monorepo, containing the following packages:
@@ -16,4 +16,4 @@ This is the impost monorepo, containing the following packages:
It also contains a `solver` package, which is the PoW solver written in Zig,
`@impost/lib` is built on top of, an example of how to use the solver in a
nuxt 3 project.
nuxt 3 project. More in-depth documentation will be added in the future.

187
example-app/app/pages/bench.vue Normal file
View File

@@ -0,0 +1,187 @@
<script setup lang="ts">
let { data: challengeData } = await useFetch('/api/pow/challenge');
let { data: powData } = await useFetch('/api/pow');
if (!challengeData || !powData) {
throw createError({
statusCode: 500,
message: 'Failed to fetch data',
});
}
const algorithms = {
"argon2": {
name: 'argon2',
label: 'Argon2',
strategies: ['leading_zeroes', 'target_number'],
},
"kctf": {
name: 'kctf',
label: 'kCTF',
strategies: ['null'],
},
"sha256": {
name: 'sha256',
label: 'SHA256',
strategies: ['leading_zeroes', 'target_number'],
},
};
async function refresh() {
challengeData.value = await $fetch('/api/pow/challenge');
powData.value = await $fetch('/api/pow');
resetCaptcha();
}
function resetCaptcha() {
document.querySelector("pow-captcha")!.dispatchEvent(new CustomEvent('reset', {
detail: {
challenge: challengeData.value.challenge,
}
}));
}
let bench_results = ref([])
let start = ref(0);
let continue_bench: Promise<void> | null = null;
async function bench() {
for (let algorithm_name in algorithms) {
let algorithm = algorithms[algorithm_name as "sha256" | "argon2" | "kctf"];
for (let strategy of algorithm.strategies) {
for (let i = 1; i <= 3; i++) {
// reduce statistical anomolies by running tests multiple times and averaging after tha fact
for (let j = 0; j < 5; j++) {
let difficulty;
switch (strategy) {
case 'leading_zeroes':
difficulty = i;
break;
case 'null':
case 'target_number':
// these tests scale linearly, so to try to match the
// complexity of leading_zeroes, we grow the difficulty
// exponentially
difficulty = Math.pow(16, i);
break;
}
await changeAlgorithm(algorithm_name);
if (strategy !== 'null') {
await changeStrategy(strategy);
}
await $fetch('/api/pow/difficulty', {
method: 'PUT',
body: JSON.stringify({
difficulty: difficulty,
}),
})
// sleep for 300ms
await new Promise((resolve) => setTimeout(resolve, 750));
await refresh();
continue_bench = new Promise((resolve) => {
document.querySelector("pow-captcha")!.addEventListener('impost:solved', () => {
resolve();
});
});
start.value = performance.now();
document.querySelector("pow-captcha")!.dispatchEvent(new Event('solve'));
await continue_bench;
let end = performance.now();
const data = {
algorithm: algorithm_name,
cores: navigator.hardwareConcurrency,
strategy: strategy,
difficulty: difficulty,
time: end - start.value,
};
const should_scroll = document.documentElement.scrollTop + document.documentElement.clientHeight >= document.documentElement.scrollHeight;
bench_results.value.push(data);
if (should_scroll) {
document.documentElement.scrollTop = document.documentElement.scrollHeight;
}
}
}
}
}
}
function solved(ev: CustomEvent) {
console.log("Solved:", ev.detail.solution);
}
async function changeAlgorithmEV(ev: Event) {
changeAlgorithm(ev.target.value);
refresh();
}
async function changeAlgorithm(algorithm: string) {
await $fetch('/api/pow/algorithm', {
method: 'PUT',
body: JSON.stringify({
algorithm: algorithm
}),
});
}
async function changeStrategyEV(ev: Event) {
changeStrategy(ev.target.value);
refresh();
}
async function changeStrategy(strategy: string) {
await $fetch('/api/pow/strategy', {
method: 'PUT',
body: JSON.stringify({
strategy: strategy
}),
});
}
</script>
<template>
<pow-captcha challengeUrl="/api/pow" :challengejson="JSON.stringify(challengeData!.challenge)"
@impost:solved="solved" />
<div class="flex flex-row gap-4">
<div class="flex flex-row gap-2" v-for="algorithm in algorithms" :key="algorithm.label">
<input type="radio" name="algorithm" @change="changeAlgorithmEV" :value="algorithm.name"
:id="algorithm.name" :checked="powData!.algorithm === algorithm.name"> <label :for="algorithm.name">{{
algorithm.label
}}</label>
</div>
</div>
<div v-if="algorithms[powData!.algorithm].strategies.length > 1 && powData!.algorithm === algorithms[powData!.algorithm].name"
class="flex flex-row gap-4">
<div class="flex flex-row gap-2" v-for="strategy in algorithms[powData!.algorithm].strategies">
<input type="radio" name="strategy" @change="changeStrategyEV" :value="strategy" :id="strategy"
:checked="powData!.strategy === strategy"> <label :for="strategy">{{ strategy }}</label>
</div>
</div>
<input type="button" value="Start benchmark" @click="bench" />
<div v-if="bench_results.length > 0">
<table>
<thead>
<tr>
<th>Algorithm</th>
<th>Strategy</th>
<th>Difficulty</th>
<th>Time (ms)</th>
</tr>
</thead>
<tbody>
<tr v-for="result in bench_results" :key="result.algorithm + result.strategy + result.difficulty">
<td>{{ algorithms[result.algorithm].label }}</td>
<td>{{ result.strategy }}</td>
<td>{{ result.difficulty }}</td>
<td>{{ result.time }}</td>
</tr>
</tbody>
</table>
</div>
</template>

411
example-app/app/pages/index.vue.old
View File

@@ -1,411 +0,0 @@
<script setup lang="ts">
import { type WorkerRequest, type SolutionMessage, WorkerResponseType, WorkerMessageType, ChallengeStrategy, type Challenge } from '~/types/pow';
import WASMSolverUrl from "~/utils/solver.wasm?url";
import ChallengeWorker from '~/utils/worker?worker';
let shared_atomics = new SharedArrayBuffer(12);
let workers: Worker[] = [];
let workers_initialized = false;
if (import.meta.client) {
try {
// const num_workers = 1;
const num_workers = navigator.hardwareConcurrency;
for (let i = 0; i < num_workers; i++) {
workers.push(new ChallengeWorker());
}
} catch (error: any) {
console.error("Failed to create worker:", error);
}
}
let autoSolve: Ref<boolean> = ref(false);
watch(autoSolve, async () => {
if (autoSolve.value) {
while (autoSolve.value) {
if (solving.value) {
await new Promise(resolve => setTimeout(resolve, 100));
continue;
}
await getChallenge();
await solveChallenge();
if (!autoSolve.value) {
break;
}
await new Promise(resolve => setTimeout(resolve, 100));
}
}
});
let total_solved: Ref<number> = ref(0);
let total_solving_for: Ref<number> = ref(0);
function pluralize(value: number, string: string) {
return value === 1 ? string : `${string}s`;
}
let challenge_loading: Ref<boolean> = ref(false);
let challenge_loading_indicator: Ref<string> = ref('');
let challenge: Ref<Challenge | null> = ref(null);
let nonce: Ref<string | null> = ref(null);
let solved: Ref<boolean> = ref(false);
let solving_for: Ref<string> = ref('0');
const number_formatter = new Intl.NumberFormat('en-US', {
notation: 'compact',
compactDisplay: 'short',
maximumFractionDigits: 2,
});
// the hashrate of all the runs
let hashrate_array: Ref<Array<number>> = ref([]);
let hashrate = computed(() => {
if (hashrate_array.value.length === 0) {
return 0;
}
return hashrate_array.value.reduce((a, b) => a + b, 0) / hashrate_array.value.length;
});
let solving = ref(false);
let solveTime: Ref<number> = ref(0);
let solveTimeout: Ref<any | null> = ref(null);
let challenge_error: Ref<string | null> = ref(null);
let difficulty: Ref<number> = ref(0);
let { data } = await useFetch('/api/pow/difficulty');
if (data.value) {
difficulty.value = data.value.difficulty;
}
const MESSAGE_TIMEOUT = 3000;
async function getChallenge() {
challenge_error.value = null;
challenge_loading_indicator.value = '';
challenge.value = null;
nonce.value = null;
challenge_loading.value = true;
const spinners = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
let spinner_index = 0;
const loading_interval = setInterval(() => {
challenge_loading_indicator.value = spinners[spinner_index]!;
spinner_index = (spinner_index + 1) % spinners.length;
console.log(spinners[spinner_index]);
}, 100);
try {
const new_challenge = await $fetch('/api/pow/challenge');
challenge.value = new_challenge.challenge;
} catch (error: any) {
console.error("Failed to get challenge:", error);
challenge_error.value = `Failed to get challenge: ${error.message}`;
} finally {
challenge_loading.value = false;
clearInterval(loading_interval);
}
}
async function initWorkers() {
if (workers_initialized) {
throw createError("Workers already initialized");
}
workers_initialized = true;
const module = await WebAssembly.compileStreaming(fetch(WASMSolverUrl));
const atomics_view = new Int32Array(shared_atomics);
Atomics.store(atomics_view, 0, 0);
Atomics.store(atomics_view, 1, 0);
console.debug(`Initializing ${workers.length} workers`);
let worker_promises: Promise<void>[] = [];
for (let i = 0; i < workers.length; i++) {
const worker = workers[i]!;
worker_promises.push(new Promise<void>((resolve, reject) => {
const message_handler = (event: MessageEvent<SolutionMessage>) => {
if (event.data.type === WorkerResponseType.Error) {
console.error("Worker error:", event.data.error);
reject(event.data.error);
}
if (event.data.type === WorkerResponseType.Ok) {
resolve();
}
reject(new Error("Unexpected message from worker"));
};
const error_handler = (error: ErrorEvent) => {
console.error("Worker error:", error);
reject(error);
};
worker.addEventListener('message', message_handler);
worker.addEventListener('error', error_handler);
worker.postMessage({
type: WorkerMessageType.Init,
module: module,
sab: shared_atomics,
} as WorkerRequest);
}));
}
const timeoutMs = 10 * 1000;
const timeoutPromise = new Promise((_, reject) => {
setTimeout(() => {
reject(new Error(`Function timed out after ${timeoutMs}ms`));
}, timeoutMs);
});
await Promise.race([
Promise.all(worker_promises),
timeoutPromise,
]);
console.log("All workers initialized");
}
async function getChallengeSolution(worker: Worker, request: { strategy: ChallengeStrategy.LeadingZeroes, target: string, difficulty: number } | { strategy: ChallengeStrategy.TargetNumber, target: string, salt: string }): Promise<SolutionMessage> {
return new Promise<SolutionMessage>((resolve, reject) => {
const message_handler = (event: MessageEvent<SolutionMessage>) => {
worker.removeEventListener('message', message_handler);
worker.removeEventListener('error', error_handler);
resolve(event.data);
};
const error_handler = (error: ErrorEvent) => {
worker.removeEventListener('error', error_handler);
worker.removeEventListener('message', message_handler);
console.error("Worker error:", error);
reject(error);
};
worker.addEventListener('message', message_handler);
worker.addEventListener('error', error_handler);
switch (request.strategy) {
case ChallengeStrategy.LeadingZeroes:
worker.postMessage({
strategy: ChallengeStrategy.LeadingZeroes,
target: request.target,
difficulty: request.difficulty,
} as WorkerRequest);
break;
case ChallengeStrategy.TargetNumber:
worker.postMessage({
strategy: ChallengeStrategy.TargetNumber,
target: request.target,
salt: request.salt,
} as WorkerRequest);
break;
}
});
}
async function solveChallenge() {
if (!challenge.value?.target) {
return;
}
if (!workers_initialized) {
try {
await initWorkers();
} catch (error: any) {
console.error("Failed to initialize workers:", error);
return;
}
}
const atomics_view = new Int32Array(shared_atomics);
Atomics.store(atomics_view, 0, 0);
Atomics.store(atomics_view, 1, -1);
solved.value = false;
challenge_error.value = null;
solving.value = true;
solveTime.value = 0;
solving_for.value = '0';
let startTime = performance.now();
let solving_for_interval = setInterval(() => {
solving_for.value = ((performance.now() - startTime) / 1000).toFixed(1);
}, 100);
function cleanup() {
clearTimeout(solveTimeout.value);
solveTimeout.value = setTimeout(() => {
solveTime.value = 0;
}, MESSAGE_TIMEOUT);
solved.value = false;
solving.value = false;
clearInterval(solving_for_interval);
}
try {
let request: { strategy: ChallengeStrategy.LeadingZeroes, target: string, difficulty: number } | { strategy: ChallengeStrategy.TargetNumber, target: string, salt: string };
switch (challenge.value.strategy) {
case ChallengeStrategy.LeadingZeroes:
request = {
strategy: ChallengeStrategy.LeadingZeroes,
target: challenge.value.target,
difficulty: challenge.value.difficulty,
};
break;
case ChallengeStrategy.TargetNumber:
request = {
strategy: ChallengeStrategy.TargetNumber,
target: challenge.value.target,
salt: challenge.value.salt,
};
break;
}
let worker_promises: Promise<SolutionMessage>[] = [];
for (let worker of workers) {
// dispatch to all workers, func is async so it will not block
worker_promises.push(getChallengeSolution(worker, request));
}
let solution = await Promise.race(worker_promises);
if (solution.type === WorkerResponseType.Error) {
throw createError(solution.error);
}
if (solution.type === WorkerResponseType.Ok) {
throw createError("spurious solution");
}
console.log(shared_atomics.slice(8, 12));
nonce.value = Atomics.load(atomics_view, 1).toString();
solveTime.value = Math.floor(performance.now() - startTime);
total_solved.value += 1;
total_solving_for.value += solveTime.value;
// since nonce is the number of iterations we have completed, we can divide that by how long it took in second
// to get H/s
hashrate_array.value.push(+Atomics.load(atomics_view, 1) / (solveTime.value / 1000));
clearTimeout(solveTimeout.value);
await $fetch('/api/pow/challenge', {
method: 'POST',
body: {
challenge: challenge.value.target,
nonce: nonce.value,
}
});
solved.value = true;
solveTimeout.value = setTimeout(() => {
solveTime.value = 0;
solved.value = false;
}, MESSAGE_TIMEOUT);
switch (challenge.value.strategy) {
case ChallengeStrategy.LeadingZeroes:
console.debug("Solved challenge with difficulty", challenge.value.difficulty, "in " + solveTime.value + "ms");
break;
case ChallengeStrategy.TargetNumber:
console.debug("Solved challenge with salt", challenge.value.salt, "in " + solveTime.value + "ms");
break;
}
solving.value = false;
clearInterval(solving_for_interval);
} catch (error: any) {
challenge_error.value = `Failed to solve challenge: ${error.message}`;
console.error(error);
cleanup();
}
}
async function setDifficulty(difficulty: number) {
const response = await $fetch('/api/pow/difficulty', {
method: 'PUT',
body: {
difficulty,
}
});
console.log(response);
}
</script>
<template>
<div class="flex justify-between" v-if="hashrate_array.length !== 0">
<span>Your average Hashrate: {{ number_formatter.format(hashrate) }} H/s</span>
<span>You have solved {{ total_solved }} {{ pluralize(total_solved, "challenge") }} in
{{ number_formatter.format(total_solving_for / 1000) }}s</span>
<span>Your Hashrate on the last challenge: {{ number_formatter.format(hashrate_array.at(-1)!) }} H/s</span>
</div>
<p v-else>You have not solved any challenges yet</p>
<p>Challenge: <span v-if="challenge_loading">{{ challenge_loading_indicator }}</span>
<span v-else>{{ challenge }}</span>
</p>
<p>Nonce: {{ nonce }}</p>
<button @click="getChallenge()" :disabled="solving || challenge_loading">
Get Challenge
</button>
<button @click="solveChallenge()" :disabled="solving || challenge === null || nonce !== null">
<span v-if="!solving">Solve Challenge</span>
<span v-else>Solving challenge for {{ solving_for }}s...</span>
</button>
<div>
<div v-if="solveTime && !challenge_error" class="min-h-[1rem]">
<span v-if="solved">Challenge solved in {{ solveTime }}ms!</span>
<span v-else>Validating solution...</span>
</div>
<div v-else-if="challenge_error">{{ challenge_error }}</div>
<p v-else class="empty-p"><!-- Empty so there is no content shift when there is text or isnt --></p>
</div>
<div class="flex flex-row w-fit">
<label for="autoSolve">Auto solve</label>
<input class="w-min" type="checkbox" v-model="autoSolve" id="autoSolve"></input>
</div>
<div class="flex flex-col w-fit">
<label for="difficulty">Difficulty</label>
<input class="w-min" type="number" min="1" max="64" v-model="difficulty" @change="setDifficulty(difficulty)"
id="difficulty"></input>
</div>
</template>
<style scoped>
button {
min-width: 140px;
padding: 0.25rem 0.375rem;
}
.empty-p {
margin: 0;
&::after {
content: "-";
visibility: hidden;
}
}
</style>

6
example-app/app/utils/worker-name.ts
View File

@@ -1,6 +0,0 @@
const adjectives = ['swift', 'silent', 'hidden', 'clever', 'brave', 'sharp', 'shadow', 'crimson', 'bright', 'quiet', 'loud', 'happy', 'dark', 'evil', 'good', 'intelligent', 'lovely', 'mysterious', 'peaceful', 'powerful', 'pure', 'quiet', 'shiny', 'sleepy', 'strong', 'sweet', 'tall', 'warm', 'gentle', 'kind', 'nice', 'polite', 'rough', 'rude', 'scary', 'shy', 'silly', 'smart', 'strange', 'tough', 'ugly', 'vivid', 'wicked', 'wise', 'young', 'sleepy'];
const nouns = ['fox', 'river', 'stone', 'cipher', 'link', 'comet', 'falcon', 'signal', 'anchor', 'spark', 'stone', 'comet', 'rocket', 'snake', 'snail', 'shark', 'elephant', 'cat', 'dog', 'whale', 'orca', 'cactus', 'flower', 'frog', 'toad', 'apple', 'strawberry', 'raspberry', 'lemon', 'bot', 'gopher', 'dinosaur', 'racoon', 'penguin', 'chameleon', 'atom', 'particle', 'witch', 'wizard', 'warlock', 'deer']
export function getWorkerName() {
return `${adjectives[Math.floor(Math.random() * adjectives.length)]}-${nouns[Math.floor(Math.random() * nouns.length)]}`;
}

170
example-app/app/utils/worker.ts
View File

@@ -1,170 +0,0 @@
// This worker just sits on another thread and waits for message to solve
// challenges so that we dont block the render thread
import {
type WorkerRequest,
type SolutionMessage,
WorkerMessageType,
WorkerResponseType,
ChallengeStrategy,
} from "~/types/pow";
const worker_name = getWorkerName();
let solver: SolverModule | null = null;
let atomic_nonce: Int32Array | null = null;
let atomic_solution: Int32Array | null = null;
async function loadWasmSolver(module: WebAssembly.Module) {
if (atomic_nonce === null || atomic_solution === null) {
throw createError("Atomics not initialized");
}
console.debug(`[${worker_name}]: Loading WASM solver`);
solver = await WebAssembly.instantiate(module, {
env: {
__get_solution: () => Atomics.load(atomic_solution!, 0),
__set_solution: (value: number) => Atomics.store(atomic_solution!, 0, value),
__cmpxchg_solution: (expected: number, replacement: number) => Atomics.compareExchange(atomic_solution!, 0, expected, replacement),
__fetch_add_nonce: (value: number) => Atomics.add(atomic_nonce!, 0, value),
__log: (ptr: number, len: number) => {
const string_data = new Uint8Array(solver!.exports.memory.buffer, ptr, len);
console.log(`[${worker_name}]: ${new TextDecoder().decode(string_data)}`);
},
}
}) as unknown as SolverModule;
console.debug(`[${worker_name}]: WASM solver loaded`);
}
onmessage = async (event: MessageEvent<WorkerRequest>) => {
if (event.data.type === WorkerMessageType.Init) {
console.log(`[${worker_name}]: Initializing...`);
atomic_nonce = new Int32Array(event.data.sab, 0, 1);
atomic_solution = new Int32Array(event.data.sab, 4, 1);
try {
await loadWasmSolver(event.data.module);
} catch (error: any) {
console.error(`[${worker_name}]: Failed to load WASM solver:`, error);
postMessage({
type: WorkerResponseType.Error,
error: `Could not load WASM solver: ${error.message}`,
} as SolutionMessage);
return;
}
if (!solver) {
console.error(`[${worker_name}]: Failed to load WASM solver`);
postMessage({
type: WorkerResponseType.Error,
error: "Failed to load WASM solver",
} as SolutionMessage);
return;
}
postMessage({
type: WorkerResponseType.Ok,
} as SolutionMessage);
return;
}
if (!solver) {
postMessage({
type: WorkerResponseType.Error,
error: "WASM solver not loaded",
} as SolutionMessage);
return;
}
const { strategy } = event.data;
const encoder = new TextEncoder();
let solution: number;
let target: string = event.data.target;
let target_bytes, target_ptr;
let memory;
switch (strategy) {
case ChallengeStrategy.LeadingZeroes:
const { difficulty } = event.data;
console.debug(`[${worker_name}]: recieved ${strategy} challenge: ${target}, difficulty: ${difficulty}`);
target_bytes = encoder.encode(target);
target_ptr = solver.exports.malloc(target_bytes.length);
if (target_ptr === 0 || target_ptr === null) {
console.error(`[${worker_name}]: Failed to allocate memory for challenge string`);
postMessage({
type: WorkerResponseType.Error,
error: "Failed to allocate memory for challenge string",
} as SolutionMessage);
return;
}
memory = new Uint8Array(solver.exports.memory.buffer);
memory.set(target_bytes, target_ptr);
solution = solver.exports.solve_leaading_zeroes_challenge(
target_ptr,
target.length,
difficulty,
);
console.debug(`[${worker_name}]: WASM solver found nonce: ${solution}`);
break;
case ChallengeStrategy.TargetNumber:
const { salt } = event.data;
console.debug(`[${worker_name}]: recieved ${strategy} challenge: ${target}, salt: ${salt}`);
const salt_bytes = encoder.encode(salt);
target_bytes = encoder.encode(target);
const salt_ptr = solver.exports.malloc(salt_bytes.length);
if (salt_ptr === 0 || salt_ptr === null) {
console.error(`[${worker_name}]: Failed to allocate memory for salt string`);
postMessage({
type: WorkerResponseType.Error,
error: "Failed to allocate memory for salt string",
} as SolutionMessage);
return;
}
target_ptr = solver.exports.malloc(target_bytes.length);
if (target_ptr === 0 || target_ptr === null) {
console.error(`[${worker_name}]: Failed to allocate memory for target string`);
postMessage({
type: WorkerResponseType.Error,
error: "Failed to allocate memory for target string",
} as SolutionMessage);
return;
}
memory = new Uint8Array(solver.exports.memory.buffer);
memory.set(salt_bytes, salt_ptr);
memory.set(target_bytes, target_ptr);
solution = solver.exports.solve_target_number_challenge(
target_ptr,
target_bytes.length,
salt_ptr,
salt_bytes.length,
);
console.debug(`[${worker_name}]: WASM solver found nonce: ${solution}`);
break;
}
// we are just assuming that if its less than -1, its the min i32
if (solution < 0) {
return postMessage({
type: WorkerResponseType.Error,
error: "failed to solve challenge",
} as SolutionMessage);
}
postMessage({
type: WorkerResponseType.Solution,
nonce: solution === -1 ? null : solution.toString()
} as SolutionMessage);
};

3
example-app/config.toml
View File

@@ -1,4 +1,5 @@
strategy = "kctf"
algorithm = "argon2"
strategy = "target_number"
[leading_zeroes]
difficulty = 4

7
example-app/server/api/pow/algorithm.get.ts Normal file
View File

@@ -0,0 +1,7 @@
import { defineEventHandler } from 'h3'
export default defineEventHandler((event) => {
return {
algorithm: config.algorithm
}
})

43
example-app/server/api/pow/algorithm.put.ts Normal file
View File

@@ -0,0 +1,43 @@
import { defineEventHandler } from 'h3'
import { ChallengeAlgorithm } from '@impost/lib';
import * as z from 'zod';
const algorithmSchema = z.object({
algorithm: z.enum(ChallengeAlgorithm),
});
export default defineEventHandler(async (event) => {
const body = await readValidatedBody(event, algorithmSchema.safeParse);
if (!body.success) {
throw createError({
statusCode: 400,
statusMessage: 'Validation failed'
})
}
switch (body.data.algorithm) {
case 'sha256':
case 'argon2':
config.algorithm = body.data.algorithm;
config.strategy = config.strategy || 'leading_zeroes';
switch (config.strategy) {
case 'leading_zeroes':
config.leading_zeroes.difficulty = config.leading_zeroes.difficulty || 4;
break;
case 'target_number':
config.target_number.max_number = config.target_number.max_number || 10_000;
break;
}
break;
case 'kctf':
config.algorithm = body.data.algorithm;
config.kctf = config.kctf || {};
config.kctf.difficulty = config.kctf.difficulty || 100;
break;
}
return {
message: `Algorithm set to ${config.algorithm}`
};
});

74
example-app/server/api/pow/challenge.get.ts
View File

@@ -1,34 +1,58 @@
import { defineEventHandler } from 'h3'
import { config } from '~~/server/utils/config';
import { generate_challenge } from '@impost/lib/validator';
import { ChallengeStrategy } from '@impost/lib';
import { generate_challenge, kCTFChallengeConfig, Argon2ChallengeConfig, SHA256ChallengeConfig } from '@impost/lib/validator';
import { ChallengeStrategy, ChallengeAlgorithm } from '@impost/lib';
import { CHALLENGE_TIMEOUT_MS, outstandingChallenges } from '~~/server/utils/pow';
export default defineEventHandler(async () => {
let challenge_config;
// switch (config.strategy) {
// case ChallengeStrategy.LeadingZeroes:
// challenge_config = {
// parameters: { expires_at: CHALLENGE_TIMEOUT_MS },
// strategy: config.strategy,
// difficulty: config.leading_zeroes?.difficulty!,
// };
// break;
// case ChallengeStrategy.TargetNumber:
// challenge_config = {
// parameters: { expires_at: CHALLENGE_TIMEOUT_MS },
// strategy: config.strategy,
// max_number: config.target_number.max_number,
// };
// break;
// }
switch (config.algorithm) {
case ChallengeAlgorithm.SHA256:
switch (config.strategy) {
case ChallengeStrategy.kCTF:
case ChallengeStrategy.LeadingZeroes:
challenge_config = {
parameters: { expires_at: CHALLENGE_TIMEOUT_MS },
strategy: config.strategy,
algorithm: ChallengeAlgorithm.SHA256,
strategy: ChallengeStrategy.LeadingZeroes,
difficulty: config.leading_zeroes.difficulty,
parameters: { expires_at: Date.now() + CHALLENGE_TIMEOUT_MS },
} as SHA256ChallengeConfig;
break;
case ChallengeStrategy.TargetNumber:
challenge_config = {
algorithm: ChallengeAlgorithm.SHA256,
strategy: ChallengeStrategy.TargetNumber,
difficulty: config.target_number.max_number,
parameters: { expires_at: Date.now() + CHALLENGE_TIMEOUT_MS },
} as SHA256ChallengeConfig;
break;
}
break;
case ChallengeAlgorithm.Argon2:
switch (config.strategy) {
case ChallengeStrategy.LeadingZeroes:
challenge_config = {
algorithm: ChallengeAlgorithm.Argon2,
strategy: ChallengeStrategy.LeadingZeroes,
difficulty: config.leading_zeroes.difficulty,
parameters: { expires_at: Date.now() + CHALLENGE_TIMEOUT_MS },
} as Argon2ChallengeConfig;
break;
case ChallengeStrategy.TargetNumber:
challenge_config = {
algorithm: ChallengeAlgorithm.Argon2,
strategy: ChallengeStrategy.TargetNumber,
difficulty: config.target_number.max_number,
parameters: { expires_at: Date.now() + CHALLENGE_TIMEOUT_MS },
} as Argon2ChallengeConfig;
break;
}
break;
case ChallengeAlgorithm.kCTF:
challenge_config = {
algorithm: ChallengeAlgorithm.kCTF,
difficulty: config.kctf.difficulty,
};
parameters: { expires_at: Date.now() + CHALLENGE_TIMEOUT_MS },
} as kCTFChallengeConfig;
break;
}
@@ -40,10 +64,10 @@ export default defineEventHandler(async () => {
});
}
outstandingChallenges.set(challenge.challenge, {
outstandingChallenges.set(challenge.salt, {
challenge, timeout: setTimeout(() => {
console.log("Challenge timed out:", challenge.challenge);
outstandingChallenges.delete(challenge.challenge);
console.log("Challenge timed out:", challenge.salt);
outstandingChallenges.delete(challenge.salt);
}, CHALLENGE_TIMEOUT_MS)
});

14
example-app/server/api/pow/challenge.post.ts
View File

@@ -4,13 +4,13 @@ import * as z from 'zod';
import { outstandingChallenges } from '~~/server/utils/pow';
const challengeSchema = z.object({
challenge: z.string().startsWith("s."),
solution: z.string().startsWith("s.")
salt: z.string(),
// either a string if the algorithm is kCTF, or a number if the algorithm is Argon2 or SHA256
solution: z.string().or(z.number()),
})
// post handler that takes in the challenge, and the nonce
export default defineEventHandler(async (event) => {
console.log(await readBody(event));
const body = await readValidatedBody(event, challengeSchema.safeParse);
if (!body.success) {
@@ -20,9 +20,9 @@ export default defineEventHandler(async (event) => {
})
}
let { challenge, solution } = body.data;
let { salt, solution } = body.data;
const outstanding_challenge = outstandingChallenges.get(challenge);
const outstanding_challenge = outstandingChallenges.get(salt);
if (outstanding_challenge === undefined) {
throw createError({
statusCode: 400,
@@ -37,8 +37,8 @@ export default defineEventHandler(async (event) => {
if (challenge_valid) {
// clear the challenge
clearTimeout(outstandingChallenges.get(challenge)!.timeout);
outstandingChallenges.delete(challenge);
clearTimeout(outstandingChallenges.get(salt)!.timeout);
outstandingChallenges.delete(salt);
return {
message: 'Challenge solved'

12
example-app/server/api/pow/difficulty.get.ts
View File

@@ -1,9 +1,14 @@
import { defineEventHandler } from 'h3'
import { ChallengeStrategy } from '@impost/lib';
import { ChallengeStrategy, ChallengeAlgorithm } from '@impost/lib';
export default defineEventHandler((event) => {
let difficulty: number;
console.log("CONFIG", config);
switch (config.algorithm) {
case ChallengeAlgorithm.SHA256:
case ChallengeAlgorithm.Argon2:
switch (config.strategy) {
case ChallengeStrategy.LeadingZeroes:
difficulty = config.leading_zeroes.difficulty!;
@@ -12,6 +17,11 @@ export default defineEventHandler((event) => {
difficulty = config.target_number.max_number!;
break;
}
break;
case ChallengeAlgorithm.kCTF:
difficulty = config.kctf.difficulty!;
break;
}
return {
difficulty

12
example-app/server/api/pow/difficulty.put.ts
View File

@@ -1,11 +1,14 @@
import { defineEventHandler } from 'h3'
import { ChallengeStrategy } from '@impost/lib';
import { ChallengeStrategy, ChallengeAlgorithm } from '@impost/lib';
export default defineEventHandler(async (event) => {
const body = await readBody(event)
let difficulty = body.difficulty;
switch (config.algorithm) {
case ChallengeAlgorithm.SHA256:
case ChallengeAlgorithm.Argon2:
switch (config.strategy) {
case ChallengeStrategy.LeadingZeroes:
if (!difficulty || difficulty < 1 || difficulty > 64) {
@@ -28,8 +31,13 @@ export default defineEventHandler(async (event) => {
config.target_number.max_number = difficulty;
break;
}
break;
case ChallengeAlgorithm.kCTF:
config.kctf.difficulty = difficulty;
break;
}
return {
message: 'Challenge difficulty set'
message: `Challenge difficulty set to ${difficulty}`
};
});

35
example-app/server/api/pow/index.get.ts Normal file
View File

@@ -0,0 +1,35 @@
import { ChallengeAlgorithm } from '@impost/lib';
import { defineEventHandler } from 'h3'
export default defineEventHandler((event) => {
let difficulty: number;
switch (config.algorithm) {
case ChallengeAlgorithm.SHA256:
case ChallengeAlgorithm.Argon2:
switch (config.strategy) {
case 'leading_zeroes':
difficulty = config.leading_zeroes.difficulty!;
break;
case 'target_number':
difficulty = config.target_number.max_number!;
break;
}
break;
case ChallengeAlgorithm.kCTF:
difficulty = config.kctf.difficulty!;
break;
default:
throw createError({
statusCode: 500,
statusMessage: 'Unknown algorithm',
})
break;
}
return {
difficulty,
algorithm: config.algorithm,
strategy: config.strategy || undefined,
}
})

14
example-app/server/api/pow/strategy.get.ts Normal file
View File

@@ -0,0 +1,14 @@
import { defineEventHandler } from "h3";
import { ChallengeAlgorithm } from "@impost/lib";
export default defineEventHandler(async (event) => {
if (config.algorithm === ChallengeAlgorithm.kCTF) {
return {
strategy: undefined,
}
}
return {
strategy: config.strategy,
}
});

43
example-app/server/api/pow/strategy.put.ts Normal file
View File

@@ -0,0 +1,43 @@
import { defineEventHandler } from 'h3'
import { ChallengeAlgorithm, ChallengeStrategy } from '@impost/lib';
import * as z from 'zod';
const strategySchema = z.object({
strategy: z.enum(ChallengeStrategy),
});
export default defineEventHandler(async (event) => {
const body = await readValidatedBody(event, strategySchema.safeParse);
if (!body.success) {
throw createError({
statusCode: 400,
statusMessage: 'Validation failed'
})
}
switch (config.algorithm) {
case ChallengeAlgorithm.SHA256:
case ChallengeAlgorithm.Argon2:
config.strategy = body.data.strategy;
switch (config.strategy) {
case ChallengeStrategy.LeadingZeroes:
config.leading_zeroes = config.leading_zeroes || {};
config.leading_zeroes.difficulty = config.leading_zeroes.difficulty || 4;
break;
case ChallengeStrategy.TargetNumber:
config.target_number = config.target_number || {};
config.target_number.max_number = config.target_number.max_number || 10_000;
break;
}
break;
case ChallengeAlgorithm.kCTF:
return {
message: "Strategy cannot be set for kCTF"
}
}
return {
message: `Strategy set to ${config.strategy}`
};
});

56
example-app/server/utils/config.ts
View File

@@ -1,34 +1,52 @@
import { readFileSync } from 'fs';
import { load } from 'js-toml';
import z from 'zod';
import { ChallengeStrategy } from "@impost/lib";
import { ChallengeAlgorithm, ChallengeStrategy } from "@impost/lib";
// const LeadingZeroesSchema = z.object({
// strategy: z.literal(ChallengeStrategy.LeadingZeroes),
// leading_zeroes: z.object({
// difficulty: z.number().int().min(1).max(64),
// }),
// });
const SHA256Schema = z.discriminatedUnion("strategy", [
z.object({
algorithm: z.literal(ChallengeAlgorithm.SHA256),
strategy: z.literal(ChallengeStrategy.LeadingZeroes),
leading_zeroes: z.object({
difficulty: z.number().int().min(1).max(64),
}),
}),
z.object({
algorithm: z.literal(ChallengeAlgorithm.SHA256),
strategy: z.literal(ChallengeStrategy.TargetNumber),
target_number: z.object({
max_number: z.number().int().min(1).max(100_000),
}),
}),
]);
// const TargetNumberSchema = z.object({
// strategy: z.literal(ChallengeStrategy.TargetNumber),
// target_number: z.object({
// max_number: z.number().int().min(1).max(100_000),
// }),
// });
const Argon2Schema = z.discriminatedUnion("strategy", [
z.object({
algorithm: z.literal(ChallengeAlgorithm.Argon2),
strategy: z.literal(ChallengeStrategy.LeadingZeroes),
leading_zeroes: z.object({
difficulty: z.number().int().min(1).max(64),
}),
}),
z.object({
algorithm: z.literal(ChallengeAlgorithm.Argon2),
strategy: z.literal(ChallengeStrategy.TargetNumber),
target_number: z.object({
max_number: z.number().int().min(1).max(100_000),
}),
}),
]);
const kCTFSchema = z.object({
strategy: z.literal(ChallengeStrategy.kCTF),
const KCTFSchema = z.object({
algorithm: z.literal(ChallengeAlgorithm.kCTF),
kctf: z.object({
difficulty: z.number().int().min(1),
}),
});
export type Config = z.infer<typeof Config>;
export const Config = z.union([SHA256Schema, Argon2Schema, KCTFSchema]);
export const Config = z.discriminatedUnion('strategy', [
kCTFSchema,
]);
export type Config = z.infer<typeof Config>;
export let config: Config;

67
packages/lib/src/index.ts
View File

@@ -1,44 +1,69 @@
import { UUID } from "uuidv7";
export enum ChallengeAlgorithm {
Argon2id = "argon2id",
SHA256 = "sha256",
Argon2 = "argon2",
kCTF = "kctf",
}
export function algorithmToInt(algorithm: ChallengeAlgorithm): number {
switch (algorithm) {
case ChallengeAlgorithm.SHA256:
return 0;
case ChallengeAlgorithm.Argon2:
return 1;
case ChallengeAlgorithm.kCTF:
return 2;
}
}
export enum ChallengeStrategy {
kCTF = "kctf",
Null = "null",
LeadingZeroes = "leading_zeroes",
TargetNumber = "target_number",
}
export function strategyToInt(strategy: ChallengeStrategy): number {
switch (strategy) {
case ChallengeStrategy.Null:
return 0;
case ChallengeStrategy.LeadingZeroes:
return 1;
case ChallengeStrategy.TargetNumber:
return 2;
}
}
// In this case, the client will repeatedly hash a number with has until it
// finds a hash thaat starts with *difficulty* leading zeroes
// export interface ChallengeLeadingZeroes {
// algorithm: ChallengeAlgorithm;
// strategy: ChallengeStrategy.LeadingZeroes;
// salt: string; // random string
// difficulty: number;
// }
export interface ChallengeLeadingZeroes {
algorithm: ChallengeAlgorithm.SHA256 | ChallengeAlgorithm.Argon2;
strategy: ChallengeStrategy.LeadingZeroes;
salt: string; // random string
difficulty: number;
}
// // In this case, the server generates a random number, and the client will hash
// // the salt (a random string) + a random number until it finds a hash that is equal to challenge
// export interface ChallengeTargetNumber {
// algorithm: ChallengeAlgorithm;
// strategy: ChallengeStrategy.TargetNumber;
// salt: string; // random string
// target: string; // hash of salt + random number
// }
// In this case, the server generates a random number, and the client will hash
// the salt (a random string) + a random number until it finds a hash that is equal to challenge
export interface ChallengeTargetNumber {
algorithm: ChallengeAlgorithm.SHA256 | ChallengeAlgorithm.Argon2;
strategy: ChallengeStrategy.TargetNumber;
salt: string; // random string
target: string; // hash of salt + random number
}
export interface InnerChallengekCTF {
strategy: ChallengeStrategy.kCTF;
algorithm: ChallengeAlgorithm.kCTF;
salt: UUID; // UUIDv7
difficulty: number;
}
export interface ChallengekCTF {
strategy: ChallengeStrategy.kCTF;
challenge: string;
algorithm: ChallengeAlgorithm.kCTF;
salt: string;
difficulty: number;
}
export type InnerChallenge = InnerChallengekCTF;
export type InnerChallenge = InnerChallengekCTF | ChallengeLeadingZeroes | ChallengeTargetNumber;
export type Challenge = ChallengekCTF;
export type Challenge = ChallengekCTF | ChallengeLeadingZeroes | ChallengeTargetNumber;

107
packages/lib/src/solver.ts
View File

@@ -1,12 +1,10 @@
import { ChallengeAlgorithm, ChallengeStrategy, algorithmToInt, strategyToInt } from "./index";
import WASMSolverUrl from '../../../solver/zig-out/bin/solver.wasm?url&inline';
type WasmExports = Record<string, Function> & {
"malloc": (byte_count: number) => number | null;
"free": (ptr: number | null, byte_count: number) => void;
// "solve_leaading_zeroes_challenge": (challenge_ptr: number, challenge_len: number, difficulty: number) => number;
// "solve_target_number_challenge": (challenge_ptr: number, challenge_len: number, target_ptr: number, target_len:
// number) => number;
"solve": (value_ptr: number, value_len: number) => number,
"solve": (algorithm: number, strategy: number, salt_ptr: number, salt_len: number, difficulty: number, target_ptr: number, target_len: number) => number,
"memory": WebAssembly.Memory;
}
@@ -32,35 +30,100 @@ export async function init_solver(env: SolverEnv, module: WebAssembly.Module): P
}) as unknown as SolverModule;
}
export function solve(solver: SolverModule, challenge: string): string {
console.log(challenge);
type Argon2LeadingZeroesParams = {
name: ChallengeAlgorithm.Argon2;
strategy: ChallengeStrategy.LeadingZeroes;
salt: string;
difficulty: number;
};
type Argon2TargetNumberParams = {
name: ChallengeAlgorithm.Argon2;
strategy: ChallengeStrategy.TargetNumber;
salt: string;
target: string;
};
type Argon2Params = Argon2LeadingZeroesParams | Argon2TargetNumberParams;
type SHA256LeadingZeroesParams = {
name: ChallengeAlgorithm.SHA256;
strategy: ChallengeStrategy.LeadingZeroes;
salt: string;
difficulty: number;
};
type SHA256TargetNumberParams = {
name: ChallengeAlgorithm.SHA256;
strategy: ChallengeStrategy.TargetNumber;
salt: string;
target: string;
};
type SHA256Params = SHA256LeadingZeroesParams | SHA256TargetNumberParams;
type KCTFParams = {
name: ChallengeAlgorithm.kCTF;
strategy: ChallengeStrategy.Null;
salt: string;
difficulty: number;
};
export type SolveParams = Argon2Params | SHA256Params | KCTFParams;
export function solve(solver: SolverModule, algorithm: SolveParams): string | number {
if (algorithm.name === ChallengeAlgorithm.kCTF) {
algorithm.salt = algorithm.salt.split("?")[0];
}
const encoder = new TextEncoder();
const challenge_buf = encoder.encode(challenge);
let salt_buf = encoder.encode(algorithm.salt);
const challenge_ptr = solver.exports.malloc(challenge_buf.length);
if (challenge_ptr === 0 || challenge_ptr === null) {
let salt_ptr = solver.exports.malloc(salt_buf.length);
if (salt_ptr === 0 || salt_ptr === null) {
throw new Error("Failed to allocate memory for challenge string");
}
const memory = new Uint8Array(solver.exports.memory.buffer);
memory.set(challenge_buf, challenge_ptr);
let memory = new Uint8Array(solver.exports.memory.buffer);
memory.set(salt_buf, salt_ptr);
const ret = solver.exports.solve(challenge_ptr, challenge_buf.length);
let ret: string | number;
switch (algorithm.name) {
case ChallengeAlgorithm.SHA256:
case ChallengeAlgorithm.Argon2:
switch (algorithm.strategy) {
case ChallengeStrategy.LeadingZeroes: {
ret = solver.exports.solve(algorithmToInt(algorithm.name), strategyToInt(ChallengeStrategy.LeadingZeroes), salt_ptr, salt_buf.length, algorithm.difficulty, 0, 0);
break;
}
case ChallengeStrategy.TargetNumber: {
const target_buf = encoder.encode(algorithm.target);
const target_ptr = solver.exports.malloc(target_buf.length);
if (target_ptr === 0 || target_ptr === null) {
throw new Error("Failed to allocate memory for target string");
}
console.log("RET", ret);
memory = new Uint8Array(solver.exports.memory.buffer);
memory.set(target_buf, target_ptr);
if (ret <= 0) {
ret = solver.exports.solve(algorithmToInt(algorithm.name), strategyToInt(ChallengeStrategy.TargetNumber), salt_ptr, salt_buf.length, 0, target_ptr, target_buf.length);
break;
}
}
break;
case ChallengeAlgorithm.kCTF:
const solution_ptr = solver.exports.solve(algorithmToInt(ChallengeAlgorithm.kCTF), strategyToInt(ChallengeStrategy.Null), salt_ptr, salt_buf.length, algorithm.difficulty, 0, 0);
if (solution_ptr <= 0) {
throw new Error("Failed to solve challenge");
}
const length = new DataView(solver.exports.memory.buffer, ret, 2).getUint16(0, true);
const solution = new TextDecoder().decode(solver.exports.memory.buffer.slice(ret + 2, ret + 2 + length));
const length = new DataView(solver.exports.memory.buffer, solution_ptr, 2).getUint16(0, true);
ret = new TextDecoder().decode(solver.exports.memory.buffer.slice(solution_ptr + 2, solution_ptr + 2 + length));
console.log("SOLUTION", solution);
console.log("LENGTH", length);
solver.exports.free(ret, 2 + length);
return solution;
solver.exports.free(solution_ptr, 2 + length);
break;
}
return ret;
}

266
packages/lib/src/validator.ts
View File

@@ -1,11 +1,12 @@
import { ChallengeStrategy, type Challenge, type InnerChallenge } from '.';
import { ChallengeStrategy, type Challenge, type InnerChallenge, ChallengeAlgorithm, algorithmToInt, strategyToInt } from '.';
import WASMValidatorUrl from '../../../solver/zig-out/bin/validator.wasm?url&inline';
import { uuidv7obj } from 'uuidv7';
type WasmExports = Record<string, Function> & {
"malloc": (byte_count: number) => number | null;
"free": (ptr: number | null, byte_count: number) => void;
"validate": (challenge_ptr: number, challenge_len: number, solution_ptr: number, solution_len: number) => boolean;
"validate": (algorithm: number, strategy: number, challenge_ptr: number, challenge_len: number, solution_ptr: number, solution_len: number, nonce: number, difficulty: number) => boolean;
"hash": (challenge_ptr: number, challebge_len: number, nonce_ptr: number, nonce_len: number, algorithm: number) => bigint;
"memory": WebAssembly.Memory;
}
@@ -22,31 +23,81 @@ function array_to_base64(buffer: ArrayBufferLike): string {
return btoa(binary);
}
export interface kCTFChallengeConfig {
parameters: Object;
strategy: ChallengeStrategy.kCTF;
export interface SHA256ChallengeConfig {
algorithm: ChallengeAlgorithm.SHA256;
strategy: ChallengeStrategy.LeadingZeroes | ChallengeStrategy.TargetNumber;
difficulty: number;
parameters: Object;
}
export type ChallengeConfig = kCTFChallengeConfig;
const VERSION = "s";
async function encode_challenge(challenge: InnerChallenge, parameters: Object = {}): Promise<string> {
if (challenge.strategy !== ChallengeStrategy.kCTF) {
throw new Error("Unsupported challenge strategy");
export interface Argon2ChallengeConfig {
algorithm: ChallengeAlgorithm.Argon2;
strategy: ChallengeStrategy.LeadingZeroes | ChallengeStrategy.TargetNumber;
difficulty: number;
parameters: Object;
}
if (challenge.difficulty < 1) {
throw new Error("Difficulty must be at least 1");
export interface kCTFChallengeConfig {
algorithm: ChallengeAlgorithm.kCTF;
difficulty: number;
parameters: Object;
}
const difficulty_buf = new Uint8Array(4);
const view = new DataView(difficulty_buf.buffer);
view.setUint32(0, challenge.difficulty, false);
export type ChallengeConfig = kCTFChallengeConfig | SHA256ChallengeConfig | Argon2ChallengeConfig;
const difficulty_str = array_to_base64(difficulty_buf.buffer);
const salt_str = array_to_base64(challenge.salt.bytes.buffer);
async function encode_challenge(inner_challenge: InnerChallenge, parameters: Object = {}): Promise<Challenge> {
let challenge: Challenge = {} as Challenge;
switch (inner_challenge.algorithm) {
case ChallengeAlgorithm.SHA256: {
challenge.algorithm = ChallengeAlgorithm.SHA256;
challenge.salt = inner_challenge.salt;
switch (inner_challenge.strategy) {
case ChallengeStrategy.LeadingZeroes: {
// @ts-ignore
challenge.strategy = ChallengeStrategy.LeadingZeroes;
// @ts-ignore
challenge.difficulty = inner_challenge.difficulty;
break;
}
case ChallengeStrategy.TargetNumber: {
// @ts-ignore
challenge.strategy = ChallengeStrategy.TargetNumber;
// @ts-ignore
challenge.target = inner_challenge.target;
break;
}
}
break;
}
case ChallengeAlgorithm.Argon2: {
challenge.algorithm = ChallengeAlgorithm.Argon2;
challenge.salt = inner_challenge.salt;
switch (inner_challenge.strategy) {
case ChallengeStrategy.LeadingZeroes: {
// @ts-ignore
challenge.strategy = ChallengeStrategy.LeadingZeroes;
// @ts-ignore
challenge.difficulty = inner_challenge.difficulty;
break;
}
case ChallengeStrategy.TargetNumber: {
// @ts-ignore
challenge.strategy = ChallengeStrategy.TargetNumber;
// @ts-ignore
challenge.target = inner_challenge.target;
break;
}
}
break;
}
case ChallengeAlgorithm.kCTF: {
// @ts-ignore
challenge.difficulty = inner_challenge.difficulty;
challenge.algorithm = ChallengeAlgorithm.kCTF;
challenge.salt = array_to_base64(inner_challenge.salt.bytes.buffer);
break;
}
}
// the parameters str is expected to be sliced out of the challenge via the widget before it sends it to the wasm solver.
let parameters_str = Object.entries(parameters).map(([key, value]) => `${key}=${value}`).join("&");
@@ -54,7 +105,9 @@ async function encode_challenge(challenge: InnerChallenge, parameters: Object =
parameters_str = "?" + parameters_str;
}
return `${VERSION}.${difficulty_str}.${salt_str}${parameters_str}`;
challenge.salt = challenge.salt + parameters_str;
return challenge;
}
export async function generate_challenge(config: ChallengeConfig): Promise<Challenge | null> {
@@ -62,43 +115,180 @@ export async function generate_challenge(config: ChallengeConfig): Promise<Chall
throw new Error("Difficulty must be at least 1");
}
const challenge: InnerChallenge = {
strategy: ChallengeStrategy.kCTF,
salt: uuidv7obj(),
difficulty: config.difficulty,
const validator = (await WebAssembly.instantiateStreaming(fetch(WASMValidatorUrl), {
env: {
__log: (str_ptr: number, str_len: number) => console.log(new TextDecoder().decode(new Uint8Array(validator.exports.memory.buffer, str_ptr, str_len))),
}
})).instance as unknown as ValidatorModule;
const encoder = new TextEncoder();
var inner_challenge: InnerChallenge = {
algorithm: config.algorithm,
} as InnerChallenge;
let salt = `${array_to_base64(crypto.getRandomValues(new Uint8Array(32)).buffer)}`;
let parameters_str: string;
switch (config.algorithm) {
case ChallengeAlgorithm.SHA256:
case ChallengeAlgorithm.Argon2:
switch (config.strategy) {
case ChallengeStrategy.LeadingZeroes:
if (config.difficulty < 1 || config.difficulty > 64) {
throw new Error("Invalid difficulty for leading zeroes strategy");
}
return {
strategy: ChallengeStrategy.kCTF,
challenge: await encode_challenge(challenge),
};
// @ts-ignore
inner_challenge.strategy = ChallengeStrategy.LeadingZeroes;
// @ts-ignore
inner_challenge.difficulty = config.difficulty;
parameters_str = Object.entries(config.parameters).map(([key, value]) => `${key}=${value}`).join("&");
if (parameters_str.length > 0) {
parameters_str = "?" + parameters_str;
}
inner_challenge.salt = salt + parameters_str;
config.parameters = {};
break;
case ChallengeStrategy.TargetNumber:
if (config.difficulty < 1) {
throw new Error("Difficulty must be at least 1");
}
export async function validate_challenge(challenge: Challenge, challenge_solution: string): Promise<boolean> {
// @ts-ignore
inner_challenge.strategy = ChallengeStrategy.TargetNumber;
parameters_str = Object.entries(config.parameters).map(([key, value]) => `${key}=${value}`).join("&");
if (parameters_str.length > 0) {
parameters_str = "?" + parameters_str;
}
inner_challenge.salt = salt + parameters_str;
config.parameters = {};
const random_number = Math.floor(Math.random() * config.difficulty).toString();
console.log("RANDOM NUMBER", random_number);
const challenge_buf = encoder.encode(inner_challenge.salt + random_number);
const challenge_ptr = validator.exports.malloc(challenge_buf.length);
if (challenge_ptr === 0 || challenge_ptr === null) {
console.error("Failed to allocate memory for challenge string");
return null;
}
const memory = new Uint8Array(validator.exports.memory.buffer);
memory.set(challenge_buf, challenge_ptr);
const challenge_len = inner_challenge.salt.length;
const nonce_ptr = challenge_ptr + challenge_len;
const nonce_len = challenge_buf.length - challenge_len;
const target = validator.exports.hash(challenge_ptr, challenge_len, nonce_ptr, nonce_len, algorithmToInt(inner_challenge.algorithm));
const target_len = Number((target >> 32n) & 0xFFFFFFFFn);
const target_ptr = Number(target & 0xFFFFFFFFn);
const target_buf = new Uint8Array(validator.exports.memory.buffer, target_ptr, target_len);
// @ts-ignore
inner_challenge.target = new TextDecoder().decode(target_buf);
// @ts-ignore
console.log("TARGET", inner_challenge.target);
validator.exports.free(challenge_ptr, challenge_len + random_number.length);
validator.exports.free(target_ptr, target_len);
break;
}
break;
case ChallengeAlgorithm.kCTF:
if (config.difficulty < 1) {
throw new Error("Difficulty must be at least 1");
}
inner_challenge.salt = uuidv7obj();
// @ts-ignore
inner_challenge.difficulty = config.difficulty;
break;
}
return await encode_challenge(inner_challenge, config.parameters);
}
export async function validate_challenge(challenge: Challenge, challenge_solution: string | number): Promise<boolean> {
const validator = (await WebAssembly.instantiateStreaming(fetch(WASMValidatorUrl), {
env: {
__log: (str_ptr: number, str_len: number) => console.log(new TextDecoder().decode(new Uint8Array(validator.exports.memory.buffer, str_ptr, str_len))),
}
})).instance as unknown as ValidatorModule
const encoder = new TextEncoder();
const challenge_buf = encoder.encode(challenge.challenge);
const solution_buf = encoder.encode(challenge_solution);
if (challenge.algorithm === ChallengeAlgorithm.kCTF) {
challenge.salt = challenge.salt.split("?")[0];
}
const challenge_buf = encoder.encode(challenge.salt);
const challenge_ptr = validator.exports.malloc(challenge_buf.length);
const solution_ptr = validator.exports.malloc(solution_buf.length);
if (challenge_ptr === 0 || challenge_ptr === null || solution_ptr === 0 || solution_ptr === null) {
if (challenge_ptr === 0 || challenge_ptr === null) {
console.error("Failed to allocate memory for challenge string");
return false;
}
const memory = new Uint8Array(validator.exports.memory.buffer);
memory.set(challenge_buf, challenge_ptr);
switch (challenge.algorithm) {
case ChallengeAlgorithm.SHA256:
if (typeof challenge_solution === "string") {
throw new Error("Argon2 challenges do not support a solution as a number");
}
switch (challenge.strategy) {
case ChallengeStrategy.LeadingZeroes:
return validator.exports.validate(algorithmToInt(challenge.algorithm), strategyToInt(challenge.strategy), challenge_ptr, challenge_buf.length, 0, 0, challenge_solution, challenge.difficulty);
case ChallengeStrategy.TargetNumber:
const solution_buf = encoder.encode(challenge.target);
const solution_ptr = validator.exports.malloc(solution_buf.length);
if (solution_ptr === 0 || solution_ptr === null) {
console.error("Failed to allocate memory for challenge string");
return false;
}
const memory = new Uint8Array(validator.exports.memory.buffer);
memory.set(solution_buf, solution_ptr);
const is_valid = validator.exports.validate(challenge_ptr, challenge.challenge.length, solution_ptr, challenge_solution.length);
validator.exports.free(challenge_ptr, challenge.challenge.length);
validator.exports.free(solution_ptr, challenge_solution.length);
return is_valid;
return validator.exports.validate(algorithmToInt(challenge.algorithm), strategyToInt(challenge.strategy), challenge_ptr, challenge_buf.length, solution_ptr, solution_buf.length, challenge_solution, 0);
}
case ChallengeAlgorithm.Argon2:
if (typeof challenge_solution === "string") {
throw new Error("Argon2 challenges do not support a solution as a number");
}
switch (challenge.strategy) {
case ChallengeStrategy.LeadingZeroes:
return validator.exports.validate(algorithmToInt(challenge.algorithm), strategyToInt(challenge.strategy), challenge_ptr, challenge_buf.length, 0, 0, challenge_solution, challenge.difficulty);
case ChallengeStrategy.TargetNumber:
const solution_buf = encoder.encode(challenge.target);
const solution_ptr = validator.exports.malloc(solution_buf.length);
if (solution_ptr === 0 || solution_ptr === null) {
console.error("Failed to allocate memory for challenge string");
return false;
}
const memory = new Uint8Array(validator.exports.memory.buffer);
memory.set(solution_buf, solution_ptr);
return validator.exports.validate(algorithmToInt(challenge.algorithm), strategyToInt(challenge.strategy), challenge_ptr, challenge_buf.length, solution_ptr, solution_buf.length, challenge_solution, 0);
}
case ChallengeAlgorithm.kCTF:
if (typeof challenge_solution === "number") {
throw new Error("KCTF challenges do not support a solution as a number");
}
const solution_buf = encoder.encode(challenge_solution);
const solution_ptr = validator.exports.malloc(solution_buf.length);
if (solution_ptr === 0 || solution_ptr === null) {
console.error("Failed to allocate memory for challenge string");
return false;
}
const memory = new Uint8Array(validator.exports.memory.buffer);
memory.set(solution_buf, solution_ptr);
return validator.exports.validate(algorithmToInt(challenge.algorithm), 0, challenge_ptr, challenge_buf.length, solution_ptr, solution_buf.length, 0, challenge.difficulty);
}
}

142
packages/widget/src/pow-captcha.ts
View File

@@ -1,7 +1,7 @@
import { LitElement, html, css, isServer, type PropertyValues } from 'lit';
import { customElement, property, state } from 'lit/decorators.js';
import { type ChallengeSolveRequest, type SolutionMessage, WorkerMessageType, type WorkerRequest, WorkerResponseType } from './types/worker';
import { type Challenge, ChallengeStrategy } from '@impost/lib';
import { type Challenge, ChallengeStrategy, ChallengeAlgorithm } from '@impost/lib';
import { get_wasm_module } from '@impost/lib/solver';
import ChallengeWorker from './solver-worker?worker&inline';
@@ -109,6 +109,9 @@ export class PowCaptcha extends LitElement {
this.initWorkers();
this.addEventListener('reset', (ev) => this.reset(ev as CustomEvent));
this.addEventListener('solve', () => this.solveChallenge());
switch (this.auto) {
case 'onload':
this.solveChallenge();
@@ -139,6 +142,19 @@ export class PowCaptcha extends LitElement {
}
}
reset(ev: CustomEvent) {
this.challengejson = JSON.stringify(ev.detail.challenge);
this.challengeData = null;
this.status = 'unsolved';
this.solution = '';
console.log("received reset event");
this.fetchChallenge();
console.log(this.challengeData);
}
getCurrentWorkingNonce() {
return Atomics.load(new Uint32Array(this.sab), 0);
}
@@ -172,15 +188,11 @@ export class PowCaptcha extends LitElement {
async initWorkers() {
this.solverWorkers = [];
const num_workers = 1;
const num_workers = navigator.hardwareConcurrency || 4;
for (let i = 0; i < num_workers; i++) {
this.solverWorkers.push(new ChallengeWorker());
}
const atomics_view = new Int32Array(this.sab);
Atomics.store(atomics_view, 0, 0);
Atomics.store(atomics_view, 1, 0);
let wasm_module = await get_wasm_module();
let worker_promises: Promise<void>[] = [];
for (let i = 0; i < this.solverWorkers.length; i++) {
@@ -275,11 +287,52 @@ export class PowCaptcha extends LitElement {
// } as WorkerRequest);
// break;
// }
switch (request.algorithm) {
case ChallengeAlgorithm.SHA256:
switch (request.strategy) {
case ChallengeStrategy.kCTF:
case ChallengeStrategy.LeadingZeroes:
worker.postMessage({
strategy: ChallengeStrategy.kCTF,
challenge: request.challenge,
algorithm: ChallengeAlgorithm.SHA256,
strategy: ChallengeStrategy.LeadingZeroes,
salt: request.salt,
difficulty: request.difficulty,
} as WorkerRequest);
break;
case ChallengeStrategy.TargetNumber:
worker.postMessage({
algorithm: ChallengeAlgorithm.SHA256,
strategy: ChallengeStrategy.TargetNumber,
target: request.target,
salt: request.salt,
} as WorkerRequest);
break;
}
break;
case ChallengeAlgorithm.Argon2:
switch (request.strategy) {
case ChallengeStrategy.LeadingZeroes:
worker.postMessage({
algorithm: ChallengeAlgorithm.Argon2,
strategy: ChallengeStrategy.LeadingZeroes,
salt: request.salt,
difficulty: request.difficulty,
} as WorkerRequest);
break;
case ChallengeStrategy.TargetNumber:
worker.postMessage({
algorithm: ChallengeAlgorithm.Argon2,
strategy: ChallengeStrategy.TargetNumber,
target: request.target,
salt: request.salt,
} as WorkerRequest);
break;
}
break;
case ChallengeAlgorithm.kCTF:
worker.postMessage({
algorithm: ChallengeAlgorithm.kCTF,
salt: request.salt,
difficulty: request.difficulty,
} as WorkerRequest);
break;
}
@@ -313,27 +366,52 @@ export class PowCaptcha extends LitElement {
let request: ChallengeSolveRequest;
// switch (this.challengeData.strategy) {
// case ChallengeStrategy.LeadingZeroes:
// request = {
// strategy: ChallengeStrategy.LeadingZeroes,
// salt: this.challengeData.salt,
// difficulty: this.challengeData.difficulty,
// };
// break;
// case ChallengeStrategy.TargetNumber:
// request = {
// strategy: ChallengeStrategy.TargetNumber,
// target: this.challengeData.target,
// salt: this.challengeData.salt,
// };
// break;
// }
switch (this.challengeData.algorithm) {
case ChallengeAlgorithm.SHA256:
switch (this.challengeData.strategy) {
case ChallengeStrategy.kCTF:
case ChallengeStrategy.LeadingZeroes:
request = {
strategy: ChallengeStrategy.kCTF,
challenge: this.challengeData.challenge,
algorithm: ChallengeAlgorithm.SHA256,
strategy: ChallengeStrategy.LeadingZeroes,
salt: this.challengeData.salt,
difficulty: this.challengeData.difficulty,
};
break;
case ChallengeStrategy.TargetNumber:
request = {
algorithm: ChallengeAlgorithm.SHA256,
strategy: ChallengeStrategy.TargetNumber,
target: this.challengeData.target,
salt: this.challengeData.salt,
};
break;
}
break;
case ChallengeAlgorithm.Argon2:
switch (this.challengeData.strategy) {
case ChallengeStrategy.LeadingZeroes:
request = {
algorithm: ChallengeAlgorithm.Argon2,
strategy: ChallengeStrategy.LeadingZeroes,
salt: this.challengeData.salt,
difficulty: this.challengeData.difficulty,
};
break;
case ChallengeStrategy.TargetNumber:
request = {
algorithm: ChallengeAlgorithm.Argon2,
strategy: ChallengeStrategy.TargetNumber,
target: this.challengeData.target,
salt: this.challengeData.salt,
};
break;
}
break;
case ChallengeAlgorithm.kCTF:
request = {
algorithm: ChallengeAlgorithm.kCTF,
salt: this.challengeData.salt,
difficulty: this.challengeData.difficulty,
};
break;
}
@@ -346,10 +424,14 @@ export class PowCaptcha extends LitElement {
// TODO: We need to do a better job of tracking solvers, so if one worker
// errors out, we only error out if all workers have errored out.
let worker_promises: Promise<SolutionMessage>[] = [];
if (request.algorithm === ChallengeAlgorithm.kCTF) {
worker_promises.push(this.issueChallengeToWorker(this.solverWorkers[0], request));
} else {
for (let worker of this.solverWorkers) {
// dispatch to all workers, func is async so it will not block
worker_promises.push(this.issueChallengeToWorker(worker, request));
}
}
let solution = await Promise.race(worker_promises);
@@ -370,7 +452,7 @@ export class PowCaptcha extends LitElement {
await fetch(`${this.challengeUrl}/challenge`, {
method: 'POST',
body: JSON.stringify({
challenge: this.challengeData.challenge,
salt: this.challengeData.salt,
solution: solution.solution,
}),
headers: {
@@ -382,7 +464,7 @@ export class PowCaptcha extends LitElement {
this.dispatchEvent(new CustomEvent('impost:solved', {
detail: {
challenge: this.challengeData.challenge,
salt: this.challengeData.salt,
solution: solution.solution,
},
bubbles: true,

44
packages/widget/src/solver-worker.ts
View File

@@ -8,7 +8,8 @@ import {
WorkerResponseType,
} from "./types/worker";
import { type SolverModule, init_solver, solve } from '@impost/lib/solver';
import { type SolverModule, init_solver, solve, type SolveParams } from '@impost/lib/solver';
import { ChallengeStrategy, ChallengeAlgorithm } from '@impost/lib';
let solver: SolverModule | null = null;
@@ -59,9 +60,45 @@ onmessage = async (event: MessageEvent<WorkerRequest>) => {
return;
}
let solution: string;
let solution: string | number;
try {
solution = solve(solver, event.data.challenge);
let params = {
name: event.data.algorithm,
salt: event.data.salt,
};
switch (event.data.algorithm) {
case ChallengeAlgorithm.Argon2:
case ChallengeAlgorithm.SHA256:
switch (event.data.strategy) {
case ChallengeStrategy.LeadingZeroes:
// @ts-ignore
params.strategy = ChallengeStrategy.LeadingZeroes;
// @ts-ignore
params.difficulty = event.data.difficulty;
break;
case ChallengeStrategy.TargetNumber:
// @ts-ignore
params.strategy = ChallengeStrategy.TargetNumber;
// @ts-ignore
params.target = event.data.target;
break;
}
break;
case ChallengeAlgorithm.kCTF:
// @ts-ignore
params.strategy = ChallengeStrategy.Null;
// @ts-ignore
params.difficulty = event.data.difficulty;
break;
}
solution = solve(solver, params as SolveParams);
if (event.data.algorithm !== ChallengeAlgorithm.kCTF) {
console.log(Atomics.load(atomic_nonce!, 0));
solution = Atomics.load(atomic_solution!, 0);
}
} catch (error: any) {
postMessage({
type: WorkerResponseType.Error,
@@ -70,6 +107,7 @@ onmessage = async (event: MessageEvent<WorkerRequest>) => {
return;
}
postMessage({
type: WorkerResponseType.Solution,
solution,

47
packages/widget/src/types/worker.ts
View File

@@ -1,4 +1,4 @@
import { ChallengeStrategy } from "@impost/lib";
import { ChallengeAlgorithm, ChallengeStrategy } from "@impost/lib";
export enum WorkerMessageType {
Init = "init",
@@ -12,37 +12,40 @@ interface WorkerInitRequest {
sab: SharedArrayBuffer;
}
// interface ChallengeLeadingZeroesSolveRequest {
// strategy: ChallengeStrategy.LeadingZeroes;
// salt: string;
// difficulty: number;
// }
interface ChallengeLeadingZeroesSolveRequest {
algorithm: ChallengeAlgorithm.SHA256 | ChallengeAlgorithm.Argon2;
strategy: ChallengeStrategy.LeadingZeroes;
salt: string;
difficulty: number;
}
// interface WorkerChallengeLeadingZeroesSolveRequest extends ChallengeLeadingZeroesSolveRequest {
// type: WorkerMessageType.Challenge;
// }
interface WorkerChallengeLeadingZeroesSolveRequest extends ChallengeLeadingZeroesSolveRequest {
type: WorkerMessageType.Challenge;
}
// interface ChallengeTargetNumberSolveRequest {
// strategy: ChallengeStrategy.TargetNumber;
// target: string;
// salt: string;
// }
interface ChallengeTargetNumberSolveRequest {
algorithm: ChallengeAlgorithm.SHA256 | ChallengeAlgorithm.Argon2;
strategy: ChallengeStrategy.TargetNumber;
target: string;
salt: string;
}
// interface WorkerChallengeTargetNumberSolveRequest extends ChallengeTargetNumberSolveRequest {
// type: WorkerMessageType.Challenge;
// }
interface WorkerChallengeTargetNumberSolveRequest extends ChallengeTargetNumberSolveRequest {
type: WorkerMessageType.Challenge;
}
interface ChallengekCTFSolveRequest {
strategy: ChallengeStrategy.kCTF;
challenge: string;
algorithm: ChallengeAlgorithm.kCTF;
salt: string;
difficulty: number;
}
interface WorkerChallengekCTFSolveRequest extends ChallengekCTFSolveRequest {
type: WorkerMessageType.Challenge;
}
export type ChallengeSolveRequest = ChallengekCTFSolveRequest;
type WorkerChallengeSolveRequest = WorkerChallengekCTFSolveRequest;
export type ChallengeSolveRequest = ChallengekCTFSolveRequest | ChallengeLeadingZeroesSolveRequest | ChallengeTargetNumberSolveRequest;
type WorkerChallengeSolveRequest = WorkerChallengekCTFSolveRequest | WorkerChallengeLeadingZeroesSolveRequest | WorkerChallengeTargetNumberSolveRequest;
export type WorkerRequest = WorkerInitRequest | WorkerChallengeSolveRequest;
@@ -59,7 +62,7 @@ interface ErrorMessageResponse {
interface SolutionMessageResponse {
type: WorkerResponseType.Solution;
solution: string;
solution: string | number;
}
interface InitOkMessageResponse {

15
solver/src/algorithms/algorithms.zig Normal file
View File

@@ -0,0 +1,15 @@
pub const Algorithm = enum(u8) {
sha256 = 0,
argon2 = 1,
kctf = 2,
};
pub const Strategy = enum(u8) {
null = 0,
leading_zeros = 1,
target_number = 2,
};
pub const SHA256 = @import("sha256.zig");
pub const Argon2 = @import("argon2.zig");
pub const kCTF = @import("kctf.zig");

17
solver/src/algorithms/argon2.zig Normal file
View File

@@ -0,0 +1,17 @@
const std = @import("std");
const Allocator = std.mem.Allocator;
var argon2_params = std.crypto.pwhash.argon2.Params{
.t = 3, // time cost
.m = 8192, // memory cost (in KiB)
.p = 1, // parallelism
};
const dk_len: usize = 32; // 16 or 32 byte key
pub fn hash(allocator: Allocator, challenge: []const u8, nonce: []const u8) ![]u8 {
const derived = try allocator.alloc(u8, dk_len);
try std.crypto.pwhash.argon2.kdf(allocator, derived, nonce, challenge, argon2_params, .argon2d);
return derived;
}

155
solver/src/algorithms/kctf.zig Normal file
View File

@@ -0,0 +1,155 @@
// A PoW algorithm based on google's kCTF scheme
// https://google.github.io/kctf/
const std = @import("std");
const Allocator = std.mem.Allocator;
const assert = std.debug.assert;
const math = std.math;
const Int = math.big.int.Managed;
var managed_one: ?Int = null;
fn get_bit(n: *Int, idx: usize) !bool {
if (n.len() < idx / @typeInfo(usize).int.bits) {
return false;
}
var foo = try n.clone();
defer foo.deinit();
try foo.shiftRight(n, idx);
try foo.bitAnd(&foo, &managed_one.?);
return foo.eql(managed_one.?);
}
pub fn square_mod(n: *Int) !void {
const allocator = n.allocator;
try n.sqr(n);
var high = try Int.init(allocator);
defer high.deinit();
try high.shiftRight(n, 1279); // high = n >> 1279
var mask = try Int.init(allocator);
defer mask.deinit();
if (managed_one == null) {
managed_one = try Int.init(allocator);
try managed_one.?.set(1);
}
try mask.set(1);
try mask.shiftLeft(&mask, 1279);
try mask.sub(&mask, &managed_one.?);
try n.bitAnd(n, &mask);
try n.add(n, &high);
if (try get_bit(n, 1279)) {
// clear bit 1279
var power_of_2 = try Int.init(allocator);
defer power_of_2.deinit();
try power_of_2.set(1);
try power_of_2.shiftLeft(&power_of_2, 1279);
try n.sub(n, &power_of_2);
// *n += 1;
try n.add(n, &managed_one.?);
}
}
pub const Challenge = struct {
difficulty: usize,
salt: std.math.big.int.Managed,
const Self = @This();
pub fn destroy(self: *Self, allocator: Allocator) void {
self.salt.deinit();
allocator.destroy(self);
}
pub fn from_string(allocator: Allocator, challenge: []const u8, difficulty: usize) !*Self {
var salt = try std.math.big.int.Managed.init(allocator);
errdefer salt.deinit();
const salt_str = challenge;
const salt_bytes_len = try std.base64.standard.Decoder.calcSizeForSlice(salt_str);
const salt_bytes = try allocator.alloc(u8, salt_bytes_len);
defer allocator.free(salt_bytes);
try std.base64.standard.Decoder.decode(salt_bytes, salt_str);
const usize_salt_bytes: []align(1) usize = std.mem.bytesAsSlice(usize, salt_bytes);
try salt.ensureCapacity(usize_salt_bytes.len);
@memcpy(salt.limbs[0..usize_salt_bytes.len], usize_salt_bytes);
salt.setLen(usize_salt_bytes.len);
const challenge_ptr = try allocator.create(Self);
errdefer challenge_ptr.destroy(allocator);
challenge_ptr.* = Self{
.difficulty = difficulty,
.salt = salt,
};
return challenge_ptr;
}
pub fn encode(self: *Self, allocator: Allocator) ![]u8 {
const solution_base64_len = std.base64.standard.Encoder.calcSize(self.salt.len() * @sizeOf(usize));
const dest = try allocator.alloc(u8, solution_base64_len);
defer allocator.free(dest);
@memset(dest, 0);
const limbs_u8_buffer: []u8 = std.mem.sliceAsBytes(self.salt.limbs[0..self.salt.len()]);
const base64_str = std.base64.standard.Encoder.encode(dest, limbs_u8_buffer);
return try std.fmt.allocPrint(allocator, "{s}", .{base64_str});
}
pub fn solve(self: *Self, allocator: Allocator) ![]u8 {
for (0..self.difficulty) |_| {
for (0..1277) |_| {
try square_mod(&self.salt);
}
try self.salt.bitXor(&self.salt, &managed_one.?);
}
return try self.encode(allocator);
}
pub fn verify(self: *Self, allocator: Allocator, solution: *Challenge) !bool {
if (managed_one == null) {
managed_one = try Int.init(allocator);
try managed_one.?.set(1);
}
for (0..self.difficulty) |_| {
try solution.salt.bitXor(&solution.salt, &managed_one.?);
try square_mod(&solution.salt);
}
// I'm like 99.999% sure this can NEVER happen, but its how the solution that I translated from did it so that's
// how I will do it
if (self.salt.eql(solution.salt)) {
return true;
}
var foo = try std.math.big.int.Managed.initSet(allocator, 2);
defer foo.deinit();
try foo.pow(&foo, 1279);
try foo.sub(&foo, &managed_one.?);
try foo.sub(&foo, &self.salt);
if (foo.eql(solution.salt)) {
std.log.info("challenge solved!\n", .{});
return true;
}
return false;
}
};

9
solver/src/algorithms/sha256.zig Normal file
View File

@@ -0,0 +1,9 @@
const std = @import("std");
const Allocator = std.mem.Allocator;
pub fn hash(allocator: Allocator, data: []const u8) ![]u8 {
const output_hash = try allocator.alloc(u8, std.crypto.hash.sha2.Sha256.digest_length);
std.crypto.hash.sha2.Sha256.hash(data, @ptrCast(output_hash), .{});
return output_hash;
}

31
solver/src/hasher.zig
View File

@@ -1,31 +0,0 @@
const std = @import("std");
const Allocator = std.mem.Allocator;
var argon2_params = std.crypto.pwhash.argon2.Params{
.t = 4, // time cost
.m = 256, // memory cost (in KiB)
.p = 1, // parallelism (this doesnt do anything because we are targeting wasm, and we do multithreading differently anyways)
};
const dk_len: usize = 32; // 16 or 32 byte key
var derived: [dk_len]u8 = undefined;
var buffer_hash_hex: [64]u8 = undefined;
fn bytesToHex(bytes: []const u8, output: []u8) void {
const hex_chars = "0123456789abcdef";
var i: usize = 0;
while (i < bytes.len) : (i += 1) {
output[i * 2] = hex_chars[(bytes[i] >> 4)];
output[i * 2 + 1] = hex_chars[bytes[i] & 0x0F];
}
}
pub fn hash(allocator: Allocator, challenge: []const u8, nonce: []const u8) ![]u8 {
try std.crypto.pwhash.argon2.kdf(allocator, &derived, nonce, challenge, argon2_params, .argon2id);
var hash_bytes: [32]u8 = undefined;
std.crypto.hash.sha2.Sha256.hash(&derived, @ptrCast(hash_bytes[0..].ptr), .{});
bytesToHex(&hash_bytes, &buffer_hash_hex);
return buffer_hash_hex[0..];
}

215
solver/src/kctf.zig
View File

@@ -1,215 +0,0 @@
// A PoW algorithm based on google's kCTF scheme
// https://google.github.io/kctf/
const std = @import("std");
const Allocator = std.mem.Allocator;
const assert = std.debug.assert;
const math = std.math;
const Int = math.big.int.Managed;
var managed_one: ?Int = null;
fn get_bit(n: *Int, idx: usize) !bool {
if (n.len() < idx / @typeInfo(usize).int.bits) {
return false;
}
var foo = try n.clone();
defer foo.deinit();
try foo.shiftRight(n, idx);
try foo.bitAnd(&foo, &managed_one.?);
return foo.eql(managed_one.?);
}
pub fn square_mod(n: *Int) !void {
const allocator = n.allocator;
try n.sqr(n);
var high = try Int.init(allocator);
defer high.deinit();
try high.shiftRight(n, 1279); // high = n >> 1279
var mask = try Int.init(allocator);
defer mask.deinit();
if (managed_one == null) {
managed_one = try Int.init(allocator);
try managed_one.?.set(1);
}
try mask.set(1);
try mask.shiftLeft(&mask, 1279);
try mask.sub(&mask, &managed_one.?);
try n.bitAnd(n, &mask);
try n.add(n, &high);
if (try get_bit(n, 1279)) {
// clear bit 1279
var power_of_2 = try Int.init(allocator);
defer power_of_2.deinit();
try power_of_2.set(1);
try power_of_2.shiftLeft(&power_of_2, 1279);
try n.sub(n, &power_of_2);
// *n += 1;
try n.add(n, &managed_one.?);
}
}
pub const Version = "s";
pub const Challenge = struct {
difficulty: ?u32,
salt: std.math.big.int.Managed,
const Self = @This();
pub fn destroy(self: *Self, allocator: Allocator) void {
self.salt.deinit();
allocator.destroy(self);
}
pub fn encode(self: *Self, allocator: Allocator) ![]u8 {
const solution_base64_len = std.base64.standard.Encoder.calcSize(self.salt.len() * @sizeOf(usize));
const dest = try allocator.alloc(u8, solution_base64_len);
defer allocator.free(dest);
@memset(dest, 0);
const limbs_u8_buffer: []u8 = std.mem.sliceAsBytes(self.salt.limbs[0..self.salt.len()]);
const base64_str = std.base64.standard.Encoder.encode(dest, limbs_u8_buffer);
return try std.fmt.allocPrint(allocator, "{s}", .{base64_str});
}
};
pub fn decode(allocator: Allocator, challenge: []const u8) !*Challenge {
var parts = std.mem.splitAny(u8, challenge, ".");
if (parts.next()) |part| {
if (!std.mem.eql(u8, part, Version)) {
return error.InvalidChallenge;
}
} else {
return error.InvalidChallenge;
}
var difficulty: ?u32 = null;
var next_part = parts.next() orelse return error.InvalidChallenge;
if (parts.peek()) |_| {
// must be <version>.<difficulty>.<salt>
const difficulty_bytes = try allocator.alloc(u8, try std.base64.standard.Decoder.calcSizeForSlice(next_part));
defer allocator.free(difficulty_bytes);
try std.base64.standard.Decoder.decode(difficulty_bytes, next_part);
std.log.info("Decoded difficulty bytes: {any}\n", .{difficulty_bytes});
var difficulty_array: [4]u8 = .{0} ** 4;
if (difficulty_bytes.len > 4) {
const split_idx = difficulty_bytes.len - 4;
for (difficulty_bytes[0..split_idx]) |byte| {
if (byte != 0) return error.DifficultyTooLarge;
}
@memcpy(&difficulty_array, difficulty_bytes[split_idx..]);
difficulty = std.mem.readInt(u32, &difficulty_array, .big);
} else {
const start_idx = 4 - difficulty_bytes.len;
@memcpy(&difficulty_array, difficulty_bytes[start_idx..]);
difficulty = std.mem.readInt(u32, &difficulty_array, .big);
}
next_part = parts.next() orelse return error.InvalidChallenge;
}
var salt = try std.math.big.int.Managed.init(allocator);
errdefer salt.deinit();
const salt_str = next_part;
const salt_bytes_len = try std.base64.standard.Decoder.calcSizeForSlice(salt_str);
std.log.info("salt_bytes_len: {d}\n", .{salt_bytes_len});
const salt_bytes = try allocator.alloc(u8, salt_bytes_len);
defer allocator.free(salt_bytes);
try std.base64.standard.Decoder.decode(salt_bytes, salt_str);
std.log.info("decoded salt: {any}\n", .{salt_bytes});
const usize_salt_bytes: []align(1) usize = std.mem.bytesAsSlice(usize, salt_bytes);
// TODO: the bytes are being read in as little endian, but need to be read in as big endian
std.log.info("usize_salt_bytes: {any}\n", .{usize_salt_bytes});
try salt.ensureCapacity(usize_salt_bytes.len);
@memcpy(salt.limbs[0..usize_salt_bytes.len], usize_salt_bytes);
salt.setLen(usize_salt_bytes.len);
const challenge_ptr = try allocator.create(Challenge);
errdefer challenge_ptr.destroy(allocator);
challenge_ptr.* = Challenge{
.difficulty = difficulty,
.salt = salt,
};
return challenge_ptr;
}
pub fn solve(allocator: Allocator, challenge: *Challenge) ![]u8 {
if (challenge.difficulty == null) {
return error.InvalidChallenge;
}
for (0..challenge.difficulty.?) |_| {
std.log.info("Solving challenge with difficulty {d}\n", .{challenge.difficulty.?});
for (0..1277) |_| {
try square_mod(&challenge.salt);
}
try challenge.salt.bitXor(&challenge.salt, &managed_one.?);
}
std.log.info("solved challenge: {any}\n", .{challenge});
return try challenge.encode(allocator);
}
pub fn check(allocator: Allocator, challenge: *Challenge, solution: *Challenge) !bool {
std.log.info("{d}", .{challenge.difficulty.?});
std.log.info("{any} vs {any}\n", .{ challenge, solution });
if (challenge.difficulty == null) {
return error.InvalidChallenge;
}
if (managed_one == null) {
managed_one = try Int.init(allocator);
try managed_one.?.set(1);
}
for (0..challenge.difficulty.?) |_| {
try solution.salt.bitXor(&solution.salt, &managed_one.?);
try square_mod(&solution.salt);
}
std.log.info("{any} vs {any}\n", .{ challenge, solution });
if (challenge.salt.eql(solution.salt)) {
return true;
}
var foo = try std.math.big.int.Managed.initSet(allocator, 2);
defer foo.deinit();
try foo.pow(&foo, 1279);
try foo.sub(&foo, &managed_one.?);
try foo.sub(&foo, &challenge.salt);
if (foo.eql(solution.salt)) {
std.log.info("challenge solved!\n", .{});
return true;
}
return false;
}

245
solver/src/solver.zig
View File

@@ -2,11 +2,16 @@ const std = @import("std");
const builtin = @import("builtin");
const Allocator = std.mem.Allocator;
const kCTF = @import("kctf.zig");
const algorithms = @import("algorithms/algorithms.zig");
const utils = @import("utils.zig");
var gpa: std.heap.GeneralPurposeAllocator(.{}) = .init;
var allocator = gpa.allocator();
extern fn __get_solution() i32;
extern fn __set_solution(value: i32) void;
extern fn __cmpxchg_solution(old: i32, new: i32) i32;
extern fn __fetch_add_nonce(value: i32) i32;
extern fn __log(str_ptr: usize, str_len: usize) void;
fn log(comptime level: std.log.Level, comptime scope: @TypeOf(.EnumLiteral), comptime fmt: []const u8, args: anytype) void {
@@ -15,9 +20,18 @@ fn log(comptime level: std.log.Level, comptime scope: @TypeOf(.EnumLiteral), com
return;
}
const log_level_str = switch (level) {
.err => "Error: ",
.warn => "Warning: ",
.info => "Info: ",
.debug => "Debug: ",
};
const formatted = std.fmt.allocPrint(allocator, fmt, args) catch return;
__log(@intFromPtr(formatted.ptr), formatted.len);
const log_str = std.fmt.allocPrint(allocator, "{s}{s}", .{ log_level_str, formatted }) catch return;
allocator.free(formatted);
__log(@intFromPtr(log_str.ptr), log_str.len);
allocator.free(log_str);
}
pub const std_options: std.Options = .{ .logFn = log };
@@ -34,42 +48,164 @@ export fn free(ptr: ?*anyopaque, byte_count: usize) void {
}
}
// value_ptr is a string to the entire encoded challenge string (e.g. "s.xxxxxxxxx.xxxxxxx")
export fn solve(value_ptr: [*]u8, value_len: usize) usize {
/// Both SHA256 and Argon2 are thread safe and are explicitly designed to be used in a multithreaded environment.
/// kCTF is designed only to be used in a single threaded environment. It does not use the same nonce atomics,
/// and duplicates work if solved across multiple threads.
///
/// If a target is not needed for the strategy, target_ptr and target_len should be 0.
export fn solve(algorithm: algorithms.Algorithm, strategy: algorithms.Strategy, salt_ptr: [*]u8, salt_len: usize, difficulty: usize, target_ptr: [*]u8, target_len: usize) isize {
switch (algorithm) {
algorithms.Algorithm.sha256 => return solve_argon2_or_sha256(salt_ptr, salt_len, difficulty, algorithm, strategy, target_ptr, target_len),
algorithms.Algorithm.argon2 => return solve_argon2_or_sha256(salt_ptr, salt_len, difficulty, algorithm, strategy, target_ptr, target_len),
algorithms.Algorithm.kctf => {
if (strategy != algorithms.Strategy.null) {
std.log.err("kCTF does not support a strategy", .{});
return -1;
}
return solve_kctf(salt_ptr, salt_len, difficulty);
},
}
}
fn solve_argon2_or_sha256(salt_ptr: [*]u8, salt_len: usize, difficulty: usize, algorithm: algorithms.Algorithm, strategy: algorithms.Strategy, target_ptr: [*]u8, target_len: usize) isize {
if (strategy == algorithms.Strategy.null) {
std.log.err("Argon2 needs a strategy", .{});
return -1;
}
if (strategy == .leading_zeros) {
if (difficulty < 1 or difficulty > 64) {
std.log.err("Argon2 difficulty must be between 1 and 64 when using leading_zeros", .{});
return -1;
}
}
const salt_slice = salt_ptr[0..salt_len];
var target_slice: ?[]u8 = null;
if (@intFromPtr(target_ptr) != 0) {
target_slice = target_ptr[0..target_len];
}
if (strategy == .target_number and target_slice == null) {
std.log.err("A target must be specified when using the target_number strategy", .{});
return -1;
}
const max_nonce_iterations: u64 = 1_000_000_000;
// const max_nonce_iterations: u64 = 100_000;
// 64 + 9 digits for nonce since the max nonce is 999_999_999 (not 1 billion since nonce < max_nonce_iterations)
var input_buffer: []u8 = allocator.alloc(u8, salt_len + 9) catch {
std.log.err("Out of memory", .{});
return -1;
};
// dont leak memory :pepega:
defer allocator.free(input_buffer);
@memcpy(input_buffer[0..salt_len], salt_slice);
var nonce = __fetch_add_nonce(1);
var hex_encoder = utils.HexEncoder{};
var input: []u8 = undefined;
while (nonce < max_nonce_iterations) : (nonce = __fetch_add_nonce(1)) {
if (__get_solution() != -1) {
// solution has already been found, no point in continuing
return 0;
}
const nonce_str = std.fmt.bufPrint(input_buffer[salt_len..], "{d}", .{nonce}) catch {
std.log.err("Error formatting nonce", .{});
return -1;
};
if (algorithm == .argon2) {
input = algorithms.Argon2.hash(allocator, input_buffer[0..salt_len], input_buffer[salt_len .. salt_len + nonce_str.len]) catch {
std.log.err("Error hashing salt", .{});
return -1;
};
} else {
input = algorithms.SHA256.hash(allocator, input_buffer[0 .. salt_len + nonce_str.len]) catch {
std.log.err("Error hashing salt", .{});
return -1;
};
}
switch (strategy) {
.leading_zeros => {
_ = hex_encoder.encode(input);
allocator.free(input);
if (hex_encoder.countZeroes(difficulty)) {
// Found a solution!
if (__cmpxchg_solution(-1, nonce) == -1) {
// we found a solution, and we are the first to do so
return nonce;
} else {
// we found a solution, but we are not the first to do so
return 0;
}
}
},
.target_number => {
const hex = hex_encoder.encode(input);
allocator.free(input);
if (std.mem.eql(u8, hex, target_slice.?)) {
// Found a solution!
if (__cmpxchg_solution(-1, nonce) == -1) {
// we found a solution, and we are the first to do so
return nonce;
} else {
// we found a solution, but we are not the first to do so
return 0;
}
}
},
else => {
std.log.err("Invalid strategy: {s}", .{@tagName(strategy)});
return -1;
},
}
}
return 0;
}
// value_ptr is a just the base64 challenge string (e.g. "xxxxxxxxx==")
fn solve_kctf(value_ptr: [*]u8, value_len: usize, difficulty: usize) isize {
if (difficulty < 1) {
std.log.err("KCTF difficulty must be at least 1", .{});
return -1;
}
const challenge_slice = value_ptr[0..value_len];
std.log.info("Solve called with challenge {s}\n", .{challenge_slice});
const challenge = kCTF.decode(allocator, challenge_slice) catch |err| {
const challenge = algorithms.kCTF.Challenge.from_string(allocator, challenge_slice, difficulty) catch |err| {
std.log.info("Error decoding challenge: {s}\n", .{@errorName(err)});
return 0;
return -1;
};
defer challenge.destroy(allocator);
std.log.info("decoded challenge {any}\n", .{challenge});
const solution = kCTF.solve(allocator, challenge) catch |err| {
const solution = challenge.solve(allocator) catch |err| {
std.log.info("Error solving challenge: {s}\n", .{@errorName(err)});
return 0;
return -1;
};
std.log.info("Solution: {s}\n", .{solution});
const output_ptr = allocator.alloc(u8, solution.len + 4) catch return 0;
var output_slice = output_ptr[0 .. solution.len + 4];
var output_slice = output_ptr[0 .. solution.len + 2];
if (output_slice.len - 2 > std.math.maxInt(u16)) {
return 0;
return -1;
}
const output_len: u16 = @intCast(output_slice.len - 2);
// convert to little endian
output_slice[0] = @intCast(output_len & 0xFF); // LSB
output_slice[1] = @intCast(output_len >> 8); // MSB
@memcpy(output_slice[2..4], "s.");
@memcpy(output_slice[4 .. 4 + solution.len], solution);
@memcpy(output_slice[2 .. 2 + solution.len], solution);
allocator.free(solution);
return @intFromPtr(output_ptr.ptr);
return @intCast(@intFromPtr(output_ptr.ptr));
}
pub fn main() anyerror!void {
@@ -77,12 +213,79 @@ pub fn main() anyerror!void {
var args = try std.process.argsAlloc(allocator);
if (args.len < 2) {
std.log.err("Usage: zig run src/kctf.zig <challenge>", .{});
std.log.err("Usage: {s} <algorithm> [options] <challenge>", .{args[0]});
return;
}
const challenge = try kCTF.decode(allocator, args[1]);
const solution = try kCTF.solve(allocator, challenge);
var algorithm: ?algorithms.Algorithm = null;
var strategy: algorithms.Strategy = algorithms.Strategy.null;
var target: ?[]u8 = null;
if (std.mem.eql(u8, args[1], "sha256")) {
algorithm = algorithms.Algorithm.sha256;
} else if (std.mem.eql(u8, args[1], "argon2")) {
algorithm = algorithms.Algorithm.argon2;
} else if (std.mem.eql(u8, args[1], "kctf")) {
algorithm = algorithms.Algorithm.kctf;
}
var i: usize = 2;
while (i < args.len) : (i += 1) {
const arg = args[i];
if (std.mem.eql(u8, arg, "--strategy")) {
if (args.len <= i + 1) {
std.log.err("Expected strategy after --strategy", .{});
return;
}
if (std.mem.eql(u8, args[i + 1], "leading_zeros")) {
strategy = algorithms.Strategy.leading_zeros;
}
if (std.mem.eql(u8, args[i + 1], "target_number")) {
strategy = algorithms.Strategy.target_number;
}
if (strategy == .null) {
std.log.err("Invalid strategy: {s}", .{args[i + 1]});
return;
}
i += 1;
}
if (std.mem.eql(u8, arg, "--target")) {
if (args.len <= i + 1) {
std.log.err("Expected target after --target", .{});
return;
}
target = args[i + 1];
i += 1;
}
if (std.mem.eql(u8, arg, "--help")) {
std.log.info("Options:\n", .{});
std.log.info(" --strategy <strategy>: Specify the strategy to use. This only applies to some algorithms.\n", .{});
std.log.info(" --target <target>: Specify the target hash when using the target_number strategy.\n", .{});
std.log.info(" --help: Print this help message\n", .{});
std.log.info("Usage: {s} <strategy> [options] <challenge>", .{args[0]});
return;
}
}
if (strategy == .null and algorithm != .kctf) {
std.log.warn("No strategy specified, defaulting to leading_zeros", .{});
strategy = algorithms.Strategy.leading_zeros;
}
if (strategy == .target_number and target == null) {
std.log.err("A target must be specified when using the target_number strategy", .{});
return;
}
const challenge = try algorithms.kCTF.decode(allocator, args[1]);
const solution = try algorithms.kCTF.solve(allocator, challenge);
std.log.info("Solution: {s}", .{solution});
}

47
solver/src/utils.zig Normal file
View File

@@ -0,0 +1,47 @@
const std = @import("std");
const Allocator = std.mem.Allocator;
pub const HexEncoder = struct {
scratch: [64]u8 = undefined,
scratch_set: bool = false,
const Self = @This();
pub fn encode(self: *Self, bytes: []const u8) []u8 {
self.scratch_set = true;
bytesToHex(bytes, &self.scratch);
return &self.scratch;
}
// counts the number of leading hexidecimal zeroes in the scratch buffer
// which is set by encode
pub fn countZeroes(self: *Self, zeroes: usize) bool {
if (!self.scratch_set) {
return false;
}
if (zeroes > 64 or zeroes == 0) {
return false;
}
var i: usize = 0;
while (i < zeroes) : (i += 1) {
if (self.scratch[i] != '0') {
return false;
}
}
return true;
}
};
fn bytesToHex(bytes: []const u8, output: []u8) void {
const hex_chars = "0123456789abcdef";
var i: usize = 0;
while (i < bytes.len) : (i += 1) {
output[i * 2] = hex_chars[(bytes[i] >> 4)];
output[i * 2 + 1] = hex_chars[bytes[i] & 0x0F];
}
}

164
solver/src/validator.zig
View File

@@ -2,7 +2,8 @@ const std = @import("std");
const builtin = @import("builtin");
const Allocator = std.mem.Allocator;
const kCTF = @import("kctf.zig");
const algorithms = @import("algorithms/algorithms.zig");
const utils = @import("utils.zig");
var gpa: std.heap.GeneralPurposeAllocator(.{}) = .init;
var allocator = gpa.allocator();
@@ -34,60 +35,143 @@ export fn free(ptr: ?*anyopaque, byte_count: usize) void {
}
}
fn bytesToHex(bytes: []const u8, buf: []u8) void {
const hex_chars = "0123456789abcdef";
var i: usize = 0;
while (i < bytes.len) : (i += 1) {
buf[i * 2] = hex_chars[(bytes[i] >> 4)];
buf[i * 2 + 1] = hex_chars[bytes[i] & 0x0F];
export fn validate(algorithm: algorithms.Algorithm, strategy: algorithms.Strategy, challenge_ptr: [*]u8, challenge_len: usize, solution_ptr: [*]u8, solution_len: usize, nonce: usize, difficulty: usize) bool {
switch (algorithm) {
algorithms.Algorithm.sha256 => return validate_argon2_or_sha256(challenge_ptr, challenge_len, nonce, solution_ptr, solution_len, difficulty, algorithms.Algorithm.sha256, strategy),
algorithms.Algorithm.argon2 => return validate_argon2_or_sha256(challenge_ptr, challenge_len, nonce, solution_ptr, solution_len, difficulty, algorithms.Algorithm.argon2, strategy),
algorithms.Algorithm.kctf => return validate_kctf(challenge_ptr, challenge_len, solution_ptr, solution_len, difficulty),
}
}
// challenge_ptr should look like s.<difficulty>.<challenge>
// solution_ptr should look like s.<solved_hash>
export fn validate(challenge_ptr: [*]u8, challenge_len: usize, solution_ptr: [*]u8, solution_len: usize) bool {
fn validate_argon2_or_sha256(challenge_ptr: [*]u8, challenge_len: usize, nonce: usize, target_ptr: [*]u8, target_len: usize, difficulty: usize, algorithm: algorithms.Algorithm, strategy: algorithms.Strategy) bool {
if (strategy == algorithms.Strategy.null) {
return false;
}
if (strategy == .leading_zeros) {
if (difficulty < 1 or difficulty > 64) {
return false;
}
}
const challenge_slice = challenge_ptr[0..challenge_len];
const nonce_slice = std.fmt.allocPrint(allocator, "{d}", .{nonce}) catch return false;
var target_slice: ?[]u8 = null;
if (@intFromPtr(target_ptr) != 0) {
target_slice = target_ptr[0..target_len];
}
if (strategy == .target_number and target_slice == null) {
return false;
}
const input_slice = allocator.alloc(u8, challenge_len + nonce_slice.len) catch return false;
defer allocator.free(input_slice);
@memcpy(input_slice[0..challenge_len], challenge_slice);
@memcpy(input_slice[challenge_len..], nonce_slice);
var input: []u8 = undefined;
if (algorithm == .argon2) {
input = algorithms.Argon2.hash(allocator, input_slice[0..challenge_len], input_slice[challenge_len .. challenge_len + nonce_slice.len]) catch return false;
} else {
input = algorithms.SHA256.hash(allocator, input_slice[0 .. challenge_len + nonce_slice.len]) catch return false;
}
defer allocator.free(input);
var hex_encoder = utils.HexEncoder{};
switch (strategy) {
.leading_zeros => {
_ = hex_encoder.encode(input);
if (hex_encoder.countZeroes(difficulty)) {
return true;
}
},
.target_number => {
if (std.mem.eql(u8, hex_encoder.encode(input), target_slice.?)) {
return true;
}
},
else => unreachable,
}
return false;
}
fn validate_kctf(challenge_ptr: [*]u8, challenge_len: usize, solution_ptr: [*]u8, solution_len: usize, difficulty: usize) bool {
const challenge_buf = challenge_ptr[0..challenge_len];
const solution_buf = solution_ptr[0..solution_len];
std.log.info("Validate called with challenge {s} and solution {s}\n", .{ challenge_buf, solution_buf });
const challenge = kCTF.decode(allocator, challenge_buf) catch return false;
std.log.info("decoded challenge {any}\n", .{challenge});
const solution = kCTF.decode(allocator, solution_buf) catch return false;
const challenge = algorithms.kCTF.Challenge.from_string(allocator, challenge_buf, difficulty) catch return false;
const solution = algorithms.kCTF.Challenge.from_string(allocator, solution_buf, difficulty) catch return false;
defer {
challenge.destroy(allocator);
solution.destroy(allocator);
}
std.log.info("decoded challenge and solution\n", .{});
const is_valid = kCTF.check(allocator, challenge, solution) catch return false;
const is_valid = challenge.verify(allocator, solution) catch return false;
return is_valid;
}
export fn hash(challenge_ptr: [*]u8, challenge_len: usize, nonce_ptr: [*]u8, nonce_len: usize, algorithm: algorithms.Algorithm) u64 {
const challenge = challenge_ptr[0..challenge_len];
const nonce = nonce_ptr[0..nonce_len];
var hash_slice: []u8 = undefined;
switch (algorithm) {
algorithms.Algorithm.sha256 => {
const input_slice = allocator.alloc(u8, challenge_len + nonce_len) catch return 0;
defer allocator.free(input_slice);
@memcpy(input_slice[0..challenge_len], challenge);
@memcpy(input_slice[challenge_len..], nonce);
hash_slice = algorithms.SHA256.hash(allocator, input_slice[0 .. challenge_len + nonce_len]) catch return 0;
},
algorithms.Algorithm.argon2 => {
hash_slice = algorithms.Argon2.hash(allocator, challenge, nonce) catch return 0;
},
else => return 0,
}
var hex_encoder = utils.HexEncoder{};
const hex_slice = hex_encoder.encode(hash_slice);
// hex_slice is stack allocated, therefore, if we pass it to the caller without copying it onto the heap, we are
// potentially (and likely) sending garbage memory to the caller
const heap_hex_slice = allocator.dupe(u8, hex_slice) catch return 0;
// bs to get the compiler to not whine about hash_slice.len being a u5 annd thus cannot be shifted by 32
var ret: u64 = heap_hex_slice.len;
ret <<= 32;
ret |= @intFromPtr(heap_hex_slice.ptr);
allocator.free(hash_slice);
return ret;
}
pub fn main() anyerror!void {
if (comptime builtin.cpu.arch == .wasm32) return;
// TODO
// if (comptime builtin.cpu.arch == .wasm32) return;
const args = try std.process.argsAlloc(allocator);
if (args.len < 3) {
std.log.err("Usage: zig run src/validator.zig <challenge> <solution>", .{});
return;
}
const challenge = try kCTF.decode(allocator, args[1]);
defer challenge.destroy(allocator);
const solution = try kCTF.decode(allocator, args[2]);
defer solution.destroy(allocator);
std.log.info("Challenge: {any}\n", .{challenge});
std.log.info("Solution: {any}\n", .{solution});
const is_valid = kCTF.check(allocator, challenge, solution) catch |err| {
std.log.info("Error checking challenge: {s}\n", .{@errorName(err)});
return;
};
std.log.info("Is valid: {}\n", .{is_valid});
// const args = try std.process.argsAlloc(allocator);
// if (args.len < 3) {
// std.log.err("Usage: zig run src/validator.zig <challenge> <solution>", .{});
// return;
// }
// const challenge = try kCTF.decode(allocator, args[1]);
// defer challenge.destroy(allocator);
// const solution = try kCTF.decode(allocator, args[2]);
// defer solution.destroy(allocator);
// std.log.info("Challenge: {any}\n", .{challenge});
// std.log.info("Solution: {any}\n", .{solution});
// const is_valid = kCTF.check(allocator, challenge, solution) catch |err| {
// std.log.info("Error checking challenge: {s}\n", .{@errorName(err)});
// return;
// };
// std.log.info("Is valid: {}\n", .{is_valid});
}