防止学生拷贝虚拟机

我一直给学生上两门课,即《IaaS云计算——OpenStack》和《PaaS云计算——Kubernetes》。每个学生都要在各自的电脑上(安装了windows 10)创建若干台VMWare WorkStation虚拟机,虚拟机里面安装Rocky操作系统,然后部署多节点云计算平台。学期末检查学生的实验完成进度,并进行考评打分。实操分数在期末综合评分当中占了相当比重,所以特别重要,也要求学生重视平时的课堂实操。

但是经常有部分学生平时不动手,快到期末时直接拷贝别人的虚拟机来应付期末检查。

1. 菜鸟方法

为了杜绝这种“作弊”行为,我写了个给虚拟机打标记的小程序,要求学生在安装完Rocky操作系统并做完基本配置后运行此程序,给控制虚拟机(一般是master)打上标记(相当于盖了邮戳),标记内容包括学号、姓名、machine-id、磁盘序列号、登记时间。而且一台虚拟机只允许打一次标记,但可以无限次查看标记。这样其他学生拷贝虚拟机后,就不能再修改标记了。老师期末检查时,只要查看标记即可判断是不是拷贝了别人的虚拟机。

但程序暗含了一个功能,当执行markctl clear,然后输入正确的密码后,会清除标记,然后就可以重新打标机。这个清除标记的密码只有老师知道,当有学生具备正当理由需要重新打标记时,就可以先清除其标记。

这个小程序的代码如下:

/*
 * markctl - 在虚拟机磁盘的原始扇区里写入"学号:姓名"标记
 *
 * 用法:
 *   sudo ./markctl register [--disk /dev/sda]   写入标记(每块磁盘只能成功一次)
 *   sudo ./markctl show     [--disk /dev/sda]   读取并显示标记(可多次)
 *
 * 编译(老师在一台机器上编译一次,把二进制分发给学生):
 *   gcc -O2 -static -s -o markctl markctl.c
 *   strip markctl 
 *
 * 标记写在磁盘 LBA 1024 和 LBA 1040 各一份(第一个分区之前的空隙)。
 */
#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>
#include <errno.h>
#include <fcntl.h>
#include <unistd.h>
#include <time.h>
#include <ctype.h>
#include <termios.h>

#define SECTOR 512
#define MAGIC "STUMARK1"
#define NLOC 2
static const long LOCS[NLOC] = {1024, 1040};

/* 布局: magic8 | ver2 | rsv2 | time8 | id32 | name64 | mid32 | ...填零... | crc4 */
#define OFF_VER 8
#define OFF_TIME 12
#define OFF_ID 20
#define OFF_NAME 52
#define OFF_MID 116
#define LEN_ID 32
#define LEN_NAME 64
#define LEN_MID 32

static uint32_t crc_table[256];

static void crc_init(void)
{
    for (uint32_t i = 0; i < 256; i++) {
        uint32_t c = i;
        for (int k = 0; k < 8; k++)
            c = (c & 1) ? 0xEDB88320u ^ (c >> 1) : c >> 1;
        crc_table[i] = c;
    }
}

static uint32_t crc32_buf(const unsigned char *p, size_t n)
{
    uint32_t c = 0xFFFFFFFFu;
    while (n--)
        c = crc_table[(c ^ *p++) & 0xFF] ^ (c >> 8);
    return c ^ 0xFFFFFFFFu;
}

static void die(const char *msg, int code)
{
    fprintf(stderr, "错误: %s\n", msg);
    exit(code);
}

/* 执行命令取第一行输出 */
static int run_line(const char *cmd, char *out, size_t n)
{
    FILE *f = popen(cmd, "r");
    if (!f) return -1;
    if (!fgets(out, (int)n, f)) { pclose(f); return -1; }
    pclose(f);
    out[strcspn(out, "\r\n")] = 0;
    return 0;
}

static int shell_safe(const char *s)
{
    for (; *s; s++)
        if (!isalnum((unsigned char)*s) && !strchr("/_.-:", *s)) return 0;
    return 1;
}

/* 找 /boot(没有则 /)所在的物理磁盘,兼容 LVM */
static int detect_disk(char *disk, size_t n)
{
    const char *mnts[] = {"/boot", "/"};
    for (int i = 0; i < 2; i++) {
        char cmd[512], src[256], line[256];
        snprintf(cmd, sizeof cmd, "findmnt -n -o SOURCE %s 2>/dev/null", mnts[i]);
        if (run_line(cmd, src, sizeof src) < 0 || !src[0]) continue;
        char *br = strchr(src, '[');
        if (br) *br = 0;
        if (!shell_safe(src)) continue;
        /* 从该设备向上追溯到 TYPE=disk 的那一行 */
        snprintf(cmd, sizeof cmd,
                 "lsblk -nsrpo NAME,TYPE %s 2>/dev/null | awk '$2==\"disk\"{print $1; exit}'", src);
        if (run_line(cmd, line, sizeof line) == 0 && line[0]) {
            snprintf(disk, n, "%s", line);
            return 0;
        }
    }
    return -1;
}

static void read_machine_id(char *buf, size_t n)
{
    buf[0] = 0;
    FILE *f = fopen("/etc/machine-id", "r");
    if (!f) return;
    if (fgets(buf, (int)n, f)) buf[strcspn(buf, "\r\n")] = 0;
    fclose(f);
}

static void build_block(unsigned char *b, const char *id, const char *name)
{
    char mid[64];
    uint16_t ver = 1;
    uint64_t t = (uint64_t)time(NULL);
    memset(b, 0, SECTOR);
    memcpy(b, MAGIC, 8);
    memcpy(b + OFF_VER, &ver, 2);
    memcpy(b + OFF_TIME, &t, 8);
    strncpy((char *)b + OFF_ID, id, LEN_ID - 1);
    strncpy((char *)b + OFF_NAME, name, LEN_NAME - 1);
    read_machine_id(mid, sizeof mid);
    memcpy(b + OFF_MID, mid, strnlen(mid, LEN_MID));
    uint32_t c = crc32_buf(b, SECTOR - 4);
    memcpy(b + SECTOR - 4, &c, 4);
}

