md5信息摘要算法实现(python 和 go版本)

纯手写实现的md5信息摘要算法

https://github.com/kittysmith5/dgst/blob/main/md5

python3版本代码

#!/usr/bin/python3

# _*_ encoding: utf-8 _*_

"""

@File   :   my_md5.py

@Time   :   9:07 PM

@Author :   Barry Johnson

@Version:   1.0

@Contact:   *******@***.com

@License:   None

@Desc   :   None

"""

T = (0xd76aa478, 0xe8c7b756, 0x242070db, 0xc1bdceee,

     0xf57c0faf, 0x4787c62a, 0xa8304613, 0xfd469501,

     0x698098d8, 0x8b44f7af, 0xffff5bb1, 0x895cd7be,

     0x6b901122, 0xfd987193, 0xa679438e, 0x49b40821,

     0xf61e2562, 0xc040b340, 0x265e5a51, 0xe9b6c7aa,

     0xd62f105d, 0x2441453, 0xd8a1e681, 0xe7d3fbc8,

     0x21e1cde6, 0xc33707d6, 0xf4d50d87, 0x455a14ed,

     0xa9e3e905, 0xfcefa3f8, 0x676f02d9, 0x8d2a4c8a,

     0xfffa3942, 0x8771f681, 0x6d9d6122, 0xfde5380c,

     0xa4beea44, 0x4bdecfa9, 0xf6bb4b60, 0xbebfbc70,

     0x289b7ec6, 0xeaa127fa, 0xd4ef3085, 0x4881d05,

     0xd9d4d039, 0xe6db99e5, 0x1fa27cf8, 0xc4ac5665,

     0xf4292244, 0x432aff97, 0xab9423a7, 0xfc93a039,

     0x655b59c3, 0x8f0ccc92, 0xffeff47d, 0x85845dd1,

     0x6fa87e4f, 0xfe2ce6e0, 0xa3014314, 0x4e0811a1,

     0xf7537e82, 0xbd3af235, 0x2ad7d2bb, 0xeb86d391)

SFF = (7, 12, 17, 22)

SGG = (5, 9, 14, 20)

SHH = (4, 11, 16, 23)

SII = (6, 10, 15, 21)

def f(x, y, z):

    return x & y | ~x & z

def g(x, y, z):

    return x & z | y & ~z

def h(x, y, z):

    return x ^ y ^ z

def i(x, y, z):

    return y ^ (x | ~z)

def rol(num, count):

    #

    # num需要是32位的

    """

    坑！！！

    :param num:

    :param count:

    :return:

    """

    b = (num & 0xffffffff) << count

    return (b & 0xffffffff) + (b >> 32)

    # return (num << count) | (num >> 32 - count)

def ff(a, b, c, d, mj, s, ti):

    """

    返回值不需要控制长度 超过32位也可以

    :param a:

    :param b:

    :param c:

    :param d:

    :param mj:

    :param s:

    :param ti:

    :return:

    """

    return b + rol((a + f(b, c, d) + mj + ti), s)

def gg(a, b, c, d, mj, s, ti):

    return b + rol((a + g(b, c, d) + mj + ti), s)

def hh(a, b, c, d, mj, s, ti):

    return b + rol((a + h(b, c, d) + mj + ti), s)

def ii(a, b, c, d, mj, s, ti):

    return b + rol((a + i(b, c, d) + mj + ti), s)

def plain2bit(plain: str):

    """

    三个部分，原文需要小端序就是 0xabce f012   ---> 0x12f0 cdab

            中间的补充码和前面原文一起小端序  8bit小端序

            最后的长度需要单独处理，前后32位进行交换即可

    :param plain:

    :return:

    """

    bit_lis = []

    bit_str = ""

    bit_lis_32 = []

    for char in plain:

        bit_str += f"{int(str(bin(ord(char))).replace('0b', '')):08}"

    # 补位 使总长度除以512的余数为448 512->64B  一个ascii码 8位->1个B

    rmd = len(bit_str) % 512

    if rmd == 448:

        bit_str += '1' + '0' * 511

    else:

        bit_str += '1' + '0' * (448 - rmd - 1)

    # 后64位补充长度信息 采用小端序

    # len 是比特的数量，不是字符串的数量

    len2_str = f"{int(str(bin(len(plain) * 8)).replace('0b', '')):064}"

    bit_str += len2_str

    for j in range(int(len(bit_str) / 512)):

        bit_lis.append(bit_str[j * 512:(j + 1) * 512])

    for block in bit_lis:

        bit_lis_32_item = []

        for j in range(int(512 / 32)):

            hex_str = hex(int(block[j * 32:(j + 1) * 32], 2))

            bit_lis_32_item.append(int(reverse_hex(hex_str.replace("0x", '')), 16))

        bit_lis_32.append(bit_lis_32_item)

    # 最后64位是32位小端序

    bit_lis_32[-1][-1] = int(len2_str[0:32], 2)

    bit_lis_32[-1][-2] = int(len2_str[32:64], 2)

    print(bit_lis_32)

    return bit_lis_32

