精华内容
下载资源
问答
  • linux生成sha256校验文件的方法例如要对“a”这个文件生成一个sha256的校验文件; 方法如下:sha256sum a > a.sha256sum 也就是:sha256sum 文件名 > 文件名.sha256.sum 然后a.sha256sum这个校验文件就会在a同...

    在linux下生成sha256校验文件的方法

    例如要对“a”这个文件生成一个sha256的校验文件;
    方法如下:

    sha256sum a > a.sha256sum 

    也就是:sha256sum 文件名 > 文件名.sha256.sum
    然后a.sha256sum这个校验文件就会在a同目录下;

    在linux下使用sha256校验某个文件

    首先需要两个东西,一个是带校验的文件,另一个是这个文件的sha256校验文件(校验文件别人提供,或者在网上下载文件的时候,同时把这个校验文件下载下来);
    校验方法如下:
    那上面的“a”文件来举例

    sha256sum -c <(grep a a.sha256sum)

    如果校验成功输出“OK”

    展开全文
  • 文件校验码

    千次阅读 2014-04-10 17:01:32
    文件校验码:在文件传输过程中可

    在文件传输过程中可能会造成文件损坏或被他人恶意更改,为了了解文件是否出现了上述情况,我们常为文件生成“文件校验码”

    常用的有:

    一. md5sum:一般由32个或64个字符组成(unsigned char md5_32[16] 或者 unsigned char md5_64[32])

    用户:常使用md5校验工具生成和比较文件的“文件校验码”

    developer:常使用开源代码,在程序中使用md5接口产生“文件校验码”

    例如开源MD5.cpp接口的使用

    声明:

    md5_state_t   sstate;   //  一个结构体,用来存放计算的中间结果

    unsigned char smd5[16] = {0};  // 存放最后的md5值

    初始化:

    void md5_init(md5_state_t *pms); // 将结构体里的变量根据特定规则初始化

    添加buff:

    void md5_append(md5_state_t *pms, const md5_byte_t *data, int nbytes); // 根据buff中的内容更新结构体

    pms: 结构体

    data: buff

    nbytes: buff 的长度

    得出md5值:

    void md5_finish(md5_state_t *pms, md5_byte_t digest[16]); // 经过算法将结构体的内容转化为md5


    二. sha1sum : 一般由40个字符组成

    linux/unix平台下可以使用命令行生成一个文件的sha1sum值。

    $ sha1sum filename [filename] ... > SHA1SUM
    详见:http://en.wikipedia.org/wiki/Sha1sum点击打开链接
    windows平台下未使用过。
    

    展开全文
  • Linux CRC校验码

    2017-05-15 23:19:53
    CRC即循环冗余校验码(Cyclic Redundancy Check):是数据通信领域中最常用的种差错校验码,其特征是信息字段和校验字段的长度可以任意选定。CRC校验实用程序库在数据存储和数据通讯领域,为了保证数据的正确,就...

    1、CRC简介:

    CRC即循环冗余校验码(Cyclic Redundancy Check):是数据通信领域中常用的一种差错校验码,其特征是信息字段和校验字段的长度
    
    可以任意选定。CRC校验实用程序库在数据存储和数据通讯领域,为了保证数据的正确,就不得不采用检错的手段。

    crc校验原理:

    利用CRC进行检错的过程可简单描述为:在发送端根据要传送的k位二进制码列,以一定的规则产生一个校验用的r位监督码(CRC码),
    
    附在原始信息后边,构成一个新的二进制码序列数共k+r位,然后发送出去。在接收端,根据信息码和CRC码之间所遵循的规则进行检验,
    
    以确定传送中是否出错。这个规则,在差错控制理论中称为“生成多项式”。

    2、生成CRC码的基本原理:

    任意一个由二进制位串组成的代码都可以和一个系数仅为‘0’和‘1’取值的多项一一对应。例如:代码1010111对应的多项式为x6+x4+x2+x+1
    
    ,而多项式为x5+x3+x2+x+1对应的代码101111。

    3、CRC码集选择的原则:

    若设码字长度为N,信息字段为K位,校验字段为R位(N=K+R),则对于CRC码集中的任一码字,存在且仅存在一个R次多项式g(x),使得
    V(x)=A(x)g(x)=xRm(x)+r(x);
    
    其中:    m(x)为K次信息多项式, r(x)为R-1次校验多项式,
    
             g(x)称为生成多项式:
    
    g(x)=g0+g1x+ g2x2+...+g(R-1)x(R-1)+gRxR
    
    发送方通过指定的g(x)产生CRC码字,接收方则通过该g(x)来验证收到的CRC码字。

    标准CRC生成多项式如下表:

    名称 生成多项式 简记式* 标准引用
    CRC-4 x4+x+1 3 ITU G.704
    CRC-8 x8+x5+x4+1 0x31
    CRC-8 x8+x2+x1+1 0x07
    CRC-8 x8+x6+x4+x3+x2+x1 0x5E
    CRC-12 x12+x11+x3+x+1 80F
    CRC-16 x16+x15+x2+1 8005 IBM SDLC
    CRC16-CCITT x16+x12+x5+1 1021 ISO HDLC, ITU X.25, V.34/V.41/V.42, PPP-FCS
    CRC-32 x32+x26+x23+…+x2+x+1 04C11DB7 ZIP, RAR, IEEE 802 LAN/FDDI, IEEE 1394, PPP-FCS
    CRC-32c x32+x28+x27+…+x8+x6+1 1EDC6F41 SCTP

    基本算法(人工笔算):
    以CRC16-CCITT为例进行说明,CRC校验码为16位,生成多项式17位。假如数据流为4字节:BYTE[3]、BYTE[2]、BYTE[1]、BYTE[0];
    数据流左移16位,相当于扩大256×256倍,再除以生成多项式0x11021,做不借位的除法运算(相当于按位异或),所得的余数就是CRC校验码。
    发送时的数据流为6字节:BYTE[3]、BYTE[2]、BYTE[1]、BYTE[0]、CRC[1]、CRC[0];

    举例:

    信息字段代码为: m(x)=x6+x4+x3+1    代码为:1011001
    
    生成多项式:    g(x)=x4+x3+1       代码为:11001
    
    m(x)x4=x10+x8+x7+x4 对应的代码记为:10110010000     即 左移4位
    
    m(x)x4 在与 g(x)进行 模2的除法运算,相当于按位异或,计算过程如下:
    
    1 0 1 1 0 0 1 0 0 0 0
    1 1 0 0 1
    -----------------------------
    0 1 1 1 1 0 1 0 0 0 0
    1 1 0 0 1
    -----------------------------
    0 0 0 1 1 1 1 0 0 0 0
          1 1 0 0 1
    -----------------------------
          0 0 1 1 1 0 0 0
              1 1 0 0 1
    -----------------------------
              0 0 1 0 1 0             --------------> 余数     即 校验码
    
    
    
    
    
    发送数据码为: 10110011010 
    展开全文
  • C语言生成MD5校验码

    千次阅读 2015-04-30 16:01:24
    如有转载,请注明出处:... 作者:super_bert@csdn C语言生成MD5校验码源码,从Linux命令源码md5sum移植,MS Windows VS2010环境可用。 头文件md5.h #ifndef MD5_H #define MD5_H #ifdef __alpha typedef unsigned in

    如有转载,请注明出处:http://blog.csdn.net/embedded_sky

    作者:super_bert@csdn

    C语言生成MD5校验码源码,从Linux命令源码md5sum移植,MS Windows VS2010环境可用。

    头文件md5.h

    #ifndef MD5_H
    #define MD5_H
    
    #ifdef __alpha
    typedef unsigned int uint32;
    #else
    typedef unsigned long uint32;
    #endif
    
    #define FOPRTXT "r"
    
    
    struct MD5Context {
    	uint32 buf[4];
    	uint32 bits[2];
    	unsigned char in[64];
    };
    
    void MD5Init(struct MD5Context *context);
    void MD5Update(struct MD5Context *context, unsigned char const *buf, unsigned len);
    void MD5Final(unsigned char digest[16], struct MD5Context *context);
    void MD5Transform(uint32 buf[4], uint32 const in[16]);
    
    /*
     * This is needed to make RSAREF happy on some MS-DOS compilers.
     */
    typedef struct MD5Context MD5_CTX;
    
    
    /*add by super bert 2014-09-29*/
    //生成文件MD5
    int mdfile(FILE *fp, unsigned char *digest);
    
    int md5sum(const char *file, char *digest );
    
    void print_digest(unsigned char *p, char *md5code);
    
    #endif /* !MD5_H */

    源文件md5.cpp

    /*
     * This code implements the MD5 message-digest algorithm.
     * The algorithm is due to Ron Rivest.  This code was
     * written by Colin Plumb in 1993, no copyright is claimed.
     * This code is in the public domain; do with it what you wish.
     *
     * Equivalent code is available from RSA Data Security, Inc.
     * This code has been tested against that, and is equivalent,
     * except that you don't need to include two pages of legalese
     * with every copy.
     *
     * To compute the message digest of a chunk of bytes, declare an
     * MD5Context structure, pass it to MD5Init, call MD5Update as
     * needed on buffers full of bytes, and then call MD5Final, which
     * will fill a supplied 16-byte array with the digest.
     */
    
    #include "stdafx.h"
    
    #include <string.h>		/* for memcpy() */
    #include "md5.h"
    
    void byteReverse(unsigned char *buf, unsigned longs);
    
    enum { UNKNOWN, MSB1st, LSB1st } byteOrder = UNKNOWN;
    
    void setByteOrder(void) {
    	union {
    		unsigned short int usi;
    		unsigned char uc[2];
    	} w;
    
    	w.usi = 0x1234;
    	if (w.uc[0] == 0x12)
    		byteOrder = MSB1st;
    	else
    		byteOrder = LSB1st;
    }
    
    #ifndef ASM_MD5
    void byteReverse(unsigned char *buf, unsigned longs)
    {
        uint32 t;
    
        if (byteOrder == UNKNOWN)
    	setByteOrder();
        if (byteOrder == LSB1st)
    	return;
        do {
    	t = (uint32) ((unsigned) buf[3] << 8 | buf[2]) << 16 |
    	    ((unsigned) buf[1] << 8 | buf[0]);
    	*(uint32 *) buf = t;
    	buf += 4;
        } while (--longs);
    }
    #endif
    
    /*
     * Start MD5 accumulation.  Set bit count to 0 and buffer to mysterious
     * initialization constants.
     */
    void MD5Init(struct MD5Context *ctx)
    {
        ctx->buf[0] = 0x67452301;
        ctx->buf[1] = 0xefcdab89;
        ctx->buf[2] = 0x98badcfe;
        ctx->buf[3] = 0x10325476;
    
        ctx->bits[0] = 0;
        ctx->bits[1] = 0;
    }
    
    /*
     * Update context to reflect the concatenation of another buffer full
     * of bytes.
     */
    void MD5Update(struct MD5Context *ctx, unsigned char const *buf, unsigned len)
    {
        uint32 t;
    
        /* Update bitcount */
    
        t = ctx->bits[0];
        if ((ctx->bits[0] = t + ((uint32) len << 3)) < t)
    	ctx->bits[1]++;		/* Carry from low to high */
        ctx->bits[1] += len >> 29;
    
        t = (t >> 3) & 0x3f;	/* Bytes already in shsInfo->data */
    
        /* Handle any leading odd-sized chunks */
    
        if (t) {
    	unsigned char *p = (unsigned char *) ctx->in + t;
    
    	t = 64 - t;
    	if (len < t) {
    	    memcpy(p, buf, len);
    	    return;
    	}
    	memcpy(p, buf, t);
    	byteReverse(ctx->in, 16);
    	MD5Transform(ctx->buf, (uint32 *) ctx->in);
    	buf += t;
    	len -= t;
        }
        /* Process data in 64-byte chunks */
    
        while (len >= 64) {
    	memcpy(ctx->in, buf, 64);
    	byteReverse(ctx->in, 16);
    	MD5Transform(ctx->buf, (uint32 *) ctx->in);
    	buf += 64;
    	len -= 64;
        }
    
        /* Handle any remaining bytes of data. */
    
        memcpy(ctx->in, buf, len);
    }
    
    /*
     * Final wrapup - pad to 64-byte boundary with the bit pattern 
     * 1 0* (64-bit count of bits processed, MSB-first)
     */
    void MD5Final(unsigned char digest[16], struct MD5Context *ctx)
    {
        unsigned count;
        unsigned char *p;
    
        /* Compute number of bytes mod 64 */
        count = (ctx->bits[0] >> 3) & 0x3F;
    
        /* Set the first char of padding to 0x80.  This is safe since there is
           always at least one byte free */
        p = ctx->in + count;
        *p++ = 0x80;
    
        /* Bytes of padding needed to make 64 bytes */
        count = 64 - 1 - count;
    
        /* Pad out to 56 mod 64 */
        if (count < 8) {
    	/* Two lots of padding:  Pad the first block to 64 bytes */
    	memset(p, 0, count);
    	byteReverse(ctx->in, 16);
    	MD5Transform(ctx->buf, (uint32 *) ctx->in);
    
    	/* Now fill the next block with 56 bytes */
    	memset(ctx->in, 0, 56);
        } else {
    	/* Pad block to 56 bytes */
    	memset(p, 0, count - 8);
        }
        byteReverse(ctx->in, 14);
    
        /* Append length in bits and transform */
        ((uint32 *) ctx->in)[14] = ctx->bits[0];
        ((uint32 *) ctx->in)[15] = ctx->bits[1];
    
        MD5Transform(ctx->buf, (uint32 *) ctx->in);
        byteReverse((unsigned char *) ctx->buf, 4);
        memcpy(digest, ctx->buf, 16);
        memset(ctx, 0, sizeof(ctx));	/* In case it's sensitive */
    }
    
    #ifndef ASM_MD5
    
    /* The four core functions - F1 is optimized somewhat */
    
    /* #define F1(x, y, z) (x & y | ~x & z) */
    #define F1(x, y, z) (z ^ (x & (y ^ z)))
    #define F2(x, y, z) F1(z, x, y)
    #define F3(x, y, z) (x ^ y ^ z)
    #define F4(x, y, z) (y ^ (x | ~z))
    
    /* This is the central step in the MD5 algorithm. */
    #define MD5STEP(f, w, x, y, z, data, s) \
    	( w += f(x, y, z) + data,  w = w<<s | w>>(32-s),  w += x )
    
    /*
     * The core of the MD5 algorithm, this alters an existing MD5 hash to
     * reflect the addition of 16 longwords of new data.  MD5Update blocks
     * the data and converts bytes into longwords for this routine.
     */
    void MD5Transform(uint32 buf[4], uint32 const in[16])
    {
        register uint32 a, b, c, d;
    
        a = buf[0];
        b = buf[1];
        c = buf[2];
        d = buf[3];
    
        MD5STEP(F1, a, b, c, d, in[0] + 0xd76aa478, 7);
        MD5STEP(F1, d, a, b, c, in[1] + 0xe8c7b756, 12);
        MD5STEP(F1, c, d, a, b, in[2] + 0x242070db, 17);
        MD5STEP(F1, b, c, d, a, in[3] + 0xc1bdceee, 22);
        MD5STEP(F1, a, b, c, d, in[4] + 0xf57c0faf, 7);
        MD5STEP(F1, d, a, b, c, in[5] + 0x4787c62a, 12);
        MD5STEP(F1, c, d, a, b, in[6] + 0xa8304613, 17);
        MD5STEP(F1, b, c, d, a, in[7] + 0xfd469501, 22);
        MD5STEP(F1, a, b, c, d, in[8] + 0x698098d8, 7);
        MD5STEP(F1, d, a, b, c, in[9] + 0x8b44f7af, 12);
        MD5STEP(F1, c, d, a, b, in[10] + 0xffff5bb1, 17);
        MD5STEP(F1, b, c, d, a, in[11] + 0x895cd7be, 22);
        MD5STEP(F1, a, b, c, d, in[12] + 0x6b901122, 7);
        MD5STEP(F1, d, a, b, c, in[13] + 0xfd987193, 12);
        MD5STEP(F1, c, d, a, b, in[14] + 0xa679438e, 17);
        MD5STEP(F1, b, c, d, a, in[15] + 0x49b40821, 22);
    
        MD5STEP(F2, a, b, c, d, in[1] + 0xf61e2562, 5);
        MD5STEP(F2, d, a, b, c, in[6] + 0xc040b340, 9);
        MD5STEP(F2, c, d, a, b, in[11] + 0x265e5a51, 14);
        MD5STEP(F2, b, c, d, a, in[0] + 0xe9b6c7aa, 20);
        MD5STEP(F2, a, b, c, d, in[5] + 0xd62f105d, 5);
        MD5STEP(F2, d, a, b, c, in[10] + 0x02441453, 9);
        MD5STEP(F2, c, d, a, b, in[15] + 0xd8a1e681, 14);
        MD5STEP(F2, b, c, d, a, in[4] + 0xe7d3fbc8, 20);
        MD5STEP(F2, a, b, c, d, in[9] + 0x21e1cde6, 5);
        MD5STEP(F2, d, a, b, c, in[14] + 0xc33707d6, 9);
        MD5STEP(F2, c, d, a, b, in[3] + 0xf4d50d87, 14);
        MD5STEP(F2, b, c, d, a, in[8] + 0x455a14ed, 20);
        MD5STEP(F2, a, b, c, d, in[13] + 0xa9e3e905, 5);
        MD5STEP(F2, d, a, b, c, in[2] + 0xfcefa3f8, 9);
        MD5STEP(F2, c, d, a, b, in[7] + 0x676f02d9, 14);
        MD5STEP(F2, b, c, d, a, in[12] + 0x8d2a4c8a, 20);
    
        MD5STEP(F3, a, b, c, d, in[5] + 0xfffa3942, 4);
        MD5STEP(F3, d, a, b, c, in[8] + 0x8771f681, 11);
        MD5STEP(F3, c, d, a, b, in[11] + 0x6d9d6122, 16);
        MD5STEP(F3, b, c, d, a, in[14] + 0xfde5380c, 23);
        MD5STEP(F3, a, b, c, d, in[1] + 0xa4beea44, 4);
        MD5STEP(F3, d, a, b, c, in[4] + 0x4bdecfa9, 11);
        MD5STEP(F3, c, d, a, b, in[7] + 0xf6bb4b60, 16);
        MD5STEP(F3, b, c, d, a, in[10] + 0xbebfbc70, 23);
        MD5STEP(F3, a, b, c, d, in[13] + 0x289b7ec6, 4);
        MD5STEP(F3, d, a, b, c, in[0] + 0xeaa127fa, 11);
        MD5STEP(F3, c, d, a, b, in[3] + 0xd4ef3085, 16);
        MD5STEP(F3, b, c, d, a, in[6] + 0x04881d05, 23);
        MD5STEP(F3, a, b, c, d, in[9] + 0xd9d4d039, 4);
        MD5STEP(F3, d, a, b, c, in[12] + 0xe6db99e5, 11);
        MD5STEP(F3, c, d, a, b, in[15] + 0x1fa27cf8, 16);
        MD5STEP(F3, b, c, d, a, in[2] + 0xc4ac5665, 23);
    
        MD5STEP(F4, a, b, c, d, in[0] + 0xf4292244, 6);
        MD5STEP(F4, d, a, b, c, in[7] + 0x432aff97, 10);
        MD5STEP(F4, c, d, a, b, in[14] + 0xab9423a7, 15);
        MD5STEP(F4, b, c, d, a, in[5] + 0xfc93a039, 21);
        MD5STEP(F4, a, b, c, d, in[12] + 0x655b59c3, 6);
        MD5STEP(F4, d, a, b, c, in[3] + 0x8f0ccc92, 10);
        MD5STEP(F4, c, d, a, b, in[10] + 0xffeff47d, 15);
        MD5STEP(F4, b, c, d, a, in[1] + 0x85845dd1, 21);
        MD5STEP(F4, a, b, c, d, in[8] + 0x6fa87e4f, 6);
        MD5STEP(F4, d, a, b, c, in[15] + 0xfe2ce6e0, 10);
        MD5STEP(F4, c, d, a, b, in[6] + 0xa3014314, 15);
        MD5STEP(F4, b, c, d, a, in[13] + 0x4e0811a1, 21);
        MD5STEP(F4, a, b, c, d, in[4] + 0xf7537e82, 6);
        MD5STEP(F4, d, a, b, c, in[11] + 0xbd3af235, 10);
        MD5STEP(F4, c, d, a, b, in[2] + 0x2ad7d2bb, 15);
        MD5STEP(F4, b, c, d, a, in[9] + 0xeb86d391, 21);
    
        buf[0] += a;
        buf[1] += b;
        buf[2] += c;
        buf[3] += d;
    }
    
    /*add by super bert 2014-09-29*/
    /*生成文件MD5 - 修改版*/
    int mdfile(FILE *fp, unsigned char *digest)
    {
    	unsigned char buf[100];
    	MD5_CTX ctx;
    	int n;
    
    	MD5Init(&ctx);
    	/*first step*/
    	/*读取文件前100byte*/
    	n = fread(buf, 1, sizeof(buf), fp);
    	MD5Update(&ctx, buf, n);
    
    	/*second step*/
    	/*读取文件末尾100byte*/
    	fseek(fp, -100L, SEEK_END);
    	n = fread(buf, 1, sizeof(buf), fp);
    	MD5Update(&ctx, buf, n);
    
    	MD5Final(digest, &ctx);
    	
    	if (ferror(fp)) 
    	{
    		return -1;
    	}
    
    	return 0;
    }
    
    
    /*add by super bert 2014-10-08*/
    int md5sum(const char *file, char *md5code )
    {
    	unsigned char digest[16] = {0};
    
    	FILE *fp = fopen(file, FOPRTXT);
    
    	if (fp == NULL) 
    	{
             return -1;
    	}
                    
    	if (mdfile(fp, digest)) 
    	{
    		Printf("md5sum error!\n");
    		fclose(fp);
    		return -1;
    	} 
    
    	print_digest(digest, md5code);
    	fclose(fp);
    
    	return 0;
    }
    
    void print_digest(unsigned char *p, char *md5code)
    {
    	int i;
    	char str[3];
    	//char md5code[33];
                      
    	//strcpy(md5code,"");
    	//memset(md5code, 0x00, sizeof(md5code));
    	for (i = 0; i < 16; ++i)
    	{
    		//printf("%02x", *p++);
    		sprintf(str,"%02x", *p++);
    		strcat(md5code,str);
    	}
    }
    
    #endif



    展开全文
  • Linux文件MD5校验

    千次阅读 2019-04-11 19:25:06
    md5sum命令用于生成文件的md5数字摘要,可以验证文件内容是否发生了改变,间接地还可以检验两文件内容是否完全相同。因为md5sum是读取文件内容来计算校验码的,因此只能验证文件内容,而无法验证文件属性。 md5...
  • MD5校验bin文件代码,用于升级,校验代码是否一致;进行MD5校验代码,亲测OK,打开bin文件就可以校验出校验码,然后再应用。
  • [root@localhost 4]# echo "123...生成sha256文件校验文件 [root@localhost 4]# sha256sum test.zip >test.zip.sha256sum 使用sha256sum校验文件一致性 [root@localhost 4]# sha256sum -c <(grep test.zi...
  • MD5 生成文件校验

    千次阅读 2014-02-25 15:29:47
    linux 下 shell命令 ,制作md5 也用于软件的md5校验MD5算法常常被用来验证网络文件传输的完整性,防止文件被人篡改。 MD5 全称是报文摘要算法(Message-Digest Algorithm 5),此算法对任意长度的信息逐位进行...
  • linux文件完整性校验

    千次阅读 2017-10-10 11:27:49
     md5sum是通过在传输前后比对文件生成的md5的值进行比对,它会逐位对文件的内容进行校验(md5值是一个128位的二进制数据,转换成16进制则是32(128/4)位的进制值,文件越大,校验的时间越长),如果值一致,则表示...
  • Linux文件校验指令md5sum

    千次阅读 2019-06-21 09:50:49
    1. 背景 在网络传输、设备之间转存、复制大文件等时,可能会出现传输前后数据不一致的情况。这种情况在网络这种相对更不稳定的环境中,容易出现。...md5值是一个128位的二进制数据,转换成16进制则是32(1...
  • 有时,我们需要生成或核对文件的MD5或SHA等检验值,以确定这个文件是“官方原版”的, 即内容是一样的。下面,我们针对同样的文档`file_name.elf`,分别在Windows和Linux系统中来校验
  • 说明:寿命老长的一个Hash算法,适用范围广,网站存储密码也经常使用。不同的文件产生的MD5哈希值是唯一的,但这点已经有办法通过对文件进行少量的修改,让文件的MD5后的哈希值保持一致。 使用:在CentOS下,要对...
  • Linux shell脚本013(生成配置文件

    千次阅读 2018-06-14 16:56:45
    #生成配置文件auto-ops.conf的中间件配置项,要求auto-ops.conf文件已经存在 ###参数规范性校验 ###清除原有中间件的参数配置 CONFIG=auto-ops.conf if [ -f ${CONFIG} ]; then sed -i '/\&amp;quot;jboss\...
  • 是的,Linux 中有许多可用的工具能满足这需求。本文中我将会介绍五种最好的密码生成器。 这些工具可以为你生成高强度随机密码。如果你想要为多用户和服务器更新密码,请继续读下去。 这些工具易于使用,这...
  • 文件在实际应用传输过程中往往经历拆分、合并的过程。文件在多次传输后有可能会损坏,在使用前...1. 文件生成MD5 使用md5sum命令来生成MD5: [root@liuyzh1 ~]# md5sum rhel-server-6.3-x86_64-dvd.iso d7...
  • Linux下的学习开始总是艰难的,但有的时候,却发现Linux下远比Windows的操作来的实在的多——这下载文件的完整性就是其中件,让本人觉着很爽的件事情。在编译安装各种软件的时候,总要到各个网站上收集下软件...
  • Linux计算md5sum(md5校验和) && 使用crypt和gpg加密/解密文件 1. md5sum 判断两个文件是否相同,可以使用校验和(checksum),检验和一样,则两个文件相同。这里介绍使用md5sum命令计算md5sum: qingsong@...
  • Linux日常——CRC校验

    千次阅读 2017-06-18 20:54:51
    即循环冗余校验码(Cyclic Redundancy Check[1] ):是数据通信领域中最常用的种查错校验码,其特征是信息字段和校验字段的长度可以任意选定。 循环冗余检查(CRC)是种数据传输检错功能,对数据进行多项式计算...
  • MD5 全称是报文摘要算法(Message-Digest Algorithm 5),此算法对任意长度的信息逐位进行计算,产生一个二进制长度为128位(十六进制长度就是32位)的“指纹”(或称“报文摘要”),不同的文件产生相同的报文摘要...
  • Linux/CRC校验

    千次阅读 2012-12-24 10:49:46
    CRC即循环冗余校验码(Cyclic Redundancy Check):是数据通信领域中最常用的种差错校验码,其特征是信息字段和校验字段的长度可以任意选定。 CRC校验实用程序库在数据存储和数据通讯领域,为了保证数据的正确...
  • Linux下几种文件传输命令

    万次阅读 2018-11-07 15:16:02
    Secure Ftp 是一个基于SSH安全协议的文件传输管理工具。由于它是基于SSH的,会在传输过程中对用户的密码、数据等敏感信息进行加密,因此可以有效的防止用户信息在传输的过程中被窃取,比FTP有更高的安全性。在功能...
  • MD5校验 for linux

    千次阅读 2015-12-15 11:04:22
    linux下MD5校验方法
  • 校验下载的文件

    2016-02-18 17:34:21
    当下载一个很大的文件时,比如linux或windows系统安装文件, 最好校验一下是否下载完整。有一次,下载了CentOS6.7系统的iso文件,大约3.6G大小,安装了好几次,都是走到半道,下一步的界面出不来,就是因为系统iso...
  • Linux Shell 生成随机数和随机字符串

    千次阅读 2019-02-08 22:54:55
    Shell 下如何生成随机数呢,米扑博客特意写了本文,总结 Linux Shell 产生随机数的多种方法。 本文原文转自米扑博客:Linux Shell 生成随机数和随机字符串 计算机产生的的只是“伪随机数”,不会产生绝对的随机数...
  • Linux驱动开发_设备文件系统详解

    千次阅读 多人点赞 2021-05-11 14:09:24
    设备管理器就是负责管理这台电脑上的外设,当我们通过电脑提供的USB口插入一个键盘、鼠标时设备管理器会与其通讯来确认你插入的到底是一个什么样的设备,然后在创建对应的设备驱动。 以上的前提下是你的设备是流行...
  • 通常用一种指定的算法对原始数据计算出一个校验值,接收方用同样的算法也计算出一个校验值,如果接收方计算的校验值正确,则说明数据是完整的。 本实验探讨累加和校验和crc循环冗余校验的原理及在Linux C系统下的...
  • Linux和Windows文件编码格式区别

    千次阅读 2015-12-29 15:00:57
    1.业务场景 ...因需要保证文件的完整性和一致性,我们对文本添加MD5校验码,并将MD5码一并发送到目标机器。结果发现linux服务器上对文本生成的MD5码与windows pc上对文本生成的MD5码不一致。 3.寻找答案
  • Linux gcc编写的socket UDP文件传输 本文实现了用UDP协议传输传输文件 UDP传1GB的文件仅需15秒 该代码包含 根据文件内容长度生成MD5,以供校验文件完整性

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 33,343
精华内容 13,337
关键字:

linux生成一个文件的校验码

linux 订阅