精华内容
下载资源
问答
  • FVN 哈希算法

    千次阅读 2017-05-23 16:50:28
    关于FNV Hash算法的详情,见参考,下面只记录FNV Hash值的分布情况。 FNV hash算法对一个字符串计算,可以得到一个唯一确定的无符号整数值。对于大量的随机输入字符串,比如UUID串,得到的无符号整数值,通过...

    参考:http://www.isthe.com/chongo/tech/comp/fnv/


    关于FNV Hash算法的详情,见参考,下面只记录FNV Hash值的分布情况。


    FNV hash算法对一个字符串计算,可以得到一个唯一确定的无符号整数值。对于大量的随机输入字符串,比如UUID串,得到的无符号整数值,通过简单的取余运算,基本上是均匀分布的。比如,对100,000个UUID字符串做FNV Hash计算,得到的每个结果值hashValue,都做 hashValue %= 10,000,其结果基本上是在 0 ~ 9,999 范围内均匀分布的。但是请注意,是“基本上“均匀分布,事实上还存在一定的偏差。


    Landon在参考页面中详细介绍了直接取余的 Lazy mode mapping method Retry method

    Lazy mode mapping method(以32 bit 、目标范围 0~2142779559 、FNV-1 为例)做法是:

    1. #define TRUE_HASH_SIZE ((u_int32_t)2142779560) /* range top plus 1 */  
    2. #define FNV1_32_INIT ((u_int32_t)2166136261)  
    3. u_int32_t hash;  
    4. void *data;  
    5. size_t data_len;  
    6.   
    7. hash = fnv_32_buf(data, data_len, FNV1_32_INIT);  
    8. hash %= TRUE_HASH_SIZE;  

    Retry method(以 32 bit 、目标范围 0~49999 、FNV-1 为例):
    1. #define TRUE_HASH_SIZE ((u_int32_t)50000) /* range top plus 1 */  
    2. #define FNV_32_PRIME ((u_int32_t)16777619)  
    3. #define FNV1_32_INIT ((u_int32_t)2166136261)  
    4. #define MAX_32BIT ((u_int32_t)0xffffffff) /* largest 32 bit unsigned value */  
    5. #define RETRY_LEVEL ((MAX_32BIT / TRUE_HASH_SIZE) * TRUE_HASH_SIZE)  
    6. u_int32_t hash;  
    7. void *data;  
    8. size_t data_len;  
    9.   
    10. hash = fnv_32_buf(data, data_len, FNV1_32_INIT);  
    11. while (hash >= RETRY_LEVEL) {  
    12.     hash = (hash * FNV_32_PRIME) + FNV1_32_INIT;  
    13. }  
    14. hash %= TRUE_HASH_SIZE;  

    根据Landon的介绍,对于32 bit 的情况,以分布目标 0~999999为例:

    The values 0 through 967295 will be created by 4295 different 32-bit FNV hash values whereas the values 967296 through 999999 will be created by only 4294 different 32-bit FNV hash values. In other words, the values 0 through 967295 will occur ~1.0002328 times as often as the values 967296 through 999999.

    即 967296~999999 的范围内分布明显比 0~967295 段的分布要密集


    对于64 bit 的情况,以分布目标 0~10000000000000000000 为例:

    The values 0 through 9999999999999999999 will be created by 2 different 64-bit FNV hash values whereas the values 10000000000000000000 through 18446744073709551615 will be created by only 1 64-bit FNV hash value.

    分布更加不均匀


    但同时,Landon 也提到:

    NOTE: This bias issue may not be of concern to you, but we thought we should point out this issue just in case you care. Many applications should / will not care about this bias. Most applications can use the lazy mod mapping method without any problems. Your application, may vary however.

    NOTE: One may substitute the FNV-1a hash for the FNV-1 hash in any of the lazy mod mapping method examples. Some people believe that FNV-1a lazy mod mapping method gives then slightly better dispersion without any impact on CPU performance. See the FNV-1a hash description for more information.

    就是说,这样的”些许“分布不均匀的情况,对大多数应用来说,是无关紧要的。同时,在不增加CPU负载的情况下,相比FNV-1 ,使用FNV-1a 的 lazy mode mapping method 得到的分布情况要稍微好一些。


    ================================================


    附上32bit、FNV-1的示例代码

    (需要先安装 libuuid,如 yum install libuuid-devel.x86_64)

    1. #include <iostream>  
    2. #include <string>  
    3. #include <uuid/uuid.h>  
    4. #include <stdlib.h>  
    5.   
    6. using namespace std;  
    7.   
    8. // typedef      unsigned long long  UINT64;  
    9. typedef     unsigned int        DWORD;  
    10.   
    11. const int range = 8;  
    12.   
    13. DWORD Hash4Bytes(const string &key)  
    14. {  
    15.     const char * first = key.c_str();  
    16.     DWORD length = key.size();  
    17.     DWORD result = 2166136261;  
    18.     for(; length > 0; --length) {  
    19.         result ^= (std::size_t)*first++;  
    20.         result *= 16777619;  
    21.     }  
    22.     return result;  
    23. }  
    24.   
    25. int Disperse(const string &key)  
    26. {  
    27.     DWORD hash = Hash4Bytes(key);         
    28.     int index = hash % range;  
    29.   
    30.     return index;  
    31. }  
    32.   
    33. int main(int argc, char * argv[]) {  
    34.     long key_count = 10000;  
    35.     if(argc > 1) {  
    36.         key_count = atol(argv[1]);  
    37.     }  
    38.   
    39.     uuid_t uuid;  
    40.     char str[36];  
    41.   
    42.     long stat[range];  
    43.   
    44.     for(int i = 0; i < range; ++i) {  
    45.         stat[i] = 0;  
    46.     }  
    47.   
    48.     for(int i = 0; i < key_count; ++i) {  
    49.         uuid_generate(uuid);  
    50.         uuid_unparse(uuid, str);  
    51.   
    52.         stat[Disperse(str)]++;  
    53.     }  
    54.   
    55.     cout << "Range: 0 ~ " << range - 1 << endl;  
    56.     cout << "Key count: " << key_count << endl;  
    57.     for(int i = 0; i < range; ++i) {  
    58.         cout << "Index #" << i << ": " << stat[i] << endl;  
    59.     }  
    60.     cout << endl;  
    61.   
    62.     return 0;  
    63. }  

    执行结果:
    1. [root@amons02 fnv]# ./t 1000000  
    2. Range: 0 ~ 7  
    3. Key count: 1000000  
    4. Index #0: 124995  
    5. Index #1: 125483  
    6. Index #2: 124735  
    7. Index #3: 124692  
    8. Index #4: 124920  
    9. Index #5: 124956  
    10. Index #6: 124912  
    11. Index #7: 125307  

    对于上面的代码,如果执行 ./ 1000000 的目的是”将1000000个随机的UUID字符串一一放入0~999999“的范围内,那么从结果看,分布情况是可以接受的。

    注意:

    上面代码中的Hash4Bytes() 函数,它的返回值类型必须是32位无符号整型,并且函数内部的result 变量也必须是32位无符号整型因为我们用的是32bit的FNV-1算法不要用std::size_t,因为在64 bit 机器上,sizeof(std::size_t) 是8

    展开全文
  • FNV Hash算法

    千次阅读 2015-06-11 18:41:22
    FNV Hash算法

    当我们看到她的时候是不是感觉好高大上,好白富美,女神啊,赶紧撤,哈哈。

    什么是Hash算法

    Hash算法,直译哈希算法,又名散列算法,是将任意长度的二进制值映射为较短的固定长度的二进制值,这个固定长度的二进制值就是Hash值。换句话说Hash值是一堆数据唯一紧凑的数值表示形式。
    这里的“唯一”只是相对于算法上,同一个Hash值不可能存在两个不同的输入值(经过特殊处理的除外,如取模就很容易得到相同的Hash值)。所以Hash算法可以验证数值的完整性,用于快速查找,或者加密算法。

    FNV Hash算法

    Hash算法有很多种,FNV是其中的一种。FVN的名字由三个发明人的首字母组成(Fowler/Noll/Vo)。FNV有三个版本,分别为FNV-0、FNV-1、FNV-1a,其中FNV-0已经废弃不用,FNV-1与FNV-1a的差别在于计算算法的顺序不同。

    算法实现
    FNV-1算法

    // hash/哈希值,是一个n位的无符号整型数/unsigned int,n为2的x次方,如n=32、n=64...等
    hash = offset_basis // offset_basis是哈希初始化值,大小与n有关
    for each octet_of_data to be hashed // octet_of_data为计算哈希值的数据的每一字节
        hash = hash * FNV_prime // FNV_prime为质数,大小与n有关(可以包含取模运算,%(2的n次方))
        hash = hash xor octet_of_data // 异或
    return hash

    FNV-1a算法

    // hash/哈希值,是一个n位的无符号整型数/unsigned int,n为2的x次方,如n=32、n=64...等
    hash = offset_basis // offset_basis是哈希初始化值,大小与n有关
    for each octet_of_data to be hashed // octet_of_data为计算哈希值的数据的每一字节
        hash = hash xor octet_of_data // 顺序与FNV-1a刚好相反,先异或再相乘
        hash = hash * FNV_prime
    return hash

    在FNV-1与FNV-1a中,变量offset_basis、octet_of_data、FNV_prime的意义都是一样的,他们的区别仅在算法的顺序上。
    octet_of_data数据的取值与n有关,下面为取值列表:
    32 bit offset_basis = 2166136261
    64 bit offset_basis = 14695981039346656037
    128 bit offset_basis = 144066263297769815596495629667062367629
    256 bit offset_basis =
    100029257958052580907070968620625704837092796014241193945225284501741471925557
    512 bit offset_basis =
    96593031294966694980094354007163104660904187456726378961083743294344626579945829
    32197716438449813051892206539805784495328239340083876191928701583869517785
    1024 bit offset_basis =
    14197795064947621068722070641403218320880622795441933960878474914617582723252296
    73230371772215086409652120235554936562817466910857181476047101507614802975596980
    40773201576924585630032153049571501574036444603635505054127112859663616102678680
    82893823963790439336411086884584107735010676915

    FNV_prime数据的取值也与n有关,下面为取值列表:
    32 bit FNV_prime = 224 + 28 + 0x93 = 16777619
    64 bit FNV_prime = 240 + 28 + 0xb3 = 1099511628211
    128 bit FNV_prime = 288 + 28 + 0x3b = 309485009821345068724781371
    256 bit FNV_prime = 2168 + 28 + 0x63 = 374144419156711147060143317175368453031918731002211
    512 bit FNV_prime = 2344 + 28 + 0x57 =
    35835915874844867368919076489095108449946327955754392558399825615420669938882575
    126094039892345713852759
    1024 bit FNV_prime = 2680 + 28 + 0x8d =
    50164565101131186554345988110352789550307653454047907443030175238311120551081474
    51509157692220295382716162651878526895249385292291816524375083746691371804094271
    873160484737966720260389217684476157468082573

    参考的博客文章:
    FNV哈希算法
    FNV Hash
    以上都是个人笔记 如果有错还望指出 唯有时间了解爱

    展开全文
  • 一致性Hash算法

    2016-04-16 01:22:44
    一致性Hash算法是分布式系统中的一个算法

    一致性Hash算法是分布式系统中的一个算法

    1


    2


    3:一致性hash是通过虚拟节点来进行数据均匀分配的。


       
          最近在研究一致性HASH算法(Consistent Hashing),用于解决memcached集群中当服务器出现增减变动时对散列值的影响。后来
     在JAVAEYE上的一篇文章中,找到了其中的 KetamaHash 算法的JAVA实现(一种基于虚拟结点的HASH算法),于是为了加深理解,对照
     JAVA版本,用C#重写了一个。放到这 里,如果大家感兴趣的话, 可以下载测试一下,如果发现写法有问题请及时告之我,以便我及时修正。
     
     
        下面是对Ketama的介绍: 
    Ketama is an implementation of a consistent hashing algorithm, meaning you can add or remove servers from the memcached pool without causing a complete remap of all keys. 
    Here’s how it works: 
    * Take your list of servers (eg: 1.2.3.4:11211, 5.6.7.8:11211, 9.8.7.6:11211) 
    * Hash each server string to several (100-200) unsigned ints 
    * Conceptually, these numbers are placed on a circle called the continuum. (imagine a clock face that goes from 0 to 2^32) 
    * Each number links to the server it was hashed from, so servers appear at several points on the continuum, by each of the numbers they hashed to. 
    * To map a key->server, hash your key to a single unsigned int, and find the next biggest number on the continuum. The server linked to that number is the correct server for that key. 
    * If you hash your key to a value near 2^32 and there are no points on the continuum greater than your hash, return the first server in the continuum. 
    If you then add or remove a server from the list, only a small proportion of keys end up mapping to different servers.
         
        我的理解,这类方法其实有点像大学里的微积分的思想(通过连续函数的取值区间来计算图形面积)。通过把已知的实结点(memcached
    服务IP端口)列表结成一个圆,然后在两两实结点之间“放置”尽可能多的虚拟节点(上面文中的unsigned ints), 假设用户数据映射在虚拟
    节点上(用户数据真正存储位置是在该虚拟节点代表的实际物理服务器上),这样就能抑制分布不均匀,最大限度地减小服务器增减时的缓存
    重新分布。如下图:


        http://dl.javaeye.com/upload/attachment/215217/0807479b-b5a2-3ae5-a46e-e2c39574bfaa.jpg


        下面是添加结点时:
        
        http://dl.javaeye.com/upload/attachment/215219/c898718d-6560-39bf-a5fe-6b539783eefd.jpg
        
        如这篇文章所说(总结一致性哈希(Consistent Hashing) http://www.javaeye.com/topic/611976):
        
        Consistent Hashing最大限度地抑制了hash键的重新分布。另外要取得比较好的负载均衡的效果,往往在服务器数量比较少的时候需要增
    加虚拟节点来保证服务器能均匀的分布在圆环上。因为使用一般的hash方法,服务器的映射地点的分布非常不均匀。使用虚拟节点的思想,为
    每个物理节点(服务器)在圆上分配100~200个点。这样就能抑制分布不均匀,最大限度地减小服务器增减时的缓存重新分布。用户数据映射
    在虚拟节点上,就表示用户数据真正存储位置是在该虚拟节点代表的实际物理服务器上。


        了解了原理,下面看一下具体实现。


        JAVA实现代码取自Spy Memcached client中的类,原文的作者也尽可能的对代码进行注释说明,所以让我剩了不少时间。 
        
        下面是相应的.NET实现(注释参考JAVA版本):
        
    public class KetamaNodeLocator
    {
        private SortedList<long, string> ketamaNodes = new SortedList<long, string>();
        private HashAlgorithm hashAlg;
        private int numReps = 160;


        //此处参数与JAVA版中有区别,因为使用的静态方法,所以不再传递HashAlgorithm alg参数
        public KetamaNodeLocator(List<string> nodes, int nodeCopies)
        {
            ketamaNodes = new SortedList<long, string>();


            numReps = nodeCopies;
            //对所有节点,生成nCopies个虚拟结点
            foreach (string node in nodes)
            {
                //每四个虚拟结点为一组
                for (int i = 0; i < numReps / 4; i++)
                {
                    //getKeyForNode方法为这组虚拟结点得到惟一名称 
                    byte[] digest = HashAlgorithm.computeMd5(node + i);
                    /** Md5是一个16字节长度的数组,将16字节的数组每四个字节一组,分别对应一个虚拟结点,这就是为什么上面把虚拟结点四个划分一组的原因*/  
                    for (int h = 0; h < 4; h++)
                    {
                        long m = HashAlgorithm.hash(digest, h);
                        ketamaNodes[m] = node;
                    }
                }
            }
        }


        public string GetPrimary(string k)
        {
            byte[] digest = HashAlgorithm.computeMd5(k);
            string rv = GetNodeForKey(HashAlgorithm.hash(digest, 0));
            return rv;
        }


        string GetNodeForKey(long hash)
        {
            string rv;
            long key = hash;
            //如果找到这个节点,直接取节点,返回   
            if (!ketamaNodes.ContainsKey(key))
            {
                //得到大于当前key的那个子Map,然后从中取出第一个key,就是大于且离它最近的那个key 说明详见: http://www.javaeye.com/topic/684087
                var tailMap = from coll in ketamaNodes
                              where coll.Key > hash
                              select new { coll.Key };
                if (tailMap == null || tailMap.Count() == 0)
                    key = ketamaNodes.FirstOrDefault().Key;
                else
                    key = tailMap.FirstOrDefault().Key;
            }
            rv = ketamaNodes[key];
            return rv;
        }
    }
        
        
        下面的代码与JAVA中有所不同,它使用静态方法实现:
        
    public class HashAlgorithm
    {
        public static long hash(byte[] digest, int nTime)
        {
            long rv = ((long)(digest[3 + nTime * 4] & 0xFF) << 24)
                    | ((long)(digest[2 + nTime * 4] & 0xFF) << 16)
                    | ((long)(digest[1 + nTime * 4] & 0xFF) << 8)
                    | ((long)digest[0 + nTime * 4] & 0xFF);


            return rv & 0xffffffffL; /* Truncate to 32-bits */
        }


        /**
         * Get the md5 of the given key.
         */
        public static byte[] computeMd5(string k)
        {
            MD5 md5 = new MD5CryptoServiceProvider();
           
            byte[] keyBytes = md5.ComputeHash(Encoding.UTF8.GetBytes(k));
            md5.Clear();
            //md5.update(keyBytes);
            //return md5.digest();
            return keyBytes;
        }
    }
        
        
        下面是.net版本下的测试结果
        
        分布平均性测试:测试随机生成的众多key是否会平均分布到各个结点上测试结果如下: 
        
        
        
        
        最上面一行是参数说明,节点数目,总共有多少key,每个节点应该分配key的比例是多少。下面是每个结点分配到key的数目和比例。 
    多次测试后发现,这个Hash算法的节点分布还是不错的,都在标准比例左右徘徊,是个合适的负载均衡算法。 




        节点增删测试:在环上插入N个结点,每个节点nCopies个虚拟结点。随机生成众多key,在增删节点时,测试同一个key选择相同节点
    的概率,测试如果如下:








        上面三行分别是正常情况,节点增加,节点删除情况下的节点数目。下面两行表示在节点增加和删除情况下,同一个key分配在相同
    节点上的比例(命中率)。 


         后来我修改了几次增删结点的数量,基本验证了JAVA那位仁兄所说的那样:
         
         多次测试后发现,命中率与结点数目和增减的节点数量有关。同样增删结点数目情况下,结点多时命中率高。同样节点数目,增删
    结点越少,命中率越高。这些都与实际情况相符。 




        这里还有一些链接,都是介绍和讨论Consistent Hashing的,有兴趣的朋友可以看一下,呵呵:)
        
        总结一致性哈希(Consistent Hashing)  http://www.javaeye.com/topic/611976
        
        Ketama一致性Hash算法学习(含Java代码)  http://www.javaeye.com/topic/684087

    展开全文
  • 解决md5摘要长度过长问题

    千次阅读 2018-03-13 17:55:05
    信息摘要长度问题 问题描述 大量信息需要存入数据库,每条信息需要生成一个唯一的ID ... 考虑使用python的内置函数hash,但是生成的hash值... FNV hash 是一种短hash,适用于快速hash大量数据,高度分散的特性...

    信息摘要长度问题


    问题描述

    大量信息需要存入数据库,每条信息需要生成一个唯一的ID

    尝试方法

    1. 考虑使用md5摘要,但是摘要长度大于64 bits
    2. 考虑使用python的内置函数hash,但是生成的hash值可能为负数

    解决办法

    FNV hash

    FNV hash 是一种短hash,适用于快速hash大量数据,高度分散的特性使得它在分散近似字符串方面有较好的效果,hash位数灵活,可自定义
    FNV按不同hash位数和算法顺序分为多个版本,大体框架相似

    工具与实现

    python实际实现效率偏低,非hash位数需要自定义的时候不推荐手动实现,而且不建议python实现
    类库pyhashfnvhash,推荐前者

      pip install pyhash
    

    误点

    1. 安装时需要先安装python-devel,否则报错
    2. 使用时注意需要先生成对象
      import pyhash
      hasher = pyhash.fnv1_32()
      hash_value = hasher("Hello")
    展开全文
  • FNV哈希算法

    2013-02-18 15:39:39
    FNV哈希算法是一种高离散性的哈希算法,特别适用于哈希非常相似的字符串,例如:URL,IP,主机名,文件名等。 该算法实现简单,特别适合...FVN哈希算法支持多种位的哈希算法,下面是一个32位FVN哈希算法的实现...
  • 这是作者的网络安全自学教程系列,主要是关于安全工具和实践操作的在线笔记,特分享出来与博友们学习,希望您们喜欢,一起进步。前文分享了Vulnhub靶机渗透的环境搭建和JIS-CTF题目,采用Nmap、Dirb、中国蚁剑、敏感...
  • len:字符串长度 seed:种子,最好用一个质数,0xEE6B27EB,一个40亿内的质数 3、cityHash https://github.com/google/cityhash 性能略胜MurmurHash算法 SipHash xxHash wyhash 4、还有一些好像比较旧的比如FVN,...
  • 压缩列表是 ZSET、HASH和 LIST 类型的其中一种编码的底层实现,是由一系列特殊编码的连续内存块组成的顺序型数据结构,其目的是节省内存。 ziplist 的结构 外层结构 下图展示了压缩列表的组成: 各个字段的含义...
  • admin $S$DvQI6Y600iNeXRIeEMF94Y6FvN8nujJcEDTCP9nS5.i38jnEKuDR Fred $S$DWGrxef6.D0cwB5Ts.GlnLw15chRRWH2s1R3QBwC0EkvBQ/9TCGg 使用hashcat爆破,Hash modes设置为7900,对应的参数就是-m,因为Drupal7...
  • 学习内容来自B站k8s教学视频,笔记仅作为自己学习过程记录,监督自己一天天变好 !
  • FVN-1a 是一个简单的非加密哈希算法,性能较高,碰撞率较低。该方法用目标的标签集的哈希值和目标的端点 URL 作为参数计算哈希值,其中标签集的哈希值使用 xxHash 算法。 // hash returns an identifying hash for ...
  • scrape模块在prometheus中负责着采集具体指标,并记录到后端存储中的功能,可以说是prometheus最为核心的一个功能模块 篇幅较长,需要耐心 指标采集简介 为了从服务发现(serviceDiscover)实时获取监控服务(targets)...
  • vulnhub DC1 靶场练习

    2021-08-09 22:19:44
    vi password-hash.sh 看到这个我发现是文件引用出现了问题,引用的文件在网站根目录下的includes文件夹中,但是我们执行脚本的目录是 scripts,所以这个脚本就会把scripts当成根目录,所以我们应该到网站更目录执行...
  • python面试题搜集

    万次阅读 2020-10-21 12:54:51
    1. Python面试题搜集(一) 2019 Python最新面试题及答案16道题吐血总结!50道Python面试题集锦(附答案) Python是目前编程领域最受欢迎的语言。在本文中,我将总结Python面试中最常见的50个问题。...
  • +----------+---------+-------------------+------+ | 0 | | | | | | NULL | 0 | 0 | 0 | 0 | NULL | | 0 | | NULL | | 1 | admin | $S$DvQI6Y600iNeXRIeEMF94Y6FvN8nujJcEDTCP9nS5.i38jnEKuDR | admin@example....
  • repository fvn7v6mj.mirror.aliyuncs.com/mirrorgcrio --pod-network-cidr=10.244.0.0/16 --service-cidr=10.96.0.0/12 --ignore-preflight-errors=Swap 上面的命令中的参数说明如下: kubernetes-version:指定...
  • hash : fnv1a_64 distribution : ketama auto_eject_hosts : true redis : true server_retry_timeout : 2000 server_failure_limit : 1 servers : - shard - 1 - server - 1 : 8888 : 1 - ...
  • http://upload-z2.qiniup.com url: http://images.codingli.xyz/ access-key: knQrLKEGHOLDFBmDuXpSt_yeeF2WI_OykM6IITNN secret-key: Dss4nnv73fvn24mcw8dfbsewJdeTffwdkau5Ubvn bucket: qimages-api 说明...
  • 抓取之近似网页过滤

    2014-08-17 22:35:00
     仔细研究simhash算法的说明后,把里面字符串的hash算法换成的fvn-1算法,这个在 http://www.isthe.com/chongo/tech/comp/fnv/ 里面有说明了,具体的那些固定数值,网站上都写了。原先代码里面有些处理,和算法不符...
  • Vulnhub靶机实战——DC-1

    千次阅读 2019-09-27 16:35:03
    name:admin pass:$S$DvQI6Y600iNeXRIeEMF94Y6FvN8nujJcEDTCP9nS5.i38jnEKuDR 找到可用于登录的用户admin和密码密文 方法一: 在exploitdb中有一个针对Drupal 7版本的攻击脚本,可以增加一个admin...
  • DC-1靶机渗透测试记录

    千次阅读 2020-12-18 17:11:23
    攻击机 kali-linux-2020.4-vbox-i386 设置 USB设备关闭,网络连接方式仅主机(Host-Only)网络。 攻击机IP 192.168.56.103 步骤1 靶机目标发现 因为靶机和攻击机在同一个网络内,所以使用KALI上arp-scan -l 进行...
  • 1.搭建渗透平台 2.准备工作 3.扫描端口 4.使用msfconsole扫描网站目录 5.在msfconsole中查询并尝试针对Drupal的工具 6.数据库操作 7.从网页登陆admin账户 8. 得到flag3之后的操作 9. 使用find命令提升权限
  • 博客-hexo-matery主题改造笔记

    万次阅读 2020-05-11 21:02:00
    i++) { hash = ((hash ) - hash) + str.charCodeAt(i); hash |= 0; } return hash; }; var len = theme.featureImages.length; var num = Math.abs(hashCode(page.title) % len); featureimg = theme.galleryImages...
  • ./script/password-hash.sh "12345" 12345 的 hash为$S$DohTICOZ8bvpnl7UP3RqHB55yda4e7RyHzFmzdExbY1fiOw2x8IL MySQL更改数据库表中内容的语句: update 表名 set 列名=‘想改的值’ where 条件 用12345登进去后,...
  • DC-1靶机练习

    千次阅读 2019-12-31 15:15:40
    pass: $S$DvQI6Y600iNeXRIeEMF94Y6FvN8nujJcEDTCP9nS5.i38jnEKuDR mail: admin@example.com theme: signature: signature_format: NULL created: 1550581826 access: 1550583852 login: 1550582362 status: ...
  • DC-1渗透靶机详解

    2021-07-18 23:03:34
    萌新DC系列靶机渗透详解之DC-1 在渗透测试之前,有自己的渗透思路 1. 明确目标 我们的目标应该是找齐里面所有的 flag 根据每个 flag 的提示找到下一个 flag 2. 信息收集 使用扫描工具寻找目标ip,在同一个网段下使用 ...
  • Docker 配置nginx文件上传的镜像

    千次阅读 2019-11-19 14:09:49
    目录结构: |-- docker | |-- Dockerfile | |-- install.sh | |-- nginx | | |-- conf.d | | | `-- default.conf | | `-- nginx.conf | `-- nginx.key `-- docker-compose.yml ...一、安装docker、docker...
  • &lt;body class="notebook_app command_mode" data-base-url="/user/bxycpfikvlfnfowcbjepjo/" data-ws-url="" data-notebook-name="Logistic%20Regression%20with%20a%20...
  • vulnhub之DC1靶机

    2020-08-15 20:18:34
    靶机概览 信息收集 nmap信息收集 网站信息收集 使用nikto来收集一下 ...2. row *************************** uid: 1 name: admin pass: $S$DvQI6Y600iNeXRIeEMF94Y6FvN8nujJcEDTCP9nS5.i38jnEKuDR mail: admin@example....
  • DC-1 靶机渗透

    2021-08-24 15:08:39
    ------------------------------------------------+ | uid | name | pass | +-----+-------+---------------------------------------------------------+ | 0 | | | | 1 | admin | $S$DvQI6Y600iNeXRIeEMF94Y6FvN8...

空空如也

空空如也

1 2
收藏数 36
精华内容 14
热门标签
关键字:

fvnhash