逆向工程实验_pre1（密码学算法破解）

最新推荐文章于 2024-05-05 11:04:10 发布
最新推荐文章于 2024-05-05 11:04:10 发布
阅读量6.8k 收藏 5
点赞数 3
分类专栏： # 逆向工程实验 文章标签： 算法 反编译 python java 密码学
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Onlyone_1314/article/details/108936842
版权

文章目录

一、Base64编码算法

一、搜索Base64算法资料，详细解释该算法。用Python实现它，把自己的学号（字母大写）用Base64编码输出。并且把上面的源代码文件编译成pyc文件。

Base64算法实现转换原理
它是用64个可打印字符表示二进制所有数据方法。由于2的6次方等于64，所以可以用每6个位元为一个单元，对应某个可打印字符。我们知道三个字节有24个位元，就可以刚好对应于4个Base64单元，即3个字节需要用4个Base64的可打印字符来表示。在Base64中的可打印字符包括字母A-Z、a-z、数字0-9 ，这样共有62个字符，此外两个可打印符号在不同的系统中一般有所不同。但是，我们经常所说的Base64另外2个字符是：“+/”。这64个字符，所对应表如下。

转换的时候，将三个byte的数据，先后放入一个24bit的缓冲区中，先来的byte占高位。数据不足3byte的话，于缓冲区中剩下的bit用0补足。然后，每次取出6个bit，按照其值选择ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/中的字符作为编码后的输出。不断进行，直到全部输入数据转换完成。
这是恰好三个字节转为base64：

如果最后剩下两个输入数据，在编码结果后加1个“=”；如果最后剩下一个输入数据，编码结果后加2个“=”：
如果没有剩下任何数据，就什么都不要加，这样才可以保证资料还原的正确性。无论什么样的字符都会全部被编码，编码后的数据比原始数据略长，为原来的4/3。
源代码：

import string
# Base64的64个可打印字符
#letters = list( string . ascii_letters) + list(string.digits) + ['+', '/']
#print(letters)

letters = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
#print(letters)

#定义base64加密函数
def encryption(inputString):
    # 对每一个字节取ascii数值或unicode数值，然后转换为2进制
    ascii = ['{:0>8}'.format(str(bin(ord(i))).replace('0b', ''))
             for i in inputString]
    #返回的加密文本
    outputString = ''
    # 不够3字节的整数倍，需要补齐“=”的个数
    equalNumber = 0
    #对每个字符的转换
    while ascii:
        #三个asciiw为一组
        AsciiList = ascii[:3]
        if len(AsciiList) != 3:
            #不满三个的，在后面加“=”
            while len(AsciiList) < 3:
                equalNumber += 1
                AsciiList += ['0'*8]
        #join方法连接成三个8字节的字符串
        tempString = ''.join(AsciiList)
        # 三个8字节的二进制，转换为4个6字节的二进制
        tempStringList = [tempString[x:x+6] for x in [0, 6, 12, 18]]
        # 二进制转为10进制
        tempStringList = [int(x, 2) for x in tempStringList]
        # 判断是否需要补“=”,只要equakNumber大于0即需要
        if equalNumber:
            tempStringList = tempStringList[0:4-equalNumber]
        #装换成那64个字符
        outputString += ''.join([letters[x] for x in tempStringList])
        ascii = ascii[3:]
    #在最后加上“=”
    outputString = outputString + '=' * equalNumber
    #返回加密后的文本
    return outputString

#定义base64解密函数
def decryption(inputString):
    # 对前面不是“=”的字节取索引，然后转换为2进制
    asciiList = ['{:0>6}'.format(str(bin(letters.index(i))).replace('0b', ''))
                      for i in inputString if i != '=']
    outputString = ''
    #补齐“=”的个数
    equalNumber = inputString.count('=')
    while asciiList:
        tempList = asciiList[:4]
        #转换成2进制字符串
        tempString = ''.join(tempList)
        # 对没有8位2进制的字符串补够8位2进制
        if len(tempString) % 8 != 0:
            tempString = tempString[0:-1*equalNumber*2]
        # 4个6字节的二进制  转换  为三个8字节的二进制
        tempStringList = [tempString[x:x+8] for x in [0, 8, 16]]
        # 二进制转为10进制
        tempStringList = [int(x, 2) for x in tempStringList if x]
        #连接成字符串
        outputString += ''.join([chr(x) for x in tempStringList])
        asciiList = asciiList[4:]
    #print(output_str)
    return outputString