def reverse_hex(hex_str: str):

    hex_str = hex_str.replace('0x', '')

    hex_str_list = []

    for j in range(len(hex_str)):

        hex_str = "0" * (8 - len(hex_str)) + hex_str

    for j in range(0, 8, 2):

        hex_str_list.append(hex_str[j: j + 2])

    hex_str_list.reverse()

    hex_str = "".join(hex_str_list)

    return hex_str

def main_loop(plain):

    lis = plain2bit(plain)

    A = 0x67452301

    B = 0xefcdab89

    C = 0x98badcfe

    D = 0x10325476

    for item in lis:

        a = A

        b = B

        c = C

        d = D

        # Round 1   --->  1

        a = ff(a, b, c, d, mj=item[0], s=SFF[0], ti=T[0])

        d = ff(d, a, b, c, mj=item[1], s=SFF[1], ti=T[1])

        c = ff(c, d, a, b, mj=item[2], s=SFF[2], ti=T[2])

        b = ff(b, c, d, a, mj=item[3], s=SFF[3], ti=T[3])

        a = ff(a, b, c, d, mj=item[4], s=SFF[0], ti=T[4])

        d = ff(d, a, b, c, mj=item[5], s=SFF[1], ti=T[5])

        c = ff(c, d, a, b, mj=item[6], s=SFF[2], ti=T[6])

        b = ff(b, c, d, a, mj=item[7], s=SFF[3], ti=T[7])

        a = ff(a, b, c, d, mj=item[8], s=SFF[0], ti=T[8])

        d = ff(d, a, b, c, mj=item[9], s=SFF[1], ti=T[9])

        c = ff(c, d, a, b, mj=item[10], s=SFF[2], ti=T[10])

        b = ff(b, c, d, a, mj=item[11], s=SFF[3], ti=T[11])

        a = ff(a, b, c, d, mj=item[12], s=SFF[0], ti=T[12])

        d = ff(d, a, b, c, mj=item[13], s=SFF[1], ti=T[13])

        c = ff(c, d, a, b, mj=item[14], s=SFF[2], ti=T[14])

        b = ff(b, c, d, a, mj=item[15], s=SFF[3], ti=T[15])

        # Round 2   ---> 5

        a = gg(a, b, c, d, mj=item[1], s=SGG[0], ti=T[0 + 16])

        d = gg(d, a, b, c, mj=item[6], s=SGG[1], ti=T[1 + 16])

        c = gg(c, d, a, b, mj=item[11], s=SGG[2], ti=T[2 + 16])

        b = gg(b, c, d, a, mj=item[0], s=SGG[3], ti=T[3 + 16])

        a = gg(a, b, c, d, mj=item[5], s=SGG[0], ti=T[4 + 16])

        d = gg(d, a, b, c, mj=item[10], s=SGG[1], ti=T[5 + 16])

        c = gg(c, d, a, b, mj=item[15], s=SGG[2], ti=T[6 + 16])

        b = gg(b, c, d, a, mj=item[4], s=SGG[3], ti=T[7 + 16])

        a = gg(a, b, c, d, mj=item[9], s=SGG[0], ti=T[8 + 16])

        d = gg(d, a, b, c, mj=item[14], s=SGG[1], ti=T[9 + 16])

        c = gg(c, d, a, b, mj=item[3], s=SGG[2], ti=T[10 + 16])

        b = gg(b, c, d, a, mj=item[8], s=SGG[3], ti=T[11 + 16])

        a = gg(a, b, c, d, mj=item[13], s=SGG[0], ti=T[12 + 16])

        d = gg(d, a, b, c, mj=item[2], s=SGG[1], ti=T[13 + 16])

        c = gg(c, d, a, b, mj=item[7], s=SGG[2], ti=T[14 + 16])

        b = gg(b, c, d, a, mj=item[12], s=SGG[3], ti=T[15 + 16])

        # Round 3 --->3

        a = hh(a, b, c, d, mj=item[5], s=SHH[0], ti=T[0 + 16 * 2])

        d = hh(d, a, b, c, mj=item[8], s=SHH[1], ti=T[1 + 16 * 2])

        c = hh(c, d, a, b, mj=item[11], s=SHH[2], ti=T[2 + 16 * 2])

        b = hh(b, c, d, a, mj=item[14], s=SHH[3], ti=T[3 + 16 * 2])

        a = hh(a, b, c, d, mj=item[1], s=SHH[0], ti=T[4 + 16 * 2])

        d = hh(d, a, b, c, mj=item[4], s=SHH[1], ti=T[5 + 16 * 2])

        c = hh(c, d, a, b, mj=item[7], s=SHH[2], ti=T[6 + 16 * 2])

        b = hh(b, c, d, a, mj=item[10], s=SHH[3], ti=T[7 + 16 * 2])

        a = hh(a, b, c, d, mj=item[13], s=SHH[0], ti=T[8 + 16 * 2])

        d = hh(d, a, b, c, mj=item[0], s=SHH[1], ti=T[9 + 16 * 2])

        c = hh(c, d, a, b, mj=item[3], s=SHH[2], ti=T[10 + 16 * 2])

        b = hh(b, c, d, a, mj=item[6], s=SHH[3], ti=T[11 + 16 * 2])

        a = hh(a, b, c, d, mj=item[9], s=SHH[0], ti=T[12 + 16 * 2])

        d = hh(d, a, b, c, mj=item[12], s=SHH[1], ti=T[13 + 16 * 2])

        c = hh(c, d, a, b, mj=item[15], s=SHH[2], ti=T[14 + 16 * 2])

        b = hh(b, c, d, a, mj=item[2], s=SHH[3], ti=T[15 + 16 * 2])

        # Round 4 --->7

        a = ii(a, b, c, d, mj=item[0], s=SII[0], ti=T[0 + 16 * 3])

        d = ii(d, a, b, c, mj=item[7], s=SII[1], ti=T[1 + 16 * 3])

        c = ii(c, d, a, b, mj=item[14], s=SII[2], ti=T[2 + 16 * 3])

        b = ii(b, c, d, a, mj=item[5], s=SII[3], ti=T[3 + 16 * 3])

        a = ii(a, b, c, d, mj=item[12], s=SII[0], ti=T[4 + 16 * 3])

        d = ii(d, a, b, c, mj=item[3], s=SII[1], ti=T[5 + 16 * 3])

        c = ii(c, d, a, b, mj=item[10], s=SII[2], ti=T[6 + 16 * 3])

        b = ii(b, c, d, a, mj=item[1], s=SII[3], ti=T[7 + 16 * 3])

        a = ii(a, b, c, d, mj=item[8], s=SII[0], ti=T[8 + 16 * 3])

        d = ii(d, a, b, c, mj=item[15], s=SII[1], ti=T[9 + 16 * 3])

        c = ii(c, d, a, b, mj=item[6], s=SII[2], ti=T[10 + 16 * 3])

        b = ii(b, c, d, a, mj=item[13], s=SII[3], ti=T[11 + 16 * 3])

        a = ii(a, b, c, d, mj=item[4], s=SII[0], ti=T[12 + 16 * 3])

        d = ii(d, a, b, c, mj=item[11], s=SII[1], ti=T[13 + 16 * 3])

        c = ii(c, d, a, b, mj=item[2], s=SII[2], ti=T[14 + 16 * 3])

        b = ii(b, c, d, a, mj=item[9], s=SII[3], ti=T[15 + 16 * 3])

        A = (a + A) & 0xffffffff

        B = (b + B) & 0xffffffff

        C = (c + C) & 0xffffffff

        D = (d + D) & 0xffffffff

    result = reverse_hex(hex(A)) + reverse_hex(hex(B)) + reverse_hex(hex(C)) + reverse_hex(hex(D))

    return result

