精华内容
下载资源
问答
  • win7企业英文版: 文件名  en_windows_7_enterprise_x86_dvd_X15-70745.iso SHA1  C6B905E48FDB6CB5BFCA967715A64461B812D40C 文件大小  2.24GB 发布时间  2009-08-06 ed2k://|file|en_windows_7_enterprise_x86
    win7企业英文版:
    文件名
        en_windows_7_enterprise_x86_dvd_X15-70745.iso
    SHA1
        C6B905E48FDB6CB5BFCA967715A64461B812D40C
    文件大小:2.24GB
    发布时间:2009-08-06
    ed2k://|file|en_windows_7_enterprise_x86_dvd_X15-70745.iso|2400401408|4117C4CB9648A9ED79CC6CFB47A10696|/


    文件名
        en_windows_7_enterprise_with_sp1_x86_dvd_u_677710.iso
    SHA1
        4E0450AC73AB6F9F755EB422990CD9C7A1F3509C
    文件大小:2.27GB
    发布时间:2011-05-12
    ed2k://|file|en_windows_7_enterprise_with_sp1_x86_dvd_u_677710.iso|2434502656|9B710D7876B754D5F96F72B4A7C9B9A8|/

    ------------------------------------------------------------------------------------------------------------------------------------------------------------
    win7专业英文版:
    文件名
        en_windows_7_professional_x86_dvd_x15-65804.iso
    SHA1
        697FA06554502FB21D30275273B25747299C020D
    文件大小:2.33GB
    发布时间:2009-08-06
    ed2k://|file|en_windows_7_professional_x86_dvd_x15-65804.iso|2501894144|61D69F2250F114B95720CB81D3C1C5EE|/


    win7专业英文版64位:
    文件名
        en_windows_7_professional_x64_dvd_x15-65805.iso
    SHA1
        50127304441A793EE51B3F501289F6599A559E9F
    文件大小:3GB
    发布时间:2009-08-06
    ed2k://|file|en_windows_7_professional_x64_dvd_x15-65805.iso|3224686592|A71F26E478076FFC75F02CB6459E87B0|/


    win7专业批量版:
    文件名
        en_windows_7_professional_vl_build_x86_dvd_x15-71033.iso
    SHA1
        304817E859A5B27E828F46AAC54CB46A576A34CC
    文件大小:2.24GB
    发布时间:2009-11-12
    ed2k://|file|en_windows_7_professional_vl_build_x86_dvd_x15-71033.iso|2400239616|A9A9F338CE1040FCFB8D22DBD7269765|/
    ----------------------------------------------------------------------------------------------------------------------------------------------------------------

    win7专业中文简体版
    文件名
        cn_windows_7_professional_with_sp1_vl_build_x86_dvd_u_677939.iso
    SHA1
        27AE9FBAF9EE076F50F153353E42A3BE74A61FAB
    文件大小:2.33GB
    发布时间:2011-05-12
    ed2k://|file|cn_windows_7_professional_with_sp1_vl_build_x86_dvd_u_677939.iso|2502909952|935E5B4B754527BE3C238FA6ABDD9B86|/

    ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
    win10最新英文版本:
    文件名
        en_windows_10_multiple_editions_version_1607_updated_jan_2017_x64_dvd_9714399.iso
    SHA1
        44064680647EE4C877A6F54739AD82759147C828
    文件大小:4.49GB
    发布时间:2017-01-19
    ed2k://|file|en_windows_10_multiple_editions_version_1607_updated_jan_2017_x64_dvd_9714399.iso|4823797760|CD6DB15B96A23F95CD4594B7F5061AB3|/


    win10最新中文版本:
    文件名
        cn_windows_10_multiple_editions_version_1607_updated_jan_2017_x64_dvd_9714394.iso
    SHA1
        163DE39B1E40C02C1E774BBFF6448FB439F61AC0
    文件大小:4.42GB
    发布时间:2017-01-19
    ed2k://|file|cn_windows_10_multiple_editions_version_1607_updated_jan_2017_x64_dvd_9714394.iso|4747692032|27841B07666580185078EE62915191A1|/

    win10最新中文企业版:
    文件名
        cn_windows_10_enterprise_version_1607_updated_jan_2017_x64_dvd_9714414.iso
    SHA1
        570A5347A2318C533891967120CC21451BD8A6BA
    文件大小:4.17GB
    发布时间:2017-01-19
    ed2k://|file|cn_windows_10_enterprise_version_1607_updated_jan_2017_x64_dvd_9714414.iso|4474976256|21E442B2D57E3F1C15C13DBE9F4A09AD|/
    ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
    展开全文
  • 07.哈希和信息验证码

    2018-01-06 16:16:00
    7.1 Overview of Hashes and MACs ... 其次,构造第二个消息产生相同的哈希值应该是非常困难的。 第三,也很难找到任何两个产生相同散列值的消息。 Table 7-1. Message digests and the EVP ...
    7.1 Overview of Hashes and MACs
    首先,摘要值不应包含可用于确定原始输入的信息。 为了实现这一点,输入数据中的一位变化应该改变摘要值中的许多位(平均一半)。 其次,构造第二个消息产生相同的哈希值应该是非常困难的。 第三,也很难找到任何两个产生相同散列值的消息。
     
    Table 7-1. Message digests and the EVP interface
    Hash algorithm
    EVP call for getting EVP_MD
    String for lookup
    Digest length (in bits)
    MD2
    EVP_md2
    md2
    128
    MD4
    EVP_md4
    md4
    128
    MD5
    EVP_md5
    md5
    128
    MDC2
    EVP_mdc2
    mdc2
    128
    SHA1
    EVP_sha1
    EVP_dssl
    sha1
    dssl
    160
    RIPEMD-160
    EVP_ripemd160
    ripemd
    160
     
    函数
     
    void EVP_DigestInit(EVP_MD_CTX *ctx, const EVP_MD *type);
    功能
    初始化ctx句柄
    参数
     
    ctx
     
    type
    listed Table 7-1
     
     
    函数
     
     
    void EVP_DigestUpdate(EVP_MD_CTX *ctx, const void *buf, unsigned int len);
    功能
    用于在散列计算中包含数据
    参数
     
    ctx
     
    buf
    计算hash数据
     
    len
    buf长度
     
     
    函数
     
     
    void EVP_DigestFinal(EVP_MD_CTX *ctx, unsigned char *hash, unsigned int *len);
     
    功能
    一旦散列考虑的所有数据已经传递给EVP_DigestUpdate,
    结果散列值可以使用EVP_DigestFinal检索。
    参数
     
    ctx
     
    hash
    哈希值将放置在其中的缓冲区。 这个缓冲区应该至少是EVP_MAX_MD_SIZE字节的大小。
     
    len
    buf长度
     
     
    7.3 Using MACs
    函数
     
    unsigned char *HMAC(const EVP_MD *type, const void *key, int keylen,
    const unsigned char *data, int datalen,
    unsigned char *hash, unsigned int *hashlen);
    功能
    产生MAC值
    参数
     
    type
    要使用的消息摘要。
    key
    包含将使用的密钥的缓冲区。
     
    keylen
    密钥长度
    data
    包含将要计算HMAC的数据的缓冲区。
    datalen
    数据长度
    hash
    计算的消息摘要将被放置的缓冲区
    hashlen
    指向一个整数的指针,该整数将接收填充的散列缓冲区的字节数。
     
    函数
     
    void HMAC_Init(HMAC_CTX *ctx, const void *key, int keylen, const
    EVP_MD *type);
     
    功能
    初始化HMAC对象
    参数
     
    ctx
    ctx对象
    key
    包含将要使用的密钥的缓冲区。
     
    keylen
    密钥缓冲区中的字节数将被视为有效的密钥数据。
    type
    将使用的消息摘要对象。
     
     
    函数
     
    void HMAC_Update(HMAC_CTX *ctx, const unsigned char *data, int len);
     
    功能
    正在用于计算MAC的HMAC上下文对象。
    参数
     
    ctx
    ctx对象
    data
    计算的数据
     
     
    len
     
    计算数据的长度
     
     
    函数
     
    void HMAC_Final(HMAC_CTX *ctx, unsigned char *hash, unsigned int *len);
     
     
    功能
    获取HMAC值
    参数
     
    ctx
    ctx对象
    hash
    将接收计算出的散列值的缓冲区。
     
     
    len
     
    hash长度
     
     
    7.3.1 Other MACs

    转载于:https://www.cnblogs.com/aixiaoxiaoyu/p/8214529.html

    展开全文
  • 我的目录是这样的 测试的源码 我知道的有两种种方式【相似图片-均值哈希】: 1.从网站拿到原图 - 进行每张旋转拿哈希值【主要麻烦是每张图片都要提前拿哈希值进行存储】 2.从网站拿到原图 - 每次判断角度时都要遍历...

    我的目录是这样的

    在这里插入图片描述

    测试的源码

    我知道的有两种种方式【相似图片-均值哈希】:

    1.从网站拿到原图 - 进行每张旋转拿哈希值【主要麻烦是每张图片都要提前拿哈希值进行存储】
    2.从网站拿到原图 - 每次判断角度时都要遍历原图拿到角度【主要是遍历图片的性能开销】
    裁剪圆图这里不建议返回img_new进行哈希运算,试了会发现不是圆图(保存的是圆图)

    %%time
    # https://blog.csdn.net/san1156/article/details/76691841
    import cv2
    import os
    import sys
    import pickledb
    import numpy as np
    from PIL import Image
    from functools import partial
    from matplotlib import pyplot as plt
    # 从文件反序列化,auto_dump 是每次写入操作都会写到文件,可以设置为False避免多次io
    db = pickledb.load('./images/cv.db', False)
    
    
    
    # 图像处理,获取图片最大内接圆,其他区域置为透明
    def circle(img_path,show=False):
        try:
            img = cv2.imread(img_path, cv2.IMREAD_UNCHANGED)
            rows, cols = img.shape[:2]
    
            # 创建一张4通道的新图片,包含透明通道,初始化是透明的
            img_new = np.zeros((rows,cols,4), np.uint8)
            img_new[:,:,0:3] = img[:,:,0:3]
    
            # 创建一张单通道的图片,设置最大内接圆为不透明,注意圆心的坐标设置,cols是x坐标,rows是y坐标
            img_circle = np.zeros((rows,cols,1),np.uint8)
            img_circle[:,:,:] = 0  # 设置为全透明
    
            # 设置最大内接圆为不透明
            x,y,radius = rows/2,cols/2,int(min(rows, cols)/2)
            img_circle = cv2.circle(
                img=img_circle, # 画圆的图像
                center=(int(x),int(y)), # 圆心
                radius=radius-2, # 圆的半径
                color=(255), # 圆圈颜色
                thickness=-1,#  圆形轮廓的粗细(如果为正)。负值(如FILLED)表示要绘制一个实心圆。
                lineType=cv2.LINE_AA,# 圆边界的类型
                shift=0,
            ) 
            # 图片融合
            img_new[:,:,3] = img_circle[:,:,0]
            
    
            # 显示图片,调用matplotlib.pyplot展示
            plt.subplot(121), plt.imshow(img_convert(img), cmap='gray'), plt.title('IMG')
            plt.subplot(122), plt.imshow(img_convert(img_new), cmap='gray'), plt.title('IMG_NEW')
            plt.show()
            if show:
                cv2.imwrite('./temp.png', img_new)
                return True
            else:
                cv2.imwrite(r'./images/1/1.png', img_new)
                return True
        except Exception as e:
            print(f"错误:{e}")
            return False
        
        
        
        
    # cv2与matplotlib的图像转换,cv2是bgr格式,matplotlib是rgb格式
    def img_convert(cv2_img):
        # 灰度图片直接返回
        if len(cv2_img.shape) == 2:
            return cv2_img
        # 3通道的BGR图片
        elif len(cv2_img.shape) == 3 and cv2_img.shape[2] == 3:
            b, g, r = cv2.split(cv2_img)
            return cv2.merge((r, g, b))
        # 4通道的BGR图片
        elif len(cv2_img.shape) == 3 and cv2_img.shape[2] == 4:
            b, g, r, a = cv2.split(cv2_img)
            return cv2.merge((r, g, b, a))
        # 未知图片格式
        else:
            return cv2_img
        
    
    
    
    def Get_hash(image_path='',im=None):
        if im is None:
            im = Image.open(image_path)
            # im.show(image_path)
        # 1.缩小尺寸。将图片缩小到8×8的尺寸,总共64个像素。这一步的作用是去除图片的细节,只保留结构、明暗等基本信息,摒弃不同尺寸、比例带来的图片差异。
        # 2.简化色彩。将缩小后的图片,转为64级灰度。也就是说,所有像素点总共只有64种颜色。
        im = im.resize((8, 8), Image.ANTIALIAS).convert('L')
        # 3.计算平均值。计算所有64个像素的灰度平均值。
        avg =  sum(list(im.getdata())) / 64.0
        # 4.比较像素的灰度。将每个像素的灰度,与平均值进行比较。大于或等于平均值,记为1;小于平均值,记为0。
        # 5.计算哈希值。将上一步的比较结果,组合在一起,就构成了一个64位的整数,这就是这张图片的指纹。组合的次序并不重要,只要保证所有图片都采用同样次序就行了。
        str1 = ''.join(map(lambda i: '0' if i < avg else '1', im.getdata()))  # 得到哈希字符串
        # 6.将64位哈希值序列4个4个分割,转为十六进制。
        str2 = ''.join(map(lambda x: '%x' % int(str1[x: x + 4], 2), range(0, 64, 4)))  # %x:转换无符号十六进制
        return str2
    
    
        
    
    
    # 得到汉明距离
    def Get_Hamming(str1, str2=''):
        # 如果不相同的数据位不超过5,就说明两张图片很相似;如果大于10,就说明这是两张不同的图片。
        Hamming = 0
        for i in range(16):
            if str1[i] != str2[i]:
                Hamming += 1
        return Hamming
    
    
    
    
    # 逆时针旋转
    def rotate(angle,img):
        height, width = img.shape[:2]
        matRotation = cv2.getRotationMatrix2D((width / 2, height / 2), angle, 1)
        imgRotation = cv2.warpAffine(img, matRotation, (width, height),)
        cv2.imwrite(r'./images/1/%s.png'%(angle), imgRotation)
    
    
    
    
    
    
    
    """
    print(f"开始训练--------------------------------------------------------------------------------------✨")
    filename = '4'
    # 1.创建存放模型图片的文件
    path = os.path.join(os.getcwd(), 'images', '1')
    if not os.path.exists(path):
        os.mkdir(path)
    
        
        
        
    # 2.创建模型圆形图案【算是第二版:解决图片边缘】
    ok = circle(r'./images/%s-yuan.png'%filename)
    pHash = Get_hash(r'./images/1/1.png')
    print(f"临时哈希Key:{pHash}")
    
    ok = circle(r'D:/jupyter_working/mi.png',True)
    hash_str = Get_hash('D:/jupyter_working/temp.png')
    similar = partial(Get_Hamming, str2=hash_str)
    print(f"临时哈希Key:{hash_str}")
        
    if ok:
        dome = set() # 保存图片哈希Key
        # 3.创建模型【解决图片旋转时失真】
        # COLOR_GRAY2RGB:只读取彩色像素【解决了默认底色为黑并且图片不会失真】
        img = cv2.imread(r'./images/1/1.png',cv2.COLOR_GRAY2RGB) 
    
        tick = cv2.TickMeter()
        # 4.存储图片的均值哈希密文
        with open("./images/%s.txt"%filename,'w+',encoding='utf-8') as f:
            for angle in range(1,361):
                tick.reset()
                tick.start()
                rotate(angle, img) # 旋转图片
                info = Get_hash(r'./images/1/%s.png'%(angle))
                dome.add(info)
    #             f.write(f"{info},{angle}\n") # 写入txt文件
                db.set(str(info),angle)
                tick.stop()
                print(f'哈希:{info} \t度数:{angle} \t误差数:{similar(info)} \t{tick.getTimeMilli():.3f} ms')
        # 序列化到文件【写入db文件】
        db.dump()
        print(f"360张图片去掉相似的数量:{len(dome)} 哈希键数:{len(db.getall())}")
        print(f"db存储成功 ✨")
    """
    
    
    
    
    
    
    print(f"开始测试---------------------------------------------------------------------------------------✨")
    ok = circle(r'D:/jupyter_working/mi.png',True)
    if ok:
        hash_str = Get_hash('D:/jupyter_working/temp.png')
        print(f"临时哈希Key:{hash_str}")
        if db.exists(hash_str):
            angle = db.get(hash_str)
            print(f"\t✨哈希Key:{hash_str} 原图逆旋转的角度:{angle}") 
        else:
            try:
                # 以偏函数传递参数【hash:找出相似的位置】
                similar = partial(Get_Hamming, str2=hash_str)
                res= {i:similar(i) for i in db.getall() if similar(i) < 4}
                print(f"\t✨哈希键数:{len(db.getall())} \n\t✨哈希值与误差数:{res}")
                hash_str = min(res, key=res.get)
                angle = db.get(hash_str)
                print(f"\t✨哈希Key:{hash_str} \t原图逆旋转的角度:{angle}") 
            except Exception as e:
                print(f"错误:{e}")
    
               
                
    print('执行结束...')
    cv2.waitKey(0)
    cv2.destroyAllWindows()
    
    开始测试---------------------------------------------------------------------------------------✨
    

    在这里插入图片描述

    临时哈希Key:004e6f1f0f476030
    	✨哈希键数:823 
    	✨哈希值与误差数:{'006e2f1f0f476020': 3, '004e2f1f0f476020': 2, '004e2f1f0f476030': 1, '00ce6f1f0f476030': 1, '00ce6f3f0f476030': 2, '00ce6f3e0f476030': 3}
    	✨哈希Key:004e2f1f0f476030 	原图逆旋转的角度:311
    执行结束...
    Wall time: 1.04 s
    

    puppeteer 代码

    console.log('Running...✨')
        // 创建一个新的隐身浏览器上下文
        const context = await browser.createIncognitoBrowserContext();
        // 在上下文中创建一个新页面。
        const page = await context.newPage();
        appUrl = 'https://www.moyublog.com/code/5de692b9c93a4/index.html'
        await page.goto(appUrl)
    
    
    
        console.log(`测试开始. ✨`)
        let errNum = 0
        while (errNum < 100) {
            try {
                console.log(`1.点击测试按钮. ✨`)
                await page.waitForSelector('body > .btn')
                await page.click('body > .btn')
    
    
    
                console.log(`2.获取旋转图片. ✨`)
                let img_name = 'C:/Users/lenovo/Desktop/mi.png'
                const iframe_element = await page.waitForSelector('#rotateWrap1 > div > div.rotate-can-wrap > canvas')
                if (iframe_element) {
                    console.log('对象存在')
                    await iframe_element.screenshot({ 'path': img_name })
                    await page.waitForTimeout(200)
                } else {
                    console.log('对象不存在')
                    await page.screenshot({ 'path': img_name })
                }
    
    
    
    
                console.log(`3.获取旋转的位移和角度. ✨`)
                let datas = { 'name': 'moyublog', 'bg': img_name }
                let data = await axios.post(
                    'http://127.0.0.1:6868/whirling', datas
                ).then(res => {
                    return res.data
                }).catch(error => {
                    console.error(error)
                })
                console.log(data)
                let angle = data['angle']
                let move = data['move']
                // let move = 160
    
    
    
                console.log(`4.验证缺口位置. ✨`)
                await page.waitForSelector('.box > #rotateWrap1 > .rotateverify-contaniner > .control-wrap > .control-btn')
                let dragButton = await page.$('.box > #rotateWrap1 > .rotateverify-contaniner > .control-wrap > .control-btn')
                let box = await dragButton.boundingBox();
                // 获取滑动按钮中心点位置
                let x = box.x + (box.width / 2);
                let y = box.y + (box.height / 2);
                // 鼠标滑动至滑动按钮中心点
                await page.mouse.move(x, y);
                // 按下鼠标
                await page.mouse.down();
                // 慢慢滑动至缺口位置,终点值为 x + move
    
                for (let i = x; i <= x + move; i = i + 5) {
                    // 滑动鼠标
                    let steps = Math.ceil(Math.random() * 10)
                    await page.mouse.move(i, y, { 'steps': steps });
                }
                await page.mouse.move(x + move, y, { 'steps': 2 });
                // 假装有个停顿,看起来更像是人为操作
                await page.waitForTimeout(200);
                // 放开鼠标
                await page.mouse.up();
                errNum++
                await page.waitForTimeout(1000);
    
                await page.goto(appUrl)
                await page.reload(appUrl);
                window.location.reload()
            } catch (e) {
                // errNum++
                // console.log(await page.content())
            }
        }
    
    展开全文
  • 哈希算法

    2016-11-10 14:19:36
    哈希算法将任意长度的二进制值映射为较短的固定长度的二进制值,这个小的二进制值称为哈希值。哈希值是一段数据唯一且极其紧凑的数值表示形式。如果散列一段明文而且哪怕只更改该段落的一个字母,随后的哈希都将产生...

    哈希算法将任意长度的二进制映射为较短的固定长度的二进制值,这个小的二进制值称为哈希值哈希值是一段数据唯一且极其紧凑的数值表示形式。如果散列一段明文而且哪怕只更改该段落的一个字母,随后的哈希都将产生不同的值。要找到散列为同一个值的两个不同的输入,在计算上是不可能的,所以数据的哈希值可以检验数据的完整性。一般用于快速查找和加密算法。[1] 
    中文名 哈希算法 外文名 Hash
    别    称  散列
    应用学科
    程序加密
    适用领域范围
    网络,软件

    基本特点

    哈希表是根据设定的哈希函数H(key)和处理冲突方法将一组关键字映射到一个有限的地址区间上,并以关键字在地址区间中的象作为记录在表中的存储位置,这种表称为哈希表或散列,所得存储位置称为哈希地址或散列地址。作为线性数据结构与表格和队列等相比,哈希表无疑是查找速度比较快的一种。
    通过将单向数学函数(有时称为“哈希算法”)应用到任意数量的数据所得到的固定大小的结果。如果输入数据中有变化,则哈希也会发生变化。哈希可用于许多操作,包括身份验证和数字签名。也称为“消息摘要”。
    简单解释:哈希(Hash)算法,即散列函数。它是一种单向密码体制,即它是一个从明文到密文的不可逆的映射,只有加密过程,没有解密过程。同时,哈希函数可以将任意长度的输入经过变化以后得到固定长度的输出。哈希函数的这种单向特征和输出数据长度固定的特征使得它可以生成消息或者数据。[1] 

    内容

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    class GeneralHashFunctionLibrary
    {/*RSHash*/
        public long RSHash(String str)
        {
            int b = 378551;
            int a = 63689;
            long hash = 0;
            for(int i = 0; i < str.length(); i++)
            {
                hash = hash * a + str.charAt(i);
                a = a * b;
             }
             return hash;
         }
        /*JSHash*/
        public long JSHash(String str)
        {
            long hash = 1315423911;
            for(int i = 0; i < str.length(); i++)
                hash ^= ((hash << 5) + str.charAt(i) + (hash >> 2));
            return hash;
        }
        /*PJWHash*/
        public long PJWHash(String str)
        {
            long BitsInUnsignedInt = (long)(4 * 8);
            long ThreeQuarters = (long)((BitsInUnsignedInt * 3) / 4);
            long OneEighth = (long)(BitsInUnsignedInt / 8);
            long HighBits = (long)(0xFFFFFFFF)<<(BitsInUnsignedInt-OneEighth);
            long hash = 0;
            long test = 0;
            for(int i = 0; i < str.length(); i++)
            {
                hash = (hash << OneEighth) + str.charAt(i);
                if((test = hash & HighBits) != 0)
                    hash = ((hash ^ (test >> ThreeQuarters)) & (~HighBits));
            }
            return hash;
        }
        /*ELFHash*/
        public long ELFHash(String str)
        {
            long hash = 0;
            long x = 0;
            for(int i = 0; i < str.length(); i++)
            {
                hash = (hash << 4) + str.charAt(i);
                if(( x = hash & 0xF0000000L) != 0)
                hash ^= ( x >> 24);
                hash &= ~x;
            }
            return hash;
        }
        /*BKDRHash*/
        public long BKDRHash(String str)
        {
            long seed = 131;//31131131313131131313etc..
            long hash = 0;
            for(int i = 0; i < str.length(); i++)
            hash = (hash * seed) + str.charAt(i);
            return hash;
        }
        /*SDBMHash*/
        public long SDBMHash(String str)
        {
            long hash = 0;
            for(int i = 0; i < str.length(); i++)
            hash = str.charAt(i) + (hash << 6) + (hash << 16) - hash;
            return hash;
        }
        /*DJBHash*/
        public long DJBHash(String str)
        {
            long hash = 5381;
            for(int i = 0; i < str.length(); i++)
            hash = ((hash << 5) + hash) + str.charAt(i);
            return hash;
        }
        /*DEKHash*/
        public long DEKHash(String str)
        {
            long hash = str.length();
            for(int i = 0; i < str.length(); i++)
                hash = ((hash << 5) ^ (hash >> 27)) ^ str.charAt(i);
            return hash;
        }
        /*BPHash*/
        public long BPHash(String str)
        {
            long hash=0;
            for(int i = 0;i < str.length(); i++)
            hash = hash << 7 ^ str.charAt(i);
            return hash;
        }
        /*FNVHash*/
        public long FNVHash(String str)
        {
            long fnv_prime = 0x811C9DC5;
            long hash = 0;
            for(int i = 0; i < str.length(); i++) 
        {
            hash *= fnv_prime;
            hash ^= str.charAt(i);
        }
            return hash;
        }
        /*APHash*/
        long APHash(String str)
        {
            long hash = 0xAAAAAAAA;
            for(int i = 0; i < str.length(); i++)
            {
                if((i & 1) == 0)
                    hash ^=((hash << 7) ^ str.charAt(i) ^ (hash >> 3));
                else
                    hash ^= (~((hash << 11) ^ str.charAt(i) ^ (hash >> 5)));
            }
            return hash;
        }
    }

    计算方法

    编辑
    用来产生一些数据片段(例如消息或会话项)的哈希值的算法。使用好的哈希算法,在输入数据中所做的更改就可以更改结果哈希值中的所有位;因此,哈希对于检测数据对象(例如消息)中的修改很有用。此外,好的哈希算法使得构造两个相互独立且具有相同哈希的输入不能通过计算方法实现。典型的哈希算法包括 MD2、MD4、MD5 和 SHA-1。哈希算法也称为“哈希函数”。[1] 
    另请参阅: 基于哈希的消息验证模式 (HMAC), MD2, MD4, MD5,消息摘要, 安全哈希算法 (SHA-1)
    MD5一种符合工业标准的单向 128 位哈希方案,由 RSA Data Security, Inc. 开发。 各种“点对点协议(PPP)”供应商都将它用于加密的身份验证。哈希方案是一种以结果唯一并且不能返回到其原始格式的方式来转换数据(如密码)的方法。质询握手身份验证协议(CHAP) 使用质询响应并在响应时使用单向 MD5哈希法。按照此方式,您无须通过网络发送密码就可以向服务器证明您知道密码。
    质询握手身份验证协议(CHAP)“点对点协议(PPP)”连接的一种质询响应验证协议,在 RFC 1994 中有所描述。 该协议使用业界标准 MD5哈希算法来哈希质询串(由身份验证服务器所发布)和响应中的用户密码的组合。
    点对点协议
    用点对点链接来传送多协议数据报的行业标准协议套件。RFC 1661 中有关于 PPP 的文档。

    展开全文
  • 哈希 in python

    2019-03-08 00:09:53
    # 哈希的介绍 ## 哈希 本节内容从介绍哈希的基本概念 。主要包含数论基础,介绍哈希表的介绍及实现,双哈希,混沌机,以及摘要算法。 #### 知识点 + 哈希的概念 + 数论基础 + 哈希表的介绍及实现 + ...
  • python hashlib 哈希算法

    千次阅读 2019-09-28 23:03:22
    哈希加密算法应用非常广泛,包括数字签名,身份验证,操作检测,指纹,校验和(消息完整性检查),哈希表,密码存储等。在密码学中,好的哈希算法应该满足以下两个条件:一是无法从哈希值解密原始消息;二是,...
  • 哈希随机

    2020-01-09 09:17:40
    常用于生成随机数,多运用于抽奖 测试数据 验证码等 接口名称 导入库 import random random . random ( ) 用于生成一个 0 到 1 的随机浮点数 : [ 0 , 1 ) random . randint ( ) 成 [ a , b ] 的随机整数,...
  • Java破解验证码

    2019-02-21 13:42:41
    具体步骤: 1、访问验证码链接保存图片 2、去除干扰线 3、把图片分割,保存素材 3、图片匹配() 比较图片相似: 1、把图片转换成二进制码,进行...4、均值哈希实现图像比较(FingerPrint),素材越多,成功率越高。
  • 加盐哈希

    2016-03-15 13:33:23
    最好的办法就是对密码进行加盐哈希,这篇文章将介绍它是如何做到这点。 在对密码进行哈希加密的问题上,人们有许多争论和误解,这大概是由于网络上广泛的误传吧。密码哈希是一件非常简单的事情,但是依然有很多人...
  • 消息验证码

    2018-03-14 10:24:14
    消息验证码称为密码学校验或密钥的哈希函数,提供消息完整性和消息验证。MAC是对称密钥方案,它也不提供不可否认性。速度比数字签名快
  • HMAC哈希消息认证码

    2019-09-24 03:27:11
    收藏 137 14 ...HMAC是密钥相关的哈希运算消息认证码,HMAC运算利用哈希算法,以一个密钥和...中文名哈希消息认证码外文名Hash-based Message Authentication Code缩写HMAC概述HMAC是密钥相关的哈希运算运算作用...
  • 百度的验证码又双叒更新了。 当然出于好奇,猫又拿起了键盘开始挑战。 正文来了。 先来看看继上次破解百度旋转验证码后,百度的大佬又做出了哪些改变。 1.抓取图片时加上了马赛克 2.增加了图片库 抓取图片时加上...
  • 哈希hash与消息认证码

    千次阅读 2019-06-24 23:49:24
    哈希hash与消息认证码 哈希hash 特点 不可逆(原像不可逆) 单向的,无法通过哈希值反推会原内容 抗碰撞 基数极大,无法给定义一个哈希,找到另外的内容,两者哈希值相同。 唯一性(算法固定时) 内容不变,...
  • 1、介绍 在爬虫中经常会遇到验证码识别的问题,现在的验证码大多分计算验证码、滑块验证码、识图验证码、...经常用的库有pytesseract(识别库)、OpenCV(高级图像处理库)、imagehash(图片哈希值库)、numpy(开源的、高
  • 图片验证码和短信验证码开发

    千次阅读 2018-11-11 10:36:17
    图片验证码和短信验证码开发 tip :前后端分离,先开发后端,后完善前端 一、图片验证码流程 1、引入captcha包放入utils 不是独立的第三方包放入utils,独立的包放入libs里面 captcha.py 里的生成验证码方法captcha...
  • 【破解旋转验证码】百度拖动旋转验证码识别方案

    万次阅读 多人点赞 2020-12-18 11:57:55
    百度的验证码又双叒更新了,这次在图片请求和图片库上又做了手脚。 当然出于好奇,猫又拿起了键盘开始挑战。 正文来了。 先来看看继上次破解百度旋转验证码后,百度的大佬又做出了哪些改变。 首先来看下我们获取到...
  • 1SHA-1哈希函数族存储密码用于存储密码的哈希函数保护消息的完整性保护消息的完整性和真实性消息验证码- MAC来自Block cipher的mac: CBC-MACMAC属性哈希消息认证码(HMAC)HMAC实现结论/总结 哈希函数Hashes 数据完整...
  • 哈希摘要 - 数字签名/指纹 - 单向哈希函数(没有反函数不可逆) 应用领域: 1. 数据库种的用户敏感信息保存成哈希摘要 2. 给数据生成签名验证数据没有被恶意篡改 3. 云存储服务的妙传功能(去重功能) ''' class ...
  • 初次学习验证码

    2017-12-15 13:31:37
    在之前的生活中,也经常遇到验证码的问题,当时不太能理解这个东西到底有什么用处。也是伴随着12306验证码的发展,对那些非人类的验证码深恶痛绝。后来种种原因导致走上了程序员的道路。做了身份认证这一块。 身份...
  • PCHAIN幸运哈希比赛

    2018-09-30 20:28:38
    欢迎大家参与PCHAIN Testnet 发布上线后的第一个小游戏——比赛,体验测试网络高达123,424TPS。此次比赛我们将给予哈希值最小者即本次游戏的最终获胜者5,000 PAI...
  • 感知哈希本质上是哈希算法中的一类算法,最初被提出来就是用来做相似图片的匹配与计算的,以图搜图的本质也是在做详细图片的计算与匹配,不同的算法会有不同的计算精度和计算速度。 对于我们每个人来说,我们有...
  • 加盐密码哈希

    2015-01-04 11:38:10
    最好的办法就是对密码进行加盐哈希,这篇文章将介绍它是如何做到这点的。 在对密码进行哈希加密的问题上,人们有许多争论和误解,这大概是由于网络上广泛的误传吧。密码哈希是一件非常简单的事情,但是依然有很多...
  • hashlib 计算哈希

    2019-07-20 14:33:55
    哈希函数能把一个字符串不可逆地转换为一个十六进制值,可能是 32 位,可能 64 位,可能 128 位,甚至更高 import hashlib code = 'zjk' result = hashlib.sha256(code.encode()).hexdigest() print(result) >...
  • Cryptographic Hash Functions and Message Authentication Codes什么是哈希函数?加密哈希函数-安全属性1. Pre-image resistance2. Second pre-image resistance3. Collision resistance哈希函数可以用来干什么?The...
  • 在《写给开发人员的实用密码学 - Hash算法》和《写给开发人员的实用密码学 - MAC》这两篇文章分别介绍了哈希算法和消息验证码,其中消息验证码使用到了哈希算法。国密标准中也定义了一种哈...
  • 验证码-源码

    2021-03-04 11:55:34
    生成被最小化,并且文件名包括哈希值。 您的应用已准备好进行部署! 有关更多信息,请参见关于的部分。 yarn eject 注意:这是单向操作。 eject ,您将无法返回! 如果您对构建工具和配置选择不满意,则可以随时...
  • 计算和验证文件的 MD5 或 SHA-1 加密哈希

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 6,462
精华内容 2,584
关键字:

哈希验证码