精华内容
下载资源
问答
  • 文件hash工具

    2018-04-18 20:12:07
    文件hash工具,支持包括MD5、SHA1、CRC32等多种hash算法
  • 文件hash算法,对大文件进行hash计算

    热门讨论 2009-12-25 14:37:15
    文件hash算法,对大文件进行hash计算,并可以返回base64编码.文件hash算法,对大文件进行hash计算,并可以返回base64编码.
  • 快速文件hash

    千次阅读 2016-10-31 23:56:21
    想把重复的文件找出来,虽然我已经用了ZFS的dedup,实际占用空间并不会重复,但是还是觉得有必要理一下……写个程序扫描一遍并不复杂,但是要判断文件是不是重复就比较麻烦,可靠的方法当然是做全文件HASH,但是对于...

    最近打算把家里服务器上的文件理一下,想把重复的文件找出来,虽然我已经用了ZFS的dedup,实际占用空间并不会重复,但是还是觉得有必要理一下……

    写个程序扫描一遍并不复杂,但是要判断文件是不是重复就比较麻烦,可靠的方法当然是做全文件HASH,但是对于T级的硬盘来说,这样效率太低了,所以写了一段小代码来做一个快速的HASH。

    def get_filemd5(fullpath, filename):
        file_size = get_filesize(fullpath, filename)
        block_count = int((QUICK_HASH_SIZE + BUFSIZE / 2) / BUFSIZE
                          if QUICK_HASH_SIZE else file_size / BUFSIZE)
        block_size = file_size * 1.0 / block_count if QUICK_HASH_SIZE \
            else BUFSIZE
        m = hashlib.md5()
        with open(os.path.join(fullpath, filename), "rb") as f:
            for i in xrange(block_count):
                pos = int(i * block_size / MINSIZE) * MINSIZE
                f.seek(pos, 0)
                buf = f.read(BUFSIZE)
                m.update(buf)
            remaining = file_size - f.tell()
            if remaining > 0:
                if QUICK_HASH_SIZE and remaining > BUFSIZE:
                    f.seek(file_size - BUFSIZE, 0)
                    remaining = BUFSIZE
                buf = f.read(remaining)
                m.update(buf)
        return m.hexdigest()
    

    HASH算法是直接用MD5,简单方便。其中定义了三个常量:QUICK_HASH_SIZE、BUFSIZE和MINSIZE。

    其中MINSIZE定义了对齐的大小,BUFSIZE定义了HASH分块的大小,QUICK_HASH_SIZE则是定义了需要做快速HASH的文件大小阈值。

    方法很简单:文件小于QUICK_HASH_SIZE,则做全文件HASH,大于QUICK_HASH_SIZE则按BUFSIZE大小间隔取样,总取样数据大小为QUICK_HASH_SIZE。

    每个BUFSIZE块在文件中的分布为均匀的,但是每块又以MINSIZE对齐,另外,因为通常文件最经常被修改的部分是最后的部分,所以最后一块一定是与文件结尾对齐,以保证HASH部分包括文件的结尾。

    当然,因为没有对全文件做HASH,所以没有被HASH到的部分如果有修改,是不会被发现的,但是对我的需求来说基本不会有这种情况,所以不要紧,但是这样可以让HASH速度大大加快,特别是对那些几个G的大文件(不许联想,我说的是操作系统的安装ISO镜像文件之类)。

    展开全文
  • Java计算文件hash

    万次阅读 热门讨论 2017-12-21 14:04:02
    当然是用比较文件hash值的方法,文件hash又叫文件签名,文件中哪怕一个bit位被改变了,文件hash就会不同。 比较常用的文件hash算法有MD5和SHA-1。 我用的是MD5算法,java中,计算MD5可以用MessageDigest这个类。 ...

     

    如何知道一个文件是否改变了呢?当然是用比较文件hash值的方法,文件hash又叫文件签名,文件中哪怕一个bit位被改变了,文件hash就会不同。

    比较常用的文件hash算法有MD5和SHA-1。
    我用的是MD5算法,java中,计算MD5可以用MessageDigest这个类。

     

    下面提供两个工具类(请使用第一个工具类,第二个有问题

     

    第一个工具类:

    代码如下:

    package com.test;  
      
    import java.io.FileInputStream;  
    import java.io.FileNotFoundException;  
    import java.io.InputStream;  
    import java.math.BigInteger;  
    import java.security.MessageDigest;  
      
    public class MD5Util {  
          
        public static void main(String[] args) {  
            try {  
                //此处我测试的是我本机jdk源码文件的MD5值 
            	String filePath = "C:\\Program Files\\Java\\jdk1.7.0_45\\src.zip";
            	
                String md5Hashcode = md5HashCode(filePath);
                String md5Hashcode32 = md5HashCode32(filePath);  
                
                System.out.println(md5Hashcode + ":文件的md5值");  
                System.out.println(md5Hashcode32+":文件32位的md5值"); 
                
                //System.out.println(-100 & 0xff);
            } catch (FileNotFoundException e) {  
                e.printStackTrace();  
            }  
        }  
        
        /**
         * 获取文件的md5值 ,有可能不是32位
         * @param filePath	文件路径
         * @return
         * @throws FileNotFoundException
         */
        public static String md5HashCode(String filePath) throws FileNotFoundException{  
            FileInputStream fis = new FileInputStream(filePath);  
            return md5HashCode(fis);  
        }  
        
        /**
         * 保证文件的MD5值为32位
         * @param filePath	文件路径
         * @return
         * @throws FileNotFoundException
         */
        public static String md5HashCode32(String filePath) throws FileNotFoundException{  
        	FileInputStream fis = new FileInputStream(filePath);  
        	return md5HashCode32(fis);  
        }  
        
        /**
         * java获取文件的md5值  
         * @param fis 输入流
         * @return
         */
        public static String md5HashCode(InputStream fis) {  
            try {  
            	//拿到一个MD5转换器,如果想使用SHA-1或SHA-256,则传入SHA-1,SHA-256  
                MessageDigest md = MessageDigest.getInstance("MD5"); 
                
                //分多次将一个文件读入,对于大型文件而言,比较推荐这种方式,占用内存比较少。
                byte[] buffer = new byte[1024];  
                int length = -1;  
                while ((length = fis.read(buffer, 0, 1024)) != -1) {  
                    md.update(buffer, 0, length);  
                }  
                fis.close();
                //转换并返回包含16个元素字节数组,返回数值范围为-128到127
      			byte[] md5Bytes  = md.digest();
                BigInteger bigInt = new BigInteger(1, md5Bytes);//1代表绝对值 
                return bigInt.toString(16);//转换为16进制
            } catch (Exception e) {  
                e.printStackTrace();  
                return "";  
            }  
        }  
        
        /**
         * java计算文件32位md5值
         * @param fis 输入流
         * @return
         */
      	public static String md5HashCode32(InputStream fis) {
      		try {
      			//拿到一个MD5转换器,如果想使用SHA-1或SHA-256,则传入SHA-1,SHA-256  
      			MessageDigest md = MessageDigest.getInstance("MD5");
      			
      			//分多次将一个文件读入,对于大型文件而言,比较推荐这种方式,占用内存比较少。
      			byte[] buffer = new byte[1024];
      			int length = -1;
      			while ((length = fis.read(buffer, 0, 1024)) != -1) {
      				md.update(buffer, 0, length);
      			}
      			fis.close();
      			
      			//转换并返回包含16个元素字节数组,返回数值范围为-128到127
      			byte[] md5Bytes  = md.digest();
      			StringBuffer hexValue = new StringBuffer();
      			for (int i = 0; i < md5Bytes.length; i++) {
      				int val = ((int) md5Bytes[i]) & 0xff;//解释参见最下方
      				if (val < 16) {
      					/**
      					 * 如果小于16,那么val值的16进制形式必然为一位,
      					 * 因为十进制0,1...9,10,11,12,13,14,15 对应的 16进制为 0,1...9,a,b,c,d,e,f;
      					 * 此处高位补0。
      					 */
      					hexValue.append("0");
      				}
      				//这里借助了Integer类的方法实现16进制的转换 
      				hexValue.append(Integer.toHexString(val));
      			}
      			return hexValue.toString();
      		} catch (Exception e) {
      			e.printStackTrace();
      			return "";
      		}
      	}
      	
      	/**
      	 * 方法md5HashCode32 中     ((int) md5Bytes[i]) & 0xff   操作的解释:
      	 * 在Java语言中涉及到字节byte数组数据的一些操作时,经常看到 byte[i] & 0xff这样的操作,这里就记录总结一下这里包含的意义: 
    	 * 1、0xff是16进制(十进制是255),它默认为整形,二进制位为32位,最低八位是“1111 1111”,其余24位都是0。 
         * 2、&运算: 如果2个bit都是1,则得1,否则得0; 
         * 3、byte[i] & 0xff:首先,这个操作一般都是在将byte数据转成int或者其他整形数据的过程中;使用了这个操作,最终的整形数据只有低8位有数据,其他位数都为0。 
         * 4、这个操作得出的整形数据都是大于等于0并且小于等于255的
      	 */
      
    }  
    

    运行结果如下图:

    第二个工具类:

    结果一定为32位的,具体可看代码,代码如下:

    package com.test;
    
    import java.io.File;
    import java.io.FileInputStream;
    import java.io.FileNotFoundException;
    import java.io.IOException;
    import java.nio.ByteBuffer;
    import java.nio.channels.FileChannel;
    import java.security.MessageDigest;
    import java.security.NoSuchAlgorithmException;
    import java.util.Arrays;
    
    /**
     * Md5校验工具类
     */
    public class MD5Util2 {
    
        private static final char[] hexDigits = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
                'a', 'b', 'c', 'd', 'e', 'f'};
        
        public static void main(String[] args) {
        	//此处我测试的是我本机jdk源码文件的MD5值
    		String filePath = "C:\\Program Files\\Java\\jdk1.7.0_45\\src.zip";
    		String md5Hashcode2 = MD5Util2.getFileMD5(new File(filePath));
    		
    		System.out.println("MD5Util2计算文件md5值为:" + md5Hashcode2);
    		System.out.println("MD5Util2计算文件md5值的长度为:" + md5Hashcode2.length());
    	}
    
        /**
         * Get MD5 of a file (lower case)
         * @return empty string if I/O error when get MD5
         */
        public static String getFileMD5( File file) {
    
            FileInputStream in = null;
            try {
                in = new FileInputStream(file);
                FileChannel ch = in.getChannel();
                return MD5(ch.map(FileChannel.MapMode.READ_ONLY, 0, file.length()));
            } catch (FileNotFoundException e) {
                return "";
            } catch (IOException e) {
                return "";
            } finally {
                if (in != null) {
                    try {
                        in.close();
                    } catch (IOException e) {
                        // 关闭流产生的错误一般都可以忽略
                    }
                }
            }
    
        }
    
        /**
         * MD5校验字符串
         * @param s String to be MD5
         * @return 'null' if cannot get MessageDigest
         */
        
        private static String getStringMD5( String s) {
            MessageDigest mdInst;
            try {
                // 获得MD5摘要算法的 MessageDigest 对象
                mdInst = MessageDigest.getInstance("MD5");
            } catch (NoSuchAlgorithmException e) {
                e.printStackTrace();
                return "";
            }
    
            byte[] btInput = s.getBytes();
            // 使用指定的字节更新摘要
            mdInst.update(btInput);
            // 获得密文
            byte[] md = mdInst.digest();
            // 把密文转换成十六进制的字符串形式
            int length = md.length;
            char str[] = new char[length * 2];
            int k = 0;
            for (byte b : md) {
                str[k++] = hexDigits[b >>> 4 & 0xf];
                str[k++] = hexDigits[b & 0xf];
            }
            return new String(str);
        }
    
        
        @SuppressWarnings("unused")
    	private static String getSubStr( String str, int subNu, char replace) {
            int length = str.length();
            if (length > subNu) {
                str = str.substring(length - subNu, length);
            } else if (length < subNu) {
                // NOTE: padding字符填充在字符串的右侧,和服务器的算法是一致的
                str += createPaddingString(subNu - length, replace);
            }
            return str;
        }
    
        
        private static String createPaddingString(int n, char pad) {
            if (n <= 0) {
                return "";
            }
    
            char[] paddingArray = new char[n];
            Arrays.fill(paddingArray, pad);
            return new String(paddingArray);
        }
    
        /**
         * 计算MD5校验
         * @param buffer
         * @return 空串,如果无法获得 MessageDigest实例
         */
        
        private static String MD5(ByteBuffer buffer) {
            String s = "";
            try {
                MessageDigest md = MessageDigest.getInstance("MD5");
                md.update(buffer);
                byte tmp[] = md.digest(); // MD5 的计算结果是一个 128 位的长整数,
                // 用字节表示就是 16 个字节
                char str[] = new char[16 * 2]; // 每个字节用 16 进制表示的话,使用两个字符,
                // 所以表示成 16 进制需要 32 个字符
                int k = 0; // 表示转换结果中对应的字符位置
                for (int i = 0; i < 16; i++) { // 从第一个字节开始,对 MD5 的每一个字节
                    // 转换成 16 进制字符的转换
                    byte byte0 = tmp[i]; // 取第 i 个字节
                    str[k++] = hexDigits[byte0 >>> 4 & 0xf]; // 取字节中高 4 位的数字转换, >>>,
                    // 逻辑右移,将符号位一起右移
                    str[k++] = hexDigits[byte0 & 0xf]; // 取字节中低 4 位的数字转换
                }
                s = new String(str); // 换后的结果转换为字符串
    
            } catch (NoSuchAlgorithmException e) {
                e.printStackTrace();
            }
            return s;
        }
    
    }
    

    运行结果如下图:

     

    两个工具类的对比:

    测试代码如下:

    package com.test;
    
    import java.io.File;
    import java.io.FileNotFoundException;
    
    public class test {
    	public static void main(String[] args) {
    		try {
    			//此处我测试的是我本机jdk源码文件的MD5值
    			String filePath = "C:\\Program Files\\Java\\jdk1.7.0_45\\src.zip";
    			
    			long start = System.currentTimeMillis();
    			String md5Hashcode = MD5Util.md5HashCode(filePath);
    			long end = System.currentTimeMillis();
    			
    			String md5Hashcode2 = MD5Util2.getFileMD5(new File(filePath));
    			long end1 = System.currentTimeMillis();
    			
    			System.out.println("MD5Util 计算文件md5值为:" + md5Hashcode + " --useTime:"+(end-start));
    			System.out.println("MD5Util2计算文件md5值为:" + md5Hashcode2 + " --useTime:"+(end1-end));
    		} catch (FileNotFoundException e) {
    			e.printStackTrace();
    		}
    		
    	}
    }
    

    运行结果如下图:


     

    结论:

    虽然对比用时,感觉使用第二个工具类效率更高!

    但是 NIO的FileChannel 存在一个巨大的BUG使用它会一直不释放文件句柄,即生成MD5的文件不能操作(移动或删除等),这个BUG网上吵得沸沸扬扬,至今没有解决,毕竟是SUN的BUG,解铃还需系铃人啊!所以推荐使用文件分块读取的方法-

    即应该用第一个工具类!

    即应该用第一个工具类!

    即应该用第一个工具类!

     

    番外篇:

    其实还有一个重点,就是如何知道自己生成的MD5值是否正确呢?

    方法很多,其实有一个挺简单的方法,不需要另外安装什么软件。

    使用windows自带的命令即可:certutil -hashfile [文件路径] MD5,

    例子如下:

     

     

     

     

    展开全文
  • 主要介绍了Python实现通过文件路径获取文件hash值的方法,结合实例形式分析了Python针对文件进行hash运算的实现方法与相关注意事项,需要的朋友可以参考下
  • 文件hash值校验

    千次阅读 2018-06-16 14:40:09
    在互联网中下载软件或其它文件时,经常需要验证,下载文件是否被恶意篡改过,需要在本机计算下载文件hash值,与官方提供的hash值进行比较。hash的计算不需要添加额外的软件,Windows系统本身便具有这样的工具。...

    在互联网中下载软件或其它文件时,经常需要验证,下载的文件是否被恶意篡改过,需要在本机计算下载文件的hash值,与官方提供的hash值进行比较。hash的计算不需要添加额外的软件,Windows系统本身便具有这样的工具。

    打开cmd,执行以下命令即可。

    certutil -hashfile yourfilename.ext MD5

    certutil -hashfile yourfilename.ext SHA1

    certutil -hashfile yourfilename.ext SHA256


    展开全文
  • 文件系统——Hash结构文件

    千次阅读 2013-11-13 13:07:19
    实验四 文件系统——Hash结构文件   一、实验目的 1、理解Linux文件系统的内部技术,掌握Linux与文件有关的系统调用命令,并在此基础上建立面向随机检索的hash结构文件。 2、Linux系统保持UNIX文件系统的...

    实验 文件系统——Hash结构文件    

    一、实验目的

    1、理解Linux文件系统的内部技术,掌握Linux与文件有关的系统调用命令,并在此基础上建立面向随机检索的hash结构文件。

    2Linux系统保持UNIX文件系统的风格,提供流式文件界面,这种结构具有简洁灵活的特点,但并不直接支持记录式文件和关键字检索。本实验是在Linux文件系统基础上,设计一组库函数,以提供对随机检索的支持。

     

    、实验内容

    1参考教材中hash文件构造算法,设计一组hash文件函数,包括hash文件创建、打开、关闭、读、写等。

    2编写一个测试程序,通过记录保存、查找、删除等操作,检查上述hash文件是否实现相关功能。

     

    、实验准备

    1教程Hash文件核心算法,包括记录保存、记录查找、记录删除等。

    2教程Linux系统有关文件的系统调用命令:creatopenclosereadwritelseek

     

    、实验设计

    1由于在Linux系统核心之外模拟实现hash文件,有关hash文件的说明信息不能保存 inode中,而只能记录在文件的头部。这些信息包括hash文件标志、记录大小、文件 长度、记录数量等。

    2可以根据hash文件核心算法设计内部函数,包括记录的保存、查找、删除等,在此 基础上实现读、写等常规操作。 

     

    五、实验源码

    //hashfile.h

     

    #include<unistd.h>

    #include<sys/stat.h>

    #define COLLISIONFACTOR 0.5


    struct HashFileHeader

    {

    int sig; //Hash文件印鉴

    int reclen; //记录长度

    int total_rec_num; //总记录数

    int current_rec_num; //当前记录数 

    };

    struct CFTag

    {

    char collision; //冲突计数

    char free; //空闲标志

    };


    int hashfile_creat(const char *filename,mode_t mode,int reclen,int total_rec_num);

    //int hashfile_open(const char *filename,int flags); 

    int hashfile_open(const char *filename,int flags,mode_t mode);

    int hashfile_close(int fd);

    int hashfile_read(int fd,int keyoffset,int keylen,void *buf);

    int hashfile_write(int fd,int keyoffset,int keylen,void *buf);

    int hashfile_delrec(int fd,int keyoffset,int keylen,void *buf);

    int hashfile_findrec(int fd,int keyoffset,int keylen,void *buf);

    int hashfile_saverec(int fd,int keyoffset,int keylen,void *buf);

    int hash(int keyoffset,int keylen,void *buf,int total_rec_num);

    int checkHashFileFull(int fd);

    int readHashFileHeader(int fd,struct HashFileHeader *hfh);


    //hashfile.c
    #include<unistd.h>
    #include<sys/types.h>
    #include<sys/stat.h>
    #include<fcntl.h>
    #include<stdio.h>
    #include<stdlib.h>
    #include<memory.h>
    #include"HashFile.h"

    int hashfile_creat(const char *filename,mode_t mode,int reclen,int total_rec_num)
    {
    struct HashFileHeader hfh;
    int fd;
    int rtn;
    char *buf;
    int i=0;
    hfh.sig = 31415926;
    hfh.reclen = reclen;
    hfh.total_rec_num = total_rec_num;
    hfh.current_rec_num = 0;
    //fd = open(filename,mode);
    fd = creat(filename,mode);
    if(fd != -1)
    {
    rtn = write(fd,&hfh,sizeof(struct HashFileHeader));
    //lseek(fd,sizeof(struct HashFileHeader),SEEK_SET);
    if(rtn != -1)
    {
    buf = (char*)malloc((reclen+sizeof(struct CFTag))*total_rec_num);
    memset(buf,0,(reclen+sizeof(struct CFTag))*total_rec_num);   ????
    rtn = write(fd,buf,(reclen+sizeof(struct CFTag))*total_rec_num);
    free(buf);
    }
    close(fd);
    return rtn;
    }
    else{
    close(fd);
    return -1;
    }
    }

    int hashfile_open(const char *filename,int flags,mode_t mode)
    {
    int fd = open(filename,flags,mode);
    struct HashFileHeader hfh;
    if(read(fd,&hfh,sizeof(struct HashFileHeader))!= -1)
    {
    lseek(fd,0,SEEK_SET);
    if(hfh.sig == 31415926)
    return fd;
    else
    return -1;
    }
    else return -1;
    }
    int hashfile_close(int fd)
    {
    return close(fd);
    }
    int hashfile_read(int fd,int keyoffset,int keylen,void *buf)
    {
    struct HashFileHeader hfh;
    readHashFileHeader(fd,&hfh);
    int offset = hashfile_findrec(fd,keyoffset,keylen,buf);
    if(offset != -1)
    {
    lseek(fd,offset+sizeof(struct CFTag),SEEK_SET);
    return read(fd,buf,hfh.reclen);
    }
    else
    {
    return -1;
    }
    }
    int hashfile_write(int fd,int keyoffset,int keylen,void *buf)
    {
    return hashfile_saverec(fd,keyoffset,keylen,buf);
    //return -1;
    }
    int hashfile_delrec(int fd,int keyoffset,int keylen,void *buf)
    {
    int offset;
    offset = hashfile_findrec(fd,keyoffset,keylen,buf);
    if(offset != -1)
    {
    struct CFTag tag;
    read(fd,&tag,sizeof(struct CFTag));
    tag.free =0; //置空闲标志 
    lseek(fd,offset,SEEK_SET);
    write(fd,&tag,sizeof(struct CFTag));
    struct HashFileHeader hfh;
    readHashFileHeader(fd,&hfh);
    int addr = hash(keyoffset,keylen,buf,hfh.total_rec_num);
    offset = sizeof(struct HashFileHeader)+addr*(hfh.reclen+sizeof(struct CFTag));
    if(lseek(fd,offset,SEEK_SET)==-1)
    return -1;
    read(fd,&tag,sizeof(struct CFTag));
    tag.collision--; //冲突计数减1
    lseek(fd,offset,SEEK_SET);
    write(fd,&tag,sizeof(struct CFTag));
    hfh.current_rec_num--; //当前记录数减1
    lseek(fd,0,SEEK_SET);
    write(fd,&hfh,sizeof(struct HashFileHeader));
    }
    else{
    return -1;
    }
    }

    int hashfile_findrec(int fd,int keyoffset,int keylen,void *buf)
    {
    struct HashFileHeader hfh;
    readHashFileHeader(fd,&hfh);
    int addr = hash(keyoffset,keylen,buf,hfh.total_rec_num);
    int offset = sizeof(struct HashFileHeader)+addr*(hfh.reclen+sizeof(struct CFTag));
    if(lseek(fd,offset,SEEK_SET)==-1)
    return -1;
    struct CFTag tag;
    read(fd,&tag,sizeof(struct CFTag));
    char count = tag.collision;
    if(count==0)
    return -1; //不存在
    recfree:
    if(tag.free == 0)
    {
    offset += hfh.reclen+sizeof(struct CFTag);
    if(lseek(fd,offset,SEEK_SET)==-1)
    return -1;
    read(fd,&tag,sizeof(struct CFTag));
    goto recfree;
    }
    else{
    char *p =(char*)malloc(hfh.reclen*sizeof(char));
    read(fd,p,hfh.reclen);
    //printf("Record is {%d , %s}\n",((struct jtRecord *)p)->key,((struct jtRecord *p)->other);
    char *p1,*p2;
    p1 = (char *)buf+keyoffset;
    p2 = p + keyoffset;
    int j=0;
    while((*p1 == *p2)&&(j<keylen))
    {
    p1++;
    p2++;
    j++;
    }
    if(j==keylen)
    {
    free(p);
    p = NULL;
    return(offset);
    }
    else{
    if(addr == hash(keyoffset,keylen,p,hfh.total_rec_num))
    {
    count--;
    if(count == 0)
    {
    free(p);
    p = NULL;
    return -1;//不存在 
    }
    }
    free(p);
    p = NULL;
    offset += hfh.reclen+sizeof(struct CFTag);
    if(lseek(fd,offset,SEEK_SET) == -1)
    return -1;
    read(fd,&tag,sizeof(struct CFTag));
    goto recfree;
    }
    }
    }
    int hashfile_saverec(int fd,int keyoffset,int keylen,void *buf)
    {
    if(checkHashFileFull(fd))
    {
    return -1;
    }
    struct HashFileHeader hfh;
    readHashFileHeader(fd,&hfh);
    int addr = hash(keyoffset,keylen,buf,hfh.total_rec_num);
    int offset = sizeof(struct HashFileHeader)+addr*(hfh.reclen+sizeof(struct CFTag));
    if(lseek(fd,offset,SEEK_SET)==-1)
    return -1;
    struct CFTag tag;
    read(fd,&tag,sizeof(struct CFTag));
    tag.collision++;
    lseek(fd,sizeof(struct CFTag)*(-1),SEEK_CUR);
    write(fd,&tag,sizeof(struct CFTag));
    while(tag.free!=0) //冲突,顺序探查
    {
    offset += hfh.reclen+sizeof(struct CFTag);
    if(offset >= lseek(fd,0,SEEK_END))
    offset = sizeof(struct HashFileHeader); //reach at and,then rewind
    if(lseek(fd,offset,SEEK_SET)==-1)
    return -1;
    read(fd,&tag,sizeof(struct CFTag));
    tag.free =-1;
    lseek(fd,sizeof(struct CFTag)*(-1),SEEK_CUR);
    write(fd,&tag,sizeof(struct CFTag));
    write(fd,buf,hfh.reclen);
    hfh.current_rec_num++;
    lseek(fd,0,SEEK_SET);
    return write(fd,&hfh,sizeof(struct HashFileHeader));  //存入记录 
    }

    int hash(int keyoffset,int keylen,void *buf,int total_rec_num)
    {
    int i=0;
    char *p =(char*)buf+keyoffset;
    int addr =0;
    for(i=0;i<keylen;i++)
    {
    addr += (int)(*p);
    p++;
    }
    return addr%(int)(total_rec_num*COLLISIONFACTOR);
    }

    int checkHashFileFull(int fd)
    {
    struct HashFileHeader hfh;
    readHashFileHeader(fd,&hfh);
    if(hfh.current_rec_num<hfh.total_rec_num)
    return 0;
    else
    return 1;
    }
    int readHashFileHeader(int fd,struct HashFileHeader *hfh)
    {
    lseek(fd,0,SEEK_SET);
    return read(fd,hfh,sizeof(struct HashFileHeader));
    }
    //jtRecord.h
    #define RECORDLEN 32

    struct jtRecord
    {
    int key;
    char other[RECORDLEN-sizeof(int)];
    };

    #ifdef HAVE_CONFIG_H
    #include<config.h>
    #endif

    //jtRecord.c
    #ifdef HAVE_CONFIG_H
    #include<config.h>
    #endif

    #include<stdio.h>
    #include<stdlib.h>
    #include<sys/types.h>
    #include<sys/stat.h>
    #include<fcntl.h>
    #include<string.h>

    #include"HashFile.h"
    #include"jtRecord.h"
    #define KEYOFFSET 0
    #define KEYLEN sizeof(int)
    #define FileNAME "jing.hash"

    void showHashFile();

    int main(int argc,char *argv[])
    {
    struct jtRecord rec[6] = {
    {1,"jing"},{2,"wang"},{3,"li"},
    {4,"zhang"},{5,"qing"},{6,"yuan"}
    };
    int j=0;
    for(j=0;j<6;j++)
    {
    printf("<%d,%d>\t",rec[j].key,hash(KEYOFFSET,KEYLEN,&rec[j],6));
    }
    int fd = hashfile_creat(FileNAME,O_RDWR|O_CREAT,RECORDLEN,6);
    int i=0;
    printf("\nOpen and Save Record...\n");
    fd = hashfile_open(FileNAME,O_RDWR,0);
    for(i=0;i<6;i++)
    {
    hashfile_saverec(fd,KEYOFFSET,KEYLEN,&rec[i]);
    }
    hashfile_close(fd);
    showHashFile();
    //Demo find Rec
    printf("\nFind Record...");
    fd = hashfile_open(FileNAME,O_RDWR,0);
    int offset = hashfile_findrec(fd,KEYOFFSET,KEYLEN,&rec[4]);
    printf("\noffset is %d\n",offset);
    hashfile_close(fd);
    struct jtRecord jt;
    struct CFTag tag;
    fd = open(FileNAME,O_RDWR);
    lseek(fd,offset,SEEK_SET);
    read(fd,&tag,sizeof(struct CFTag));
    printf("Tag is <%d,%d>\t",tag.collision,tag.free);
    read(fd,&jt,sizeof(struct jtRecord));
    printf("Record is {%d,%s}\n",jt.key,jt.other);
    //Demo Delete Rec
    printf("\nDelete Record...");
    fd = hashfile_open(FileNAME,O_RDWR,0);
    hashfile_delrec(fd,KEYOFFSET,KEYLEN,&rec[2]);
    hashfile_close(fd);
    showHashFile();
    //Demo Read
    fd = hashfile_open(FileNAME,O_RDWR,0);
    char buf[32];
    memcpy(buf,&rec[1],KEYLEN);
    hashfile_read(fd,KEYOFFSET,KEYLEN,buf);
    printf("\nRead Record is {%d,%s}\n",
    ((struct jtRecord *)buf)->key,((struct jtRecord *)buf)->other);
    hashfile_close(fd);
    //Demo Write
    printf("\nWrite Record...");
    fd = hashfile_open(FileNAME,O_RDWR,0);
    hashfile_write(fd,KEYOFFSET,KEYLEN,&rec[3]);
    hashfile_close(fd);
    showHashFile();
    return 0;
    }

    void showHashFile()
    {
    int fd;
    printf("\n");
    fd = open(FileNAME,O_RDWR);
    lseek(fd,sizeof(struct HashFileHeader),SEEK_SET);
    struct jtRecord jt;
    struct CFTag tag;
    while(1)
    {
    if(read(fd,&tag,sizeof(struct CFTag))<=0)
    break;
    printf("Tag is <%d,%d>\t",tag.collision,tag.free);
    if(read(fd,&jt,sizeof(struct jtRecord))<=0)
    break;
    printf("Record is {%d,%s}\n",jt.key,jt.other);
    }
    close(fd);
    }

    六、实验结果

    文件系统鈥斺擧ash结构文件

    七、实验小结

    编译成功后,要在管理员权限下运行,因为程序要运行文件的系统调用(createwrite

    展开全文
  • HashTools 是一款优秀的hash值计算工具 包含文件: 1.0 HashTools 4.1版本(需要.net 4.5) 2.0 HashTools 2.0版本(绿色版) 3.0 制作sfv校验文件 功能: 1.0 同时选择某个文件夹下所有文件 2.0 支持算法:...
  • 文件HASH值修改

    千次阅读 2018-02-04 13:50:36
    在CSDN上传文件时,提示文件已经存在,可以通过修改hash的方式完成文件上传 http://www.xsnow.moe/2015/10/23/HashModifier/
  • 获取任意文件Hash

    2009-06-08 15:59:21
    C#自己封装的获取任意文件Hash值DLL,添加引用,实例对象,传入文件path,返回hash值.
  • 文件hash

    千次阅读 2013-09-10 15:31:04
    Hash,一般翻译做“散列”,也有直接音译为"哈希"的,就是把任意长度的输入(又叫做预映射,pre-image),通过散列算法,变换成固定长度的输出,该输出就是散列值。这种转换是一种压缩映射,也就是,散列值的空间...
  • 获取文件hash

    千次阅读 2017-03-30 16:25:34
    3 Android UGC 上传本地视频需要先获取签名,获取签名接口的传参需要视频文件hash,不是很清楚是什么意思,后来我在网上找了很多资料,最终成功了一个//第一步将文件名字MD5 public static byte[] getMd5(String ...
  • 获取文件hash

    千次阅读 2019-07-24 14:21:51
    public string getFilesMD5Hash(string file) { //MD5 hash provider for computing the hash of the file MD5CryptoServiceProvider md5 = new MD5CryptoServiceProvider(); ...
  • perl Hash 我比较喜欢的,好多数据我都是存在 hash中。 但是有些数据我是不想他,程序退出后不保存的。所以想把数据存入文件中。 这个东西研究了 好多个小时,想找一个和 SHELL 语言一样的 >> 文件...
  • 计算文件Hash

    千次阅读 2016-08-16 13:41:15
    计算文件Hash
  • 用java计算文件MD5(文件hash

    千次阅读 2014-01-19 09:40:03
    distributed system的第一个实验需要提供...当然是用比较文件hash值的方法,文件hash又叫文件签名,文件中哪怕一个bit位被改变了,文件hash就会不同。 比较常用的文件hash算法有MD5和SHA-1 public static void main(St
  • 获取同目录下多文件Hash

    千次阅读 2017-09-02 23:08:35
    获取同目录下多文件Hash
  • python计算文件hash

    千次阅读 2016-11-29 16:33:45
    python计算文件hash值 import hashlib#读取文件 f = open('c:\\aaa.txt') thehash = hashlib.md5() #读取文件第一行 theline = f.readline() #逐行读取文件,并计算 while(theline): thehash.update(theline) ...
  • 如何对文件进行hash

    千次阅读 2019-03-16 09:42:27
    import hashlib def filehash(filename): # 对文件hash算法 # 用sha256方法计算 h = hashlib.sha256() # 将文件按照4096k大小读出, with open(filename, "rb") as f: content = f.read(4096) h.up...
  • 今天查了一下,发现windows10的PowerShell命令自带的Get-FileHash命令可以直接用来计算文件Hash值(MD5、SHA1、SHA256等),这样就不用再使用第三方软件了,直接一条命令搞定。 windows10打开PowerShell命令窗口的...
  • C++ 文件hash值 BT种子的hash

    千次阅读 2013-10-31 11:10:25
    这个两个东东,是我在网上找到的。小小的修改了一下方便大家使用。 ...文件hash值: http://pan.baidu.com/share/link?shareid=3718436681&uk=3037189616 torrent Hash值: http://pan.
  • IPFS-文件HASH值计算

    千次阅读 2020-05-20 15:41:30
    文章目录IPFS如何计算文件hash?IPFS-Multihash易用需求:Base58 IPFS如何计算文件hash? IPFS采用了SHA2-256这个安全级别还算高的算法,对任意长度的内容,生成的HASH值长度固定,都是32个字节。 在Linux下,直接用...
  • 文件hash值自动批量修改软件[源码]

    热门讨论 2015-05-26 16:08:47
    文件[二进制]hash值自动批量修改软件[源码],可用来修改AV上传到网盘
  • 校验文件hash

    千次阅读 2016-09-09 00:03:17
    在OSX平台,系统自带了 shanum用来校验文件的sha值。...任意修改一下文件,比如只是在文件最末尾加一个空行,之后再校验文件的shanum值时发现值已经变了。 或者用$ openssl sha mp.py $ openssl sha1 mp.py
  • 使用hash方法切割文件

    千次阅读 2015-01-08 20:24:40
    如果有大型数据文件(如每行为url或者ip或者单词等的),以G为单位的,处理的时候需先切分。...可以使用hash切分法。 public class Test { static int HASHLEN = 7303; public static void main(String[] args
  • SHA256 HASH计算方法,大文件、小文件、流式读取计算
  • 本文介绍了散列文件及其操作,包括散列文件相关的基本概念,散列函数的构造方法,以及冲突的处理方法。
  • 一:下载安装openssl windows版本64位OpenSSL:链接:Win64OpenSSL-1_1_0i 提取码:f2h4 其他版本请自行去官网下载 双击下载下来的exe文件,一直点下一步即安装成功 二:测试OpenSSL是否安装成功 Win+R,输入cmd,...
  • 建议115:通过HASH来验证文件是否被篡改  MD5算法作为一种最通用的HASH算法,也被广泛用于文件完整性的验证上。文件通过MD5-HASH算法求值,总能得到一个固定长度的MD5值。虽说MD5是一种压缩算法,以致可能存在多个...
  • 【GEEK】win10下进行文件Hash值计算

    千次阅读 2017-06-02 21:52:53
    一、目的一般用户要进行文件Hash值计算,无非出于文件安全性检查或者文件完整性检查的目的。 文件安全性检查:病毒木马广泛存在的现代网络中,我们不可能因噎废食地封闭自我,为了在网络中保护自身,多掌握一项...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 450,550
精华内容 180,220
关键字:

hash文件怎么下载