def md5_encrypt(plain_txt):

    return main_loop(plain_txt)

golang 1.8代码

package main

import (

	"fmt"

	"strconv"

)

const Int32Max = 0xffffffff

var T = [64]int{

	0xd76aa478, 0xe8c7b756, 0x242070db, 0xc1bdceee,

	0xf57c0faf, 0x4787c62a, 0xa8304613, 0xfd469501,

	0x698098d8, 0x8b44f7af, 0xffff5bb1, 0x895cd7be,

	0x6b901122, 0xfd987193, 0xa679438e, 0x49b40821,

	0xf61e2562, 0xc040b340, 0x265e5a51, 0xe9b6c7aa,

	0xd62f105d, 0x2441453, 0xd8a1e681, 0xe7d3fbc8,

	0x21e1cde6, 0xc33707d6, 0xf4d50d87, 0x455a14ed,

	0xa9e3e905, 0xfcefa3f8, 0x676f02d9, 0x8d2a4c8a,

	0xfffa3942, 0x8771f681, 0x6d9d6122, 0xfde5380c,

	0xa4beea44, 0x4bdecfa9, 0xf6bb4b60, 0xbebfbc70,

	0x289b7ec6, 0xeaa127fa, 0xd4ef3085, 0x4881d05,

	0xd9d4d039, 0xe6db99e5, 0x1fa27cf8, 0xc4ac5665,

	0xf4292244, 0x432aff97, 0xab9423a7, 0xfc93a039,

	0x655b59c3, 0x8f0ccc92, 0xffeff47d, 0x85845dd1,

	0x6fa87e4f, 0xfe2ce6e0, 0xa3014314, 0x4e0811a1,

	0xf7537e82, 0xbd3af235, 0x2ad7d2bb, 0xeb86d391,

}

