你这个问题是强行修改导致分区校验失败, 一般路由器是有修改MAC的命令, 没必要强行修改.

螃蟹家的芯片一旦出现no rootfs signature at 几乎可以肯定是分区有问题导致校验失败才报的错

这是从你原版固件提取的文件大小(验证方式用万能的7zip右键打开你的原固件即可查看rootfs的内容)

文件内容

这是你分享的怀疑有问题的那个

文件大小

文件内容

至此 可以确定你强制修改固件导致固件校验失败

爱我佳鑫 你这个问题是强行修改导致分区校验失败, 一般路由器是有修改MAC的命令, 没必要强行修改.螃蟹家的芯片一旦出现no rootfs signature at 几乎可以肯定是分区有问题导致校验失败才报的 ...

开头2字节是长度，尾部一字节检验码

（Big endian）

31 73 68 30 31 —》header

15 8E—》len

AF—》checksum_num

Data checksum应为0，即--》byte(!checksum_func(data[:len-1]))+1= checksum_num

ex:

累加158D长度的数据（结果取一字节），取反加1后要等于158E处的数据

lib/apmib.so

check_1775C

check_17048

mszgx 找不到修改MAC命令，就是修改MAC导致校验失败才求助的，factory_args.sh这个应该就是负责校验的，就是不知道校验的原理。

分区校验是bootloader的事, 螃蟹的SDK里的官方版bootloader是没有校验的, 厂商基于SDK自行开发的版本是有分区校验的. 网上可以下载到螃蟹的SDK你自己去看看.

自己看代码, 这是螃蟹芯片SDK里的bootloader代码里关于校验分区的代码片段

//------------------------------------------------------------------------------------------
// check img
unsigned int gCHKKEY_HIT = 0;
unsigned int gCHKKEY_CNT = 0;
#if defined(CONFIG_NFBI)
// return,  0: not found, 1: linux found, 2:linux with root found
int check_system_image(unsigned long addr, IMG_HEADER_Tp pHeader)
{
    // Read header, heck signature and checksum
    int i, ret = 0;
    unsigned short sum = 0, *word_ptr;
    unsigned short length = 0;
    unsigned short temp16 = 0;

    if (gCHKKEY_HIT == 1)
        return 0;

    /*check firmware image.*/
    word_ptr = (unsigned short *)pHeader;
    for (i = 0; i < sizeof(IMG_HEADER_T); i += 2, word_ptr++)
        *word_ptr = *((unsigned short *)(addr + i));

    if (!memcmp(pHeader->signature, FW_SIGNATURE, SIG_LEN))
        ret = 1;
    else if (!memcmp(pHeader->signature, FW_SIGNATURE_WITH_ROOT, SIG_LEN))
        ret = 2;
    else
        dprintf("no sys signature at %X!\n", addr);
#if defined(NEED_CHKSUM)
    if (ret)
    {
        for (i = 0; i < pHeader->len; i += 2)
        {
            sum += *((unsigned short *)(addr + sizeof(IMG_HEADER_T) + i));
            // prom_printf("x=%x\n", (addr + sizeof(IMG_HEADER_T) + i));
        }

        if (sum)
        {
            // SYSSR: checksum done, but fail
            REG32(NFBI_SYSSR) = (REG32(NFBI_SYSSR) | 0x8000) & (~0x4000);
            dprintf("sys checksum error at %X!\n", addr);
            ret = 0;
        }
        else
        {
            // SYSSR: checksum done and OK
            REG32(NFBI_SYSSR) = REG32(NFBI_SYSSR) | 0xc000;
        }
    }
#else
    // SYSSR: checksum done and OK
    REG32(NFBI_SYSSR) = REG32(NFBI_SYSSR) | 0xc000;
#endif
    return (ret);
}

