// Convert ECC-256 Public Key to an EMP address (raw 25 bytes).
func GetAddress(log chan string, x, y *big.Int) []byte {
	pubKey := elliptic.Marshal(elliptic.P256(), x, y)
	ripemd := ripemd160.New()

	sum := sha512.Sum384(pubKey)
	sumslice := make([]byte, sha512.Size384, sha512.Size384)
	for i := 0; i < sha512.Size384; i++ {
		sumslice[i] = sum[i]
	}

	ripemd.Write(sumslice)
	appender := ripemd.Sum(nil)
	appender = appender[len(appender)-20:]
	address := make([]byte, 1, 1)

	// Version 0x01
	address[0] = 0x01
	address = append(address, appender...)

	sum = sha512.Sum384(address)
	sum = sha512.Sum384(sum[:])

	for i := 0; i < 4; i++ {
		address = append(address, sum[i])
	}

	return address
}

func _passpharseHash(passpharse []byte, encodingWay []string) (encodedpasspharse []byte) {
	encodepasspharse := passpharse
	for _, hashalgor := range encodingWay {
		switch hashalgor {
		case "md5":
			sum := md5.Sum(encodepasspharse)
			encodepasspharse = sum[:]
		case "sha1":
			sum := sha1.Sum(encodepasspharse)
			encodepasspharse = sum[:]
		case "sha224":
			sum := sha256.Sum224(encodepasspharse)
			encodepasspharse = sum[:]
		case "sha256":
			sum := sha256.Sum256(encodepasspharse)
			encodepasspharse = sum[:]
		case "sha384":
			sum := sha512.Sum384(encodepasspharse)
			encodepasspharse = sum[:]
		case "sha512":
			sum := sha512.Sum512(encodepasspharse)
			encodepasspharse = sum[:]
		}
	}
	//issue if return with not args,the return value will be null
	return encodepasspharse
}

func main() {
	flag.Parse()
	if len(flag.Args()) != 0 {
		flagutil.UsageErrorf("unknown arguments: %v", flag.Args())
	}

	written := make(map[[sha512.Size384]byte]struct{})

	var skipped uint64
	rd := delimited.NewReader(os.Stdin)
	wr := delimited.NewWriter(os.Stdout)
	for {
		rec, err := rd.Next()
		if err == io.EOF {
			break
		} else if err != nil {
			log.Fatal(err)
		}

		hash := sha512.Sum384(rec)
		if _, ok := written[hash]; ok {
			skipped++
			continue
		}
		if err := wr.Put(rec); err != nil {
			log.Fatal(err)
		}
		written[hash] = struct{}{}
	}
	log.Printf("dedup_stream: skipped %d records", skipped)
}

// Add Purge Token to database, and remove corresponding message if necessary.
func AddPurge(log chan string, p objects.Purge) error {
	mutex.Lock()
	defer mutex.Unlock()

	txid := p.GetBytes()
	hashArr := sha512.Sum384(txid)
	hash := hashArr[:]

	if hashList == nil || dbConn == nil {
		return DBError(EUNINIT)
	}
	hashObj := new(objects.Hash)
	hashObj.FromBytes(hash)

	if Contains(*hashObj) == PURGE {
		return nil
	}

	err := dbConn.Exec("INSERT INTO purge VALUES (?, ?)", hash, txid)
	if err != nil {
		log <- fmt.Sprintf("Error inserting purge into db... %s", err)
		return err
	}

	Add(*hashObj, PURGE)
	return nil
}

func main() {
	length := len(os.Args)
	if length > 2 {
		if os.Args[2] == "-384" {
			c1 := sha512.Sum384([]byte(os.Args[1]))
			fmt.Printf("%s\n%x\n%T\n", os.Args[1], c1, c1)
		} else if os.Args[2] == "-512" {
			c1 := sha512.Sum512([]byte(os.Args[1]))
			fmt.Printf("%s\n%x\n%T\n", os.Args[1], c1, c1)
		} else {
			c1 := sha256.Sum256([]byte(os.Args[1]))
			fmt.Printf("%s\n%x\n%T\n", os.Args[1], c1, c1)
		}
	} else if length == 2 {
		c1 := sha256.Sum256([]byte(os.Args[1]))
		fmt.Printf("%s\n%x\n%T\n", os.Args[1], c1, c1)
	} else {
		fmt.Printf("less arguments")
	}
	// Output:
	// 2d711642b726b04401627ca9fbac32f5c8530fb1903cc4db02258717921a4881
	// 4b68ab3847feda7d6c62c1fbcbeebfa35eab7351ed5e78f4ddadea5df64b8015
	// false
	// [32]uint8
}