var SFF = [4]int{7, 12, 17, 22}

var SGG = [4]int{5, 9, 14, 20}

var SHH = [4]int{4, 11, 16, 23}

var SII = [4]int{6, 10, 15, 21}

func f(x, y, z int) int {

	return x&y | ^x&z

}

func g(x, y, z int) int {

	return x&z | y&^z

}

func h(x, y, z int) int {

	return x ^ y ^ z

}

func i(x, y, z int) int {

	return y ^ (x | ^z)

}

func rol(num, count int) int {

	b := (num & Int32Max) << count

	return (b & Int32Max) + (b >> 32)

}

func ff(a, b, c, d, mj, s, ti int) int {

	return b + rol(a+f(b, c, d)+mj+ti, s)

}

func gg(a, b, c, d, mj, s, ti int) int {

	return b + rol(a+g(b, c, d)+mj+ti, s)

}

func hh(a, b, c, d, mj, s, ti int) int {

	return b + rol(a+h(b, c, d)+mj+ti, s)

}

func ii(a, b, c, d, mj, s, ti int) int {

	return b + rol(a+i(b, c, d)+mj+ti, s)

}

func dec2bitStr(dec, bitLen int) string {

	s := ""

	for dec > 0 {

		rem := dec % 2

		dec = dec / 2

		s = strconv.Itoa(rem) + s

	}

	initLen := len(s)

	for i := 0; i < bitLen-initLen; i++ {

		s = "0" + s

	}

	return s

}

func bitStr2dec(bitStr string) int {

	intVal := 0

	for i := 0; i < len(bitStr); i++ {

		if bitStr[len(bitStr)-i-1] == 49 {

			intVal += nonNegIntPow(2, i)

		}

	}

	return intVal

}

func nonNegIntPow(base, power int) int {

	result := 1

	for i := 0; i < power; i++ {

		result *= base

	}

	return result

}

func littleEndian(str string) string {

	if len(str) < 32 {

		count := 32 - len(str)

		for i := 0; i < count; i++ {

			str = "0" + str

		}

	}

	newStr := str[24:32] + str[16:24] + str[8:16] + str[0:8]

	return newStr

}

