thuban 0.3.3 → 0.4.0

package/dist/packages/crucible/seeds/kotlin/seed-037.kt

@@ -0,0 +1,26 @@
+// [CRUCIBLE-SEED]
+// category: insecure_crypto
+// severity: high
+// language: kotlin
+// expected: AES in ECB mode — deterministic, no IV, vulnerable to pattern analysis
+
+package com.example.crypto
+
+import javax.crypto.Cipher
+import javax.crypto.spec.SecretKeySpec
+
+class AesEcbEncryptor {
+    private val key = SecretKeySpec("0123456789abcdef".toByteArray(), "AES")
+
+    fun encrypt(plaintext: String): ByteArray {
+        val cipher = Cipher.getInstance("AES/ECB/PKCS5Padding")
+        cipher.init(Cipher.ENCRYPT_MODE, key)
+        return cipher.doFinal(plaintext.toByteArray())
+    }
+
+    fun decrypt(ciphertext: ByteArray): String {
+        val cipher = Cipher.getInstance("AES/ECB/PKCS5Padding")
+        cipher.init(Cipher.DECRYPT_MODE, key)
+        return String(cipher.doFinal(ciphertext))
+    }
+}

package/dist/packages/crucible/seeds/kotlin/seed-038.kt

@@ -0,0 +1,25 @@
+// [CRUCIBLE-SEED]
+// category: insecure_crypto
+// severity: medium
+// language: kotlin
+// expected: SHA-1 used for certificate pinning and signature verification
+
+package com.example.security
+
+import java.security.MessageDigest
+import java.security.cert.X509Certificate
+
+class CertificatePinner {
+    private val pinnedSha1 = "da39a3ee5e6b4b0d3255bfef95601890afd80709"
+
+    fun isPinned(cert: X509Certificate): Boolean {
+        val md = MessageDigest.getInstance("SHA-1")
+        val fingerprint = md.digest(cert.encoded).joinToString("") { "%02x".format(it) }
+        return fingerprint == pinnedSha1
+    }
+
+    fun hashData(data: ByteArray): String {
+        val md = MessageDigest.getInstance("SHA1")
+        return md.digest(data).joinToString("") { "%02x".format(it) }
+    }
+}

package/dist/packages/crucible/seeds/kotlin/seed-039.kt

@@ -0,0 +1,29 @@
+// [CRUCIBLE-SEED]
+// category: deserialization
+// severity: critical
+// language: kotlin
+// expected: Java ObjectInputStream used to deserialize untrusted data
+
+package com.example.serialization
+
+import java.io.ObjectInputStream
+import java.io.ByteArrayInputStream
+
+class DataDeserializer {
+    fun deserialize(data: ByteArray): Any? {
+        val bais = ByteArrayInputStream(data)
+        val ois = ObjectInputStream(bais)
+        return ois.readObject()
+    }
+
+    fun deserializeFromNetwork(inputStream: java.io.InputStream): Any? {
+        val ois = ObjectInputStream(inputStream)
+        val obj = ois.readObject()
+        ois.close()
+        return obj
+    }
+
+    fun loadUserSession(sessionData: ByteArray): Map<*, *>? {
+        return deserialize(sessionData) as? Map<*, *>
+    }
+}

package/dist/packages/crucible/seeds/kotlin/seed-040.kt

@@ -0,0 +1,28 @@
+// [CRUCIBLE-SEED]
+// category: deserialization
+// severity: critical
+// language: kotlin
+// expected: ObjectInputStream deserialization from HTTP response body
+
+package com.example.network
+
+import java.io.ObjectInputStream
+import java.net.HttpURLConnection
+import java.net.URL
+
+class RemoteDataLoader {
+    fun fetchAndDeserialize(endpoint: String): Any? {
+        val conn = URL(endpoint).openConnection() as HttpURLConnection
+        conn.requestMethod = "GET"
+        return if (conn.responseCode == 200) {
+            ObjectInputStream(conn.inputStream).readObject()
+        } else null
+    }
+
+    fun loadConfig(serverUrl: String): Map<String, Any>? {
+        val conn = URL("$serverUrl/config").openConnection() as HttpURLConnection
+        val ois = ObjectInputStream(conn.inputStream)
+        @Suppress("UNCHECKED_CAST")
+        return ois.readObject() as? Map<String, Any>
+    }
+}