#elif defined(CONFIG_NONE_FLASH)
// return,  0: not found, 1: linux found, 2:linux with root found
int check_system_image(unsigned long addr, IMG_HEADER_Tp pHeader)
{
    // Read header, heck signature and checksum
    int i, ret = 0;
    unsigned short sum = 0, *word_ptr;
    unsigned short length = 0;
    unsigned short temp16 = 0;

    if (gCHKKEY_HIT == 1)
        return 0;

    /*check firmware image.*/
    word_ptr = (unsigned short *)pHeader;
    for (i = 0; i < sizeof(IMG_HEADER_T); i += 2, word_ptr++)
        *word_ptr = *((unsigned short *)(addr + i));

    if (!memcmp(pHeader->signature, FW_SIGNATURE, SIG_LEN))
        ret = 1;
    else if (!memcmp(pHeader->signature, FW_SIGNATURE_WITH_ROOT, SIG_LEN))
        ret = 2;
    else
        dprintf("no sys signature at %X!\n", addr);
#if defined(NEED_CHKSUM)
    if (ret)
    {
        for (i = 0; i < pHeader->len; i += 2)
        {
            sum += *((unsigned short *)(addr + sizeof(IMG_HEADER_T) + i));
            // prom_printf("x=%x\n", (addr + sizeof(IMG_HEADER_T) + i));
        }

        if (sum)
        {
            // SYSSR: checksum done, but fail

            dprintf("sys checksum error at %X!\n", addr);
            ret = 0;
        }
        else
        {
            // SYSSR: checksum done and OK
        }
    }
#else

#endif
    return (ret);
}

#else
#if CHECK_BURN_SERIAL
unsigned long board_rootfs_length = 0;
IMG_HEADER_T linux_imghdr;