func plain2bit(plain string) [][]int {

	bitStr := ""

	bitStrSlice := make([]string, 0)

	bitStr32 := make([][]int, 0)

	for _, c := range plain {

		bitStr += dec2bitStr(int(c), 8)

	}

	rmd := len(bitStr) % 512

	if rmd == 448 {

		bitStr += "1"

		for i := 0; i < 511; i++ {

			bitStr += "0"

		}

	} else {

		bitStr += "1"

		for i := 0; i < 448-rmd-1; i++ {

			bitStr += "0"

		}

	}

	lenBitStr := dec2bitStr(len(plain)*8, 64)

	bitStr += lenBitStr

	for i := 0; i < len(bitStr)/512; i++ {

		bitStrSlice = append(bitStrSlice, bitStr[i*512:(i+1)*512])

	}

	bitStr32Item := make([]int, 16)

	for i := 0; i < len(bitStrSlice); i++ {

		for j := 0; j < 16; j++ {

			bitStr32Item[j] = bitStr2dec(littleEndian(bitStrSlice[i][j*32 : (j+1)*32]))

		}

		bitStr32 = append(bitStr32, bitStr32Item)

	}

	bitStr32[len(bitStr32)-1][len(bitStr32[len(bitStr32)-1])-2] = bitStr2dec(lenBitStr[32:64])

	bitStr32[len(bitStr32)-1][len(bitStr32[len(bitStr32)-1])-1] = bitStr2dec(lenBitStr[0:32])

	return bitStr32

}

func md5Loop(plain string) string {

	A := 0x67452301

	B := 0xefcdab89

	C := 0x98badcfe

	D := 0x10325476

	bitStr32Arr := plain2bit(plain)

	for _, item := range bitStr32Arr {

		a := A

		b := B

		c := C

		d := D

		a = ff(a, b, c, d, item[0], SFF[0], T[0])

		d = ff(d, a, b, c, item[1], SFF[1], T[1])

		c = ff(c, d, a, b, item[2], SFF[2], T[2])

		b = ff(b, c, d, a, item[3], SFF[3], T[3])

		a = ff(a, b, c, d, item[4], SFF[0], T[4])

		d = ff(d, a, b, c, item[5], SFF[1], T[5])

		c = ff(c, d, a, b, item[6], SFF[2], T[6])

		b = ff(b, c, d, a, item[7], SFF[3], T[7])

		a = ff(a, b, c, d, item[8], SFF[0], T[8])

		d = ff(d, a, b, c, item[9], SFF[1], T[9])

		c = ff(c, d, a, b, item[10], SFF[2], T[10])

		b = ff(b, c, d, a, item[11], SFF[3], T[11])

		a = ff(a, b, c, d, item[12], SFF[0], T[12])

		d = ff(d, a, b, c, item[13], SFF[1], T[13])

		c = ff(c, d, a, b, item[14], SFF[2], T[14])

		b = ff(b, c, d, a, item[15], SFF[3], T[15])

		a = gg(a, b, c, d, item[1], SGG[0], T[0+16])

		d = gg(d, a, b, c, item[6], SGG[1], T[1+16])

		c = gg(c, d, a, b, item[11], SGG[2], T[2+16])

		b = gg(b, c, d, a, item[0], SGG[3], T[3+16])

		a = gg(a, b, c, d, item[5], SGG[0], T[4+16])

		d = gg(d, a, b, c, item[10], SGG[1], T[5+16])

		c = gg(c, d, a, b, item[15], SGG[2], T[6+16])

		b = gg(b, c, d, a, item[4], SGG[3], T[7+16])

		a = gg(a, b, c, d, item[9], SGG[0], T[8+16])

		d = gg(d, a, b, c, item[14], SGG[1], T[9+16])

		c = gg(c, d, a, b, item[3], SGG[2], T[10+16])

		b = gg(b, c, d, a, item[8], SGG[3], T[11+16])

		a = gg(a, b, c, d, item[13], SGG[0], T[12+16])

		d = gg(d, a, b, c, item[2], SGG[1], T[13+16])

		c = gg(c, d, a, b, item[7], SGG[2], T[14+16])

		b = gg(b, c, d, a, item[12], SGG[3], T[15+16])

		a = hh(a, b, c, d, item[5], SHH[0], T[0+16*2])

		d = hh(d, a, b, c, item[8], SHH[1], T[1+16*2])

		c = hh(c, d, a, b, item[11], SHH[2], T[2+16*2])

		b = hh(b, c, d, a, item[14], SHH[3], T[3+16*2])

		a = hh(a, b, c, d, item[1], SHH[0], T[4+16*2])

		d = hh(d, a, b, c, item[4], SHH[1], T[5+16*2])

		c = hh(c, d, a, b, item[7], SHH[2], T[6+16*2])

		b = hh(b, c, d, a, item[10], SHH[3], T[7+16*2])

		a = hh(a, b, c, d, item[13], SHH[0], T[8+16*2])

		d = hh(d, a, b, c, item[0], SHH[1], T[9+16*2])

		c = hh(c, d, a, b, item[3], SHH[2], T[10+16*2])

		b = hh(b, c, d, a, item[6], SHH[3], T[11+16*2])

		a = hh(a, b, c, d, item[9], SHH[0], T[12+16*2])

		d = hh(d, a, b, c, item[12], SHH[1], T[13+16*2])

		c = hh(c, d, a, b, item[15], SHH[2], T[14+16*2])

		b = hh(b, c, d, a, item[2], SHH[3], T[15+16*2])

		a = ii(a, b, c, d, item[0], SII[0], T[0+16*3])

		d = ii(d, a, b, c, item[7], SII[1], T[1+16*3])

		c = ii(c, d, a, b, item[14], SII[2], T[2+16*3])

		b = ii(b, c, d, a, item[5], SII[3], T[3+16*3])

		a = ii(a, b, c, d, item[12], SII[0], T[4+16*3])

		d = ii(d, a, b, c, item[3], SII[1], T[5+16*3])

		c = ii(c, d, a, b, item[10], SII[2], T[6+16*3])

		b = ii(b, c, d, a, item[1], SII[3], T[7+16*3])

		a = ii(a, b, c, d, item[8], SII[0], T[8+16*3])

		d = ii(d, a, b, c, item[15], SII[1], T[9+16*3])

		c = ii(c, d, a, b, item[6], SII[2], T[10+16*3])

		b = ii(b, c, d, a, item[13], SII[3], T[11+16*3])

		a = ii(a, b, c, d, item[4], SII[0], T[12+16*3])

		d = ii(d, a, b, c, item[11], SII[1], T[13+16*3])

		c = ii(c, d, a, b, item[2], SII[2], T[14+16*3])

		b = ii(b, c, d, a, item[9], SII[3], T[15+16*3])

		A = (a + A) & Int32Max

		B = (b + B) & Int32Max

		C = (c + C) & Int32Max

		D = (d + D) & Int32Max

	}

	aBinStr := littleEndian(dec2bitStr(A, 32))

	bBinStr := littleEndian(dec2bitStr(B, 32))

	cBinStr := littleEndian(dec2bitStr(C, 32))

	dBinStr := littleEndian(dec2bitStr(D, 32))

	md5BinStr := aBinStr + bBinStr + cBinStr + dBinStr

	md5HexStr := strBin2Hex(md5BinStr)

	return md5HexStr

}