package/dist/packages/crucible/seeds/kotlin/seed-041.kt

@@ -0,0 +1,31 @@
+// [CRUCIBLE-SEED]
+// category: deserialization
+// severity: high
+// language: kotlin
+// expected: Gson deserializes to arbitrary class via user-controlled type token
+
+package com.example.api
+
+import com.google.gson.Gson
+import com.google.gson.reflect.TypeToken
+
+class ApiResponseParser {
+    private val gson = Gson()
+
+    fun <T> parse(json: String, className: String): T? {
+        val clazz = Class.forName(className)
+        @Suppress("UNCHECKED_CAST")
+        return gson.fromJson(json, clazz) as? T
+    }
+
+    fun parseWithTypeToken(json: String, typeDescriptor: String): Any? {
+        val type = Class.forName(typeDescriptor)
+        return gson.fromJson(json, type)
+    }
+
+    fun deserializeList(json: String, elementType: String): List<Any?> {
+        val clazz = Class.forName(elementType)
+        val type = TypeToken.getParameterized(List::class.java, clazz).type
+        return gson.fromJson(json, type)
+    }
+}

package/dist/packages/crucible/seeds/kotlin/seed-042.kt

@@ -0,0 +1,27 @@
+// [CRUCIBLE-SEED]
+// category: deserialization
+// severity: critical
+// language: kotlin
+// expected: Kryo deserialization from untrusted byte stream without allowlist
+
+package com.example.cache
+
+import com.esotericsoftware.kryo.Kryo
+import com.esotericsoftware.kryo.io.Input
+
+class KryoDeserializer {
+    private val kryo = Kryo().apply {
+        isRegistrationRequired = false
+    }
+
+    fun deserialize(data: ByteArray): Any? {
+        val input = Input(data)
+        return kryo.readClassAndObject(input)
+    }
+
+    fun loadFromCache(cacheData: ByteArray): Any? {
+        Input(cacheData).use { input ->
+            return kryo.readClassAndObject(input)
+        }
+    }
+}

package/dist/packages/crucible/seeds/kotlin/seed-043.kt

@@ -0,0 +1,26 @@
+// [CRUCIBLE-SEED]
+// category: deserialization
+// severity: high
+// language: kotlin
+// expected: SharedPreferences stores and restores serialized object via base64 without validation
+
+package com.example.prefs
+
+import android.content.Context
+import android.util.Base64
+import java.io.ByteArrayInputStream
+import java.io.ObjectInputStream
+
+class PreferencesCache(private val context: Context) {
+    fun restoreObject(key: String): Any? {
+        val prefs = context.getSharedPreferences("cache", Context.MODE_PRIVATE)
+        val encoded = prefs.getString(key, null) ?: return null
+        val bytes = Base64.decode(encoded, Base64.DEFAULT)
+        val ois = ObjectInputStream(ByteArrayInputStream(bytes))
+        return ois.readObject()
+    }
+
+    fun restoreUserState(): Map<*, *>? {
+        return restoreObject("user_state") as? Map<*, *>
+    }
+}

package/dist/packages/crucible/seeds/kotlin/seed-044.kt

@@ -0,0 +1,27 @@
+// [CRUCIBLE-SEED]
+// category: ssrf
+// severity: critical
+// language: kotlin
+// expected: URL opened from user-supplied input without validation — SSRF
+
+package com.example.proxy
+
+import java.net.URL
+
+class WebProxy {
+    fun fetchUrl(userUrl: String): String {
+        val url = URL(userUrl)
+        val conn = url.openConnection()
+        return conn.getInputStream().bufferedReader().readText()
+    }
+
+    fun fetchImage(imageUrl: String): ByteArray {
+        return URL(imageUrl).readBytes()
+    }
+
+    fun checkEndpoint(url: String): Boolean {
+        val conn = URL(url).openConnection() as java.net.HttpURLConnection
+        conn.requestMethod = "HEAD"
+        return conn.responseCode == 200
+    }
+}

package/dist/packages/crucible/seeds/kotlin/seed-045.kt

