实习 week（二）

朱雀 2022-05-20 07:06 162阅读 0赞

上一次任务：

cms版本识别提取模块

从phpmyadmin的若干版本源码包中，找出一个路径（包括文件名），该路径大多数源码包中都包含，并且md5值不一样，寻找的文件类型为css或js  
程序输出：  
\{  
 "url": "/test/test.css",  
 "data": \{  
  "xxxversion": "32位md5",  
  "yyyversion": "32位md5"

phpmyadmin查看了一下，共更新了几百个版本。

手动下载不现实，在Linux系统中使用wget -i filename.txt 可实现。

那么就需要将所有版本的下载链接保存到filename.txt文件中。

## 1、使用爬虫进行链接的获取 ##

由于phpmyadmin软件源代码在每个网页中只有10个版本需要点击Next跳转到下一页，那么就需要找到该网页中的下一页的链接，即递归爬取。可以使用Beautiful Soup， 是一个处理Python HTML/XML的模块，功能相当强劲。

Beautiful Soup是一个库，最主要的功能是从网页抓取数据。

下载及安装：https://blog.csdn.net/a\_flying\_bird/article/details/51088485

代码实现：

import re
    from urllib.request import urlopen, urlretrieve
    from bs4 import BeautifulSoup
    zip_net_list=[]
    
    
    # 下载HTML
    def getHtml(url):
        page = urlopen(url)
        html = page.read()
        return html
    
    # 从html中解析URL
    def get(html):
        reg = r'href="(.*?\.zip)"'
        netre = re.compile(reg)
        htmld = html.decode('utf-8')
        netlist = netre.findall(htmld)
        return netlist
    
    def find_file(url):
    
        #     url = 'https://github.com/phpmyadmin/phpmyadmin/tags?after=RELEASE_4_6_6'
            html = getHtml(url)
            netlist = get(html)
            for neturl in netlist:
                neturl1,neturl2=neturl.strip().split('/a')
                neturl3,neturl4=neturl2.strip().split('/',1)
                neturl5,neturl6=neturl4.strip().split('.z')
                print('https://codeload.github.com'+neturl1+'/'+'zip/'+neturl5)
                zip_net_list.append('https://codeload.github.com'+neturl1+'/'+'zip/'+neturl5)
            return False
    
    def crawl(url):
        html = urlopen(url)
        # print('--------------------------------')
    
        find_file(url)
        html = urlopen(url)
        soup = BeautifulSoup(html, 'html.parser')
        zzr = soup.find_all('div', class_="pagination")
    
        list_net = []
        for item in zzr:
            list_tmp = item.find_all('a')
            for a in list_tmp:
                list_net.append(a.get('href'))
    
        # print(list_net)
        len_ = len(list)
        if len(list_net)==1:
            if len_>2 and list_net[0]==list[len_-2]:
                return list
            list.append(list_net[0])
            crawl(list_net[0])
    
        if len(list_net)==2:
        # else:
            list.append(list_net[1])
            crawl(list_net[1])
    
    url='https://github.com/phpmyadmin/phpmyadmin/tags'
    list=[]
    list.append(url)
    crawl(url)
    
    save_zip_net=open('phpmyadmin_net.txt','w')
    for i in range(len(zip_net_list)):
        save_zip_net.write('%s\n'%zip_net_list[i])

##       2、批量下载 ##

wget -i   phpmyadmin\_net.txt

## 3、批量解压到相应的目录 ##

ls \*  | xargs -n1 unzip -d  解压目录

到解压目录查看当前文件夹数量：

ls |wc -l

共有446个版本

## 4、计算MD5 ##

find ./ -regextype posix-extended -regex ".\*\\.(css|js)" -exec md5sum \{\} \\;>phpmyadmin\_md5.txt

5、理解

任务要求：找出一个路径（包括文件名），该路径大多数源码包中都包含

上次理解错误以为要求所有版本中都含有相同路径的文件（即446个版本中都有相同路径的相同文件），其实在代码中加一个版本数量的遍历，起初是446表示446都含有相同路径的文件，如果没有，就减1，找445个版本中有相同路径的文件。。。，直到X个版本中找到了为止。接下来就要考虑该X版本中有多少个数量为X相同路径的文件，取出其中某个相同路径的MD5不同的数量最多的那个，可能不止一个。

## 6、代码整理 ##

#对数据分割重组
    import re
    import os
    import sys
    #--------------创建all_file_merge.txt----V/P:MD5-----------
    #所有版本内容合并： V/P:md5
    all_file_to_list=[]
                                                            ######*********#########      可修改
    file_num_ = 446
    # file_num = 15
    filepath='phpmyadmin_md5.txt'                                  ######*********#########      可修改
    # filepath='new_file.txt'
    file=open(filepath,'r')
    count__=0
    # print('初始长度：\n',len(file.readlines()))
    for line in file.readlines():
        key,value=line.strip().split('./')
        all_file_to_list.append(value+':'+key)   #value:versionpath  key:md5
        count__+=1
    
    # print(count__)
    # print(all_file_to_list)                        #all_file_merge.txt
    
    
    
    
    #------------创建path_md5.txt---P:MD5------------
    list_path_md5_list=[]
    
    
    for  li in all_file_to_list:
        value, key=li.strip().split(':')
        value=value[::-1]
        match=re.match('.*/',value)
        value=match.group()[::-1]
        # dict[value]=key
        list_path_md5_list.append(value+':'+key)
    
    
    # print(list_path_md5_list) #path_md5.txt
    #
    # print('初始列表总长度：\n',len(list_path_md5_list))
    
    #--------------创建version_md5.txt-V:MD5---------------
    
    
    
    list_version_md5=[]
    
    
    for li in all_file_to_list:
        (key, value)=li.strip().split(':')
        version,path=key.strip().split('/',1)
        list_version_md5.append(version+':'+value)
    # print(list_version_md5)
    # print('success!')
    
    
    #--------------------------------第2步：
    
    
    #文件排序
    # file=open('txt2/path_md5.txt','r')           ######*********#########
    #对path_md5排序：结果写入path_md5_sort.txt文件中
    
    list_path_md5=[]
    # for i in range(len(list_path_md5_dict)):
    #     for key,value in list_path_md5_dict[i].items():
    #         list_path_md5.append(key+':'+value)
    
    for i in range(len(list_path_md5_list)):
    
        list_path_md5.append(list_path_md5_list[i])
    
    
    
    
    
    
    
    # for line in file.readlines():
    # print(len(list))
    
    list_path_md5.sort()#返回值是None，其表示是在原对象上进行的操作。返回排序后结果意味着创建了一个副本。
    
    list_path_md5_sort=list_path_md5
    
    # print(len(list_path_md5_sort))
    # print('路径排序：\n',list_path_md5_sort)
    
    
    #----------------------------------第三步：
    
    #小心：在同一个文件中不能写读同一个文件，否则读会出错
    #找到所有版本中共同的文件 路径相同
    
    
    list_path=[]
    for i in range(len(list_path_md5_sort)):
         parh,md5=list_path_md5_sort[i].strip().split(':')
         list_path.append(parh)
    
    # print('路径总数：\n',len(list_path))#
    # print('路径列表：\n',list_path)
    
    # save_list_path=open('save_same_list_path.txt','w')
    # for li in list_path:
    #     save_list_path.write('%s\n'%li)
    
    
    #记录列表中相同路径的第一个序号:与源文件少1，是因为列表从0开始遍历而源文件是从1开始计数
    list_path_record_num=[]
    file_num=0
    for num_p in range(446,0,-1):
        # print(len(path_list))
        for i in range(len(list_path)):
            # print(i)
            count = i + num_p - 1  # [i  count]范围判断
            if count<len(list_path) and list_path[i]==list_path[count]  :
                list_path_record_num.append(i)
            # print(path_list[i])
    
        # print(len(list_path_record_num))
    
        if(len(list_path_record_num)!=0):
            # print('所有版本中不存在与版本数量相同路径下的文件！')
            # sys.exit()
            file_num=num_p
            break
    
    
    
    # print('list_path_record_num:',list_path_record_num)
    #
    
    #-------------------第4步找出相同路径的文件的位置
    
    # import find_16_samepath_file_3
    # import all_file_to_merge_1
    
    # find_file_=open(r'txt2/path_md5_sort.txt','r')
    
    list_all_samefile_path=[]
    num=0 # 列表中的序号
    i=0  #第i位置
    count=0 #计数，记到所有文件的数量时，归0
    
    for j in list_path_md5_sort:
        if num<len(list_path_record_num) and \
                i>=list_path_record_num[num] and \
                i<=list_path_record_num[num]+file_num-1:##############
            list_all_samefile_path.append(j)
            count+=1
            # print(line)
        if(count==file_num):#计数到16时，count归0，并且列表指向下一个元素#########修改
            num+=1
            count=0
        i+=1
    
    # print('获得文件数量：',len(list_path_record_num))
    # print('存储的序号：\n',list_path_record_num)
    #
    # print('列表元素个数：',len(list_all_samefile_path))
    #
    #
    # print('相同路径下的MD5：\n',list_all_samefile_path)
    #
    #
    #
    #-----------第5步从相同路径下的文件中找到不同的MD5
    
    
    
    list_samepath_different_md5=[]
    num=0
    for i in range(len(list_all_samefile_path)):
        # for j in range(16)
            if i+1<len(list_all_samefile_path) and list_all_samefile_path[i]==list_all_samefile_path[i+1]:
                continue
            else:
                list_samepath_different_md5.append(list_all_samefile_path[i])
    
    # print('不相同路径下的MD5：\n',list_samepath_different_md5)
    
    # find_different_md5=open('txt/find_different_md5.txt','w')
    # for i in range(len(md5_list)):
    #     find_different_md5.write('%s'%md5_list[i])
    # #------------------------------第6步：相同路径下的不同的MD5
    #
    #
    # # file=open('txt/find_different_md5.txt','r')
    #
    list_samepath_path=[]
    #读取文本中的内容将路径保存在list中方便后面统计相同路径的数目
    
    for i in range(len(list_samepath_different_md5)):
        path,md5_=list_samepath_different_md5[i].strip().split(':')
        list_samepath_path.append(path)
    
    # for line in file.readlines():
    #     key,value=line.strip().split(':')
    #     list.append(key)
    
    # print(len(list_samepath_path))
    # print('相同路径：',list_samepath_path)
    
    count_=1   #记录相同路径数
    count_different_md5_num=0
    tmp=list_samepath_path[0]
    list_different_md5_count=[]
    
    dict={}  #保存路径--不同数量
    #用list_num记录列表中相同路径下的MD5不同的数量，并且将路径+数量保存到zid中
    for i in range(1,len(list_samepath_path)):
        if(list_samepath_path[i]==tmp):
            count_+=1
        else:
            list_different_md5_count.append(count_)
            dict[tmp]=count_
            tmp=list_samepath_path[i]
            count_=1
            list_different_md5_count.append(count_)
            dict[tmp] = count_
    
    # print('输出不同MD5:',list_different_md5_count)#输出不同MD5
    #
    # print('输出不同MD5的总数:',len(list_different_md5_count))#输出不同MD5的总数
    
    
    # print(dict)
    
    # for (key,value) in dict.items():
    #     print(key,value)
    #     count_different_md5_num+=1
    # print(count_different_md5_num)
    
    # 找到列表中的最大值,并判断最大值个数
    if len(list_different_md5_count)==1:
        max_different_md5_count=list_different_md5_count[0]
    else:
        max_different_md5_count=max(list_different_md5_count)
    
    # print('列表中的最大值',max_different_md5_count)
    
    # count_max=0
    # for i in range(len(list_num)):
    #     if(list_num[i]==max(list_num)):
    #         count_max+=1
    
    # 找到最大的数（MD5不同），将对应的路径及MD5以key，value形式保存在字典中
    dict_result={}
    for path,num in dict.items():
        if(num==max(list_different_md5_count)):
            dict_result[path]=num
    
    # print("fined the result:")
    #输出满足要求的路径及对应的不同的MD5的数量
    # for path,num in dict_result.items():
    #     print(path,num)
    
    # dict_to_list=list(dict_result)
    
    #将记录的路径保存在列表中
    list_find_final_path=[]
    for path,num in dict_result.items():
        list_find_final_path.append(path)
    
    # print(list_path)
    
    ## 找到满足要求的不同路径的数量
    need_file_num=len(list_find_final_path)
    # print(need_file_num)
    
    
    #---------------第7步找到相同路径下不同的MD5
    
    find_next_num=0
    max_different_md5_count_=0
    list_find_final_samepath_different_md5=[]
    
    
    # 从所有的相同路径不同MD5文件中遍历
    for i in range(len(list_samepath_different_md5)):
        # print(line)
        path,md5__=list_samepath_different_md5[i].strip().split(':')
        # print(key)
        #相同路径下含有最多不同的MD5的内容
        if find_next_num<len(list_find_final_path) and (path==list_find_final_path[find_next_num]):
            list_find_final_samepath_different_md5.append(list_samepath_different_md5[i])
            max_different_md5_count+=1
        #当计数到同文件下不同MD5的最大数量时，num++即遍历列表中的下一个保存路径
        if max_different_md5_count_==max_different_md5_count:
            find_next_num+=1
    
    # print(list_find_final_samepath_different_md5)
    
    # # 将找到的内容保存起来
    # P_M=open('find_final_path_md5.txt','w')
    # for i in range(len(list_find_final_samepath_different_md5)):
    #     P_M.write('%s\n'%list_find_final_samepath_different_md5[i].strip())
    
    #-----------------------第8步 找到相同路径下不同的MD5
    list_result=[]
    # 用MD5来找对应的版本，然后将version+path+md5保存到列表中
    for i in range(len(list_version_md5)):
        version,md51=list_version_md5[i].strip().split(':')
        for j in range(len(list_find_final_samepath_different_md5)):
            path,md5_1=list_find_final_samepath_different_md5[j].strip().split(':')
            if md51==md5_1:
                list_result.append(version+list_find_final_samepath_different_md5[j])
    
    # 将version+path+文本中md5写入
    final_result=open('find_final_version_path_md5.txt','w')
    for i in range(len(list_result)):
        final_result.write('%s\n'%list_result[i].strip())
    
    
    # print(len(list_result))
    # print(list_result)
    #
    #-----------------第9步格式化输出
    
    # import samepath_file_different_md5_6
    
    # file=open('txt/final_result.txt','r')
    #
    # #list中保存了16*samepath_file_different_md5_6.need_file_num个文件
    # list=[]
    # for line in file.readlines():
    #     list.append(line)
    
    # print(len(list))
    
    print('\n打印出结果：')
    list_result.sort()
    for i in range(len(list_result)):
        print(list_result[i].strip())
    
    
    save_final_output=open('final_output.txt','w')
    num=0
    print('output_result:')
    #一般性，可能含有多个相同的最大的MD5数量
    # 遍历有可能多个MD5的不同数量即符合要求多于1个其数量为samepath_file_different_md5_6.need_file_num
    for i in range(need_file_num):
        key,value=list_result[num].strip().split(':')#分割version_path：MD5，初始标志
        print('{')
    
        save_final_output.write('{\n')
    
        print('  url:',path)
        save_final_output.write('  url:%s\n'%path)
    
        print('  {\n    data:\n    {')
        save_final_output.write('  {\n    data:\n    {\n')
    
        for j in range(num+1,(i+1)*file_num):#
            key1,value1=list_result[j].strip().split(':')
            if(value==value1):#与前一个MD5对比，相同跳过
                continue
            else:
                version,mad5=key.strip().split('/',1)#MD5不同，记录初始位置的V_M
    
                print('        ',version,':',value)
                save_final_output.write('        %s:%s\n'%(version,value))
    
                key,value=key1,value1 #更新比较的值
    
        num = num+file_num
        key2,value2=list_result[num-1].strip().split(':')#最后一个
        version_, mad5_= key2.strip().split('/', 1)
    
        print('        ',version_, ':', value)
        save_final_output.write('        %s:%s\n' % (version_, value))
    
        print('    }')
        save_final_output.write('    }\n')
    
    print('  }')
    save_final_output.write('  }\n')
    # print(samepath_file_different_md5_6.max_list_num)
    
    
    # #特殊性：只有一个最大的MD5数量
    # key,value=list[0].strip().split(':')
    # print('{')
    # # vp,md5=key.strip().split(':')
    # v,p=key.strip().split('/',1)
    # print('url:',p)
    # print('{\n    data:\n    {')
    # for j in range(1,len(list)):
    #     key1,value1=list[j].strip().split(':')
    #     if(value==value1):
    #         continue
    #     else:
    #         version,mad5_=key.strip().split('/',1)
    #         print('        ',version,':',value)
    #         key,value=key1,value1
    #
    # key1,value1=list[len(list)-1].strip().split(':')
    # version, mad5= key1.strip().split('/', 1)
    # print('        ',version, ':', value)
    # print('    }')
    
    print('}')
    save_final_output.write('}\n')

修改code：