/* 0=全零  1=有效  2=有内容但无效 */
static int parse_block(const unsigned char *b)
{
    static const unsigned char zero[SECTOR];
    if (memcmp(b, zero, SECTOR) == 0) return 0;
    if (memcmp(b, MAGIC, 8) != 0) return 2;
    uint32_t c, want;
    memcpy(&c, b + SECTOR - 4, 4);
    want = crc32_buf(b, SECTOR - 4);
    return c == want ? 1 : 2;
}

static int open_disk(const char *path, int write)
{
    int fd = open(path, (write ? O_RDWR | O_SYNC : O_RDONLY));
    if (fd < 0) {
        if (errno == EACCES || errno == EPERM) die("需要 root 权限,请在命令前加 sudo", 1);
        fprintf(stderr, "错误: 无法打开 %s: %s\n", path, strerror(errno));
        exit(1);
    }
    off_t size = lseek(fd, 0, SEEK_END);
    if (size < (off_t)(LOCS[NLOC - 1] + 1) * SECTOR) die("磁盘太小,无法写入标记", 1);
    return fd;
}

static int read_sector(int fd, long lba, unsigned char *b)
{
    return pread(fd, b, SECTOR, (off_t)lba * SECTOR) == SECTOR ? 0 : -1;
}

static void get_str(const unsigned char *b, int off, int len, char *out)
{
    memcpy(out, b + off, len);
    out[len] = 0;
}

static void cmd_show(const char *disk)
{
    unsigned char blk[NLOC][SECTOR];
    int st[NLOC], good = 0, bad = 0, first = -1;
    int fd = open_disk(disk, 0);
    for (int i = 0; i < NLOC; i++) {
        if (read_sector(fd, LOCS[i], blk[i]) < 0) die("读取磁盘失败", 1);
        st[i] = parse_block(blk[i]);
        if (st[i] == 1) { good++; if (first < 0) first = i; }
        if (st[i] == 2) bad++;
    }
    close(fd);
    printf("磁盘: %s\n", disk);
    if (!good) {
        if (bad) { printf("状态: 标记已损坏(校验失败),可能被改动过\n"); exit(3); }
        printf("状态: 未登记\n");
        exit(2);
    }
    char id[LEN_ID + 1], name[LEN_NAME + 1], mid[LEN_MID + 1], cur[64];
    uint64_t t;
    get_str(blk[first], OFF_ID, LEN_ID, id);
    get_str(blk[first], OFF_NAME, LEN_NAME, name);
    get_str(blk[first], OFF_MID, LEN_MID, mid);
    memcpy(&t, blk[first] + OFF_TIME, 8);
    time_t tt = (time_t)t;
    char ts[64];
    strftime(ts, sizeof ts, "%Y-%m-%d %H:%M:%S", localtime(&tt));
    printf("学号: %s\n姓名: %s\n登记时间: %s\n登记时 machine-id: %s\n", id, name, ts, mid);
    if (good == 2 && memcmp(blk[0], blk[1], SECTOR) != 0)
        printf("警告: 两份副本内容不一致\n");
    else if (good == 1)
        printf("警告: 只有一份副本有效,另一份缺失或损坏\n");
    read_machine_id(cur, sizeof cur);
    if (mid[0] && strcmp(mid, cur) != 0)
        printf("提示: 当前系统的 machine-id 与登记时不同(虚拟机可能被拷贝或重装过)\n");
}

static void trim(char *s)
{
    size_t n = strlen(s);
    while (n && isspace((unsigned char)s[n - 1])) s[--n] = 0;
    char *p = s;
    while (*p && isspace((unsigned char)*p)) p++;
    memmove(s, p, strlen(p) + 1);
}

static void ask(const char *prompt, char *buf, size_t n)
{
    printf("%s", prompt);
    fflush(stdout);
    if (!fgets(buf, (int)n, stdin)) buf[0] = 0;
    buf[strcspn(buf, "\r\n")] = 0;
    trim(buf);
}

static void cmd_register(const char *disk)
{
    unsigned char old[NLOC][SECTOR], blk[SECTOR];
    int fd = open_disk(disk, 1);
    int any_good = 0, any_junk = 0;
    for (int i = 0; i < NLOC; i++) {
        if (read_sector(fd, LOCS[i], old[i]) < 0) die("读取磁盘失败", 1);
        int s = parse_block(old[i]);
        if (s == 1) any_good = 1;
        if (s == 2) any_junk = 1;
    }
    if (any_good) {
        for (int i = 0; i < NLOC; i++)
            if (parse_block(old[i]) == 1) {
                char id[LEN_ID + 1], name[LEN_NAME + 1];
                get_str(old[i], OFF_ID, LEN_ID, id);
                get_str(old[i], OFF_NAME, LEN_NAME, name);
                printf("这块磁盘已经登记过了,不能再次写入:\n  学号(Student ID): %s  姓名(Name): %s\n", id, name);
                break;
            }
        close(fd);
        exit(2);
    }
    if (any_junk) {
        printf("磁盘标记区域存在不明数据(可能是标记被破坏),拒绝写入。请联系老师。\n");
        close(fd);
        exit(3);
    }

    char id[128], name[256], ans[64];
    printf("磁盘: %s\n注意:登记后无法修改,请仔细核对!\n", disk);
    ask("学号(Student ID): ", id, sizeof id);
    ask("姓名(Name): ", name, sizeof name);
    if (!id[0] || !name[0]) die("学号和姓名都不能为空", 1);
    if (strlen(id) > LEN_ID - 1 || strlen(name) > LEN_NAME - 1) die("学号或姓名过长", 1);
    printf("\n请确认:  学号(Student ID) = %s    姓名(Name) = %s\n", id, name);
    ask("输入 yes 确认写入: ", ans, sizeof ans);
    for (char *p = ans; *p; p++) *p = (char)tolower((unsigned char)*p);
    if (strcmp(ans, "yes") != 0) {
        printf("已取消,未写入任何数据。\n");
        close(fd);
        return;
    }

    build_block(blk, id, name);
    for (int i = 0; i < NLOC; i++)
        if (pwrite(fd, blk, SECTOR, (off_t)LOCS[i] * SECTOR) != SECTOR)
            die("写入失败", 4);
    fsync(fd);
    for (int i = 0; i < NLOC; i++) {
        unsigned char chk[SECTOR];
        if (read_sector(fd, LOCS[i], chk) < 0 || memcmp(chk, blk, SECTOR) != 0)
            die("写入后校验失败,请联系老师", 4);
    }
    close(fd);
    printf("\n登记成功。可用 'sudo ./markctl show' 查询。\n");
}