@@ -0,0 +1,27 @@
+// [CRUCIBLE-SEED]
+// category: ssrf
+// severity: critical
+// language: kotlin
+// expected: OkHttp request built from user-controlled URL without allowlist
+
+package com.example.network
+
+import okhttp3.OkHttpClient
+import okhttp3.Request
+
+class HttpForwarder {
+    private val client = OkHttpClient()
+
+    fun forward(targetUrl: String): String {
+        val request = Request.Builder()
+            .url(targetUrl)
+            .build()
+        val response = client.newCall(request).execute()
+        return response.body?.string() ?: ""
+    }
+
+    fun fetchMetadata(instanceMetaUrl: String): String {
+        val req = Request.Builder().url(instanceMetaUrl).header("X-Forwarded-For", "127.0.0.1").build()
+        return client.newCall(req).execute().body?.string() ?: ""
+    }
+}

package/dist/packages/crucible/seeds/kotlin/seed-046.kt

@@ -0,0 +1,33 @@
+// [CRUCIBLE-SEED]
+// category: ssrf
+// severity: critical
+// language: kotlin
+// expected: Ktor server acts as open proxy — fetches user-supplied URL server-side
+
+package com.example.server
+
+import io.ktor.client.*
+import io.ktor.client.request.*
+import io.ktor.server.application.*
+import io.ktor.server.response.*
+import io.ktor.server.routing.*
+
+val httpClient = HttpClient()
+
+fun Application.proxyRoutes() {
+    routing {
+        get("/proxy") {
+            val url = call.parameters["url"] ?: return@get
+            val response = httpClient.get(url)
+            call.respond(response)
+        }
+
+        post("/webhook-test") {
+            val targetUrl = call.parameters["callback"] ?: return@post
+            httpClient.post(targetUrl) {
+                setBody("""{"event":"test"}""")
+            }
+            call.respondText("Triggered")
+        }
+    }
+}

package/dist/packages/crucible/seeds/kotlin/seed-047.kt

@@ -0,0 +1,32 @@
+// [CRUCIBLE-SEED]
+// category: ssrf
+// severity: high
+// language: kotlin
+// expected: HttpURLConnection opened to URL composed from user-supplied hostname
+
+package com.example.health
+
+import java.net.HttpURLConnection
+import java.net.URL
+
+class HealthChecker {
+    fun checkService(host: String, port: Int, path: String): Int {
+        val url = URL("http://$host:$port$path")
+        val conn = url.openConnection() as HttpURLConnection
+        conn.requestMethod = "GET"
+        conn.connectTimeout = 3000
+        conn.readTimeout = 3000
+        return conn.responseCode
+    }
+
+    fun scanPort(host: String, port: Int): Boolean {
+        return try {
+            val url = URL("http://$host:$port")
+            val conn = url.openConnection() as HttpURLConnection
+            conn.connectTimeout = 1000
+            conn.responseCode < 500
+        } catch (e: Exception) {
+            false
+        }
+    }
+}

package/dist/packages/crucible/seeds/kotlin/seed-048.kt

@@ -0,0 +1,20 @@
+// [CRUCIBLE-SEED]
+// category: hardcoded_url
+// severity: medium
+// language: kotlin
+// expected: Hardcoded production API base URL and debug endpoint left in code
+
+package com.example.api
+
+object ApiConfig {
+    const val BASE_URL = "https://api.prod.example.com/v2/"
+    const val DEBUG_URL = "http://192.168.1.100:8080/debug/"
+    const val INTERNAL_ADMIN_URL = "https://admin-internal.example.com/api/"
+    const val LEGACY_URL = "http://old-api.example.com/v1/"
+
+    fun getBaseUrl(debug: Boolean = false): String {
+        return if (debug) DEBUG_URL else BASE_URL
+    }
+
+    fun getAdminEndpoint(path: String) = "$INTERNAL_ADMIN_URL$path"
+}

package/dist/packages/crucible/seeds/kotlin/seed-049.kt

@@ -0,0 +1,23 @@
+// [CRUCIBLE-SEED]
+// category: hardcoded_url
+// severity: medium
+// language: kotlin
+// expected: Hardcoded IP address and dev server URL with credentials embedded
+
+package com.example.config
+
+class ServerConfig {
+    val prodServer = "https://backend.example.com"
+    val devServer = "http://10.0.2.2:3000"
+    val stagingServer = "https://staging.example.com"
+    val debugEndpoint = "http://localhost:9229/json/list"
+
+    val dbConnectionString = "mongodb://admin:password123@mongo.internal.example.com:27017/proddb"
+    val redisUrl = "redis://:myRedisSecret@redis.internal.example.com:6379"
+
+    fun getActiveServer(env: String): String = when (env) {
+        "prod" -> prodServer
+        "staging" -> stagingServer
+        else -> devServer
+    }
+}

