ch4/ch4-01

[giscus[bot]]

ch4/ch4-01

中文版

https://gopl-zh.github.io/ch4/ch4-01.html

[lingengyuan]

练习4.2：
package main

import (
"crypto/sha256"
"crypto/sha512"
"fmt"
"os"
)

func main() {
var flag string
var str = os.Args[1]
if len(os.Args) > 1 {
flag = os.Args[2]
} else {
flag = "256"
}
if flag == "256" {
str256 := sha256.Sum256([]byte(str))
fmt.Printf("%x\n", str256)
} else if flag == "384" {
str384 := sha512.Sum384([]byte(str))
fmt.Printf("%x\n", str384)
} else if flag == "512" {
str512 := sha512.Sum512([]byte(str))
fmt.Printf("%x\n", str512)
}
}

[lingengyuan]

练习4.1：

func PopCount(x, y string) (num int) {
X := sha256.Sum256([]byte(x))
Y := sha256.Sum256([]byte(y))
for i := 0; i < len(X); i++ {
for m := 1; m <= 8; m++ {
if (X[i] >> uint(m)) != (Y[i] >> uint(m)) {
num++
}
}
}
return num
}

[xianren68]

这样比较每一位是否相同应该有问题吧

[xianren68]

4.1

package main

import (
	"crypto/sha256"
	"fmt"
)

func main() {
	c1 := sha256.Sum256([]byte("x"))
	c2 := sha256.Sum256([]byte("X"))
	fmt.Println(differentCount(c1, c2))
}

func differentCount(c1, c2 [32]uint8) (count int) {
	count = 0
	for i, _ := range c1 {
		count += popCount(c1[i], c2[i])
	}
	return
}

// 比较每一个bit位是否相同
func popCount(x, y byte) int {
	count := 0
	for i := 0; i < 8; i++ {
		xb := x % 2
		yb := y % 2
		if xb != yb {
			count++
		}
		x = x >> 1
		y = y >> 1
	}
	return count
}

[xianren68]

4.2

func main() {
	var flag string
	if len(os.Args) > 1 {
		flag = os.Args[1]
	}
	// 标准输入的字符串
	var input string
	fmt.Scanln(&input)
	if flag == "" {
		fmt.Println(sha256.Sum256([]byte(input)))
	} else if flag == "SHA384" {
		fmt.Println(sha512.Sum384([]byte(input)))
	} else if flag == "SHA512" {
		fmt.Println(sha512.Sum512([]byte(input)))
	} else {
		fmt.Println("请输入正确的加密方式")
	}

}

[zb81]

4-2：

go run main.go --method=1
Enter a string: abcd
88d4266fd4e6338d13b845fcf289579d209c897823b9217da3e161936f031589

package main

import (
	"crypto/sha256"
	"crypto/sha512"
	"flag"
	"fmt"
	"log"
)

func main() {

	var method string

	flag.StringVar(&method, "method", "1", "编码方式（1 - SHA256, 2 - SHA384，3 - SHA512）")
	flag.Parse()

	ValidateMethod(method)

	fmt.Print("Enter a string: ")
	var input string
	fmt.Scanln(&input)
	var inputBytes = []byte(input)
	if method == "1" {
		fmt.Printf("%x\n", sha256.Sum256(inputBytes))
	} else if method == "2" {
		fmt.Printf("%x\n", sha512.Sum384(inputBytes))
	} else {
		fmt.Printf("%x\n", sha512.Sum512(inputBytes))
	}
}

func ValidateMethod(m string) {
	if m != "1" && m != "2" && m != "3" {
		log.Fatalf("method %s is not supported.", m)
	}
}

[ReReniao]

练习4.1

package main

import (
	"crypto/sha256"
	"fmt"
)

// 每个8位有几个位为1的对照表
var pc [256]byte

// 初始化pc byte数组
func init() {
	for i := range pc {
		pc[i] = pc[i/2] + byte(i&1)
	}
}

func main() {
	c1 := sha256.Sum256([]byte("X"))
    c2 := sha256.Sum256([]byte("X"))
	fmt.Printf("%d",compareSha256(c1, c2))
}

// 返回有几个1位
func Popcount(x byte) int {
	return int(pc[x])
}