// BaseLayerID returns the 64 byte hex ID for the baselayer name.
func (r *RootFS) BaseLayerID() string {
	if r.Type != TypeLayersWithBase {
		panic("tried to get base layer ID without a base layer")
	}
	baseID := sha512.Sum384([]byte(r.BaseLayer))
	return fmt.Sprintf("%x", baseID[:32])
}

// Determine if address is valid (checksum is correct, correct length, and it starts with a 1-byte number).
func ValidateAddress(addr []byte) bool {
	if len(addr) != 25 {
		return false
	}
	ripe := addr[:21]
	sum := sha512.Sum384(ripe)
	sum = sha512.Sum384(sum[:])

	for i := 0; i < 4; i++ {
		if sum[i] != addr[i+21] {
			return false
		}
	}

	return true
}

func main() {
	usage := "Usage: echo -n hello | ./ex02 [256|384|512]"
	bytes, err := ioutil.ReadAll(os.Stdin)
	if err != nil {
		fmt.Println(err)
		os.Exit(1)
	}
	n := 256
	if len(os.Args) == 2 {
		n, _ = strconv.Atoi(os.Args[1])
	}

	switch n {
	case 256:
		fmt.Printf("%x\n", sha256.Sum256(bytes))
		os.Exit(0)
		return
	case 384:
		fmt.Printf("%x\n", sha512.Sum384(bytes))
		os.Exit(0)
		return
	case 512:
		fmt.Printf("%x\n", sha512.Sum512(bytes))
		os.Exit(0)
		return
	default:
		fmt.Println(usage)
		os.Exit(1)
		return
	}
}

func (c *CLI) Run(args []string) int {
	flagSet := flag.NewFlagSet(args[0], flag.ExitOnError)
	flagSet.Usage = func() {
		fmt.Fprintf(os.Stderr, "Usage of %s:\n", args[0])
		flagSet.PrintDefaults()
	}
	hashType := flagSet.String("type", "sha256", "Hash algorithm (sha256, sha384 or sha512)")

	if err := flagSet.Parse(args[1:]); err != nil {
		return ExitCodeParseFlagError
	}

	bytes, err := ioutil.ReadAll(c.inStream)
	if err != nil {
		return ReadStdinError
	}

	switch *hashType {
	case "sha256":
		fmt.Fprintf(c.outStream, "%x\n", sha256.Sum256(bytes))
	case "sha384":
		fmt.Fprintf(c.outStream, "%x\n", sha512.Sum384(bytes))
	case "sha512":
		fmt.Fprintf(c.outStream, "%x\n", sha512.Sum512(bytes))
	default:
		flagSet.Usage()
		return ExitCodeParseFlagError
	}
	return ExitCodeOK
}

func verify(pub *ecdsa.PublicKey, data, sig []byte) bool {
	var unpackedSig ECDSASignature
	_, err := asn1.Unmarshal(sig, &unpackedSig)
	if err != nil {
		return false
	}
	h := sha512.Sum384(data)
	return ecdsa.Verify(pub, h[:], unpackedSig.R, unpackedSig.S)
}

// 返回值：长度120
func _createpasswd(salt, passwd []byte) string {
	var orig []byte

	orig = append(salt, passwd...)
	orig = append(orig, _secret...)
	hsh := sha512.Sum384(orig)

	return hex.EncodeToString(append(salt, hsh[:]...))
}