/* return 0:fail, 2:success, 1: no  burn_serial */
int check_burn_serial(unsigned long addr, IMG_HEADER_Tp pHeader)
{
    int ret = 0;

    if ((pHeader->burnAddr & (1 << 31)))
    {
        unsigned long pad;
        memcpy((void *)(&pad), addr, sizeof(unsigned long));
        BDBG_BSN("\tburnAddr=0x%08x, pad=0x%08x", pHeader->burnAddr, pad);
        if (pHeader->burnAddr == pad)
        {
            BDBG_BSN(", ok\n");
            ret = 2;
        }
    }
    else
    {
        BDBG_BSN("\tfail\n");
        ret = 1;
    }

    return ret;
}
#endif
// return,  0: not found, 1: linux found, 2:linux with root found
int check_system_image(unsigned long addr, IMG_HEADER_Tp pHeader, SETTING_HEADER_Tp setting_header)
{
    // Read header, heck signature and checksum
    int i, ret = 0;
    unsigned short sum = 0, *word_ptr;
    unsigned short length = 0;
    unsigned short temp16 = 0;
    char image_sig_check[1] = {0};
    char image_sig[4] = {0};
    char image_sig_root[4] = {0};

    if (gCHKKEY_HIT == 1)
        return 0;

#ifdef CONFIG_NAND_FLASH_BOOTING
    if (nflashread((unsigned int)pHeader, addr, sizeof(IMG_HEADER_T), 0) < 0)
    {
        prom_printf("nand flash read fail,addr=%x,size=%d\n", addr, sizeof(IMG_HEADER_T));
        return 0;
    }
#else
    /*check firmware image.*/
    word_ptr = (unsigned short *)pHeader;
    for (i = 0; i < sizeof(IMG_HEADER_T); i += 2, word_ptr++)
        *word_ptr = rtl_inw(addr + i);
#endif

    memcpy(image_sig, FW_SIGNATURE, SIG_LEN);
    memcpy(image_sig_root, FW_SIGNATURE_WITH_ROOT, SIG_LEN);

    if (!memcmp(pHeader->signature, image_sig, SIG_LEN))
        ret = 1;
    else if (!memcmp(pHeader->signature, image_sig_root, SIG_LEN))
        ret = 2;
    else
    {
        prom_printf("no sys signature at %X!\n", addr - FLASH_BASE);
    }
    // prom_printf("ret=%d  sys signature at %X!\n",ret,addr-FLASH_BASE);

#if CHECK_BURN_SERIAL
    if (ret)
    {
        int ret_val = 0;
        BDBG_BSN("==> check linux:\n");
        BDBG_BSN("\tby burn_serial\n");

        memcpy((void *)(&linux_imghdr), (void *)(pHeader), sizeof(IMG_HEADER_T));
#ifndef CONFIG_NAND_FLASH_BOOTING
        ret_val = check_burn_serial(addr + mips_io_port_base + sizeof(IMG_HEADER_T) + pHeader->len, pHeader);
#else
        /* for nand */
        goto SKIP_CHECK_BURN_SERIAL;
#endif
        if (ret_val != 1)
            return ret_val;
    }
    BDBG_BSN("\n\tno burn_serial, check by sum\n");

SKIP_CHECK_BURN_SERIAL:
#endif

    if (ret)
    {

#ifdef CONFIG_NAND_FLASH_BOOTING
#ifdef NAND_FLASH_BOOT_SPEEDUP
        unsigned char *ptr_data = (volatile unsigned char *)(pHeader->startAddr | 0x20000000);
        if (nflashread(ptr_data, addr + sizeof(IMG_HEADER_T), pHeader->len, 1) < 0)
        {
            prom_printf("nand flash read fail,addr=%x,size=%d\n", addr, pHeader->len);
            return 0;
        }

#if 1 // def NAND_FLASH_BOOT_SPEEDUP
#ifdef CONFIG_RTK_NAND_BBT
        for (i = 0; i < pHeader->len; i += 2)
        {
#if CONFIG_ESD_SUPPORT // patch for ESD
            REG32(0xb800311c) |= (1 << 23);
#endif

#if defined(NEED_CHKSUM)
            sum += (unsigned short)(((*(ptr_data + 1 + i)) | (*(ptr_data + i)) << 8) & 0xffff);
// sum += rtl_inw(ptr_data + sizeof(IMG_HEADER_T) + i);
#endif
        }
#endif
#endif
#else
        volatile unsigned char *ptr_data = (volatile unsigned char *)DRAM_DIMAGE_ADDR;
        if (nflashread(DRAM_DIMAGE_ADDR, addr, pHeader->len + sizeof(IMG_HEADER_T), 1) < 0)
        {
            prom_printf("nand flash read fail,addr=%x,size=%d\n", addr, pHeader->len + sizeof(IMG_HEADER_T));
            return 0;
        }
#ifdef CONFIG_RTK_NAND_BBT
        for (i = 0; i < pHeader->len; i += 2)
        {
#if CONFIG_ESD_SUPPORT // patch for ESD
            REG32(0xb800311c) |= (1 << 23);
#endif

#if defined(NEED_CHKSUM)
            sum += (unsigned short)(((*(ptr_data + 1 + i + sizeof(IMG_HEADER_T))) | (*(ptr_data + i + sizeof(IMG_HEADER_T))) << 8) & 0xffff);
// sum += rtl_inw(ptr_data + sizeof(IMG_HEADER_T) + i);
#endif
        }
#endif
#endif

#else
        for (i = 0; i < pHeader->len; i += 2)
        {
#if 1 // slowly
            gCHKKEY_CNT++;
            if (gCHKKEY_CNT > ACCCNT_TOCHKKEY)
            {
                gCHKKEY_CNT = 0;
                if (user_interrupt(0) == 1) // return 1: got ESC Key
                {
                    // prom_printf("ret=%d  ------> line %d!\n",ret,__LINE__);
                    return 0;
                }
            }
#else // speed-up, only support UART, not support GPIO
            if ((Get_UART_Data() == ESC) || (Get_GPIO_SW_IN() != 0))
            {
                gCHKKEY_HIT = 1;
                return 0;
            }
#endif
#if defined(NEED_CHKSUM)
            sum += rtl_inw(addr + sizeof(IMG_HEADER_T) + i);
#endif
        }
#endif

#if defined(NEED_CHKSUM)
        if (sum)
        {
            // prom_printf("ret=%d  ------> line %d!\n",ret,__LINE__);
            ret = 0;
        }
#endif
    }
    // prom_printf("ret=%d  sys signature at %X!\n",ret,addr-FLASH_BASE);

    return (ret);
}
//------------------------------------------------------------------------------------------