func compareSha256(x, y [32]byte) int{
	count := 0
	for i := 0; i < 8; i++ {  // 每8位对比一次
		count += Popcount((x[i]^y[i]))
	}
	return count
}

[SuperZ3]

练习 4.1
思路，异或后求 1 的个数

package main

import (
	"crypto/sha256"
	"fmt"
)

func popCount(num uint8) int {
	result := 0
	for num > 0 {
		num &= (num - 1)
		result++
	}
	return result
}

func countDiff(a, b [32]uint8) int {
	result := 0
	for i, aValue := range a {
		bValue := b[i]
		diffValue := aValue ^ bValue
		result += popCount(diffValue)
	}
	return result
}

func main() {
	c1 := sha256.Sum256([]byte("x"))
	c2 := sha256.Sum256([]byte("X"))
	diff := countDiff(c1, c2)
	fmt.Println(diff)
}

4.2 没看懂题目，额，，，

[lyb88999]

func HashPopCount(SHA1 [32]uint8, SHA2 [32]uint8) int {
    var same [32]uint8
    for i := 0; i < 32; i++ {
	    // 异或相同为0 不同为1 只需要统计same数组中0的个数就是SHA1和SHA2相同位的个数
	    same[i] = SHA1[i] ^ SHA2[i]
    }
    sum := 0
    for i := 0; i < 32; i++ {
	    for same[i] != 0 {
		    if same[i]&1 == 0 {
			    sum += 1
		    }
		    same[i] >>= 1
	    }
    }
    return sum
}

[xzhHas]

4.1
package main

import (
"crypto/sha256"
"encoding/hex"
"fmt"
)

func sha256Hash(data string) string {
hash := sha256.Sum256([]byte(data))
return hex.EncodeToString(hash[:])
}

func hexToBinary(hexString string) string {
bytes, _ := hex.DecodeString(hexString)
binaryStr := ""
for _, b := range bytes {
// 将b转换为二进制的8位字符串
binaryStr += fmt.Sprintf("%08b", b)
}
return binaryStr
}

func countDifferentBits(hash1, hash2 string) int {
binaryHash1 := hexToBinary(hash1)
binaryHash2 := hexToBinary(hash2)

if len(binaryHash1) != len(binaryHash2) {
	return -1
}

count := 0
for i := range binaryHash1 {
	if binaryHash1[i] != binaryHash2[i] {
		count++
	}
}
return count

}

func main() {
data1 := "example1"
data2 := "example2"

hash1 := sha256Hash(data1)
hash2 := sha256Hash(data2)

fmt.Println("SHA256 Hash 1:", hash1)
fmt.Println("SHA256 Hash 2:", hash2)

fmt.Println(countDifferentBits(hash1, hash2))

}

[hongjiala]

package main

import (
"crypto/sha256"
"fmt"
)

func main() {
c1 := sha256.Sum256([]byte("x"))
c2 := sha256.Sum256([]byte("X"))

count := countDiffBits(c1, c2)
fmt.Printf("%x\n%x\n%t\n%[1]T\n", c1, c2, c1 == c2)
fmt.Println(count)
// Output:
// 2d711642b726b04401627ca9fbac32f5c8530fb1903cc4db02258717921a4881
// 4b68ab3847feda7d6c62c1fbcbeebfa35eab7351ed5e78f4ddadea5df64b8015
// false
// [32]uint8

}

func countDiffBits(c1, c2 [32]byte) int {
count := 0
for i := 0; i < 32; i++ {
for j := 0; j < 8; j++ {
if c1[i]&(1<<uint(j)) != c2[i]&(1<<uint(j)) {
count++
}
}
}
return count
}

[hongjiala]

package main

import (
"crypto/sha256"
"crypto/sha512"
"fmt"
"os"
)

func main() {
var flag string
var str = os.Args[0]
if len(os.Args) > 1 {
flag = os.Args[1]
} else {
flag = "256"
}
switch flag {
case "256":
fmt.Printf("%x\n", sha256.Sum256([]byte(str)))
case "384":
fmt.Printf("%x\n", sha512.Sum384([]byte(str)))
case "512":
fmt.Printf("%x\n", sha512.Sum512([]byte(str)))
default:
fmt.Printf("%x\n", sha256.Sum256([]byte(str)))
}
}