package/dist/packages/crucible/seeds/kotlin/seed-050.kt

@@ -0,0 +1,19 @@
+// [CRUCIBLE-SEED]
+// category: hardcoded_url
+// severity: low
+// language: kotlin
+// expected: Hardcoded webhook and analytics endpoint URLs with tracking tokens
+
+package com.example.analytics
+
+object TrackingConfig {
+    const val MIXPANEL_ENDPOINT = "https://api.mixpanel.com/track?token=abc123def456ghi789"
+    const val SEGMENT_WRITE_KEY = "sEgMeNtWrItEkEy1234567890abcdef"
+    const val AMPLITUDE_KEY = "amp_prod_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+    const val WEBHOOK_URL = "https://hooks.slack.com/services/T00000000/B00000000/XXXXXXXXXXXXXXXXXXXXXXXX"
+    const val DATADOG_API_KEY = "datadog_api_key_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+
+    fun trackEvent(event: String, properties: Map<String, Any>) {
+        println("Tracking to $MIXPANEL_ENDPOINT: $event with key $SEGMENT_WRITE_KEY")
+    }
+}

package/dist/packages/crucible/seeds/php/seed-001.php

@@ -0,0 +1,23 @@
+<?php
+// [CRUCIBLE-SEED]
+// category: hardcoded_secret
+// severity: critical
+// language: php
+// expected: Hardcoded database credentials in PHP source file
+
+define('DB_HOST', 'prod-db.example.com');
+define('DB_USER', 'root');
+define('DB_PASS', 'Sup3rS3cr3tP@ssw0rd!2024');
+define('DB_NAME', 'production_db');
+
+function getDbConnection() {
+    $conn = new mysqli(DB_HOST, DB_USER, DB_PASS, DB_NAME);
+    if ($conn->connect_error) {
+        die("Connection failed: " . $conn->connect_error);
+    }
+    return $conn;
+}
+
+function getAdminPassword() {
+    return 'Admin@123456!';
+}

package/dist/packages/crucible/seeds/php/seed-002.php

@@ -0,0 +1,18 @@
+<?php
+// [CRUCIBLE-SEED]
+// category: hardcoded_secret
+// severity: critical
+// language: php
+// expected: Hardcoded Stripe and PayPal API keys
+
+$stripe_secret_key = 'sk_live_51HxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890abcdefgh';
+$stripe_publishable_key = 'pk_live_51HxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0987654321zyxwvu';
+$stripe_webhook_secret = 'whsec_abcdefghijklmnopqrstuvwxyz0123456789ABCDEF';
+
+$paypal_client_id = 'AaBbCcDdEeFfGgHhIiJjKkLlMmNnOoPpQqRrSs';
+$paypal_client_secret = 'EeLlKkJjIiHhGgFfEeDdCcBbAa0123456789xyz';
+
+function getStripeHeaders() {
+    global $stripe_secret_key;
+    return ['Authorization: Bearer ' . $stripe_secret_key];
+}

package/dist/packages/crucible/seeds/php/seed-003.php

@@ -0,0 +1,25 @@
+<?php
+// [CRUCIBLE-SEED]
+// category: hardcoded_secret
+// severity: critical
+// language: php
+// expected: Hardcoded AWS credentials and S3 configuration
+
+class AwsConfig {
+    const ACCESS_KEY = 'AKIAIOSFODNN7EXAMPLE1';
+    const SECRET_KEY = 'wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY';
+    const REGION     = 'us-east-1';
+    const BUCKET     = 'my-production-bucket';
+
+    public static function getCredentials(): array {
+        return [
+            'key'    => self::ACCESS_KEY,
+            'secret' => self::SECRET_KEY,
+            'region' => self::REGION,
+        ];
+    }
+
+    public static function getS3Url(string $key): string {
+        return "https://s3.amazonaws.com/" . self::BUCKET . "/$key?AWSAccessKeyId=" . self::ACCESS_KEY;
+    }
+}

package/dist/packages/crucible/seeds/php/seed-004.php

