felschr/pgp2ssh
1
0
Fork 0
mirror of https://github.com/pinpox/pgp2ssh.git synced 2025-12-08 08:52:50 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

Compare commits

base: felschr:792e3a3f107e6b4da7b96ded5d46b69efc45d8c1
Branches Tags
felschr:main
..
compare: felschr:815c00db15664512705f7cb7b36469b099fdc3eb
Branches Tags
felschr:main

No commits in common. "792e3a3f107e6b4da7b96ded5d46b69efc45d8c1" and "815c00db15664512705f7cb7b36469b099fdc3eb" have entirely different histories.
792e3a3f10 ... 815c00db15

1 changed files with 25 additions and 55 deletions
Download patch file Download diff file Expand all files Collapse all files

80
main.go
View file

@ -13,12 +13,10 @@ import (
"github.com/ProtonMail/go-crypto/openpgp/packet" "github.com/ProtonMail/go-crypto/openpgp/packet"
"crypto/ed25519" "crypto/ed25519"
"crypto/rsa"
"errors" "errors"
"reflect"
"golang.org/x/crypto/ssh" "golang.org/x/crypto/ssh"
"golang.org/x/term" "golang.org/x/term"
"reflect"
) )
func readEntity(keypath string) (*openpgp.Entity, error) { func readEntity(keypath string) (*openpgp.Entity, error) {
@ -37,48 +35,9 @@ func readEntity(keypath string) (*openpgp.Entity, error) {
} }
var ( var (
UnsupportedKeyType = errors.New("only ed25519 and rsa keys are supported") UnsupportedKeyType = errors.New("only ed25519 keys are supported")
) )
func getEDDSAKey(castkey *eddsa.PrivateKey) []byte {
log.Println("public key type:", reflect.TypeOf(castkey.PublicKey))
var pubkey ed25519.PublicKey = castkey.PublicKey.X
sshPub, err := ssh.NewPublicKey(pubkey)
if err != nil {
log.Fatal(err)
}
log.Println("public SSH key:\n" + string(ssh.MarshalAuthorizedKey(sshPub)))
var privkey = ed25519.NewKeyFromSeed(castkey.D)
privPem, err := ssh.MarshalPrivateKey(&privkey, "")
if err != nil {
log.Fatal(err)
}
return pem.EncodeToMemory(privPem)
}
func getRSAKey(castkey *rsa.PrivateKey) []byte {
log.Println("public key type:", reflect.TypeOf(castkey.PublicKey))
var pubkey rsa.PublicKey = castkey.PublicKey
sshPub, err := ssh.NewPublicKey(&pubkey)
if err != nil {
log.Fatal(err)
}
log.Println("public SSH key:\n" + string(ssh.MarshalAuthorizedKey(sshPub)))
// var privkey = ed25519.NewKeyFromSeed(castkey.D)
privPem, err := ssh.MarshalPrivateKey(castkey, "")
if err != nil {
log.Fatal(err)
}
return pem.EncodeToMemory(privPem)
}
func main() { func main() {
var keyfile string var keyfile string
log.Println("Enter path to private PGP key (default: ./priv.asc):") log.Println("Enter path to private PGP key (default: ./priv.asc):")
@ -97,7 +56,7 @@ func main() {
log.Println("Keys:") log.Println("Keys:")
log.Println("[0]", e.PrimaryKey.KeyIdString()+" (primary)") log.Println("[0]", e.PrimaryKey.KeyIdString()+" (primary)")
for i := 0; i < len(e.Subkeys); i++ { for i := 0; i < len(e.Subkeys); i++ {
log.Println(fmt.Sprintf("[%d]", i+1), e.Subkeys[i].PrivateKey.KeyIdString()+" (subkey)") log.Println(fmt.Sprintf("[%d]", i+1), e.Subkeys[i].PublicKey.KeyIdString()+" (subkey)")
} }
log.Println("Choose key by index (default: 0):") log.Println("Choose key by index (default: 0):")
@ -116,7 +75,7 @@ func main() {
targetKey = e.PrivateKey targetKey = e.PrivateKey
} else if keyIndex > 0 { } else if keyIndex > 0 {
var subkey = e.Subkeys[keyIndex-1] var subkey = e.Subkeys[keyIndex-1]
log.Println(fmt.Sprintf("Continuing with key [%d]", keyIndex), subkey.PrivateKey.KeyIdString()) log.Println(fmt.Sprintf("Continuing with key [%d]", keyIndex), subkey.PublicKey.KeyIdString())
targetKey = subkey.PrivateKey targetKey = subkey.PrivateKey
} else { } else {
log.Fatal("Invalid key index") log.Fatal("Invalid key index")
@ -130,17 +89,28 @@ func main() {
} }
targetKey.Decrypt(bytePassphrase) targetKey.Decrypt(bytePassphrase)
} }
log.Println("private key type:", reflect.TypeOf(targetKey.PrivateKey)) log.Println("private key type:", reflect.TypeOf(targetKey.PrivateKey))
castkey_eddsa, ok_eddsa := targetKey.PrivateKey.(*eddsa.PrivateKey) castkey, ok := targetKey.PrivateKey.(*eddsa.PrivateKey)
if ok_eddsa { if !ok {
privateKeyPem := getEDDSAKey(castkey_eddsa) log.Fatal("failed to cast")
log.Println("Private SSH key:\n" + string(privateKeyPem))
return
} }
castkey_rsa, ok_rsa := targetKey.PrivateKey.(*rsa.PrivateKey)
if ok_rsa { log.Println("public key type:", reflect.TypeOf(castkey.PublicKey))
privateKeyPem := getRSAKey(castkey_rsa) var pubkey ed25519.PublicKey = castkey.PublicKey.X
log.Println("Private SSH key:\n" + string(privateKeyPem))
return sshPub, err := ssh.NewPublicKey(pubkey)
if err != nil {
log.Fatal(err)
} }
log.Println("public SSH key:\n" + string(ssh.MarshalAuthorizedKey(sshPub)))
var privkey = ed25519.NewKeyFromSeed(castkey.D)
privPem, err := ssh.MarshalPrivateKey(&privkey, "")
if err != nil {
log.Fatal(err)
}
privateKeyPem := pem.EncodeToMemory(privPem)
log.Println("Private SSH key:\n" + string(privateKeyPem))
} }