/* ---------- 隐藏命令: clear(无任何提示,密码以哈希形式保存) ---------- */
static const uint32_t K256[64] = {
    0x428a2f98,0x71374491,0xb5c0fbcf,0xe9b5dba5,0x3956c25b,0x59f111f1,0x923f82a4,0xab1c5ed5,
    0xd807aa98,0x12835b01,0x243185be,0x550c7dc3,0x72be5d74,0x80deb1fe,0x9bdc06a7,0xc19bf174,
    0xe49b69c1,0xefbe4786,0x0fc19dc6,0x240ca1cc,0x2de92c6f,0x4a7484aa,0x5cb0a9dc,0x76f988da,
    0x983e5152,0xa831c66d,0xb00327c8,0xbf597fc7,0xc6e00bf3,0xd5a79147,0x06ca6351,0x14292967,
    0x27b70a85,0x2e1b2138,0x4d2c6dfc,0x53380d13,0x650a7354,0x766a0abb,0x81c2c92e,0x92722c85,
    0xa2bfe8a1,0xa81a664b,0xc24b8b70,0xc76c51a3,0xd192e819,0xd6990624,0xf40e3585,0x106aa070,
    0x19a4c116,0x1e376c08,0x2748774c,0x34b0bcb5,0x391c0cb3,0x4ed8aa4a,0x5b9cca4f,0x682e6ff3,
    0x748f82ee,0x78a5636f,0x84c87814,0x8cc70208,0x90befffa,0xa4506ceb,0xbef9a3f7,0xc67178f2};

#define ROR(x,n) (((x) >> (n)) | ((x) << (32 - (n))))

static void sha256(const unsigned char *msg, size_t len, unsigned char out[32])
{
    uint32_t h[8] = {0x6a09e667,0xbb67ae85,0x3c6ef372,0xa54ff53a,
                     0x510e527f,0x9b05688c,0x1f83d9ab,0x5be0cd19};
    unsigned char buf[128];
    size_t total = ((len + 8) / 64 + 1) * 64;
    if (total > sizeof buf) { memset(out, 0, 32); return; }   /* 密码很短,够用 */
    memset(buf, 0, total);
    memcpy(buf, msg, len);
    buf[len] = 0x80;
    uint64_t bits = (uint64_t)len * 8;
    for (int i = 0; i < 8; i++) buf[total - 1 - i] = (unsigned char)(bits >> (8 * i));
    for (size_t off = 0; off < total; off += 64) {
        uint32_t w[64], a, b, c, d, e, f, g, hh;
        for (int i = 0; i < 16; i++)
            w[i] = (uint32_t)buf[off+4*i] << 24 | (uint32_t)buf[off+4*i+1] << 16 |
                   (uint32_t)buf[off+4*i+2] << 8 | buf[off+4*i+3];
        for (int i = 16; i < 64; i++) {
            uint32_t s0 = ROR(w[i-15],7) ^ ROR(w[i-15],18) ^ (w[i-15] >> 3);
            uint32_t s1 = ROR(w[i-2],17) ^ ROR(w[i-2],19) ^ (w[i-2] >> 10);
            w[i] = w[i-16] + s0 + w[i-7] + s1;
        }
        a=h[0]; b=h[1]; c=h[2]; d=h[3]; e=h[4]; f=h[5]; g=h[6]; hh=h[7];
        for (int i = 0; i < 64; i++) {
            uint32_t S1 = ROR(e,6) ^ ROR(e,11) ^ ROR(e,25);
            uint32_t ch = (e & f) ^ (~e & g);
            uint32_t t1 = hh + S1 + ch + K256[i] + w[i];
            uint32_t S0 = ROR(a,2) ^ ROR(a,13) ^ ROR(a,22);
            uint32_t mj = (a & b) ^ (a & c) ^ (b & c);
            uint32_t t2 = S0 + mj;
            hh=g; g=f; f=e; e=d+t1; d=c; c=b; b=a; a=t1+t2;
        }
        h[0]+=a; h[1]+=b; h[2]+=c; h[3]+=d; h[4]+=e; h[5]+=f; h[6]+=g; h[7]+=hh;
    }
    for (int i = 0; i < 8; i++) {
        out[4*i] = (unsigned char)(h[i] >> 24); out[4*i+1] = (unsigned char)(h[i] >> 16);
        out[4*i+2] = (unsigned char)(h[i] >> 8); out[4*i+3] = (unsigned char)h[i];
    }
}

static const unsigned char CLEAR_HASH[32] = {
    0xdb,0x3f,0xf5,0x29,0xc1,0x9c,0x0a,0x51,0x10,0xa8,0xa0,0xb0,0x20,0xec,0x44,0xdc,
    0x54,0xa6,0x92,0x3b,0x0c,0xfa,0x4a,0xf6,0x9b,0x14,0xd3,0xd5,0xa3,0xad,0xc9,0x29
};

/* 无回显读取一行;全程不输出任何提示 */
static void read_silent(char *buf, size_t n)
{
    struct termios oldt, newt;
    int tty = isatty(STDIN_FILENO);
    if (tty && tcgetattr(STDIN_FILENO, &oldt) == 0) {
        newt = oldt;
        newt.c_lflag &= ~(tcflag_t)(ECHO);
        tcsetattr(STDIN_FILENO, TCSANOW, &newt);
    } else tty = 0;
    if (!fgets(buf, (int)n, stdin)) buf[0] = 0;
    buf[strcspn(buf, "\r\n")] = 0;
    if (tty) tcsetattr(STDIN_FILENO, TCSANOW, &oldt);
}

