Grub-Fehler „inkompatible Lizenz“

Question 1

Update 2:

Ich habe vergessen, dass du den Tarball gepostet hast. Schade. Jedenfalls habe ich deine .modDateien mit dem folgenden Code getestet und:

./grum_lic_test32 evan_teitelman/boot/grub/i386-pc/*.mod

was den folgenden Fehler ergab:

...
bufio.mod                 License: LICENSE=GPLv3+            OK
cacheinfo.mod             License: LICENSE=NONE_FOUND        ERR
cat.mod                   License: LICENSE=GPLv3+            OK
chain.mod                 License: LICENSE=GPLv3+            OK
...

aber diese Datei ist identisch mit der aus dem Archlinux-Download, also sollte das kein Problem sein. Mit anderen Worten, es war nicht die Ursache.

Beachten Sie außerdem zunächst, dass Sie LILO installiert haben – und gehen Sie davon aus, dass der Fall damit abgeschlossen ist. Wenn nicht, bleibt immer noch die Frage nach GPT und BIOS + anderen Problemen. Haben Sie es beim ersten Mal installiert? Es kann sein, dass bei der ersten Installation einige Optimierungen vorgenommen wurden, die durch die Neuinstallation von GRUB nicht behoben wurden.

Update 1:OK. Behoben. Sollte sowohl für 32- als auch für 64-Bit funktionieren ELF.

Beim GRUBLaden der Module wird geprüft, ob in der ELFDatei für jedes Modul eine Lizenz eingebettet ist. Wenn eine ungültige Lizenz gefunden wird, wird das Modul ignoriert – und dieser spezielle Fehler wird ausgegeben. Möglicherweise sind ein oder mehrere Module beschädigt.

Wenn es ein wesentliches Modul ist, würde alles schiefgehen. Sagen wir zB part_gpt.mod oder part_msdos.mod.

Akzeptierte Lizenzen sind GPLv2+, GPLv3und GPLv3+.

Es könnte natürlich auch andere Gründe haben, aber einer von vielen könnten beschädigte Moduldateien sein.

Es scheint, als wären die Module gültige ELFDateien, da sie vor dem Lizenztest als solche validiert werden. Wie in: Wenn ELFder Test fehlschlägt, wird der Lizenztest nicht ausgeführt.

Hatte ein weiteres Problem mit Modulen, bei dem ich verschiedene überprüfen musste. Ich habe Teile dieses Codes extrahiert und daraus einen schnellen Lizenztester gemacht. Sie können jede *.modDatei testen, /boot/grub/*um zu sehen, welche beschädigt ist/sind.

Dieser Code führt keine Validierung ELFoder sonstiges durch. Versuchen Sie nur, die Lizenzzeichenfolge zu finden und überprüfen Sie diese. Außerdem wurde er nur unter i386/32-Bit getestet. Der Originalcode, aus dem er extrahiert wurde, funktionierte auch unter x86-64 – aber hier wurde viel entfernt und gehackt, sodass ich mir über das Ergebnis nicht sicher bin. Wenn er unter 64-Bit nicht funktioniert, sollte er höchstwahrscheinlich nur drucken License: LICENSE=NONE_FOUND.

(Wie in der Bearbeitung oben erwähnt, habe ich jetzt für 32 und 64 Bit, Intel getestet.)

Als separater Test könnte man dann etwa Folgendes tun:

xxd file.mod | grep -C1 LIC

Nicht der schönste Code – aber als schnelle und einfache Überprüfung.

(Im Sinne von: Sie könnten es versuchen.)

Kompilierungsanweisungen, zB:

gcc -o grub_lic_test32 source.c         # 32-bit variant
gcc -o grub_lic_test64 source.c -DELF64 # 64-bit variant

Laufen:

./grub_lic_test32 /path/to/mods/*.mod

Druckt jede Datei und Lizenz, zB:

./grub_lic_test32 tar.mod gettext.mod pxe.mod
tar.mod                   License: LICENSE=GPLv1+            BAD
gettext.mod               License: LICENSE=GPLv3+            OK
pxe.mod                   License: LICENSE=GPLv3+            OK

Code:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>
#include <errno.h>

#ifdef ELF64
struct ELF_hdr
{
    unsigned char dummy0[16];
    uint32_t dummy1[6];
    uint64_t sh_off;
    uint16_t dummy2[5];
    uint16_t sh_entsize;
    uint16_t sh_num;
    uint16_t sh_strndx;
};
struct ELF_sect_hdr
{
    uint32_t sh_name;
    uint32_t dummy0[5];
    uint64_t sh_offset;
};
#else
struct ELF_hdr
{
    unsigned char dummy0[16];
    uint32_t dummy1[4];
    uint32_t sh_off;
    uint16_t dummy2[5];
    uint16_t sh_entsize;
    uint16_t sh_num;
    uint16_t sh_strndx;
};
struct ELF_sect_hdr
{
    uint32_t sh_name;
    uint32_t dummy[3];
    uint32_t sh_offset;
};
#endif

enum {
    ERR_FILE_OPEN = 1,
    ERR_FILE_READ,
    ERR_MEM,
    ERR_BAD_LICENSE,
    ERR_ELF_SECT_CORE_BREACH
};

int file_size(FILE *fh, size_t *fs)
{
    size_t cp;

    cp = ftell(fh);
    fseek(fh, 0, SEEK_END);
    *fs = ftell(fh);
    fseek(fh, cp, SEEK_SET);

    return 0;
}

static const char *valid_licenses[] = {
    "LICENSE=GPLv2+",
    "LICENSE=GPLv3",
    "LICENSE=GPLv3+",
    NULL
};

int grub_check_license(struct ELF_hdr *e)
{
    struct ELF_sect_hdr *s;
    const char *txt;
    const char *lic;
    unsigned i, j = 0;

    s = (struct ELF_sect_hdr *)
        ((char *) e + e->sh_off + e->sh_strndx * e->sh_entsize);

    txt = (char *) e + s->sh_offset;

    s = (struct ELF_sect_hdr *) ((char *) e + e->sh_off);

    for (i = 0; i < e->sh_num; ++i) {
        if (strcmp (txt + s->sh_name, ".module_license") == 0) {
            lic = (char*) e + s->sh_offset;

            if (j)
                fprintf(stdout, "%25s", "");
            fprintf(stdout, "License: %-25s ", lic);

            for (j = 0; valid_licenses[j]; ++j) {
                if (!strcmp (lic, valid_licenses[j])) {
                    fprintf(stdout, "OK\n");
                    return 0;
                }
            }
            fprintf(stdout, "BAD\n");
        }
        s = (struct ELF_sect_hdr *) ((char *) s + e->sh_entsize);
    }

    if (!j)
        fprintf(stdout, "License: %-25s ERR\n", "LICENSE=NONE_FOUND");

    return ERR_BAD_LICENSE;
}

int grub_check_module(void *buf, size_t size, int verbose)
{
    struct ELF_hdr *e = buf;

    /* Make sure that every section is within the core.  */
    if (e->sh_off + e->sh_entsize * e->sh_num > size) {
        fprintf(stderr, "ERR: Sections outside core\n");
        if (verbose)
            fprintf(stderr,
                "  %*s: %u bytes\n"
#ifdef ELF64
                "  %*s  %u < %llu\n"
                "  %*s: %llu\n"
#else
                "  %*s  %u < %u\n"
                "  %*s: %u\n"
#endif
                "  %*s: %u\n"
                "  %*s: %u\n"
                ,
                -25, "file-size", size,
                -25, "",
                size, e->sh_off + e->sh_entsize * e->sh_num,
                -25, "sector header offset", e->sh_off,
                -25, "sector header entry size", e->sh_entsize,
                -25, "sector header num", e->sh_num
            );
        return ERR_ELF_SECT_CORE_BREACH;
    }

    return grub_check_license(e);
}