func strBin2Hex(str string) string {

	hexStr := ""

	bin2hex := map[string]string{

		"0000": "0", "0001": "1", "0010": "2", "0011": "3",

		"0100": "4", "0101": "5", "0110": "6", "0111": "7",

		"1000": "8", "1001": "9", "1010": "a", "1011": "b",

		"1100": "c", "1101": "d", "1110": "e", "1111": "f",

	}

	for i := 0; i < len(str)/4; i++ {

		hexStr += bin2hex[str[i*4:(i+1)*4]]

	}

	return hexStr

}

func main() {

	str := ""

	fmt.Print("Please input a string to md5 encrypt: ")

	_, err := fmt.Scanln(&str)

	if err != nil {

		return

	}

	res := md5Loop(str)

	fmt.Println(res)

}

md5信息摘要算法实现(python 和 go版本)的更多相关文章

MD5( 信息摘要算法)的概念原理及python代码的实现
简述: message-digest algorithm 5(信息-摘要算法).经常说的“MD5加密”,就是它→信息-摘要算法. md5,其实就是一种算法.可以将一个字符串,或文件,或压缩包,执行md ...
详解 MD5 信息摘要算法
对于软件研发人员来说 MD5 不是一个陌生的词汇,平时的软件研发中,经常使用 MD5 校验消息是否被篡改.验证文件完整性,甚至将MD5当作加密算法使用. MD5虽不陌生,但不是所有研发人员都了解其算法 ...
MD5加密算法（信息摘要算法）、Base64算法
1 什么是MD5 信息摘要算法,可以将字符进行加密,每个加密对象在进行加密后都是等长的应用场景:将用户密码经过MD5加密后再存储到数据库中,这样即使是超级管理员也没有能力知道用户的具体密码是多少:因 ...
信息摘要算法之一：MD5算法解析及实现
MD5即Message-Digest Algorithm 5(信息-摘要算法5),用于确保信息传输完整一致.是计算机广泛使用的杂凑算法之一(又译摘要算法.哈希算法),主流编程语言普遍已有MD5实现. ...
python开发学习-day01 (python安装与版本、字符串、字典、运算符、文件)
*:first-child { margin-top: 0 !important; } body>*:last-child { margin-bottom: 0 !important; } /* ...
信息摘要算法之五：HMAC算法分析与实现
MAC(Message Authentication Code,消息认证码算法)是含有密钥散列函数算法,兼容了MD和SHA算法的特性,并在此基础上加上了密钥.因此MAC算法也经常被称作HMAC算法. ...
查看python和NumPy版本和安装路径
记录查看Python和NumPy版本以及路径的几条命令 # 查看Python版本及路径 python -V python -c "import sys;print(sys.executabl ...
信息摘要算法 MessageDigestUtil
package com.xgh.message.digest.test; import java.math.BigInteger; import java.security.MessageDigest ...
【Linux】CentOS下升级Python和Pip版本全自动化py脚本
[Linux]CentOS下升级Python和Pip版本全自动化py脚本 CentOS7.6自带py2.7和py3.6 想要安装其它版本的话就要自己重新下载和编译py其它版本并且配置环境,主要是软链接 ...
OpenSSL实现了5种信息摘要算法有哪些？
OpenSSL实现了5种信息摘要算法,分别是MD2.MD5.MDC2.SHA(SHA1)和RIPEMD.SHA算法事实上包括了SHA和SHA1两种信息摘要算法.此外,OpenSSL还实现了DSS标准中 ...

随机推荐

python图片转base64、base64转图片
#图片转base64 import base64 with open("./1.png","rb") as f:#转为二进制格式 base64_data = b ...
提取可执行文件中的调试信息 objcopy --only-keep-debug app app.debug
https://blog.csdn.net/CaspianSea/article/details/17269977 set-debug-directory show-debug-directory i ...
实验1task3
<实验结论> #include <stdio.h> #include <stdlib.h> int main() { int a, b, t; a = 3; b = ...
关于ecplipse中的中文都成乱码的问题
这个问题之前也搞死我了,差不多搞了两个下午才搞好唉,说多了都是泪时间过的有点久,不是很记得了,不过我这个问题是装fx包之前发生的,后来我是改了jdk版本的所以可能会有些不同首先,中文会变成乱码主 ...
JVM运行时内存区
JVM运行时内存区是如何划分的? 方法区(Method Area):存储类的字节码信息.常量池堆区(Heap Area):存储对象 Java方法栈(Stack Area):所有方法运行时,会创建一 ...
vue高级进阶( 三 ) 组件高级用法及最佳实践
vue高级进阶( 三 ) 组件高级用法及最佳实践世界上有太多孤独的人害怕先踏出第一步. ---绿皮书书接上回,上篇介绍了vue组件通信比较有代表性的几种方法,本篇主要讲述一下组件的高级用法和最 ...
testtesttest
test test 2022-09-24 #include<iostream> using namespace std; int main(){ cout<<&qu ...
解决 django channel: zadd() got an unexpected keyword argument 'daphne.response.HzSXMUhzYL!QSfUgrDObf'
在stackoverflow上找到答案 If you are using Redis version 3.0 or above, it will not work with channels vers ...
我和Java这些年的故事(五)
时光荏苒,我来到了IBM.和慕名已久的WebSphere Application Server(WAS)打起了交道. 之前我搞过Weblogic,对应用服务器的特性有了一定的了解.但WAS无疑更为庞大 ...
1.CD冷却效果
CD冷却效果.. 一.将需要用到的图片复制到 PS 中做去色处理,将图片保存为 PNG 格式.如下二.将制作好的图片导入 Unity 中,做成图集三.在虚拟按键上添加 UI - Image 制作 ...

md5信息摘要算法实现(python 和 go版本)

纯手写实现的md5信息摘要算法

python3版本代码

golang 1.8代码

md5信息摘要算法实现(python 和 go版本)的更多相关文章

随机推荐

热门专题