int check_rootfs_image(unsigned long addr)
{
#ifdef CONFIG_RTK_VOIP
    // Don't check rootfs in voip
    return 1;
#else
    // Read header, heck signature and checksum
    int i;
    unsigned short sum = 0, *word_ptr;
    unsigned long length = 0;
    unsigned char tmpbuf[16];

    if (gCHKKEY_HIT == 1)
        return 0;

#ifdef CONFIG_NAND_FLASH_BOOTING
    if (nflashread((unsigned int)tmpbuf, addr, 16, 0) < 0)
    {
        prom_printf("nand flash read fail,addr=%x,size=%d\n", addr, 16);
        return 0;
    }
#else
    word_ptr = (unsigned short *)tmpbuf;
    for (i = 0; i < 16; i += 2, word_ptr++)
        *word_ptr = rtl_inw(addr + i);
#endif

    if (memcmp(tmpbuf, SQSH_SIGNATURE, SIG_LEN) && memcmp(tmpbuf, SQSH_SIGNATURE_LE, SIG_LEN))
    {
        prom_printf("no rootfs signature at %X!\n", addr - FLASH_BASE);
        return 0;
    }

#if CHECK_BURN_SERIAL
    board_rootfs_length =
#endif
        length = *(((unsigned long *)tmpbuf) + OFFSET_OF_LEN) + SIZE_OF_SQFS_SUPER_BLOCK + SIZE_OF_CHECKSUM;

#if CHECK_BURN_SERIAL
    {
        struct _rootfs_padding rootfs_padding;
        BDBG_BSN("==> check rootfs:\n");
        BDBG_BSN("\tby burn_serial\n");

#ifndef CONFIG_NAND_FLASH_BOOTING
        memcpy((void *)(&rootfs_padding) + sizeof(rootfs_padding.zero_pad), (void *)(mips_io_port_base + addr + length - SIZE_OF_CHECKSUM), sizeof(struct _rootfs_padding) - sizeof(rootfs_padding.zero_pad));
#else
        /* nand */
        goto SKIP_CHECK_BURN_SERIAL;
#endif

        BDBG_BSN("\trootfs_padding.signature[%s]\n", rootfs_padding.signature);
        if (!memcmp(rootfs_padding.signature, ROOT_SIGNATURE, SIG_LEN))
        {
            BDBG_BSN("\tburn_serial=0x%08x, length=0x%08x",
                     rootfs_padding.len + SIZE_OF_SQFS_SUPER_BLOCK + SIZE_OF_CHECKSUM, length);

            if (rootfs_padding.len + SIZE_OF_SQFS_SUPER_BLOCK + SIZE_OF_CHECKSUM == length)
            {
                BDBG_BSN(", ok\n");
                return 1;
            }
            else
            {
                BDBG_BSN(", fail\n");
                return 0;
            }
        }
        BDBG_BSN("\n\tno burn_serial, check by sum\n");
    }

SKIP_CHECK_BURN_SERIAL:
#endif
#ifdef CONFIG_NAND_FLASH_BOOTING
#ifndef NAND_FLASH_BOOT_SPEEDUP
    volatile unsigned char *ptr_data = (volatile unsigned char *)DRAM_DIMAGE_ADDR;
    if (nflashread(DRAM_DIMAGE_ADDR, addr, length, 1) < 0)
    {
        prom_printf("nand flash read fail,addr=%x,size=%d\n", addr, length);
        return 0;
    }
#ifdef CONFIG_RTK_NAND_BBT
    for (i = 0; i < length; i += 2)
    {
#if CONFIG_ESD_SUPPORT // patch for ESD
        REG32(0xb800311c) |= (1 << 23);
#endif

#if defined(NEED_CHKSUM)
        sum += (unsigned short)(((*(ptr_data + 1 + i)) | (*(ptr_data + i)) << 8) & 0xffff);
// sum += rtl_inw(ptr_data + sizeof(IMG_HEADER_T) + i);
#endif
    }
#endif
#endif
#else

    for (i = 0; i < length; i += 2)
    {
#if 1                  // slowly
#if CONFIG_ESD_SUPPORT // patch for ESD
        REG32(0xb800311c) |= (1 << 23);
#endif
        gCHKKEY_CNT++;
        if (gCHKKEY_CNT > ACCCNT_TOCHKKEY)
        {
            gCHKKEY_CNT = 0;
            if (user_interrupt(0) == 1) // return 1: got ESC Key
                return 0;
        }
#else // speed-up, only support UART, not support GPIO.
        if ((Get_UART_Data() == ESC) || (Get_GPIO_SW_IN() != 0))
        {
            gCHKKEY_HIT = 1;
            return 0;
        }
#endif
#if defined(NEED_CHKSUM)
        sum += rtl_inw(addr + i);
#endif
    }
#endif

#ifndef NAND_FLASH_BOOT_SPEEDUP
#if defined(NEED_CHKSUM)
    if (sum)
    {
        prom_printf("rootfs checksum error at %X!\n", addr - FLASH_BASE);
        return 0;
    }
#endif
#endif
    return 1;
#endif // CONFIG_RTK_VOIP
}

