Cgo_dll

package main

import (
	"fmt"
	"strconv"
	"strings"
)
import "C"
type SHA1Context struct {
	M                       string
	Message_Blocklist       [80][4]uint8
	Message_bitBlocklist    [80]string
	Message_bitBlocklistALL string
	index                   int
	size                    int
}

func sha1PadMessage(context *SHA1Context) {
	//pading
	context.size = len(context.M) * 8
	for _, j := range context.M {
		context.Message_bitBlocklistALL += fmt.Sprintf("%08b", j)
	}
	padsize := (448 - context.size - 1 + 512) % 512
	context.Message_bitBlocklistALL += "1" + strings.Repeat("0", padsize) + fmt.Sprintf("%064b", context.size)
	context.size = len(context.Message_bitBlocklistALL)
	for i := 0; i < context.size; i += 8 {
		tmp, _ := strconv.ParseInt(context.Message_bitBlocklistALL[i:i+8], 2, 9)
		context.Message_Blocklist[i/32][i/8%4] = uint8(tmp)
		context.Message_bitBlocklist[i/32] += context.Message_bitBlocklistALL[i : i+8]
		context.index = i/32 + 1
	}
}
func xor(a ...string) string {
	switch len(a) {
	case 2:
		tmp := ""
		for i, j := range a[0] {
			if string(j) != string(a[1][i]) {
				tmp += "1"
			} else {
				tmp += "0"
			}
		}
		return tmp
	default:
		return xor(append(a[2:], xor(a[0], a[1]))...) //...切片解包
	}
}
func and(a ...string) string {
	switch len(a) {
	case 2:
		tmp := ""
		for i, j := range a[0] {
			if string(j) == "1" && string(a[1][i]) == "1" {
				tmp += "1"
			} else {
				tmp += "0"
			}
		}
		return tmp
	default:
		return and(append(a[2:], and(a[0], a[1]))...) //...切片解包
	}
}
func not(a string) string {
	tmp := ""
	for _, j := range a {
		if string(j) == "0" {
			tmp += "1"
		} else {
			tmp += "0"
		}
	}
	return tmp
}
func add(a ...string) string {
	tmp := int64(0)
	for _, j := range a {
		tmq, _ := strconv.ParseInt(j, 2, 33)
		tmp += tmq
	}
	tmo := fmt.Sprintf("%032b", tmp)
	return tmo[len(tmo)-32:]
}
func or(a ...string) string {
	switch len(a) {
	case 2:
		tmp := ""
		for i, j := range a[0] {
			if string(j) == "0" && string(a[1][i]) == "0" {
				tmp += "0"
			} else {
				tmp += "1"
			}
		}
		return tmp
	default:
		return or(append(a[2:], or(a[0], a[1]))...) //...切片解包
	}
}
func rotl(n int, t ...string) string {
	//循环左移

	switch len(t) {
	case 1:
		return t[0][n:32] + t[0][0:n]
	case 2:
		return rotl(n, xor(t[0], t[1]))
	case 3:
		return rotl(n, xor(t[0], t[1]), t[2])
	case 4:
		return rotl(n, xor(t[0], t[1]), xor(t[2], t[3]))
	}
	return "0"
}

func sha1ProcessMessageBlock(context *SHA1Context) {
	//实现数据扩展
	for ; context.index < 80; context.index++ {
		context.Message_bitBlocklist[context.index] = rotl(1, context.Message_bitBlocklist[context.index-3], context.Message_bitBlocklist[context.index-8], context.Message_bitBlocklist[context.index-14], context.Message_bitBlocklist[context.index-16])
		for i := 0; i < 32; i += 8 {
			tmp, _ := strconv.ParseInt(context.Message_bitBlocklist[context.index][i:i+8], 2, 9)
			context.Message_Blocklist[context.index][i/8] = uint8(tmp)
		}

	}
}
func makelist(context SHA1Context) []SHA1Context {
	//用于分组
	var contextlist []SHA1Context
	for i := 0; i < context.size/512; i++ {
		var tmpbyte [80][4]byte
		var tmpstr [80]string
		for j := 0; j < 16; j++ {
			tmpbyte[j] = context.Message_Blocklist[i*16+j]
			tmpstr[j] = context.Message_bitBlocklist[i*16+j]
		}
		tmp := SHA1Context{
			Message_Blocklist:    tmpbyte,
			Message_bitBlocklist: tmpstr,
			size:                 512,
			index:                16,
		}
		contextlist = append(contextlist, tmp)
	}
	return contextlist
}
func sha1_digest(context *SHA1Context) [20]byte {
	hash := []string{
		fmt.Sprintf("%032b", 0x67452301),
		fmt.Sprintf("%032b", 0xEFCDAB89),
		fmt.Sprintf("%032b", 0x98BADCFE),
		fmt.Sprintf("%032b", 0x10325476),
		fmt.Sprintf("%032b", 0xC3D2E1F0)}
	a, b, c, d, e := hash[0], hash[1], hash[2], hash[3], hash[4]
	for i, j := range context.Message_Blocklist {
		w := fmt.Sprintf("%08b%08b%08b%08b", j[0], j[1], j[2], j[3])
		f := ""
		k := ""
		switch {
		case i < 20:
			f = or(and(b, c), and(not(b), d)) //'0b1100001011000100110001110000000'
			//'0b10001000100010001000100010001000'|'0b10000001100100101010001110110'
			k = fmt.Sprintf("%032b", 0x5A827999)
		case i < 40:
			f = xor(b, c, d)
			k = fmt.Sprintf("%032b", 0x6ED9EBA1)
		case i < 60:
			f = or(and(b, c), and(b, d), and(c, d))
			k = fmt.Sprintf("%032b", 0x8F1BBCDC)
		default:
			f = xor(b, c, d)
			k = fmt.Sprintf("%032b", 0xCA62C1D6)

		}
		tmp := add(rotl(5, a), f, e, k, w)
		e, d, c, b, a = d, c, rotl(30, b), a, tmp
	}
	hash[0], hash[1], hash[2], hash[3], hash[4] = add(hash[0], a), add(hash[1], b), add(hash[2], c), add(hash[3], d), add(hash[4], e)
	hash_list2byte_list := func(a [5]string) [20]byte {
		tmp := [20]byte{}
		for i := range a {
			for j := range make([]byte, 4) {
				tmq, _ := strconv.ParseUint(a[i][j*8:j*8+8], 2, 8)
				tmp[i*4+j] = byte(tmq)
			}
		}
		return tmp
	}
	return hash_list2byte_list([5]string(hash))
}
//export Output
func Output(input *C.char) *C.char {
	var context SHA1Context
	context.M = C.GoString(input)//Cstring转GOstring
	sha1PadMessage(&context)
	sha1ProcessMessageBlock(&context)
	tmp:=sha1_digest(&context)
	return C.CString(fmt.Sprintln(tmp))//生成对应字符串的的副本
}
func main() {
	Output(Output(C.CString("123456")))
}