@@ -0,0 +1,21 @@
+<?php
+// [CRUCIBLE-SEED]
+// category: hardcoded_secret
+// severity: critical
+// language: php
+// expected: Hardcoded JWT secret and encryption key
+
+define('JWT_SECRET', 'mySuperSecretJWTKey_doNotShare_2024_production');
+define('ENCRYPTION_KEY', 'AES256Key-32CharactersLongSecret!!');
+define('ADMIN_API_KEY', 'admin_sk_live_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx');
+
+function generateJwt(array $payload): string {
+    $header  = base64_encode(json_encode(['typ' => 'JWT', 'alg' => 'HS256']));
+    $body    = base64_encode(json_encode($payload));
+    $sig     = hash_hmac('sha256', "$header.$body", JWT_SECRET);
+    return "$header.$body.$sig";
+}
+
+function verifyAdmin(string $key): bool {
+    return $key === ADMIN_API_KEY;
+}

package/dist/packages/crucible/seeds/php/seed-005.php

@@ -0,0 +1,21 @@
+<?php
+// [CRUCIBLE-SEED]
+// category: hardcoded_secret
+// severity: critical
+// language: php
+// expected: Hardcoded SMTP credentials in mailer configuration
+
+$mail_config = [
+    'host'     => 'smtp.sendgrid.net',
+    'port'     => 587,
+    'username' => 'apikey',
+    'password' => 'SG.xxxxxxxxxxxxxxxxxxxxxxxxxxxx.yyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy',
+    'from'     => 'noreply@example.com',
+];
+
+function sendMail(string $to, string $subject, string $body): bool {
+    global $mail_config;
+    // PHPMailer usage with hardcoded credentials
+    echo "Connecting to {$mail_config['host']} with password: {$mail_config['password']}\n";
+    return true;
+}

package/dist/packages/crucible/seeds/php/seed-006.php

@@ -0,0 +1,21 @@
+<?php
+// [CRUCIBLE-SEED]
+// category: hardcoded_secret
+// severity: high
+// language: php
+// expected: Hardcoded OAuth client secret and social login tokens
+
+define('GOOGLE_CLIENT_ID', '1234567890-abcdefghijklmnopqrstuvwxyz.apps.googleusercontent.com');
+define('GOOGLE_CLIENT_SECRET', 'GOCSPX-abcdefghijklmnopqrstuvwxyz123456');
+define('FACEBOOK_APP_SECRET', 'abcdef0123456789abcdef0123456789');
+define('GITHUB_CLIENT_SECRET', 'ghsec_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx');
+
+class OAuthHelper {
+    public static function getGoogleConfig(): array {
+        return [
+            'client_id'     => GOOGLE_CLIENT_ID,
+            'client_secret' => GOOGLE_CLIENT_SECRET,
+            'redirect_uri'  => 'https://example.com/auth/google/callback',
+        ];
+    }
+}

package/dist/packages/crucible/seeds/php/seed-007.php

@@ -0,0 +1,18 @@
+<?php
+// [CRUCIBLE-SEED]
+// category: hardcoded_secret
+// severity: critical
+// language: php
+// expected: Hardcoded Twilio credentials and webhook tokens
+
+$twilio_account_sid  = 'ACxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx';
+$twilio_auth_token   = 'your_auth_token_here_32chars_long!!';
+$twilio_phone_number = '+15005550006';
+$twilio_webhook_key  = 'twilio_webhook_secret_validation_key';
+
+function sendSms(string $to, string $message): array {
+    global $twilio_account_sid, $twilio_auth_token, $twilio_phone_number;
+    $url = "https://api.twilio.com/2010-04-01/Accounts/$twilio_account_sid/Messages.json";
+    echo "Sending via SID: $twilio_account_sid Token: $twilio_auth_token\n";
+    return ['status' => 'queued'];
+}

package/dist/packages/crucible/seeds/php/seed-008.php

@@ -0,0 +1,19 @@
+<?php
+// [CRUCIBLE-SEED]
+// category: hardcoded_secret
+// severity: critical
+// language: php
+// expected: Hardcoded Redis and session secret keys
+
+define('REDIS_HOST', 'redis.prod.internal');
+define('REDIS_PASSWORD', 'myR3d1sS3cret!2024');
+define('SESSION_SECRET', 'flask-session-secret-do-not-expose-xxxxx');
+define('CSRF_SECRET', 'csrf-token-secret-key-production-2024!!');
+
+function getRedisClient() {
+    $redis = new Redis();
+    $redis->connect(REDIS_HOST, 6379);
+    $redis->auth(REDIS_PASSWORD);
+    error_log("Connected to Redis with password: " . REDIS_PASSWORD);
+    return $redis;
+}