这是螃蟹芯片SDK里的bootloader源码

堂前燕 开头2字节是长度，尾部一字节检验码（Big endian）31 73 68 30 31 —》header15 8E—》lenAF—》checksum_num Data checksu ...

大佬，非常感谢，开头73 68 30 31这个应该是header吧并没有31。这个： 73 68 30 31 —》header 

 还有大佬的公式我并没计算出来如何修改才能校验通过（水平有限，(─.─|||），如果有空请指点下，感谢！

 “ Data checksum应为0，即!checksum_func(data[:len-1])= checksum_num ” 

套用下：checksum_func(data[:158E-1])= AF  

最新提取的三个不同MAC：提取三个 不同MAC文件   这个是我提取的两个不同的AP，还有一个是修改MAC后被自动重置后的。求大佬分析下， 如果我修改MAC后如何才能让程序校验通过。

爱我佳鑫 mszgx 找不到修改MAC命令，就是修改MAC导致校验失败才求助的，factory_args.sh这个应该就是负责校验的，就是不知道校验的原理。 ...

爱我佳鑫 这是螃蟹芯片SDK里的bootloader源码

堂前燕 开头2字节是长度，尾部一字节检验码（Big endian）31 73 68 30 31 —》header15 8E—》lenAF—》checksum_num Data checksu ...

mszgx 大佬，我又仔细研究了下大概懂了一点，开头2字节文件头，第三个字节也就是四位就是要校验的长度。如158E，然后158E-1=158D ，通过程序校验这158D数据等于158E处的那个字节就行了。如您演示 ...

大佬就是牛逼，我已经算出来了，总结记录下：

73 68 30 31 文件头 15 92 文件长度 ，15 92 - 1 =1591 ，实际校验的文件长度。

提取1591所有数据 16进制相加，取末尾一个字节 减去1 ，然后取反。得出一个字节的校验值，填入15 92处。OK过了校验，随意修改MAC了。。

改这个mac 测试下 081079e3fd78

1. 上个图记录下，七八年前上学时候学习的编程都忘了，winhex可以复制C代码出来，本来想用C自动计算，复制出来直接看不懂了，现在工作和写代码没啥关系，算了不用程序程序计算了，用EXCEL算下。先用函数转换10进制，相加，然后计算出结果转换16进制4 B2DA 取DA-1=D9 。

2.取反百度了下，好像还分为什么逻辑取反，不管了，有在线工具，直接计算。D9取反得26.

填入校验结果26

3.进入BOOT,用ttl波特率38400.  用这个命令刷入。

FLW <dst_ROM_offset><src_RAM_addr><length_Byte> <SPI cnt#>: Write offset-data to SPI from RAM

刷入重启并未报错，完美解决！

在此非常感谢 堂前燕坛友。感谢了！

https://bbs.pediy.com/user-home-778603.htm

通过这个学习了不少东西，还是要多学习，还行需要懂程序，会反编译才能看出过程，靠自己瞎测试不行。至此这个问题完美解决，改下MAC刷回我的AP不折腾了。