Little Penguin 网络验证

安全高效 · 稳定可靠 · 多端适配

系统公告

暂无公告

人工审核机制

新用户注册需管理员人工核验，从源头保障用户真实性，杜绝恶意注册风险

多项目独立管理

支持创建多个项目空间，各项目密钥、数据完全隔离，管理更清晰

多语言API兼容

支持PHP/Python/Shell/HTML/Lua等多语言一键对接，适配全场景开发需求

专属加密传输链路

每个项目配备独立传输链路，采用POST请求方式，数据传输全程加密，隔绝信息泄露

精细化设备授权

支持卡密绑定设备数量自定义限制，配套便捷解绑功能，全方位保障授权安全

测试登录验证

用户登录（QQ账号）

用户注册（需审核）

昵称

QQ号

密码（至少8位）

确认密码

点击刷新

已有账号？立即登录

0

平台总用户数

0

我的项目总数

账号状态

审核状态：已通过

账号状态：正常

注册时间：

登录状态：已登录

创建新项目

我的项目

项目对接后缀

项目API密钥

项目验证公告

生成新授权码

卡密标识

有效期

卡密类型

设备数量

使用次数

卡密列表

卡密	标识	类型	有效期	设备限制	已绑设备	总次数	已用次数	状态	操作
暂无卡密

用户审核面板

昵称	QQ号	注册时间	操作
暂无待审核用户

用户管理面板

昵称	QQ号	用户类型	审核状态	账号状态	VIP状态	注册时间	操作
暂无用户数据

VIP卡密生成

生成结果

暂无卡密

VIP卡密激活

多语言对接文档

对接配置

对接地址

API密钥

专属对接后缀提示:请勿泄露配置，谨防他人盗用

接口说明

请求方式： POST
获取公告必填参数： api_request=1、api_key、path、action=get_verify_announcement
验证卡密必填参数： api_request=1、api_key、path、action=validate_api、auth_code、device_id
解绑设备参数： api_request=1、api_key、path、action=unbind_device、auth_code、device_id
成功返回格式： {"status":"success","username":"卡密标识","expiry":"有效期","left_times":"剩余次数","device_left":"剩余设备数","announcement":"验证公告内容"}
失败返回格式： {"status":"error","message":"失败原因描述"}