studentNumber = 'A12345678'
#加密
encryptedText = encryption(studentNumber)
print("加密文本为："+encryptedText)
#解密
decryptedText = decryption(encryptedText)
print("解密文本为："+decryptedText)

import base64
#Python2中可直接编码打印
#Python3中的因为3.x中字符都为unicode编码，而b64encode函数的参数为byte类型，所以必须先转码utf-8。
encodestr = base64.b64encode('A12345678'.encode('utf-8'))
print("Python库中的base64编码："+str(encodestr,'utf-8'))
decodestr = base64.b64decode(encodestr.decode('utf-8'))
print("Python库中的base64解码："+str(decodestr,'utf-8'))

代码结果截图：
在这里插入图片描述

自己实现的Base64算法编码和解码的结果，与导入Python库中的Base64算法编码和解码的结果相同，编码结果为：PTQxNjEOMDAx，解码结果为：A12345678。
转换成pyc文件：
源代码：

import py_compile
#文件路径下不要有中文，否则py_compile会编译报错
py_compile.compile('D:\pyc\Base64.py')

在这里插入图片描述

直接用Python自带的IDLE命令行编译
在这里插入图片描述

注意文件路径下不要有中文，否则py_compile会编译报错

二、pyc文件反编译

二、找班上学号和你相邻的一位同学要一下上面的pyc文件（不是源代码文件），然后搜索相关反编译工具把pyc反编译成Python源代码，最好能多找几种工具或者途径达到反编译的目的。

我找的是另一位同学的pyc文件
1、在线反编译
在这里插入图片描述

2、Easy Python Decompiler反编译工具
在这里插入图片描述

但是他的代码可能用的是最新的python环境，Easy Python Decompiler目前只支持带python3.4。但我反编译其他文件没有问题。
3、使用uncompyle6代码反编译

import os
import sys


def displayFile(file):
    unPath = sys.executable
    unPath = unPath[0: unPath.rfind(os.sep)]
    newname = file[0:file.rfind('.')] + '.py'
    command = "python -u " + unPath + "\scripts\uncompyle2 " + file + ">" + newname
    try:
        os.system(command)
    except :
        print
        file


if __name__ == '__main__':
    # print unPath
    print("init")
    displayFile('D:\\hh.pyc')
    print("finished")

反编译出来的源代码为：

import string
base64_charset = string.ascii_uppercase + string.ascii_lowercase + string.digits + '+/'
a1 = 'A12345678'
a2 = ''
a3 = ''
n1 = len(a1) % 3
n2 = len(a1) // 3
for i in range(1, n1):
    a1 += '\x00'

# WARNING: Decompyle incomplete
import string
base64_charset = string.ascii_uppercase + string.ascii_lowercase + string.digits + '+/'
a1 = 'A12345678'
a2 = ''
a3 = ''
n1 = len(a1) % 3
n2 = len(a1) // 3
for i in range(1, n1):
    a1 += '\x00'

三、sha1算法破解

三、去https://www.mysterytwisterc3.org/注册一个账号（字母大写），i注册的时候有个Captcha可能要FQ才能显示，账号密码记住以后要用到。
完成关卡Cracking SHA1-Hashed Passwords
https://www.mysterytwisterc3.org/en/challenges/level-ii/cracking-sha1-hashed-passwords
在这里插入图片描述