/* 密码正确则把两份副本清零;任何情况下都不输出任何内容,也不区分成败 */
static void cmd_clear(const char *disk)
{
    char pw[128];
    unsigned char hash[32], zero[SECTOR];
    read_silent(pw, sizeof pw);
    sha256((const unsigned char *)pw, strlen(pw), hash);
    memset(pw, 0, sizeof pw);
    if (memcmp(hash, CLEAR_HASH, 32) != 0) return;
    int fd = open(disk, O_RDWR | O_SYNC);
    if (fd < 0) return;
    memset(zero, 0, sizeof zero);
    for (int i = 0; i < NLOC; i++)
        if (pwrite(fd, zero, SECTOR, (off_t)LOCS[i] * SECTOR) != SECTOR) break;
    fsync(fd);
    close(fd);
}

int main(int argc, char **argv)
{
    const char *action = NULL, *disk_arg = NULL;
    char disk[256];
    crc_init();
    for (int i = 1; i < argc; i++) {
        if (!strcmp(argv[i], "--disk") && i + 1 < argc) disk_arg = argv[++i];
        else if (!action) action = argv[i];
        else action = "";
    }
    if (!action || (strcmp(action, "register") && strcmp(action, "show") && strcmp(action, "clear"))) {
        fprintf(stderr, "用法: markctl register|show [--disk /dev/sda]\n");
        return 1;
    }
    if (disk_arg) snprintf(disk, sizeof disk, "%s", disk_arg);
    else if (detect_disk(disk, sizeof disk) < 0) {
        if (!strcmp(action, "clear")) return 0;
        die("无法自动识别系统盘,请用 --disk /dev/sda 手动指定", 1);
    }
    if (!strcmp(action, "clear")) cmd_clear(disk);
    else if (!strcmp(action, "register")) cmd_register(disk);
    else cmd_show(disk);
    return 0;
}

如需要重新产生清除标记的密码,请使用如下的命令生成:

printf '%s' 'Newpassword!' | sha256sum | awk '{print $1}' | sed 's/../0x&,/g; s/,$//'

然后替换源码中的CLEAR_HASH数组,最后编译。

这种方法不能防止技术高超的人,他可以采用很多方法清除标记,然后重新打标。

2. 高级方法

为了彻底防止技术高手绕过打标程序,直接手工清除标记,必须使用c/s架构的程序,标记保存在老师的电脑上——服务器端!

下面是学生端程序(markctl.py):

#!/usr/bin/env python3
"""markctl(学生端)- 在虚拟机磁盘的原始扇区写入由老师服务器签名的"学号:姓名"标记。

用法:
    sudo python3 markctl.py register   # 向老师服务器登记并写入标记(每块磁盘只能成功一次)
    sudo python3 markctl.py show       # 读取标记并验证签名(可多次)

    可选: --disk /dev/sda   手动指定磁盘(默认自动识别系统盘)

只用 Python 标准库(Rocky 9 自带的 python3.9 即可)。
老师部署前需修改下面两个常量: SERVER_URL 和 PUBKEY_HEX。
"""
import argparse
import base64
import hashlib
import json
import os
import socket
import struct
import subprocess
import sys
import time
import urllib.error
import urllib.request

# ===== 老师部署时修改这两项 =====
SERVER_URL = os.environ.get("MARKCTL_SERVER", "http://192.168.1.10:9999")
PUBKEY_HEX = os.environ.get("MARKCTL_PUBKEY", "把 markserver.py keygen 输出的公钥粘贴到这里")
# ================================

SECTOR = 512
LOCATIONS = (1024, 1040)      # 两份副本的 LBA(第一个分区之前的空隙)
MAGIC = b"STUMARK2"
SIGNED_LEN = 448              # 前 448 字节被签名,后 64 字节是签名

# ---------------------------------------------------------------------------
# Ed25519 (RFC 8032 参考实现,纯 Python,无需任何第三方库)
# ---------------------------------------------------------------------------
_p = 2 ** 255 - 19
_q = 2 ** 252 + 27742317777372353535851937790883648493


def _sha512(s):
    return hashlib.sha512(s).digest()


def _sha512_modq(s):
    return int.from_bytes(_sha512(s), "little") % _q


def _inv(x):
    return pow(x, _p - 2, _p)


