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

Implement algorithm switching

Browse Source 
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.
This commit is contained in:
Zoe
2025-11-25 18:09:17 +00:00
parent 570531fe32
commit e16383e9b9
20 changed files with 1262 additions and 476 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
example-app/config.toml
View File

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

76
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.strategy) {
case ChallengeStrategy.kCTF:
switch (config.algorithm) {
case ChallengeAlgorithm.SHA256:
switch (config.strategy) {
case ChallengeStrategy.LeadingZeroes:
challenge_config = {
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.Argon2id:
switch (config.strategy) {
case ChallengeStrategy.LeadingZeroes:
challenge_config = {
algorithm: ChallengeAlgorithm.Argon2id,
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.Argon2id,
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 = {
parameters: { expires_at: CHALLENGE_TIMEOUT_MS },
strategy: config.strategy,
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 Argon2id 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'

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 Argon2idSchema = z.discriminatedUnion("strategy", [
z.object({
algorithm: z.literal(ChallengeAlgorithm.Argon2id),
strategy: z.literal(ChallengeStrategy.LeadingZeroes),
leading_zeroes: z.object({
difficulty: z.number().int().min(1).max(64),
}),
}),
z.object({
algorithm: z.literal(ChallengeAlgorithm.Argon2id),
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, Argon2idSchema, KCTFSchema]);
export const Config = z.discriminatedUnion('strategy', [
kCTFSchema,
]);
export type Config = z.infer<typeof Config>;
export let config: Config;