pdf中键盘上的指纹，它提示我们密码中可能出现的字符有“QWINqwin%(*=2468”，且密码经过sha1算法加密后的密文为：67ae1a64661ac8b4494666f58c4822408dd0a3e4，要求我们解出密。

代码的原理和第五题相似，都是sha1算法暴力破解。因为是先写的第五题，这题团里就不多说了。
源代码：

package sha1;

import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.concurrent.Callable;
import java.lang.Math;
/**
 * 文件注释：
 *
 * @Auther: Legends
 * @Date: 2018/2/27 18:30
 * @Description:
 */
public  class Sha1 implements Callable {

    private int threadNumber;
    Sha1(int threadNumber){
        this.threadNumber = threadNumber ;
    }

    /**
     * 重写call方法，分配每个线程的任务
     * @return 0或10
     * @throws Exception
     */
    @Override
    public Object call() throws Exception {
        /*可能的字符*/
        char [] encryptedText = ("QWINqwin%(*=2468").toCharArray();
        //char [] encryptedText = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890~!@#$%^&*()[]|;',<>.?".toCharArray();
        /*长度为5的密文字符串*/
        String data = null;
        /*根据输入的线程编号threadNumber，分配相应的任务*/
        int [] temp = new int[8];
        for (int i = 0; i<temp.length ; i++) {
            int n = (int) Math.pow(2,i);
            if((threadNumber & n) > 0){
                temp[i] = 1;
            }
            else {
                temp[i] = 0;
            }
        }

        int length = encryptedText.length / 2;
        /*8个字符的组合*/
        for(int a = (length * temp[0]) ; a < (length * (temp[0]+1)); a++){
            for(int b = (length * temp[1]); b < (length * (temp[1]+1)); b++){
                for(int c = (length * temp[2]); c < (length * (temp[2]+1)); c++){
                    for(int d = (length * temp[3]); d < (length * (temp[3]+1)); d++){
                        for(int e = (length * temp[4]); e < (length * (temp[4]+1)); e++){
                            for(int f = (length * temp[5]); f < (length * (temp[5]+1)); f++){
                                for(int g = (length * temp[6]); g < (length * (temp[6]+1)); g++){
                                    for(int h = (length * temp[7]); h < (length * (temp[7]+1)); h++){
                                        /*获取不同的键盘字符组合*/
                                        data = ""+ encryptedText[a] + encryptedText[b] + encryptedText[c] + encryptedText[d] + encryptedText[e] + encryptedText[f]+ encryptedText[g]+ encryptedText[h];
                                        /*将字符加密*/
                                        String result = sha1(data);
                                        String decrypted = "67ae1a64661ac8b4494666f58c4822408dd0a3e4";
                                        //String decrypted = "4b58475789e60dbf1a28d638b556a938134644c8";
                                        /*如果字符加密后的sha1哈希值和所给的相等，即为找到了答案*/
                                        if(decrypted.equals(result)){
                                            //System.out.println("4b58475789e60dbf1a28d638b556a938134644c8的sha1算法解密结果为： "+data);
                                            System.out.println("67ae1a64661ac8b4494666f58c4822408dd0a3e4的sha1算法解密结果为： "+data);
                                            return 10;
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
        return 0;
    }
    /**
     * sha1算法加密
     * @param data
     * @return
     * @throws NoSuchAlgorithmException
     */
    public static String sha1(String data) throws NoSuchAlgorithmException {
        //信息摘要器                                算法名称
        MessageDigest md = MessageDigest.getInstance("SHA1");
        //把字符串转为字节数组
        byte[] b = data.getBytes();
        //使用指定的字节来更新我们的摘要
        md.update(b);
        //获取密文  （完成摘要计算）
        byte[] b2 = md.digest();
        //获取计算的长度
        int len = b2.length;
        //16进制字符串
        String str = "0123456789abcdef";
        //把字符串转为字符串数组
        char[] ch = str.toCharArray();

        //创建一个40位长度的字节数组
        char[] chs = new char[len*2];
        //循环20次
        for(int i=0,k=0;i<len;i++) {
            //获取摘要计算后的字节数组中的每个字节
            byte b3 = b2[i];
            // >>>:无符号右移
            // &:按位与
            //0xf:0-15的数字
            chs[k++] = ch[b3 >>> 4 & 0xf];
            chs[k++] = ch[b3 & 0xf];
        }
        //字符数组转为字符串
        return new String(chs);
    }
}

package sha1;

import java.util.concurrent.ExecutionException;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.ThreadPoolExecutor;
/*Future类包含线程池执行完毕之后存储的结果*/

/**
 * 文件注释：逆向工程pre1，第五题
 *
 * @Auther: Legends
 * @Date: 2018/2/27 18:33
 * @Description:
 */
public class Sha1Test {
   public static void main(String[] args) {
      // 执行线程池
      ThreadPoolExecutor executor=(ThreadPoolExecutor)Executors.newFixedThreadPool(32);

      //分成32个任务计算，提交任务
      for (int i=0; i<256; i++){
          Sha1 sha1 = new Sha1(i);
            /*Future类获取线程的返回值*/
            Future<Integer> result = executor.submit(sha1);
            try {
                /*将返回值转换成Interger对象*/
                Integer test = result.get();
                /*比较结果后终止线程池*/
                if(test.equals((Integer)10)){
                    // 关闭线程池
                    executor.shutdown();
                }
            } catch (InterruptedException | ExecutionException e) {
                e.printStackTrace();
            }
      }
      // 关闭线程池
      executor.shutdown();
   }
}

在线解密：
在这里插入图片描述

密文67ae1a64661ac8b4494666f58c4822408dd0a3e4最后的sha1算法解密结果为：（Q=win*5。提交通过。
在这里插入图片描述

四、数据库的sha1密码破解

四、从前有一个熊孩子入侵了一个网站的数据库，找到了管理员密码，手一抖在数据库中修改了
一下，现在的密码变成了 4B58475789E60DBF1A28GD638B556A938134644C8。
（41位）那个熊孩子其实就是我！肿么办求解原始密码！在线等，挺急的。。
hint：密码长度为5

现在的密码是40位16进制数加上“G”这个多余的非16进制数，可能是题目中说的手抖修改了一下加上了这个，上次预习作业pre0中出现的sha1加密算法，加密后的密文是160位2进制数即40位16进制，所以上面的密码应该是sha1加密过的密文4B58475789E60DBF1A28D638B556A938134644C8。
在线sha1解密得到结果为：BSWAP。符合题目要求的密码长度为5。
在这里插入图片描述

它这个在线解密应该也就是匹配它的数据库中的密文，如果是新的明文经常会解密失败。
代码算法原理：
我自己写的一个暴力破解sha1算法的代码，原理就是通过对键盘输入的所有符号进行对比：abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQ RSTUVWXYZ1234567890~!@# %^&*()[]|;',<>.?。因为题目中提示了代码长度为5，通过比较5位数字不同的组合，计算他们的sha1算法的哈希值，当出现题目中的4B58475789E60DBF1A28D638B556A938134644C8是，即为找到解。这种暴力破解的方法虽然计算量比较大，但是只要密码中的字符在abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890~!@# %^&*()[]|;’,<>.?中，还是能求出解的。
因为计算量比较大，所以我采用了多线程编程的方式，新建了一个最多可以跑32条线程的线程池。将任务分成32部分，一旦有一条线程找到了正确答案，就立即退出，终止线程池中的所有线程。
源代码：Sha1.java

package sha1;

import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.concurrent.Callable;
import java.lang.Math;
/**
 * 文件注释：
 *
 * @Auther: Legends
 * @Date: 2018/2/27 18:30
 * @Description:
 */
public  class Sha1 implements Callable {

    private int threadNumber;
    Sha1(int threadNumber){
        this.threadNumber = threadNumber ;
    }

    /**
     * 重写call方法，分配每个线程的任务
     * @return 0或10
     * @throws Exception
     */
    @Override
    public Object call() throws Exception {
        char [] encryptedText = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890~!@#$%^&*()[]|;',<>.?".toCharArray();
        /*长度为5的密文字符串*/
        String data = null;
        /*根据输入的线程编号threadNumber，分配相应的任务*/
        int [] temp = new int[5];
        for (int i = 0; i<temp.length ; i++) {
            int n = (int) Math.pow(2,i);
            if((threadNumber & n) > 0){
                temp[i] = 1;
            }
            else {
                temp[i] = 0;
            }
        }

        int length = encryptedText.length / 2;
        for(int a = (length * temp[0]) ; a < (length * (temp[0]+1)); a++){
            for(int b = (length * temp[1]); b < (length * (temp[1]+1)); b++){
                for(int c = (length * temp[2]); c < (length * (temp[2]+1)); c++){
                    for(int d = (length * temp[3]); d < (length * (temp[3]+1)); d++){
                        for(int e = (length * temp[4]); e < (length * (temp[4]+1)); e++){
                            /*获取不同的键盘字符组合*/
                            data = ""+ encryptedText[a] + encryptedText[b] + encryptedText[c] + encryptedText[d] + encryptedText[e] ;
                            /*将字符加密*/
                            String result = sha1(data);
                            String decrypted = "4b58475789e60dbf1a28d638b556a938134644c8";
                            /*如果字符加密后的sha1哈希值和所给的相等，即为找到了答案*/
                            if(decrypted.equals(result)){
                                System.out.println("4b58475789e60dbf1a28d638b556a938134644c8的sha1算法解密结果为： "+data);
                                return 10;
                            }
                        }
                    }
                }
            }
        }
        return 0;
    }
    /**
     * sha1算法加密
     * @param data
     * @return
     * @throws NoSuchAlgorithmException
     */
    public static String sha1(String data) throws NoSuchAlgorithmException {
        //信息摘要器                                算法名称
        MessageDigest md = MessageDigest.getInstance("SHA1");
        //把字符串转为字节数组
        byte[] b = data.getBytes();
        //使用指定的字节来更新我们的摘要
        md.update(b);
        //获取密文  （完成摘要计算）
        byte[] b2 = md.digest();
        //获取计算的长度
        int len = b2.length;
        //16进制字符串
        String str = "0123456789abcdef";
        //把字符串转为字符串数组
        char[] ch = str.toCharArray();

        //创建一个40位长度的字节数组
        char[] chs = new char[len*2];
        //循环20次
        for(int i=0,k=0;i<len;i++) {
            //获取摘要计算后的字节数组中的每个字节
            byte b3 = b2[i];
            // >>>:无符号右移
            // &:按位与
            //0xf:0-15的数字
            chs[k++] = ch[b3 >>> 4 & 0xf];
            chs[k++] = ch[b3 & 0xf];
        }
        //字符数组转为字符串
        return new String(chs);
    }
}

Sha1Test.java

package sha1;

import java.util.concurrent.ExecutionException;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.ThreadPoolExecutor;
/*Future类包含线程池执行完毕之后存储的结果*/

/**
 * @Auther: Legends
 * @Date: 2018/2/27 18:33
 * @Description:
 */
public class Sha1Test {
   public static void main(String[] args) {
      // 执行线程池
      ThreadPoolExecutor executor=(ThreadPoolExecutor)Executors.newFixedThreadPool(32);

      //分成32个任务计算，提交任务
      for (int i=0; i<32; i++){
          Sha1 sha1 = new Sha1(i);
            executor.submit(sha1);
            /*Future类获取线程的返回值*/
            Future<Integer> result = executor.submit(sha1);
            try {
                /*将返回值转换成Interger对象*/
                Integer test = result.get();
                /*比较结果后终止线程池*/
                if(test.equals((Integer)10)){
                    // 关闭线程池
                    executor.shutdown();
                }
            } catch (InterruptedException | ExecutionException e) {
                e.printStackTrace();
            }
      }
      // 关闭线程池
      executor.shutdown();
   }
}

实验结果截图：
在这里插入图片描述

4B58475789E60DBF1A28D638B556A93813 4644C8经过解密后的结果就是BSWAP。上面输出出现的是中文乱码，由于编译器的原因，原本只是想输出一个中文提示而已。
在这里插入图片描述

后面抛出的异常是由于输出结果之后，我立即终止了所有还在运行的线程以免浪费时间，捕捉到的系统抛出的异常提示。但这些都无伤大雅，并不影响结果。

验证：
在这里插入图片描述

BSWAP经过sha1算法加密后的结果就是4B58475789E60DBF1A28D638B556A938134644C8。

大灬白
关注
  • 3
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
chatgpt赋能python：PythonSHA1解密：介绍
tulingtest的博客
05-25 375
SHA1是一种安全散列（或哈希）函数，它将任意长度的消息作为输入，输出一个固定长度的哈希值。SHA1哈希函数通常用于密码学和数据完整性验证，因为它是不可逆的，也就是说，如果知道SHA1哈希值，就无法确定原始消息的值。hashlib是Python标准库中用于加密和安全算法的模块。它包括许多散列函数，如SHA1、SHA256、MD5等等。本文由chatgpt生成，文章没有在chatgpt生成的基础上进行任何的修改。以上只是chatgpt能力的冰山一角。作为通用的Aigc大模型，只是展现它原本的实力。
逆向工程实验_lab0（密码学算法逆向）
Onlyone_1314的博客
10-03 7716
文章目录一级目录一级目录1. cipher text 一级目录 一级目录 1. cipher text bmjs dtz uqfd ymj lfrj tk ymwtsjx dtz bns tw dtz inj ymjwj nx st rniiqj lwtzsi 刚看到需要解密的文本，就觉得它很像移位密码，于是开始试了一下。 源代码： 求最大公因数：Arithmetic.java public class Arithmetic { int x = 0; int y = 0; publ
sha1 加密解密
11-29
sha1加密解密的这个不错的，经过测试的，很好的
HZNUCTFre题解
最新发布
2301_80096119的博客
05-05 285
然后再黑框输入python pyinstxtractor.py +文件名.exe，回车运行，出现一个同名文件见夹再找同名文件，然后再用pycdc.exe。用pyc转成py就是如下，但是对于其中无法编译部分，需要对照字节码进行补全，将pyc文件转化为字节码需要使用pycdas工具。关于iv先看一下这个16*16的矩阵,看的题解说是初始向量IV是通过dijkstra算法求得的最短路径。这是一道python的反汇编题先下载文件发现是.exe。用pycdas转成字符码，就可以更清晰的看见具体过程了。
逆向工程实验——lab2（密码学）
Onlyone_1314的博客
10-27 1913
1.lab2的内容为上次课堂练习的内容，把做过的题目写到实验报告里，要解释步骤，可以额外再去课堂练习的网站找一部分题目做。 第一题、01-Number-sequence 这题刚开始试过分解因数，发现没结果。上题做出来后，受到上一题后来那一串质数的启发，发现这几个数和那一串数都分别差1。这才发现是将质数减一，40=41-1，而41后面的第一个质数为43，所以下一个数为42。 第二题.02-Number Sequence - Part 2 很容易发现给出的数字都是5的倍数，将它们除以5后得到2,3,5,7,11
SHA-1 加密算法破解现已只需要 10 天
weixin_33842328的博客
10-09 561
转自：http://www.linuxeden.com/html/news/20151009/163173.html SHA-1是如今很常见的一种加密哈希算法，HTTPS传输和软件签名认证都很喜欢它，但它毕竟是诞生于1995年的老技术了(出自美国国安局NSA)，已经渐渐跟不上时代，被破解的速度也是越来越快。来自法国、荷兰、新加坡的三位科学家搞了个项目“The Shappening”，利用碰撞攻击...
sha1算法破解
Onlyone_1314的博客
10-09 1万+
去https://www.mysterytwisterc3.org/注册一个账号（字母大写），i注册的时候有个Captcha可能要FQ才能显示，账号密码记住以后要用到。 完成关卡Cracking SHA1-Hashed Passwords https://www.mysterytwisterc3.org/en/challenges/level-ii/cracking-sha1-hashed-passwords pdf中键盘上的指纹，它提示我们密码中可能出现的字符有“QWINqwin%(*=2468”，且密
DPDGOOD.rar_dpdgood_pre distortion_数字预失真_预失真_预失真算法
07-14
数字预失真的很好的算法，从原理到算法都给出比较详细的说明，对初学者有很大的帮助。
pre-mid-creattree.zip_pre_pre mid
09-20
在处理“pre-mid-creattree.zip”这个压缩包中的程序时，我们需要实现一个算法来执行上述步骤。程序可能包括以下部分： - **读取输入**：从用户或文件中获取二叉树的前序和中序遍历序列。 - **处理遍历序列**：解析...
mCAP_pre_SISO.rar_CAP.m_cap_mCAP_pre_pre equalization
07-14
文件“mCAP_pre_SISO.m”很可能是MATLAB代码，用于实现m-CAP预均衡算法的仿真。SISO系统是最基本的通信模型，其中只有一个发射器和一个接收器。在VLC的SISO系统中，预均衡可以更有效地提升信号质量，因为只有一个...
ironruby-pre-alpha1.zip_pre
09-24
这个“ironruby-pre-alpha1.zip_pre”文件是IronRuby项目的早期预览版本，即Pre-Alpha1阶段的源代码。在这一阶段，代码可能包含了初步的功能实现，但稳定性、性能和完整性都还有待提高，对于开发者，尤其是对Ruby和...
windows sha1 加密解密工具
04-03
windows sha1 加密解密工具 相当不错
MD5、SHA1、SHA256以及SHA512加解密算法实现
12-07
MD5、SHA1、SHA256以及SHA512加解密算法实现源码。 实现语言：C代码实现
pre_norm_mul.rar_pre_浮点 vhdl
09-19
4. **乘法器**：核心的浮点乘法操作可能实现为一个高效的乘法器结构，如Booth算法、Kogge-Stone算法或Carry-Lookahead加法器的扩展版本。 5. **溢出处理**：浮点运算可能会导致溢出，代码中应包含检测和处理溢出的...
安卓工程逆向之sha1暴力破解（研究篇）
wujiesunlirong的博客
06-10 1299
安卓逆向工作之sha1暴力破解 import os import hashlib import numpy as np import binascii from hashlib import blake2b class AppRsaKill(): def __init__(self,paths): self._paths = paths def run(self): try: pass
[BUUCTF] CrackRTF （哈希SHA1的爆破解密）
rabbit_dance的博客
02-23 1872
里面就是异或，a3 的值是从SizeofResource中获取，大概是从文件AAA中取得0x65这个信息，复制到lpBuffer中，将文件中取得的信息进行异或，生成.RTF文件。第二部分与第一部分相似，输入六位后进行拼接，将长度的值赋给v4，我们进入对数据进行处理的函数进行查看分析，只不过标识码变成了 0x8003u ，查询知是。功能强大，很多的密文可以一把梭，例如此题，可以直接得到passwp1 和 passwp2。，用脚本爆破没出来结果，接着向下看，进入 sub_40100F函数。
国外在线Md5,md4,mysql,Sha1,NTLM破解网站
热门推荐
springsen的专栏
03-23 3万+
下面这信息是拷来的，仅供参考 2011年07月08日 星期五 3:52 P.M.   重新整理了，左边是网站名 右边是收录的数据量， 问号代表不清楚数据数量 国外的在线解密貌似极少数支持16位MD5的 MD5解密 Tobtu 50,529,455,839 TMTO 36,436,233,567
Sha1加密是不可逆的，网上虽然有解密的方法，但只能解密很简单的密码
weixin_42158022的博客
08-30 5401
今天又踩了个坑，原因是我打算写一个密码管理工具，把密码加密存入excel中，一开始不知道sha1不能解密，所以在网上找了半天sha1解密的方法，最终在一个论坛中发现sha1是不可逆算法，只能加密，很难解密。所以我的密码管理系统到底用什么方式，应该会比较简单且安全呢？ ...
软件程序破解的难度和原理你懂多少?
chuange6363的博客
09-10 1673
从技术角度上讲、没有绝对安全的程序，只要是人为的都或多或少存在漏洞，就连巨头网络公司也不可避免的，今天本猿科普下软件破解的难度与乐趣。 简单的分级介绍下软件程序加密方式：授权验证-加壳-暗桩-云计算，以目前的技术来说，只要愿意花费时间和金钱，所有软件程序都能破解！哪...
y_pre = y_pre.reshape(300, 1)
09-18
这行代码是将数组y_pre进行了形状变换，将其转换为300行1列的矩阵。原来的y_pre可能是一个一维数组或者是一个n行m列的矩阵，通过该代码，它被重塑为了一个300行1列的矩阵。这种形状的变换可以在很多机器学习和数据处理任务中很有用。例如，在一些模型的训练过程中，需要输入一个列向量作为目标变量y，而某些算法的输出结果可能是横向量或矩阵，这时候就需要使用reshape函数进行维度调整，使得输出结果和目标变量y的形状匹配，以便进行后续计算或预测。同时，通过这种形状变换，我们还可以将数据重新组织成需要的形式或结构，方便后续处理。总之，这行代码的作用是将y_pre的形状转换为300行1列的矩阵。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值