// Key method for ssh.ClientKeyring interface func (k *SimpleKeychain) Key(i int) (ssh.PublicKey, error) { if i < 0 || i >= len(k.keys) { return nil, nil } switch key := k.keys[i].(type) { case *rsa.PrivateKey: return ssh.NewPublicKey(&key.PublicKey) case *dsa.PrivateKey: return ssh.NewPublicKey(&key.PublicKey) } panic("unknown key type") }
func (k *Keychain) Key(i int) (key ssh.PublicKey, err error) { if i < 0 || i >= len(k.keys) { return nil, nil } switch key := k.keys[i].(type) { case *rsa.PrivateKey: return ssh.NewPublicKey(&key.PublicKey) case *dsa.PrivateKey: return ssh.NewPublicKey(&key.PublicKey) } return nil, errors.New("ssh: Unknown key type") }
func (s *stepCreateSSHKey) Run(state multistep.StateBag) multistep.StepAction { client := state.Get("client").(*DigitalOceanClient) ui := state.Get("ui").(packer.Ui) ui.Say("Creating temporary ssh key for droplet...") priv, err := rsa.GenerateKey(rand.Reader, 2014) // ASN.1 DER encoded form priv_der := x509.MarshalPKCS1PrivateKey(priv) priv_blk := pem.Block{ Type: "RSA PRIVATE KEY", Headers: nil, Bytes: priv_der, } // Set the private key in the statebag for later state.Put("privateKey", string(pem.EncodeToMemory(&priv_blk))) // Marshal the public key into SSH compatible format // TODO properly handle the public key error pub, _ := ssh.NewPublicKey(&priv.PublicKey) pub_sshformat := string(ssh.MarshalAuthorizedKey(pub)) // The name of the public key on DO name := fmt.Sprintf("packer-%s", uuid.TimeOrderedUUID()) // Create the key! keyId, err := client.CreateKey(name, pub_sshformat) if err != nil { err := fmt.Errorf("Error creating temporary SSH key: %s", err) state.Put("error", err) ui.Error(err.Error()) return multistep.ActionHalt } // We use this to check cleanup s.keyId = keyId log.Printf("temporary ssh key name: %s", name) // Remember some state for the future state.Put("ssh_key_id", keyId) return multistep.ActionContinue }
// Run executes the Packer build step that generates SSH key pairs. func (s *StepCreateSSHKey) Run(state multistep.StateBag) multistep.StepAction { ui := state.Get("ui").(packer.Ui) ui.Say("Creating temporary SSH key for instance...") priv, err := rsa.GenerateKey(rand.Reader, 2048) if err != nil { err := fmt.Errorf("Error creating temporary ssh key: %s", err) state.Put("error", err) ui.Error(err.Error()) return multistep.ActionHalt } priv_blk := pem.Block{ Type: "RSA PRIVATE KEY", Headers: nil, Bytes: x509.MarshalPKCS1PrivateKey(priv), } pub, err := ssh.NewPublicKey(&priv.PublicKey) if err != nil { err := fmt.Errorf("Error creating temporary ssh key: %s", err) state.Put("error", err) ui.Error(err.Error()) return multistep.ActionHalt } state.Put("ssh_private_key", string(pem.EncodeToMemory(&priv_blk))) state.Put("ssh_public_key", string(ssh.MarshalAuthorizedKey(pub))) if s.Debug { ui.Message(fmt.Sprintf("Saving key for debug purposes: %s", s.DebugKeyPath)) f, err := os.Create(s.DebugKeyPath) if err != nil { state.Put("error", fmt.Errorf("Error saving debug key: %s", err)) return multistep.ActionHalt } // Write out the key err = pem.Encode(f, &priv_blk) f.Close() if err != nil { state.Put("error", fmt.Errorf("Error saving debug key: %s", err)) return multistep.ActionHalt } } return multistep.ActionContinue }
func (self *stepCreateSshKey) Run(state multistep.StateBag) multistep.StepAction { ui := state.Get("ui").(packer.Ui) if self.PrivateKeyFile != "" { ui.Say(fmt.Sprintf("Reading private key file (%s)...", self.PrivateKeyFile)) privateKeyBytes, err := ioutil.ReadFile(self.PrivateKeyFile) if err != nil { state.Put("error", fmt.Errorf("Error loading configured private key file: %s", err)) return multistep.ActionHalt } state.Put("ssh_private_key", string(privateKeyBytes)) return multistep.ActionContinue } client := state.Get("client").(*SoftlayerClient) ui.Say("Creating temporary ssh key for the instance...") rsaKey, err := rsa.GenerateKey(rand.Reader, 2014) if err != nil { ui.Error(err.Error()) state.Put("error", err) return multistep.ActionHalt } // ASN.1 DER encoded form privDer := x509.MarshalPKCS1PrivateKey(rsaKey) privBlk := pem.Block{ Type: "RSA PRIVATE KEY", Headers: nil, Bytes: privDer, } // Set the private key in the statebag for later state.Put("ssh_private_key", string(pem.EncodeToMemory(&privBlk))) pub, err := ssh.NewPublicKey(&rsaKey.PublicKey) if err != nil { ui.Error(err.Error()) state.Put("error", err) return multistep.ActionHalt } publicKey := strings.TrimSpace(string(ssh.MarshalAuthorizedKey(pub))) // The name of the public key label := fmt.Sprintf("packer-%s", uuid.TimeOrderedUUID()) keyId, err := client.UploadSshKey(label, publicKey) if err != nil { ui.Error(err.Error()) state.Put("error", err) return multistep.ActionHalt } self.keyId = keyId state.Put("ssh_key_id", keyId) ui.Say(fmt.Sprintf("Created SSH key with id '%d'", keyId)) return multistep.ActionContinue }
func (s *stepCreateSSHKey) Run(state multistep.StateBag) multistep.StepAction { client := state.Get("client").(*godo.Client) ui := state.Get("ui").(packer.Ui) ui.Say("Creating temporary ssh key for droplet...") priv, err := rsa.GenerateKey(rand.Reader, 2014) // ASN.1 DER encoded form priv_der := x509.MarshalPKCS1PrivateKey(priv) priv_blk := pem.Block{ Type: "RSA PRIVATE KEY", Headers: nil, Bytes: priv_der, } // Set the private key in the statebag for later state.Put("privateKey", string(pem.EncodeToMemory(&priv_blk))) // Marshal the public key into SSH compatible format // TODO properly handle the public key error pub, _ := ssh.NewPublicKey(&priv.PublicKey) pub_sshformat := string(ssh.MarshalAuthorizedKey(pub)) // The name of the public key on DO name := fmt.Sprintf("packer-%s", uuid.TimeOrderedUUID()) // Create the key! key, _, err := client.Keys.Create(&godo.KeyCreateRequest{ Name: name, PublicKey: pub_sshformat, }) if err != nil { err := fmt.Errorf("Error creating temporary SSH key: %s", err) state.Put("error", err) ui.Error(err.Error()) return multistep.ActionHalt } // We use this to check cleanup s.keyId = key.ID log.Printf("temporary ssh key name: %s", name) // Remember some state for the future state.Put("ssh_key_id", key.ID) // If we're in debug mode, output the private key to the working directory. if s.Debug { ui.Message(fmt.Sprintf("Saving key for debug purposes: %s", s.DebugKeyPath)) f, err := os.Create(s.DebugKeyPath) if err != nil { state.Put("error", fmt.Errorf("Error saving debug key: %s", err)) return multistep.ActionHalt } defer f.Close() // Write the key out if _, err := f.Write(pem.EncodeToMemory(&priv_blk)); err != nil { state.Put("error", fmt.Errorf("Error saving debug key: %s", err)) return multistep.ActionHalt } // Chmod it so that it is SSH ready if runtime.GOOS != "windows" { if err := f.Chmod(0600); err != nil { state.Put("error", fmt.Errorf("Error setting permissions of debug key: %s", err)) return multistep.ActionHalt } } } return multistep.ActionContinue }