int grub_check_module_file(const char *fn, int verbose)
{
    FILE *fh;
    void *buf;
    size_t fs;
    int eno;
    char *base_fn;

    if (!(base_fn = strrchr(fn, '/')))
        base_fn = (char*)fn;
    else
        ++base_fn;

    fprintf(stderr, "%-25s ", base_fn);

    if (!(fh = fopen(fn, "rb"))) {
        fprintf(stderr, "ERR: Unable to open `%s'\n", fn);
        perror("fopen");
        return ERR_FILE_OPEN;
    }
    file_size(fh, &fs);
    if (!(buf = malloc(fs))) {
        fprintf(stderr, "ERR: Memory.\n");
        fclose(fh);
        return ERR_MEM;
    }
    if (fread(buf, 1, fs, fh) != fs) {
        fprintf(stderr, "ERR: Reading `%s'\n", fn);
        perror("fread");
        free(buf);
        fclose(fh);
        return ERR_FILE_READ;
    }
    fclose(fh);

    eno = grub_check_module(buf, fs, verbose);
    free(buf);

    return eno;
}


int main(int argc, char *argv[])
{
    int i = 1;
    int eno = 0;
    int verbose = 0;

    if (argc > 1 && argv[1][0] == '-' && argv[1][1] == 'v') {
        verbose = 1;
        ++i;
    }

    if (argc - i < 1) {
        fprintf(stderr, "Usage: %s [-v] <FILE>[, FILE[, ...]]\n", argv[0]);
        return 1;
    }


    for (; i < argc; ++i) {
        eno |= grub_check_module_file(argv[i], verbose);
        if (eno == ERR_MEM)
            return eno;
    }

    return eno;
}

Answer