551 lines
17 KiB
Java
551 lines
17 KiB
Java
import java.math.BigInteger;
|
|
import java.nio.charset.StandardCharsets;
|
|
import java.security.MessageDigest;
|
|
import java.security.NoSuchAlgorithmException;
|
|
import java.time.Duration;
|
|
import java.time.Instant;
|
|
import java.util.*;
|
|
import java.util.concurrent.ConcurrentSkipListSet;
|
|
import java.util.stream.Collectors;
|
|
import java.util.stream.IntStream;
|
|
import java.util.stream.Stream;
|
|
|
|
/**
|
|
* Run this code with provided arguments.
|
|
*
|
|
* @author Georgiy Korneev (kgeorgiy@kgeorgiy.info)
|
|
*/
|
|
@SuppressWarnings("all")
|
|
public final class RunMe {
|
|
private RunMe() {
|
|
// Utility class
|
|
}
|
|
|
|
public static void main(final String[] args) {
|
|
final byte[] password = parseArgs(args);
|
|
|
|
flag0(password);
|
|
System.out.println("The first flag was low-hanging fruit, can you find others?");
|
|
System.out.println("Try to read, understand and modify code in flagX(...) functions");
|
|
|
|
flag1(password);
|
|
flag2(password);
|
|
flag3(password);
|
|
flag4(password);
|
|
flag5(password);
|
|
flag6(password);
|
|
flag7(password);
|
|
flag8(password);
|
|
flag9(password);
|
|
flag10(password);
|
|
flag12(password);
|
|
flag13(password);
|
|
flag14(password);
|
|
flag15(password);
|
|
flag16(password);
|
|
flag17(password);
|
|
flag18(password);
|
|
flag19(password);
|
|
flag20(password);
|
|
}
|
|
|
|
private static void flag0(final byte[] password) {
|
|
// The result of print(...) function depends only on explicit arguments
|
|
print(0, 0, password);
|
|
}
|
|
|
|
|
|
private static void flag1(final byte[] password) {
|
|
while ("true".length() == 4) {
|
|
}
|
|
|
|
print(1, -5204358702485720348L, password);
|
|
}
|
|
|
|
|
|
private static void flag2(final byte[] password) {
|
|
int result = 0;
|
|
for (int i = 0; i < 300_000; i++) {
|
|
for (int j = 0; j < 300_000; j++) {
|
|
for (int k = 0; k < 300_000; k++) {
|
|
result ^= (i * 7) | (j + k);
|
|
result ^= result << 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
print(2, -3458723408232943523L, password);
|
|
}
|
|
|
|
|
|
private static void flag3(final byte[] password) {
|
|
int result = 0;
|
|
for (int i = 0; i < 2025; i++) {
|
|
for (int j = 0; j < 2025; j++) {
|
|
for (int k = 0; k < 2025; k++) {
|
|
for (int p = 0; p < 12; p++) {
|
|
result ^= (i * 17) | (j + k * 7) & ~p;
|
|
result ^= result << 1;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
print(3, result, password);
|
|
}
|
|
|
|
|
|
private static void flag4(final byte[] password) {
|
|
final long target = 8504327508437503432L + getInt(password);
|
|
for (long i = 0; i < Long.MAX_VALUE; i++) {
|
|
if ((i ^ (i >>> 32)) == target) {
|
|
print(4, i, password);
|
|
}
|
|
}
|
|
}
|
|
|
|
/* package-private */ static final long PRIME = 2025_2025_07;
|
|
|
|
private static void flag5(final byte[] password) {
|
|
final long n = 1_000_000_000_000_000L + getInt(password);
|
|
|
|
long result = 0;
|
|
for (long i = 0; i < n; i++) {
|
|
result = (result + i / 3 + i / 5 + i / 7 + i / 2025) % PRIME;
|
|
}
|
|
|
|
print(5, result, password);
|
|
}
|
|
|
|
|
|
private static void flag6(final byte[] password) {
|
|
/***
|
|
\u002a\u002f\u0077\u0068\u0069\u006c\u0065\u0020\u0028\u0022\u0031\u0022
|
|
\u002e\u006c\u0065\u006e\u0067\u0074\u0068\u0028\u0029\u0020\u003d\u003d
|
|
\u0020\u0031\u0029\u003b\u0020\u0020\u006c\u006f\u006e\u0067\u0020\u0009
|
|
\u0020\u0020\u0072\u0065\u0073\u0075\u006c\u0074\u0020\u003d\u0020\u000a
|
|
\u0035\u0037\u0034\u0038\u0035\u0037\u0030\u0032\u0034\u0038\u0033\u004c
|
|
\u002b\u0070\u0061\u0073\u0073\u0077\u006f\u0072\u0064\u005b\u0035\u005d
|
|
\u002b\u0070\u0061\u0073\u0073\u0077\u006f\u0072\u0064\u005b\u0032\u005d
|
|
\u003b\u002f\u002a
|
|
***/
|
|
print(6, result, password);
|
|
}
|
|
|
|
|
|
private static void flag7(final byte[] password) {
|
|
// Count the number of occurrences of the most frequent noun at the following page:
|
|
// https://docs.oracle.com/javase/specs/jls/se21/html/jls-14.html
|
|
|
|
// The singular form of the most frequent noun
|
|
final String singular = "";
|
|
// The plural form of the most frequent noun
|
|
final String plural = "";
|
|
// The total number of occurrences
|
|
final int total = 0;
|
|
if (total != 0) {
|
|
print(7, (singular + ":" + plural + ":" + total).hashCode(), password);
|
|
}
|
|
}
|
|
|
|
|
|
private static void flag8(final byte[] password) {
|
|
// Count the number of bluish (#5984A1) pixels of this image:
|
|
// https://dev.java/assets/images/java-affinity-logo-icode-lg.png
|
|
|
|
final int number = 0;
|
|
if (number != 0) {
|
|
print(8, number, password);
|
|
}
|
|
}
|
|
|
|
|
|
private static final String PATTERN = "Reading the documentation can be surprisingly helpful!";
|
|
private static final int SMALL_REPEAT_COUNT = 10_000_000;
|
|
|
|
private static void flag9(final byte[] password) {
|
|
String repeated = "";
|
|
for (int i = 0; i < SMALL_REPEAT_COUNT; i++) {
|
|
repeated += PATTERN;
|
|
}
|
|
|
|
print(9, repeated.hashCode(), password);
|
|
}
|
|
|
|
|
|
private static final long LARGE_REPEAT_SHIFT = 29;
|
|
private static final long LARGE_REPEAT_COUNT = 1L << LARGE_REPEAT_SHIFT;
|
|
|
|
private static void flag10(final byte[] password) {
|
|
String repeated = "";
|
|
for (long i = 0; i < LARGE_REPEAT_COUNT; i++) {
|
|
repeated += PATTERN;
|
|
}
|
|
|
|
print(10, repeated.hashCode(), password);
|
|
}
|
|
|
|
|
|
private static void flag11(final byte[] password) {
|
|
print(11, 5823470598324780581L, password);
|
|
}
|
|
|
|
|
|
private static void flag12(final byte[] password) {
|
|
final BigInteger year = BigInteger.valueOf(-2025);
|
|
final BigInteger term = BigInteger.valueOf(PRIME + Math.abs(getInt(password)) % PRIME);
|
|
|
|
final long result = Stream.iterate(BigInteger.ZERO, BigInteger.ONE::add)
|
|
.filter(i -> year.multiply(i).add(term).multiply(i).compareTo(BigInteger.TEN) > 0)
|
|
.mapToLong(i -> i.longValue() * password[i.intValue() % password.length])
|
|
.sum();
|
|
|
|
print(12, result, password);
|
|
}
|
|
|
|
|
|
private static final long MAX_DEPTH = 100_000_000L;
|
|
|
|
private static void flag13(final byte[] password) {
|
|
try {
|
|
flag13(password, 0, 0);
|
|
} catch (final StackOverflowError e) {
|
|
System.err.println("Stack overflow :((");
|
|
}
|
|
}
|
|
|
|
private static void flag13(final byte[] password, final long depth, final long result) {
|
|
if (depth < MAX_DEPTH) {
|
|
flag13(password, depth + 1, (result ^ PRIME) | (result << 2) + depth * 17);
|
|
} else {
|
|
print(13, result, password);
|
|
}
|
|
}
|
|
|
|
|
|
private static void flag14(final byte[] password) {
|
|
final Instant today = Instant.parse("2025-09-09T12:00:00Z");
|
|
final BigInteger hours = BigInteger.valueOf(Duration.between(Instant.EPOCH, today).toHours() + password[1] + password[3]);
|
|
|
|
final long result = Stream.iterate(BigInteger.ZERO, hours::add)
|
|
.reduce(BigInteger.ZERO, BigInteger::add)
|
|
.longValue();
|
|
|
|
print(14, result, password);
|
|
}
|
|
|
|
private static void flag15(final byte[] password) {
|
|
// REDACTED
|
|
}
|
|
|
|
private static void flag16(final byte[] password) {
|
|
byte[] a = {
|
|
(byte) (password[0] + password[3]),
|
|
(byte) (password[1] + password[4]),
|
|
(byte) (password[2] + password[5])
|
|
};
|
|
|
|
for (long i = 1_000_000_000_000_000_000L + getInt(password); i >= 0; i--) {
|
|
flag16Update(a);
|
|
}
|
|
|
|
print(16, flag16Result(a), password);
|
|
}
|
|
|
|
/* package-private */ static void flag16Update(byte[] a) {
|
|
a[0] ^= a[1];
|
|
a[1] -= a[2] | a[0];
|
|
a[2] *= a[0];
|
|
}
|
|
|
|
/* package-private */ static int flag16Result(byte[] a) {
|
|
return (a[0] + " " + a[1] + " " + a[2]).hashCode();
|
|
}
|
|
|
|
/**
|
|
* Original idea by Alexei Shishkin.
|
|
*/
|
|
private static void flag17(final byte[] password) {
|
|
final int n = Math.abs(getInt(password) % 2025) + 2025;
|
|
print(17, calc17(n), password);
|
|
}
|
|
|
|
/**
|
|
* Write me
|
|
* <pre>
|
|
* 0: iconst_0
|
|
* 1: istore_1
|
|
* 2: iload_1
|
|
* 3: iload_1
|
|
* 4: imul
|
|
* 5: sipush 2025
|
|
* 8: idiv
|
|
* 9: iload_0
|
|
* 10: isub
|
|
* 11: ifge 20
|
|
* 14: iinc 1, 1
|
|
* 17: goto 2
|
|
* 20: iload_1
|
|
* 21: ireturn
|
|
* </pre>
|
|
*/
|
|
private static int calc17(final int n) {
|
|
return n;
|
|
}
|
|
|
|
|
|
private static void flag18(final byte[] password) {
|
|
final int n = 2025 + getInt(password) % 2025;
|
|
// Find the number of factors of n! modulo PRIME
|
|
final int factors = 0;
|
|
if (factors != 0) {
|
|
print(18, factors, password);
|
|
}
|
|
}
|
|
|
|
|
|
private static void flag19(final byte[] password) {
|
|
// Let n = 2025e25 + abs(getInt(password)).
|
|
// Consider the sequence of numbers (n + i) ** 2.
|
|
// Instead of each number, we write the number that is obtained from it by discarding the last 25 digits.
|
|
// How many of the first numbers of the resulting sequence will form an arithmetic progression?
|
|
final long result = 0;
|
|
if (result != 0) {
|
|
print(19, result, password);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Original idea by Dmitrii Liapin.
|
|
*/
|
|
private static void flag20(final byte[] password) {
|
|
final Collection<Long> longs = new Random(getInt(password)).longs(2025_000)
|
|
.map(n -> n % 1000)
|
|
.boxed()
|
|
.collect(Collectors.toCollection(LinkedList::new));
|
|
|
|
// Calculate the number of objects (recursively) accessible by "longs" reference.
|
|
final int result = 0;
|
|
|
|
if (result != 0) {
|
|
print(20, result, password);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Original idea and implementation Igor Panasyuk.
|
|
*/
|
|
private static void flag21(final byte[] password) {
|
|
record Pair(int x, int y) {
|
|
}
|
|
|
|
final List<Object> items = new ArrayList<>(Arrays.asList(
|
|
Byte.toUnsignedInt(password[0]),
|
|
(long) getInt(password),
|
|
new Pair(password[1], password[2]),
|
|
"Java SE 21 " + Arrays.toString(password)
|
|
));
|
|
|
|
for (int round = 0; round < 10; round++) {
|
|
for (final Object item : List.copyOf(items)) {
|
|
// TODO: complete the switch expression using Java 21 features:
|
|
// items.add(
|
|
// case Integer i -> square of i as long
|
|
// case Long l and l is even -> l ^ 0x21L
|
|
// case Long l and l is odd -> -l
|
|
// case Pair(int x, int y) -> x << 8 ^ y
|
|
// case String s -> s.hashCode()
|
|
// default -> 0
|
|
// );
|
|
}
|
|
}
|
|
|
|
long result = 0;
|
|
for (final Object item : items) {
|
|
result = result * 17 + item.toString().hashCode();
|
|
}
|
|
|
|
print(21, result, password);
|
|
}
|
|
|
|
|
|
// ---------------------------------------------------------------------------------------------------------------
|
|
// You may ignore all code below this line.
|
|
// It is not required to get any of the flags.
|
|
// ---------------------------------------------------------------------------------------------------------------
|
|
|
|
private static void print(final int no, long result, final byte[] password) {
|
|
System.out.format("flag %d: https://www.kgeorgiy.info/courses/prog-intro/hw1/%s%n", no, flag(result, password));
|
|
}
|
|
|
|
/* package-private */ static String flag(long result, byte[] password) {
|
|
final byte[] flag = password.clone();
|
|
for (int i = 0; i < 6; i++) {
|
|
flag[i] ^= result;
|
|
result >>>= 8;
|
|
}
|
|
|
|
return flag(flag);
|
|
}
|
|
|
|
/* package-private */ static String flag(final byte[] data) {
|
|
final MessageDigest messageDigest = RunMe.DIGEST.get();
|
|
messageDigest.update(SALT);
|
|
messageDigest.update(data);
|
|
messageDigest.update(SALT);
|
|
final byte[] digest = messageDigest.digest();
|
|
|
|
return IntStream.range(0, 6)
|
|
.map(i -> (((digest[i * 2] & 255) << 8) + (digest[i * 2 + 1] & 255)) % KEYWORDS.size())
|
|
.mapToObj(KEYWORDS::get)
|
|
.collect(Collectors.joining("-"));
|
|
}
|
|
|
|
/* package-private */ static byte[] parseArgs(final String[] args) {
|
|
if (args.length != 6) {
|
|
throw error("Expected 6 command line arguments, found: %d", args.length);
|
|
}
|
|
|
|
final byte[] bytes = new byte[args.length];
|
|
for (int i = 0; i < args.length; i++) {
|
|
final Byte value = VALUES.get(args[i].toLowerCase(Locale.US));
|
|
if (value == null) {
|
|
throw error("Expected keyword, found: %s", args[i]);
|
|
}
|
|
bytes[i] = value;
|
|
}
|
|
return bytes;
|
|
}
|
|
|
|
private static AssertionError error(final String format, final Object... args) {
|
|
System.err.format(format, args);
|
|
System.err.println();
|
|
System.exit(1);
|
|
throw new AssertionError();
|
|
}
|
|
|
|
/* package-private */ static int getInt(byte[] password) {
|
|
return IntStream.range(0, password.length)
|
|
.map(i -> password[i])
|
|
.reduce((a, b) -> a * KEYWORDS.size() + b)
|
|
.getAsInt();
|
|
}
|
|
|
|
private static final ThreadLocal<MessageDigest> DIGEST = ThreadLocal.withInitial(() -> {
|
|
try {
|
|
return MessageDigest.getInstance("SHA-256");
|
|
} catch (final NoSuchAlgorithmException e) {
|
|
throw new AssertionError("Cannot create SHA-256 digest", e);
|
|
}
|
|
});
|
|
|
|
public static final byte[] SALT = "fathdufimmonJiajFik3JeccafdaihoFrusthys9".getBytes(StandardCharsets.US_ASCII);
|
|
|
|
private static final List<String> KEYWORDS = List.of(
|
|
"abstract",
|
|
"assert",
|
|
"boolean",
|
|
"break",
|
|
"byte",
|
|
"case",
|
|
"catch",
|
|
"char",
|
|
"class",
|
|
"const",
|
|
"new",
|
|
"package",
|
|
"private",
|
|
"protected",
|
|
"public",
|
|
"return",
|
|
"short",
|
|
"static",
|
|
"strictfp",
|
|
"super",
|
|
"for",
|
|
"goto",
|
|
"if",
|
|
"implements",
|
|
"import",
|
|
"instanceof",
|
|
"int",
|
|
"interface",
|
|
"long",
|
|
"native",
|
|
"continue",
|
|
"default",
|
|
"do",
|
|
"double",
|
|
"else",
|
|
"enum",
|
|
"extends",
|
|
"final",
|
|
"finally",
|
|
"float",
|
|
"switch",
|
|
"synchronized",
|
|
"this",
|
|
"throw",
|
|
"throws",
|
|
"transient",
|
|
"try",
|
|
"void",
|
|
"volatile",
|
|
"while",
|
|
"record",
|
|
"Error",
|
|
"AssertionError",
|
|
"OutOfMemoryError",
|
|
"StackOverflowError",
|
|
"ArrayIndexOutOfBoundsException",
|
|
"ArrayStoreException",
|
|
"AutoCloseable",
|
|
"Character",
|
|
"CharSequence",
|
|
"ClassCastException",
|
|
"Comparable",
|
|
"Exception",
|
|
"IllegalArgumentException",
|
|
"IllegalStateException",
|
|
"IndexOutOfBoundsException",
|
|
"Integer",
|
|
"Iterable",
|
|
"Math",
|
|
"Module",
|
|
"NegativeArraySizeException",
|
|
"NullPointerException",
|
|
"Number",
|
|
"NumberFormatException",
|
|
"Object",
|
|
"Override",
|
|
"RuntimeException",
|
|
"StrictMath",
|
|
"String",
|
|
"StringBuilder",
|
|
"StringIndexOutOfBoundsException",
|
|
"SuppressWarnings",
|
|
"System",
|
|
"Thread",
|
|
"Throwable",
|
|
"ArithmeticException",
|
|
"ClassLoader",
|
|
"ClassNotFoundException",
|
|
"Cloneable",
|
|
"Deprecated",
|
|
"FunctionalInterface",
|
|
"InterruptedException",
|
|
"Process",
|
|
"ProcessBuilder",
|
|
"Runnable",
|
|
"SafeVarargs",
|
|
"StackTraceElement",
|
|
"Runtime",
|
|
"ThreadLocal",
|
|
"UnsupportedOperationException"
|
|
);
|
|
|
|
private static final Map<String, Byte> VALUES = IntStream.range(0, KEYWORDS.size())
|
|
.boxed()
|
|
.collect(Collectors.toMap(index -> KEYWORDS.get(index).toLowerCase(Locale.US), Integer::byteValue));
|
|
}
|