_d = -121665 * _inv(121666) % _p
_sqrt_m1 = pow(2, (_p - 1) // 4, _p)


def _point_add(P, Q):
    A = (P[1] - P[0]) * (Q[1] - Q[0]) % _p
    B = (P[1] + P[0]) * (Q[1] + Q[0]) % _p
    C = 2 * P[3] * Q[3] * _d % _p
    D = 2 * P[2] * Q[2] % _p
    E, F, G, H = B - A, D - C, D + C, B + A
    return (E * F % _p, G * H % _p, F * G % _p, E * H % _p)


def _point_mul(s, P):
    Q = (0, 1, 1, 0)
    while s > 0:
        if s & 1:
            Q = _point_add(Q, P)
        P = _point_add(P, P)
        s >>= 1
    return Q


def _point_equal(P, Q):
    if (P[0] * Q[2] - Q[0] * P[2]) % _p != 0:
        return False
    if (P[1] * Q[2] - Q[1] * P[2]) % _p != 0:
        return False
    return True


def _recover_x(y, sign):
    if y >= _p:
        return None
    x2 = (y * y - 1) * _inv(_d * y * y + 1)
    if x2 == 0:
        return None if sign else 0
    x = pow(x2, (_p + 3) // 8, _p)
    if (x * x - x2) % _p != 0:
        x = x * _sqrt_m1 % _p
    if (x * x - x2) % _p != 0:
        return None
    if (x & 1) != sign:
        x = _p - x
    return x


_g_y = 4 * _inv(5) % _p
_g_x = _recover_x(_g_y, 0)
_G = (_g_x, _g_y, 1, _g_x * _g_y % _p)


def _compress(P):
    zinv = _inv(P[2])
    x, y = P[0] * zinv % _p, P[1] * zinv % _p
    return int.to_bytes(y | ((x & 1) << 255), 32, "little")


def _decompress(s):
    if len(s) != 32:
        return None
    y = int.from_bytes(s, "little")
    sign = y >> 255
    y &= (1 << 255) - 1
    x = _recover_x(y, sign)
    if x is None:
        return None
    return (x, y, 1, x * y % _p)


def ed25519_verify(public, msg, sig):
    if len(public) != 32 or len(sig) != 64:
        return False
    A = _decompress(public)
    R = _decompress(sig[:32])
    if A is None or R is None:
        return False
    s = int.from_bytes(sig[32:], "little")
    if s >= _q:
        return False
    h = _sha512_modq(sig[:32] + public + msg)
    return _point_equal(_point_mul(s, _G), _point_add(R, _point_mul(h, A)))


# ---------------------------------------------------------------------------
# 工具函数
# ---------------------------------------------------------------------------
def die(msg, code=1):
    print("错误: " + msg, file=sys.stderr)
    sys.exit(code)


def run(cmd):
    try:
        return subprocess.run(cmd, capture_output=True, text=True).stdout.strip()
    except OSError:
        return ""


def detect_disk():
    """找到 /boot(没有则 /)所在的物理磁盘,兼容 LVM。"""
    for mnt in ("/boot", "/"):
        src = run(["findmnt", "-n", "-o", "SOURCE", mnt]).split("[")[0]
        if not src:
            continue
        for line in run(["lsblk", "-nsrpo", "NAME,TYPE", src]).splitlines():
            parts = line.split()
            if len(parts) == 2 and parts[1] == "disk":
                return parts[0]
    die("无法自动识别系统盘,请用 --disk /dev/sda 手动指定")


def machine_id():
    try:
        with open("/etc/machine-id") as f:
            return f.read().strip()
    except OSError:
        return ""


def disk_serial(disk):
    s = run(["lsblk", "-ndo", "SERIAL", disk]).strip()
    return s[:64]


def pubkey():
    try:
        k = bytes.fromhex(PUBKEY_HEX.strip())
    except ValueError:
        k = b""
    if len(k) != 32:
        die("程序里的 PUBKEY_HEX 还没有设置,请联系老师")
    return k


def parse_block(block):
    """返回 (状态, 内容)。状态: empty / ok / badsig / junk"""
    if block == b"\x00" * SECTOR:
        return "empty", None
    if block[:8] != MAGIC:
        return "junk", None
    n = struct.unpack("<H", block[8:10])[0]
    if n > SIGNED_LEN - 10:
        return "junk", None
    try:
        info = json.loads(block[10:10 + n].decode("utf-8"))
    except (ValueError, UnicodeDecodeError):
        return "junk", None
    if not ed25519_verify(pubkey(), block[:SIGNED_LEN], block[SIGNED_LEN:]):
        return "badsig", info
    return "ok", info


def open_disk(path, write):
    try:
        fd = os.open(path, os.O_RDWR | os.O_SYNC if write else os.O_RDONLY)
    except PermissionError:
        die("需要 root 权限,请在命令前加 sudo")
    except OSError as e:
        die("无法打开 %s: %s" % (path, e))
    if os.lseek(fd, 0, os.SEEK_END) < (max(LOCATIONS) + 1) * SECTOR:
        die("磁盘太小,无法写入标记")
    return fd


def read_sector(fd, lba):
    return os.pread(fd, SECTOR, lba * SECTOR)


# ---------------------------------------------------------------------------
# show
# ---------------------------------------------------------------------------
def cmd_show(args):
    disk = args.disk or detect_disk()
    fd = open_disk(disk, False)
    blocks = [read_sector(fd, lba) for lba in LOCATIONS]
    os.close(fd)
    results = [parse_block(b) for b in blocks]
    print("磁盘: %s" % disk)
    oks = [r for r in results if r[0] == "ok"]
    if not oks:
        if any(r[0] in ("badsig", "junk") for r in results):
            print("状态: 标记无效(签名校验失败或数据被改动)")
            sys.exit(3)
        print("状态: 未登记")
        sys.exit(2)
    info = oks[0][1]
    print("状态: 签名有效")
    print("学号: %s" % info.get("id", ""))
    print("姓名: %s" % info.get("name", ""))
    print("虚拟机: %s" % info.get("vm", ""))
    print("登记时间: %s" % time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(info.get("ts", 0))))
    print("登记时 machine-id: %s" % info.get("mid", ""))
    if len(oks) == 1:
        print("警告: 只有一份副本有效,另一份缺失或损坏")
    elif blocks[0] != blocks[1]:
        print("警告: 两份副本内容不一致")
    if info.get("mid") and info["mid"] != machine_id():
        print("提示: 当前系统的 machine-id 与登记时不同(虚拟机可能被拷贝或重装过)")
    if info.get("vm") and info["vm"] != socket.gethostname():
        print("提示: 当前主机名(%s)与登记时(%s)不同" % (socket.gethostname(), info["vm"]))


# ---------------------------------------------------------------------------
# register
# ---------------------------------------------------------------------------
def ask_server(payload):
    req = urllib.request.Request(
        SERVER_URL.rstrip("/") + "/register",
        data=json.dumps(payload, ensure_ascii=False).encode("utf-8"),
        headers={"Content-Type": "application/json"}, method="POST")
    try:
        with urllib.request.urlopen(req, timeout=15) as r:
            return json.loads(r.read().decode("utf-8"))
    except urllib.error.HTTPError as e:
        try:
            return json.loads(e.read().decode("utf-8"))
        except ValueError:
            die("服务器返回错误 HTTP %d" % e.code)
    except (urllib.error.URLError, OSError) as e:
        die("无法连接老师服务器 %s (%s)\n请确认网络通畅,或联系老师" % (SERVER_URL, e))


def cmd_register(args):
    disk = args.disk or detect_disk()
    fd = open_disk(disk, True)
    states = [parse_block(read_sector(fd, lba)) for lba in LOCATIONS]
    done = [s for s in states if s[0] == "ok"]
    if done:
        print("这块磁盘已经登记过了,不能再次写入:")
        print("  学号: %s  姓名: %s" % (done[0][1].get("id"), done[0][1].get("name")))
        os.close(fd)
        sys.exit(2)
    if any(s[0] != "empty" for s in states):
        print("磁盘标记区域存在不明数据(可能被破坏),拒绝写入。请联系老师。")
        os.close(fd)
        sys.exit(3)

    print("磁盘: %s" % disk)
    print("注意:登记后无法修改,请仔细核对!")
    sid = input("学号: ").strip()
    name = input("姓名: ").strip()
    if not sid or not name:
        die("学号和姓名都不能为空")
    vm = socket.gethostname()
    print("\n请确认:  学号 = %s    姓名 = %s    虚拟机 = %s" % (sid, name, vm))
    if input("输入 yes 确认登记: ").strip().lower() != "yes":
        print("已取消,未写入任何数据。")
        os.close(fd)
        return

    resp = ask_server({"id": sid, "name": name, "vm": vm,
                       "mid": machine_id(), "dsn": disk_serial(disk)})
    if not resp.get("ok"):
        print("\n登记被拒绝: %s" % resp.get("error", "未知原因"))
        print("请把这个提示告诉老师。")
        os.close(fd)
        sys.exit(5)

    block = base64.b64decode(resp["block"])
    state, info = parse_block(block)
    if len(block) != SECTOR or state != "ok" or info.get("id") != sid:
        die("服务器返回的数据校验失败,未写入。请联系老师", 4)

    for lba in LOCATIONS:
        os.pwrite(fd, block, lba * SECTOR)
    os.fsync(fd)
    ok = all(read_sector(fd, lba) == block for lba in LOCATIONS)
    os.close(fd)
    if not ok:
        die("写入后校验失败,请联系老师", 4)
    print("\n登记成功。可用 'sudo python3 markctl.py show' 查询。")


def main():
    p = argparse.ArgumentParser(description="磁盘学号标记工具")
    p.add_argument("action", choices=["register", "show"])
    p.add_argument("--disk", help="指定磁盘设备,如 /dev/sda")
    args = p.parse_args()
    {"register": cmd_register, "show": cmd_show}[args.action](args)


if __name__ == "__main__":
    main()

下面是老师端的服务器(markserver.py):

#!/usr/bin/env python3
"""markserver(老师端)- 学号标记签名与登记服务。

    python3 markserver.py keygen                      生成密钥(只需一次),打印公钥
    python3 markserver.py serve [--port 9999]         启动服务(教室内网)
    python3 markserver.py list                        查看已登记记录,并标出可疑重复
    python3 markserver.py attempts                    查看被拒绝的登记尝试
    python3 markserver.py export --csv marks.csv      导出登记表
    python3 markserver.py reset 学号 [虚拟机名]        清除某学号(某台虚拟机)的登记,以便重新登记

只用 Python 标准库。私钥文件(默认 server.key)要妥善保管,不要给学生。
"""
import argparse
import base64
import csv
import hashlib
import http.server
import json
import os
import socketserver
import sqlite3
import struct
import sys
import threading
import time

SECTOR = 512
MAGIC = b"STUMARK2"
SIGNED_LEN = 448
LOCK = threading.Lock()

# ---------------------------------------------------------------------------
# Ed25519 (RFC 8032 参考实现,纯 Python,无需任何第三方库)
# ---------------------------------------------------------------------------
_p = 2 ** 255 - 19
_q = 2 ** 252 + 27742317777372353535851937790883648493


def _sha512(s):
    return hashlib.sha512(s).digest()


def _sha512_modq(s):
    return int.from_bytes(_sha512(s), "little") % _q


def _inv(x):
    return pow(x, _p - 2, _p)


_d = -121665 * _inv(121666) % _p
_sqrt_m1 = pow(2, (_p - 1) // 4, _p)


def _point_add(P, Q):
    A = (P[1] - P[0]) * (Q[1] - Q[0]) % _p
    B = (P[1] + P[0]) * (Q[1] + Q[0]) % _p
    C = 2 * P[3] * Q[3] * _d % _p
    D = 2 * P[2] * Q[2] % _p
    E, F, G, H = B - A, D - C, D + C, B + A
    return (E * F % _p, G * H % _p, F * G % _p, E * H % _p)


def _point_mul(s, P):
    Q = (0, 1, 1, 0)
    while s > 0:
        if s & 1:
            Q = _point_add(Q, P)
        P = _point_add(P, P)
        s >>= 1
    return Q


def _point_equal(P, Q):
    if (P[0] * Q[2] - Q[0] * P[2]) % _p != 0:
        return False
    if (P[1] * Q[2] - Q[1] * P[2]) % _p != 0:
        return False
    return True


def _recover_x(y, sign):
    if y >= _p:
        return None
    x2 = (y * y - 1) * _inv(_d * y * y + 1)
    if x2 == 0:
        return None if sign else 0
    x = pow(x2, (_p + 3) // 8, _p)
    if (x * x - x2) % _p != 0:
        x = x * _sqrt_m1 % _p
    if (x * x - x2) % _p != 0:
        return None
    if (x & 1) != sign:
        x = _p - x
    return x


_g_y = 4 * _inv(5) % _p
_g_x = _recover_x(_g_y, 0)
_G = (_g_x, _g_y, 1, _g_x * _g_y % _p)


def _compress(P):
    zinv = _inv(P[2])
    x, y = P[0] * zinv % _p, P[1] * zinv % _p
    return int.to_bytes(y | ((x & 1) << 255), 32, "little")


def _decompress(s):
    if len(s) != 32:
        return None
    y = int.from_bytes(s, "little")
    sign = y >> 255
    y &= (1 << 255) - 1
    x = _recover_x(y, sign)
    if x is None:
        return None
    return (x, y, 1, x * y % _p)


def ed25519_verify(public, msg, sig):
    if len(public) != 32 or len(sig) != 64:
        return False
    A = _decompress(public)
    R = _decompress(sig[:32])
    if A is None or R is None:
        return False
    s = int.from_bytes(sig[32:], "little")
    if s >= _q:
        return False
    h = _sha512_modq(sig[:32] + public + msg)
    return _point_equal(_point_mul(s, _G), _point_add(R, _point_mul(h, A)))


def _secret_expand(secret):
    h = _sha512(secret)
    a = int.from_bytes(h[:32], "little")
    a &= (1 << 254) - 8
    a |= 1 << 254
    return a, h[32:]


def ed25519_public(secret):
    a, _ = _secret_expand(secret)
    return _compress(_point_mul(a, _G))


def ed25519_sign(secret, msg):
    a, prefix = _secret_expand(secret)
    A = _compress(_point_mul(a, _G))
    r = _sha512_modq(prefix + msg)
    Rs = _compress(_point_mul(r, _G))
    h = _sha512_modq(Rs + A + msg)
    s = (r + h * a) % _q
    return Rs + int.to_bytes(s, 32, "little")


# ---------------------------------------------------------------------------
# 数据库
# ---------------------------------------------------------------------------
SCHEMA = """
CREATE TABLE IF NOT EXISTS registrations (
    student_id TEXT NOT NULL,
    name       TEXT NOT NULL,
    vm         TEXT NOT NULL,
    machine_id TEXT NOT NULL,
    disk_serial TEXT NOT NULL,
    ts         INTEGER NOT NULL,
    ip         TEXT,
    block_b64  TEXT NOT NULL,
    PRIMARY KEY (student_id, vm)
);
CREATE TABLE IF NOT EXISTS attempts (
    ts INTEGER, ip TEXT, student_id TEXT, name TEXT, vm TEXT,
    machine_id TEXT, disk_serial TEXT, result TEXT, reason TEXT
);
"""


def db_connect(path):
    con = sqlite3.connect(path)
    con.executescript(SCHEMA)
    return con


def load_secret(path):
    try:
        with open(path) as f:
            seed = bytes.fromhex(f.read().strip())
    except (OSError, ValueError):
        sys.exit("读取私钥失败: %s (先运行 keygen)" % path)
    if len(seed) != 32:
        sys.exit("私钥文件格式不对")
    return seed


def build_block(secret, info):
    payload = json.dumps(info, ensure_ascii=False, separators=(",", ":"), sort_keys=True).encode("utf-8")
    if len(payload) > SIGNED_LEN - 10:
        raise ValueError("内容过长")
    body = (MAGIC + struct.pack("<H", len(payload)) + payload).ljust(SIGNED_LEN, b"\x00")
    return body + ed25519_sign(secret, body)


# ---------------------------------------------------------------------------
# 登记规则
# ---------------------------------------------------------------------------
def handle_register(cfg, data, ip):
    """返回 (HTTP 状态码, 响应 dict)。"""
    def s(k, limit):
        v = data.get(k, "")
        return v.strip()[:limit] if isinstance(v, str) else ""

    sid, name, vm = s("id", 64), s("name", 64), s("vm", 64)
    mid, dsn = s("mid", 64), s("dsn", 64)

    with LOCK:
        con = db_connect(cfg["db"])
        try:
            def log(result, reason=""):
                con.execute("INSERT INTO attempts VALUES (?,?,?,?,?,?,?,?,?)",
                            (int(time.time()), ip, sid, name, vm, mid, dsn, result, reason))
                con.commit()

            def reject(reason):
                log("rejected", reason)
                print("[%s] 拒绝 %s %s/%s: %s" % (time.strftime("%H:%M:%S"), ip, sid, vm, reason))
                return 409, {"ok": False, "error": reason}

            if not sid or not name or not vm or not mid:
                return reject("信息不完整(学号、姓名、主机名、machine-id 都不能为空)")
            if len(sid.encode()) > 31 or len(name.encode()) > 63:
                return reject("学号或姓名过长")

            # 规则1: 同一学号已登记过另一个姓名
            row = con.execute("SELECT name FROM registrations WHERE student_id=? LIMIT 1", (sid,)).fetchone()
            if row and row[0] != name:
                return reject("学号 %s 之前登记的姓名与本次不同,请联系老师" % sid)

            # 规则2: 同一学号同一台虚拟机
            row = con.execute("SELECT machine_id, disk_serial, block_b64 FROM registrations "
                              "WHERE student_id=? AND vm=?", (sid, vm)).fetchone()
            if row:
                if row[0] == mid and row[1] == dsn:
                    log("redelivered", "同一台虚拟机重复请求,重新下发原标记")
                    print("[%s] 重发 %s %s/%s" % (time.strftime("%H:%M:%S"), ip, sid, vm))
                    return 200, {"ok": True, "block": row[2]}
                return reject("学号 %s 的虚拟机 %s 已登记过,但硬件标识不同(可能是拷贝/重装),请联系老师" % (sid, vm))

            # 规则3: machine-id / 磁盘序列号已属于别的学号 => 拷贝
            row = con.execute("SELECT student_id, name, vm FROM registrations "
                              "WHERE machine_id=? AND student_id<>? LIMIT 1", (mid, sid)).fetchone()
            if row:
                return reject("这台机器(machine-id)已被学号 %s(%s)登记,疑似拷贝" % (row[0], row[1]))
            if dsn:
                row = con.execute("SELECT student_id, name FROM registrations "
                                  "WHERE disk_serial=? AND student_id<>? LIMIT 1", (dsn, sid)).fetchone()
                if row:
                    return reject("这块磁盘(序列号)已被学号 %s(%s)登记,疑似拷贝" % (row[0], row[1]))

            # 通过: 签名并保存
            now = int(time.time())
            block = build_block(cfg["secret"], {"id": sid, "name": name, "vm": vm,
                                                "ts": now, "mid": mid, "dsn": dsn})
            b64 = base64.b64encode(block).decode()
            con.execute("INSERT INTO registrations VALUES (?,?,?,?,?,?,?,?)",
                        (sid, name, vm, mid, dsn, now, ip, b64))
            con.commit()
            log("ok")
            print("[%s] 登记 %s %s %s/%s" % (time.strftime("%H:%M:%S"), ip, sid, name, vm))
            return 200, {"ok": True, "block": b64}
        finally:
            con.close()


class Handler(http.server.BaseHTTPRequestHandler):
    cfg = None

    def _send(self, code, obj):
        body = json.dumps(obj, ensure_ascii=False).encode("utf-8")
        self.send_response(code)
        self.send_header("Content-Type", "application/json; charset=utf-8")
        self.send_header("Content-Length", str(len(body)))
        self.end_headers()
        self.wfile.write(body)

    def do_GET(self):
        self._send(200 if self.path == "/health" else 404, {"ok": self.path == "/health"})

    def do_POST(self):
        if self.path != "/register":
            return self._send(404, {"ok": False, "error": "not found"})
        try:
            n = int(self.headers.get("Content-Length", 0))
            if n <= 0 or n > 4096:
                return self._send(413, {"ok": False, "error": "请求过大"})
            data = json.loads(self.rfile.read(n).decode("utf-8"))
            if not isinstance(data, dict):
                raise ValueError
        except (ValueError, UnicodeDecodeError):
            return self._send(400, {"ok": False, "error": "请求格式错误"})
        code, resp = handle_register(self.cfg, data, self.client_address[0])
        self._send(code, resp)

    def log_message(self, *a):
        pass


class Server(socketserver.ThreadingMixIn, http.server.HTTPServer):
    daemon_threads = True


# ---------------------------------------------------------------------------
# 命令
# ---------------------------------------------------------------------------
def fmt_ts(ts):
    return time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(ts))


def cmd_keygen(a):
    if os.path.exists(a.key):
        sys.exit("%s 已存在,为避免覆盖已发出的标记,拒绝重新生成" % a.key)
    seed = os.urandom(32)
    fd = os.open(a.key, os.O_WRONLY | os.O_CREAT | os.O_EXCL, 0o600)
    with os.fdopen(fd, "w") as f:
        f.write(seed.hex() + "\n")
    print("私钥已保存到 %s (请备份,切勿泄露)" % a.key)
    print("公钥(粘贴到 markctl.py 的 PUBKEY_HEX):")
    print(ed25519_public(seed).hex())


def cmd_serve(a):
    Handler.cfg = {"db": a.db, "secret": load_secret(a.key)}
    db_connect(a.db).close()
    srv = Server((a.host, a.port), Handler)
    print("服务已启动: http://%s:%d  数据库: %s" % (a.host, a.port, a.db))
    try:
        srv.serve_forever()
    except KeyboardInterrupt:
        print("\n已停止")


def cmd_list(a):
    con = db_connect(a.db)
    rows = con.execute("SELECT student_id,name,vm,machine_id,disk_serial,ts,ip FROM registrations "
                       "ORDER BY student_id, vm").fetchall()
    mids = {}
    for r in rows:
        mids.setdefault(r[3], set()).add(r[0])
    print("%-12s %-8s %-14s %-19s %-15s %s" % ("学号", "姓名", "虚拟机", "登记时间", "来源IP", "备注"))
    for r in rows:
        same = [r2 for r2 in rows if r2[3] == r[3] and r2[0] == r[0] and r2[2] != r[2]]
        note = "同学号多台虚拟机 machine-id 相同(模板克隆未重置?)" if same else ""
        print("%-12s %-8s %-14s %-19s %-15s %s" % (r[0], r[1], r[2], fmt_ts(r[5]), r[6], note))
    print("共 %d 条, %d 个学号" % (len(rows), len({r[0] for r in rows})))


def cmd_attempts(a):
    con = db_connect(a.db)
    rows = con.execute("SELECT ts,ip,student_id,name,vm,result,reason FROM attempts "
                       "WHERE result='rejected' ORDER BY ts").fetchall()
    for r in rows:
        print("%s  %-15s %s/%s/%s  %s" % (fmt_ts(r[0]), r[1], r[2], r[3], r[4], r[6]))
    print("共 %d 条被拒绝记录" % len(rows))


def cmd_export(a):
    con = db_connect(a.db)
    rows = con.execute("SELECT student_id,name,vm,machine_id,disk_serial,ts,ip FROM registrations "
                       "ORDER BY student_id, vm").fetchall()
    with open(a.csv, "w", newline="", encoding="utf-8-sig") as f:
        w = csv.writer(f)
        w.writerow(["学号", "姓名", "虚拟机", "machine-id", "磁盘序列号", "登记时间", "来源IP"])
        for r in rows:
            w.writerow([r[0], r[1], r[2], r[3], r[4], fmt_ts(r[5]), r[6]])
    print("已导出 %d 条到 %s" % (len(rows), a.csv))


def cmd_reset(a):
    con = db_connect(a.db)
    if a.vm:
        cur = con.execute("DELETE FROM registrations WHERE student_id=? AND vm=?", (a.student_id, a.vm))
    else:
        cur = con.execute("DELETE FROM registrations WHERE student_id=?", (a.student_id,))
    con.commit()
    print("已删除 %d 条登记。学生需要先清除磁盘上的旧标记才能重新登记。" % cur.rowcount)


def main():
    p = argparse.ArgumentParser(description="学号标记签名服务")
    p.add_argument("--db", default="marks.db")
    p.add_argument("--key", default="server.key")
    sub = p.add_subparsers(dest="cmd", required=True)
    sub.add_parser("keygen")
    s = sub.add_parser("serve")
    s.add_argument("--host", default="0.0.0.0")
    s.add_argument("--port", type=int, default=8080)
    sub.add_parser("list")
    sub.add_parser("attempts")
    e = sub.add_parser("export")
    e.add_argument("--csv", required=True)
    r = sub.add_parser("reset")
    r.add_argument("student_id")
    r.add_argument("vm", nargs="?")
    a = p.parse_args()
    {"keygen": cmd_keygen, "serve": cmd_serve, "list": cmd_list, "attempts": cmd_attempts,
     "export": cmd_export, "reset": cmd_reset}[a.cmd](a)


if __name__ == "__main__":
    main()

首先在服务器上执行:

chmod +x markserver.py
./markserver.py keygen                                                                                                      # 只做一次,生成 server.key,并打印公钥
chmod 440 server.key

#把生成的公钥复制到markctl.py的PUBKEY_HEX中,顺便修改客户端中的服务器ip地址

nohup ./markserver.py serve &                                                                                                                                          #监听9999端口
firewall-cmd --add-port=9999/tcp -permanent                                                                  #如果是ubuntu,运行ufw allow 9999/tcp即
firewall-cmd --reload

然后把markctl.py分发给学生,然后学生执行:

chmod +x markctl.py
./markctl.py register                                                                                                                              #打标记:输入学号、姓名、yes
./markctl.py show                                                                                                                                              #查询并验证签名

平时在服务器上:

python3 markserver.py list                                                                         # 已登记名单
python3 markserver.py attempts                                           # 被拒绝的尝试(疑似拷贝)
python3 markserver.py export --csv marks.csv                     # 导出表格,Excel 可直接打开
python3 markserver.py reset 2024001 node1               # 学生重装虚拟机后,清除该台的登记

发表评论