#!/bin/bash
API_URL="https://mynb7891.top/api.php"
USER_PATH="H32CXZFD"
API_KEY="0ca2dfd47b1b3f7e6f24fa8ad1d7671a"
TIMEOUT=3
RETRY_TIMES=3
CACHE_FILE="$HOME/.little_penguin_auth.cache"
VERSION="v2.1.0"
BRAND="Little Penguin 网络验证系统"
PENGUIN_BLUE='\033[1;38;5;33m'
PENGUIN_CYAN='\033[1;38;5;39m'
PENGUIN_WHITE='\033[1;38;5;255m'
PENGUIN_GREEN='\033[1;38;5;46m'
PENGUIN_YELLOW='\033[1;38;5;226m'
PENGUIN_RED='\033[1;38;5;196m'
NC='\033[0m'
HIDE_CURSOR='\033[?25l'
SHOW_CURSOR='\033[?25h'
CLEAR_SCREEN='\033[2J\033[H'
trap 'echo -e "${SHOW_CURSOR}"; exit' SIGINT SIGTERM EXIT
lp_brand_animation() {
    echo -e "${CLEAR_SCREEN}${HIDE_CURSOR}"
    local total_steps=25
    local load_chars=("▏" "▎" "▍" "▌" "▋" "▊" "▉" "█")
    local hack_chars=("░" "▒" "▓" "█" "0" "1" "•" "●" "◦")
    echo -e "${PENGUIN_BLUE}======================================================================${NC}"
    echo -e "│${PENGUIN_WHITE}      Little Penguin                     ${NC}│"
    echo -e "${PENGUIN_BLUE}======================================================================${NC}"
    echo -e "\n${PENGUIN_WHITE}[${PENGUIN_CYAN}*${PENGUIN_WHITE}] 系统初始化 - 网络验证模块加载中${NC}\n"
    for ((i=1; i<=total_steps; i++)); do
        local progress=$((i * 100 / total_steps))
        local load_char=${load_chars[$i % ${#load_chars[@]}]}
        local rand_hack1=${hack_chars[$RANDOM % ${#hack_chars[@]}]}
        local rand_hack2=${hack_chars[$RANDOM % ${#hack_chars[@]}]}
        local bar=$(printf "%0.s${PENGUIN_CYAN}${load_char}${NC}" $(seq 1 $i))
        local empty_bar=$(printf "%0.s${PENGUIN_WHITE}▏${NC}" $(seq 1 $((total_steps-i))))
        printf "${PENGUIN_WHITE}进度：[${bar}${empty_bar}] ${PENGUIN_GREEN}%3d%%${NC} ${PENGUIN_YELLOW}%s%s${NC}\r" $progress $rand_hack1 $rand_hack2
        sleep 0.08
    done
    echo -e "\n\n${PENGUIN_GREEN}[${PENGUIN_WHITE}✓${PENGUIN_GREEN}] 初始化完成 • 验证模块就绪${NC}"
    sleep 0.6
    echo -e "${CLEAR_SCREEN}"
}
generate_lp_device_id() {
    local raw_id
    if [ -f /etc/machine-id ]; then
        raw_id=$(cat /etc/machine-id)
    else
        raw_id=$(hostname)-$(date +%s)-$(head -c 16 /dev/urandom 2>/dev/null | md5sum | cut -d' ' -f1)
    fi
    local device_id="LP-$(echo -n "$raw_id" | md5sum | cut -d' ' -f1 | head -c 20)"
    echo "$device_id"
}
lp_api_request() {
    local action=$1
    local auth_code=$2
    local device_id=$3
    local post_data="action=${action}&api_request=1&api_key=${API_KEY}&path=${USER_PATH}"
    [ -n "$auth_code" ] && post_data="${post_data}&auth_code=${auth_code}"
    [ -n "$device_id" ] && post_data="${post_data}&device_id=${device_id}"
    for ((i=1; i<=RETRY_TIMES; i++)); do
        local response=$(curl -s -S --ipv4 --connect-timeout ${TIMEOUT} -m ${TIMEOUT} \
            -H "Content-Type: application/x-www-form-urlencoded; charset=utf-8" \
            -H "Accept: application/json" \
            -H "User-Agent: LittlePenguin-Auth/${VERSION}" \
            -H "X-LP-Device: $device_id" \
            -H "Connection: close" \
            -X POST -d "${post_data}" "${API_URL}")
        if [ -n "$response" ] && [[ "$response" =~ "\"status\"" ]]; then
            echo "$response"
            return 0
        fi
        [ $i -lt $RETRY_TIMES ] && echo -e "${PENGUIN_YELLOW}[${PENGUIN_WHITE}!${PENGUIN_YELLOW}] 第$i次请求失败，正在重试...${NC}" >&2
        sleep 1
    done
    echo '{"status":"error","message":"网络验证：接口请求超时/无响应"}'
    return 1
}
lp_check_cache() {
    if [ -f "$CACHE_FILE" ]; then
        CACHED_AUTH_CODE=$(grep -m1 "^LP_AUTH_CODE=" "$CACHE_FILE" | cut -d'=' -f2)
        CACHED_DEVICE_ID=$(grep -m1 "^LP_DEVICE_ID=" "$CACHE_FILE" | cut -d'=' -f2)
        if [ -n "$CACHED_AUTH_CODE" ] && [ -n "$CACHED_DEVICE_ID" ]; then
            echo -e "${PENGUIN_WHITE}[${PENGUIN_CYAN}→${PENGUIN_WHITE}] 检测到本地缓存，验证有效性...${NC}"
            CHECK_RESP=$(lp_api_request "validate_api" "$CACHED_AUTH_CODE" "$CACHED_DEVICE_ID")
            if [[ $CHECK_RESP == *"status\":\"success"* && $CHECK_RESP != *"left_times\":0"* ]]; then
                echo -e "${PENGUIN_GREEN}[${PENGUIN_WHITE}✓${PENGUIN_GREEN}] 缓存验证通过 ${PENGUIN_WHITE}[二次登录·免卡密]${NC}"
                echo -e "${PENGUIN_BLUE}----------------------------------------------------------------------${NC}\n"
                return 0
            else
                echo -e "${PENGUIN_YELLOW}[${PENGUIN_WHITE}!${PENGUIN_YELLOW}] 缓存失效/已过期，需要重新验证${NC}"
                rm -f "$CACHE_FILE"
            fi
        fi
    fi
    return 1
}
lp_write_cache() {
    local auth_code=$1
    local device_id=$2
    mkdir -p "$(dirname "$CACHE_FILE")"
    echo "LP_AUTH_CODE=${auth_code}" > "$CACHE_FILE"
    echo "LP_DEVICE_ID=${device_id}" >> "$CACHE_FILE"
    echo "LP_LOGIN_TIME=$(date '+%Y-%m-%d %H:%M:%S')" >> "$CACHE_FILE"
    chmod 600 "$CACHE_FILE"
}
lp_show_announcement() {
    local ann_content=$1
    echo -e "${PENGUIN_BLUE}----------------------------------------------------------------------${NC}"
    echo -e "│${PENGUIN_WHITE}📢 Little Penguin 系统公告                  ${NC}│"
    echo -e "${PENGUIN_BLUE}----------------------------------------------------------------------${NC}"
    echo -e "${PENGUIN_WHITE}${ann_content}${NC}"
    echo -e "${PENGUIN_BLUE}----------------------------------------------------------------------${NC}\n"
}
lp_show_device_card() {
    local device_id=$1
    local left_times=$2
    local device_left=$3
    [ "$left_times" = "-1" ] && left_times="无限次"
    echo -e "${PENGUIN_BLUE}----------------------------------------------------------------------${NC}"
    echo -e "│${PENGUIN_WHITE}      Little Penguin 设备信息卡片                ${NC}│"
    echo -e "${PENGUIN_BLUE}----------------------------------------------------------------------${NC}"
    echo -e "${PENGUIN_WHITE}设备ID   ：${PENGUIN_CYAN}${device_id}${NC}"
    echo -e "${PENGUIN_WHITE}剩余次数 ：${PENGUIN_GREEN}${left_times}${NC}"
    echo -e "${PENGUIN_WHITE}剩余设备 ：${PENGUIN_GREEN}${device_left}台${NC}"
    echo -e "${PENGUIN_BLUE}----------------------------------------------------------------------${NC}\n"
}
lp_main_verify() {
    lp_brand_animation
    local DEVICE_ID=$(generate_lp_device_id)
    if lp_check_cache; then
        return 0
    fi
    echo -e "${PENGUIN_WHITE}[${PENGUIN_CYAN}→${PENGUIN_WHITE}] 获取系统公告...${NC}"
    local ANNOUNCEMENT_RESP=$(lp_api_request "get_verify_announcement" "" "$DEVICE_ID")
    local ANNOUNCEMENT=$(echo "$ANNOUNCEMENT_RESP" | grep -oE '"announcement":"([^"\\]|\\.)*"' | cut -d'"' -f4 | sed -e 's/\\\\//g' -e 's/\\"/"/g')
    [ -z "$ANNOUNCEMENT" ] || [ "$ANNOUNCEMENT" = "null" ] && ANNOUNCEMENT=$(echo "$ANNOUNCEMENT_RESP" | awk -F '[:,]' '{for(i=1;i<=NF;i++)if($i~/"announcement"/)print $(i+1)}' | sed -e 's/"//g' -e 's/^[[:space:]]*//')
    [ -z "$ANNOUNCEMENT" ] && ANNOUNCEMENT="当前无系统公告，祝您使用愉快～"
    lp_show_announcement "$ANNOUNCEMENT"
    read -p "$(echo -e "${PENGUIN_WHITE}[${PENGUIN_BLUE}🐧${PENGUIN_WHITE}] 请输入卡密：${NC}")" -s AUTH_CODE
    echo -e "\n"
    [ -z "$AUTH_CODE" ] && { echo -e "${PENGUIN_RED}[${PENGUIN_WHITE}×${PENGUIN_RED}] 卡密不能为空！脚本退出${NC}"; exit 1; }
    echo -e "${PENGUIN_WHITE}[${PENGUIN_CYAN}→${PENGUIN_WHITE}] 卡密验证中... 请稍候${NC}"
    local RESPONSE=$(lp_api_request "validate_api" "$AUTH_CODE" "$DEVICE_ID")
    if [[ $RESPONSE == *"status\":\"success"* ]]; then
        local LEFT_TIMES=$(echo "$RESPONSE" | grep -o '"left_times":[-0-9]*' | cut -d':' -f2)
        local DEVICE_LEFT=$(echo "$RESPONSE" | grep -o '"device_left":[0-9]*' | cut -d':' -f2)
        lp_write_cache "$AUTH_CODE" "$DEVICE_ID"
        lp_show_device_card "$DEVICE_ID" "$LEFT_TIMES" "$DEVICE_LEFT"
        echo -e "${PENGUIN_GREEN}[${PENGUIN_WHITE}✓${PENGUIN_GREEN}] 卡密验证成功！开始运行脚本主程序...${NC}"
        echo -e "${PENGUIN_BLUE}----------------------------------------------------------------------${NC}\n"
        return 0
    else
        local ERROR_MSG=$(echo "$RESPONSE" | grep -oE '"message":"([^"\\]|\\.)*"' | cut -d'"' -f4 | sed -e 's/\\\\//g' -e 's/\\"/"/g')
        [ -z "$ERROR_MSG" ] && ERROR_MSG="卡密验证失败：未知错误"
        echo -e "${PENGUIN_RED}[${PENGUIN_WHITE}×${PENGUIN_RED}] $ERROR_MSG${NC}"
        exit 1
    fi
}
lp_main_verify
#以下开始写你的原有脚本代码

import requests
import json
import time
import datetime
import uuid
API_URL = "https://mynb7891.top/api.php"
USER_PATH = "你的对接后缀"
API_KEY = "你的API密钥"
DEVICE_ID = str(uuid.getnode())
def get_verify_announcement():
    payload = {"api_request": 1, "api_key": API_KEY, "path": USER_PATH, "action": "get_verify_announcement"}
    try:
        response = requests.post(API_URL, data=payload, timeout=10)
        result = response.json()
        return result.get("announcement", "暂无验证公告")
    except Exception as e: return f"公告获取失败：{str(e)}"
def validate_auth_code(auth_code):
    payload = {"api_request": 1, "api_key": API_KEY, "path": USER_PATH, "action": "validate_api", "auth_code": auth_code, "device_id": DEVICE_ID}
    try:
        response = requests.post(API_URL, data=payload, timeout=10)
        return response.json()
    except Exception as e: return {"status": "error", "message": f"请求异常：{str(e)}"}
def main():
    import os
    os.system('cls' if os.name == 'nt' else 'clear')
    print("=" * 40)
    print("        卡密授权验证系统")
    print("=" * 40)
    print()
    announcement = get_verify_announcement()
    print(f"📢 系统公告：{announcement}")
    print("=" * 40)
    print()
    auth_code = input("请输入授权卡密：").strip()
    if not auth_code: print("❌ 错误：卡密不能为空！"); input("按回车键退出..."); return
    print("\n🔍 正在验证卡密有效性...")
    result = validate_auth_code(auth_code)
    if result["status"] == "success":
        print(f"✅ 验证成功！")
        print(f"👤 卡密标识：{result['username']}")
        print(f"📅 有效期至：{result['expiry']}")
        print(f"🔢 剩余次数：{result['left_times']}")
        print(f"💻 剩余设备数：{result['device_left']}")
        print(f"📢 验证提示：{result['announcement']}")
        print("\n" + "=" * 40)
        print("    授权成功 · 程序将持续运行")
        print("=" * 40)
        while True:
            now = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
            print(f"✨ {now} | 服务运行中...")
            time.sleep(1)
    else: print(f"❌ 验证失败：{result['message']}"); input("按回车键退出...")
if __name__ == "__main__": main()

local http = require("socket.http")
local ltn12 = require("ltn12")
local json = require("dkjson")
local CFG = { url = "https://mynb7891.top/api.php", api_key = "你的API密钥", path = "你的对接后缀" }
local DEVICE_ID = io.popen("cat /etc/machine-id 2>/dev/null || hostname"):read("*l") or "unknown"
local function get_announcement()
    local payload = string.format("api_request=1&api_key=%s&path=%s&action=get_verify_announcement", CFG.api_key, CFG.path)
    local response = {}
    local ok, code = http.request{ url = CFG.url, method = "POST", source = ltn12.source.string(payload), headers = { ["Content-Type"] = "application/x-www-form-urlencoded", ["Content-Length"] = #payload }, sink = ltn12.sink.table(response) }
    if ok and code == 200 then local data = json.decode(table.concat(response)); return data.announcement or "暂无验证公告" else return "公告获取失败" end
end
local function validate_card(auth_code)
    local payload = string.format("api_request=1&api_key=%s&path=%s&action=validate_api&auth_code=%s&device_id=%s", CFG.api_key, CFG.path, auth_code, DEVICE_ID)
    local response = {}
    local ok, code = http.request{ url = CFG.url, method = "POST", source = ltn12.source.string(payload), headers = { ["Content-Type"] = "application/x-www-form-urlencoded", ["Content-Length"] = #payload }, sink = ltn12.sink.table(response) }
    if ok and code == 200 then return json.decode(table.concat(response)) else return {status = "error", message = "网络请求失败"} end
end
local function main()
    print("====================================")
    print("        卡密授权验证系统")
    print("====================================")
    print()
    local announcement = get_announcement()
    print("📢 系统公告：" .. announcement)
    print("====================================")
    print()
    io.write("请输入授权卡密：")
    local auth_code = io.read():gsub("%s+", "")
    if auth_code == "" then print("❌ 错误：卡密不能为空！"); io.read(); return end
    print("\n🔍 正在验证卡密有效性...")
    local result = validate_card(auth_code)
    if result.status == "success" then
        print("✅ 验证成功！")
        print("👤 卡密标识：" .. result.username)
        print("📅 有效期至：" .. result.expiry)
        print("🔢 剩余次数：" .. result.left_times)
        print("💻 剩余设备数：" .. result.device_left)
        print("📢 验证提示：" .. result.announcement)
        print("\n====================================")
        print("    授权成功 · 程序将持续运行")
        print("====================================")
        while true do local now = os.date("%Y-%m-%d %H:%M:%S"); print("✨ " .. now .. " | 服务运行中..."); os.execute("sleep 1") end
    else print("❌ 验证失败：" .. result.message); io.read() end
end
main()