// GetCustomImageInfos returns the image infos for window specific
// base images which should always be present.
func (d *Driver) GetCustomImageInfos() ([]CustomImageInfo, error) {
	strData, err := hcsshim.GetSharedBaseImages()
	if err != nil {
		return nil, fmt.Errorf("Failed to restore base images: %s", err)
	}

	type customImageInfoList struct {
		Images []CustomImageInfo
	}

	var infoData customImageInfoList

	if err = json.Unmarshal([]byte(strData), &infoData); err != nil {
		err = fmt.Errorf("JSON unmarshal returned error=%s", err)
		logrus.Error(err)
		return nil, err
	}

	var images []CustomImageInfo

	for _, imageData := range infoData.Images {
		folderName := filepath.Base(imageData.Path)

		// Use crypto hash of the foldername to generate a docker style id.
		h := sha512.Sum384([]byte(folderName))
		id := fmt.Sprintf("%x", h[:32])

		if err := d.Create(id, "", "", nil); err != nil {
			return nil, err
		}
		// Create the alternate ID file.
		if err := d.setID(id, folderName); err != nil {
			return nil, err
		}

		imageData.ID = id

		// For now, hard code that all base images except nanoserver depend on win32k support
		if imageData.Name != "NanoServer" {
			imageData.OSFeatures = append(imageData.OSFeatures, "win32k")
		}

		versionData := strings.Split(imageData.Version, ".")
		if len(versionData) != 4 {
			logrus.Warn("Could not parse Windows version %s", imageData.Version)
		} else {
			// Include just major.minor.build, skip the fourth version field, which does not influence
			// OS compatibility.
			imageData.OSVersion = strings.Join(versionData[:3], ".")
		}

		images = append(images, imageData)
	}

	return images, nil
}

func hashBySHA(s string, size int) {
	switch size {
	case 384:
		fmt.Printf("%x\n", sha512.Sum384([]byte(s)))
	case 512:
		fmt.Printf("%x\n", sha512.Sum512([]byte(s)))
	default:
		fmt.Printf("%x\n", sha256.Sum256([]byte(s)))
	}
}

func sign(priv *ecdsa.PrivateKey, data []byte) ([]byte, error) {
	var sig ECDSASignature
	var err error

	h := sha512.Sum384(data)
	sig.R, sig.S, err = ecdsa.Sign(prng, priv, h[:])
	if err != nil {
		return nil, err
	}
	return asn1.Marshal(sig)
}

func main() {

	flag.Parse()

	if *t {
		fmt.Printf("SHA384 = %x\n", sha512.Sum384([]byte(os.Args[1])))
	} else if *f {
		fmt.Printf("SHA512 = %x\n", sha512.Sum512([]byte(os.Args[1])))
	} else {
		fmt.Printf("SHA256 = %x\n", sha256.Sum256([]byte(os.Args[1])))
	}
}

func main() {
	var useType string
	flag.StringVar(&useType, "sha", "256", "256, 384, 512. ")
	flag.Parse()

	arg := []byte(flag.Arg(0))
	switch useType {
	case "384":
		fmt.Printf("%x\n", sha512.Sum384(arg))
	case "512":
		fmt.Printf("%x\n", sha512.Sum512(arg))
	default:
		fmt.Printf("%x\n", sha256.Sum256(arg))
	}
}

func main() {
	scanner := bufio.NewScanner(os.Stdin)
	for scanner.Scan() {
		switch hash {
		case "sha384":
			c := sha512.Sum384(scanner.Bytes())
			fmt.Printf("%x\n", c)
		case "sha512":
			c := sha512.Sum512(scanner.Bytes())
			fmt.Printf("%x\n", c)
		default:
			c := sha256.Sum256(scanner.Bytes())
			fmt.Printf("%x\n", c)
		}
	}
}

func calcSHA(s, opt string) []byte {
	switch opt {
	case "256":
		res := sha256.Sum256([]byte(s))
		return res[:]
	case "384":
		res := sha512.Sum384([]byte(s))
		return res[:]
	case "512":
		res := sha512.Sum512([]byte(s))
		return res[:]
	default:
		fmt.Println("undefined option.")
		return []byte{}
	}
}

func main() {
	flag.Parse()
	var b []byte
	fmt.Printf("input string to see its SHA%d: ", *bit)
	fmt.Scanln(&b)

	switch *bit {
	case 256:
		fmt.Fprintf(os.Stdout, "%x", sha256.Sum256(b))
	case 384:
		fmt.Fprintf(os.Stdout, "%x", sha512.Sum384(b))
	case 512:
		fmt.Fprintf(os.Stdout, "%x", sha512.Sum512(b))
	default:
		fmt.Fprintf(os.Stderr, "unsupported bit")
	}
}

func main() {
	flag.Parse()
	b, err := ioutil.ReadAll(os.Stdin)
	if err != nil {
		panic(err)
	}
	switch *bit {
	case 256:
		fmt.Fprintf(os.Stdout, "%x", sha256.Sum256(b))
	case 384:
		fmt.Fprintf(os.Stdout, "%x", sha512.Sum384(b))
	case 512:
		fmt.Fprintf(os.Stdout, "%x", sha512.Sum512(b))
	default:
		fmt.Fprint(os.Stderr, "unsupported bit")
	}
}