package/dist/packages/crucible/seeds/php/seed-009.php

@@ -0,0 +1,24 @@
+<?php
+// [CRUCIBLE-SEED]
+// category: sql_injection
+// severity: critical
+// language: php
+// expected: mysqli_query with string concatenation — no prepared statements
+
+function getUserByName(string $username): array {
+    $conn = getDbConnection();
+    $query = "SELECT * FROM users WHERE username = '" . $username . "'";
+    $result = mysqli_query($conn, $query);
+    return mysqli_fetch_assoc($result) ?: [];
+}
+
+function getUserPosts(string $userId): array {
+    $conn = getDbConnection();
+    $sql = "SELECT * FROM posts WHERE user_id = " . $userId . " ORDER BY created_at DESC";
+    $result = mysqli_query($conn, $sql);
+    $posts = [];
+    while ($row = mysqli_fetch_assoc($result)) {
+        $posts[] = $row;
+    }
+    return $posts;
+}

package/dist/packages/crucible/seeds/php/seed-010.php

@@ -0,0 +1,24 @@
+<?php
+// [CRUCIBLE-SEED]
+// category: sql_injection
+// severity: critical
+// language: php
+// expected: mysql_query with raw user input — deprecated and injectable
+
+function searchProducts(string $term, string $category): array {
+    $db = mysql_connect('localhost', 'root', 'password');
+    mysql_select_db('shop', $db);
+    $query = "SELECT * FROM products WHERE name LIKE '%" . $term . "%' AND category = '" . $category . "'";
+    $result = mysql_query($query, $db);
+    $items = [];
+    while ($row = mysql_fetch_assoc($result)) {
+        $items[] = $row;
+    }
+    return $items;
+}
+
+function deleteProduct(string $id): bool {
+    $db = mysql_connect('localhost', 'root', 'password');
+    mysql_select_db('shop', $db);
+    return mysql_query("DELETE FROM products WHERE id = " . $id, $db);
+}

package/dist/packages/crucible/seeds/php/seed-011.php

@@ -0,0 +1,18 @@
+<?php
+// [CRUCIBLE-SEED]
+// category: sql_injection
+// severity: critical
+// language: php
+// expected: PDO query with string interpolation instead of bound parameters
+
+function getOrdersByStatus(string $status, string $fromDate): array {
+    $pdo = new PDO('mysql:host=localhost;dbname=orders', 'app', 'pass');
+    $stmt = $pdo->query("SELECT * FROM orders WHERE status = '$status' AND created_at >= '$fromDate'");
+    return $stmt->fetchAll(PDO::FETCH_ASSOC);
+}
+
+function updateOrderStatus(string $orderId, string $newStatus): bool {
+    $pdo = new PDO('mysql:host=localhost;dbname=orders', 'app', 'pass');
+    $sql = "UPDATE orders SET status = '$newStatus' WHERE id = $orderId";
+    return $pdo->exec($sql) !== false;
+}

package/dist/packages/crucible/seeds/php/seed-012.php

@@ -0,0 +1,24 @@
+<?php
+// [CRUCIBLE-SEED]
+// category: sql_injection
+// severity: critical
+// language: php
+// expected: ORDER BY column name from user input without whitelist validation
+
+function getSortedUsers(string $sortCol, string $sortDir): array {
+    $conn = getDbConnection();
+    $query = "SELECT * FROM users ORDER BY " . $sortCol . " " . $sortDir;
+    $result = mysqli_query($conn, $query);
+    $users = [];
+    while ($row = mysqli_fetch_assoc($result)) {
+        $users[] = $row;
+    }
+    return $users;
+}
+
+function filterByColumn(string $column, string $value): array {
+    $conn = getDbConnection();
+    $sql = "SELECT * FROM records WHERE $column = '$value'";
+    $result = mysqli_query($conn, $sql);
+    return mysqli_fetch_all($result, MYSQLI_ASSOC);
+}