Beispiel #1
0
func NewPrivateKeyFromHexBytes(privKeybytes []byte) *PrivateKey {
	pk := new(PrivateKey)
	pk.AllocateNew()
	copy(pk.Key[:], privKeybytes)
	pk.Pub.UnmarshalBinary(ed25519.GetPublicKey(pk.Key)[:])
	return pk
}
// New Transaction:  key --
// We create a new transaction, and track it with the user supplied key.  The
// user can then use this key to make subsequent calls to add inputs, outputs,
// and to sign. Then they can submit the transaction.
//
// When the transaction is submitted, we clear it from our working memory.
// Multiple transactions can be under construction at one time, but they need
// their own keys. Once a transaction is either submitted or deleted, the key
// can be reused.
func (AddressFromWords) Execute(state IState, args []string) error {

	if len(args) != 14 {
		return fmt.Errorf("Invalid Parameters")
	}
	name := args[1]

	na := state.GetFS().GetDB().GetRaw([]byte(fct.W_NAME), []byte(name))
	if na != nil {
		return fmt.Errorf("The name %s is already in use.  Names must be unique.", name)
	}

	var mnstr string
	for i := 2; i < 14; i++ {
		if len(args[i]) == 0 {
			return fmt.Errorf("Invalid mnemonic; the %d word has issues", i+1)
		}
		mnstr = mnstr + args[i] + " "
	}

	privateKey, err := wallet.MnemonicStringToPrivateKey(mnstr)
	if err != nil {
		return err
	}

	var fixed [64]byte
	copy(fixed[:], privateKey)
	publicKey := ed25519.GetPublicKey(&fixed)

	state.GetFS().GetWallet().AddKeyPair("fct", []byte(name), publicKey[:], fixed[:], false)

	return nil

}
Beispiel #3
0
// This function pulls the next private key from the deterministic
// private key generator, gets the public key associated with it
// then prepares the generator for the next time a private key is needed.
// To prepare the next state, it sha512s the previous sha512 output.
// It returns a 32 byte public key, a 64 byte private key, and an error condition.
// The private key is the SUPERCOP style with the private key in the first 32 bytes
// and the public key is the last 32 bytes.
// The public key essentially returns twice because of this.
func (w *SCWallet) generateKey() (public []byte, private []byte, err error) {

	keypair := new([64]byte)
	// the secret part of the keypair is the top 32 bytes of the sha512 hash
	copy(keypair[:32], w.GetSeed()[:32])
	// the crypto library puts the pubkey in the lower 32 bytes and returns the same 32 bytes.
	pub := ed25519.GetPublicKey(keypair)

	return pub[:], keypair[:], err
}
func MakeFEREntryWithHeightFromContent(passedResidentHeight uint32, passedTargetActivationHeight uint32,
	passedTargetPrice uint64, passedExpirationHeight uint32, passedPriority uint32) *FEREntryWithHeight {

	// Create and format the signing private key
	var signingPrivateKey [64]byte
	SigningPrivateKey := "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
	signingBytes, err := hex.DecodeString(SigningPrivateKey)
	if err != nil {
		fmt.Println("Signing private key isn't parsable")
		return nil
	}
	copy(signingPrivateKey[:], signingBytes[:])
	_ = ed.GetPublicKey(&signingPrivateKey) // Needed to format the public half of the key set

	anFEREntry := new(specialEntries.FEREntry)

	anFEREntry.SetExpirationHeight(passedExpirationHeight)
	anFEREntry.SetTargetActivationHeight(passedTargetActivationHeight)
	anFEREntry.SetPriority(passedPriority)
	anFEREntry.SetTargetPrice(passedTargetPrice)

	entryJson, err := json.Marshal(anFEREntry)
	if err != nil {
		fmt.Println("Bad marshal of anFEREntry")
		return nil
	}

	// Create the factom entry with the signing private key
	signingSignature := ed.Sign(&signingPrivateKey, entryJson)

	// Make a new factom entry and populate it
	anEntry := new(factom.Entry)
	anEntry.ChainID = "111111118d918a8be684e0dac725493a75862ef96d2d3f43f84b26969329bf03"
	anEntry.ExtIDs = append(anEntry.ExtIDs, signingSignature[:])
	anEntry.Content = entryJson

	// ce := common.NewEntry()
	emb, _ := anEntry.MarshalBinary()
	// ce.UnmarshalBinary(emb)

	EBEntry := entryBlock.NewEntry()
	_, err = EBEntry.UnmarshalBinaryData(emb)
	if err != nil {
		fmt.Println("Error 3:  couldn't unmarshal binary")
		return nil
	}

	ewh := new(FEREntryWithHeight)
	// Don't set the resident height in the actual FEREntry yet because the state validate loop will handle all that
	ewh.Height = passedResidentHeight
	ewh.AnFEREntry = EBEntry

	return ewh
}
Beispiel #5
0
func Sign(priv, data []byte) []byte {
	priv2 := [64]byte{}
	if len(priv) == 64 {
		copy(priv2[:], priv[:])
	} else if len(priv) == 32 {
		copy(priv2[:], priv[:])
		pub := ed25519.GetPublicKey(&priv2)
		copy(priv2[:], append(priv, pub[:]...)[:])
	} else {
		return nil
	}

	return ed25519.Sign(&priv2, data)[:constants.SIGNATURE_LENGTH]
}
Beispiel #6
0
func GenerateKeyFromPrivateKey(privateKey []byte) (public []byte, private []byte, err error) {
	if len(privateKey) == 64 {
		privateKey = privateKey[:32]
	}
	if len(privateKey) != 32 {
		return nil, nil, fmt.Errorf("Wrong privateKey size")
	}
	keypair := new([64]byte)

	copy(keypair[:32], privateKey[:])
	// the crypto library puts the pubkey in the lower 32 bytes and returns the same 32 bytes.
	pub := ed25519.GetPublicKey(keypair)

	return pub[:], keypair[:], err
}
Beispiel #7
0
// ImportKey <name> <private key>
func (ImportKey) Execute(state IState, args []string) error {

	if len(args) != 3 {
		return fmt.Errorf("Invalid Parameters")
	}
	name := args[1]
	adr := args[2]

	if err := ValidName(name); err != nil {
		return err
	}

	a := state.GetFS().GetDB().GetRaw([]byte(fct.W_NAME), []byte(name))
	if a != nil {
		return fmt.Errorf("That address name is in use.  Specify a different name.")
	}

	fa := fct.ValidateFPrivateUserStr(adr)
	ec := fct.ValidateECPrivateUserStr(adr)
	b, err := hex.DecodeString(adr)
	if err == nil && len(b) != 32 {
		err = fmt.Errorf("wrong length")
	}
	if fa || ec || err == nil {
		var privateKey []byte
		if err != nil {
			privateKey = fct.ConvertUserStrToAddress(adr)
		} else {
			privateKey = b
		}
		var fixed [64]byte
		copy(fixed[:], privateKey)
		publicKey := ed25519.GetPublicKey(&fixed)
		adrtype := "ec"
		if fa {
			adrtype = "fct"
		}
		_, err := state.GetFS().GetWallet().AddKeyPair(adrtype, []byte(name), publicKey[:], privateKey, false)
		if err != nil {
			return err
		}
		return nil
	}

	return fmt.Errorf("Not a valid Private Key; Check that your key is typed correctly")
}
Beispiel #8
0
func PrivateKeyToEDPub(priv []byte) []byte {
	priv2 := new([ed25519.PrivateKeySize]byte)
	copy(priv2[:], priv)
	pub := ed25519.GetPublicKey(priv2)
	return pub[:]
}