DUPERREY.COM

Ceci est une ancienne révision du document !

---

Bloc Note rapide

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

#define MAX_SCRIPTS 100
#define MAX_SCRIPT_LENGTH 256

// Chemin fixe vers le fichier des scripts valides
#define VALID_SCRIPTS_FILE "/path/to/valid_scripts.txt"

// Liste des scripts valides par défaut
const char *default_scripts[] = {"toto.sh", "titi.sh", "tata.sh"};
const size_t default_scripts_count = sizeof(default_scripts) / sizeof(default_scripts[0]);

// Liste externe pour stocker les scripts supplémentaires
char external_scripts[MAX_SCRIPTS][MAX_SCRIPT_LENGTH];
size_t external_scripts_count = 0;

// Fonction pour vérifier que le programme est lancé par un script shell
void check_parent_process() {
    char path[256];
    char parent_executable[256] = {0};
    FILE *file;

    // Obtenir le PPID (Parent Process ID)
    pid_t ppid = getppid();

    // Lire le nom du processus parent dans /proc/[PPID]/comm
    snprintf(path, sizeof(path), "/proc/%d/comm", ppid);
    file = fopen(path, "r");
    if (!file) {
        perror("Error: Unable to check parent process");
        exit(1);
    }

    if (fgets(parent_executable, sizeof(parent_executable), file)) {
        // Supprimer le saut de ligne
        parent_executable[strcspn(parent_executable, "\n")] = 0;
    }
    fclose(file);

    // Vérifier si le processus parent est un shell (bash, sh, etc.)
    if (strcmp(parent_executable, "bash") != 0 && strcmp(parent_executable, "sh") != 0) {
        fprintf(stderr, "Error: This program must be launched by a shell script (bash or sh).\n");
        exit(1);
    }
}

// Fonction pour charger les scripts valides depuis un fichier
int load_external_scripts() {
    FILE *file = fopen(VALID_SCRIPTS_FILE, "r");
    if (!file) {
        perror("Error opening the valid scripts file");
        return 1;
    }

    char line[MAX_SCRIPT_LENGTH];
    while (fgets(line, sizeof(line), file)) {
        line[strcspn(line, "\n")] = 0; // Supprimer le saut de ligne

        if (external_scripts_count >= MAX_SCRIPTS) {
            fprintf(stderr, "Error: Too many scripts in the external list.\n");
            fclose(file);
            return 1;
        }

        strncpy(external_scripts[external_scripts_count], line, MAX_SCRIPT_LENGTH - 1);
        external_scripts[external_scripts_count][MAX_SCRIPT_LENGTH - 1] = '\0';
        external_scripts_count++;
    }

    fclose(file);
    return 0;
}

// Fonction pour vérifier si le script est valide
int is_valid_script(const char *script) {
    for (size_t i = 0; i < default_scripts_count; i++) {
        if (strcmp(script, default_scripts[i]) == 0) {
            return 1;
        }
    }
    for (size_t i = 0; i < external_scripts_count; i++) {
        if (strcmp(script, external_scripts[i]) == 0) {
            return 1;
        }
    }
    return 0;
}

// Fonction pour décoder en base64
void decode_base64(const char *input) {
    char command[512];
    snprintf(command, sizeof(command), "echo %s | base64 -d", input);
    system(command);
}

int main(int argc, char *argv[]) {
    // Vérifier si le programme est lancé par un script shell
    check_parent_process();

    // Charger la liste externe des scripts valides
    if (load_external_scripts() != 0) {
        return 1;
    }

    // Vérifier que la variable d'environnement SCRIPT est définie
    const char *script = getenv("SCRIPT");
    if (script == NULL) {
        fprintf(stderr, "Error: Environment variable SCRIPT is not set.\n");
        return 1;
    }

    // Vérifier si le script est valide
    if (!is_valid_script(script)) {
        fprintf(stderr, "Error: Script '%s' is not allowed.\n", script);
        return 1;
    }

    // Vérifier qu'un argument pour le décodage a été fourni
    if (argc < 2) {
        fprintf(stderr, "Missing argument for base64 decoding.\n");
        return 1;
    }

    // Décoder l'argument en base64
    decode_base64(argv[1]);
    printf("\n");

    return 0;
}