felschr/pgp2ssh
1
0
Fork 0
mirror of https://github.com/pinpox/pgp2ssh.git synced 2025-10-10 06:29:53 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

feat: WIP

Browse source
This commit is contained in:
Felix Schröter 2024-03-26 22:25:47 +01:00
parent 89c692f60e
commit 3668cbc2de
Signed by: felschr
GPG key ID: 671E39E6744C807D
3 changed files with 105 additions and 23 deletions
Download patch file Download diff file Expand all files Collapse all files

110
main.go
View file

@ -5,19 +5,22 @@ import (
"fmt"
"log"
"os"
"syscall"
"strings"
"encoding/pem"
"github.com/ProtonMail/go-crypto/openpgp"
"github.com/ProtonMail/go-crypto/openpgp/armor"
"github.com/ProtonMail/go-crypto/openpgp/eddsa"
"github.com/ProtonMail/go-crypto/openpgp/eddsa"
"github.com/ProtonMail/go-crypto/openpgp/packet"
"strings"
"crypto/ed25519"
"errors"
"github.com/Mic92/ssh-to-age/bech32"
"github.com/davecgh/go-spew/spew"
"golang.org/x/term"
"golang.org/x/crypto/curve25519"
"golang.org/x/crypto/ssh"
// "bytes"
// "golang.org/x/crypto/ssh"
// "golang.org/x/crypto/curve25519"
@ -56,8 +59,7 @@ func ed25519PrivateKeyToCurve25519(pk ed25519.PrivateKey) ([]byte, error) {
return out[:curve25519.ScalarSize], nil
}
func SSHPrivateKeyToAge(bytes, passphrase []byte) (*string, error) {
func SSHPrivateKeyToAge(bytes []byte) (*string, error) {
s, err := bech32.Encode("AGE-SECRET-KEY-", bytes)
if err != nil {
return nil, err
@ -67,8 +69,8 @@ func SSHPrivateKeyToAge(bytes, passphrase []byte) (*string, error) {
}
func main() {
keyfile := "./gnupg/test-key.asc"
// TODO turn these into CLI inputs
keyfile := "./priv-gpg"
e, err := readEntity(keyfile)
if err != nil {
@ -77,25 +79,103 @@ func main() {
spew.Config.MaxDepth = 2
spew.Config.Indent = " "
log.Println(reflect.TypeOf(e.PrivateKey.PrivateKey))
castkey, ok := e.PrivateKey.PrivateKey.(*eddsa.PrivateKey)
if !ok {
log.Fatal("failed to cast")
}
spew.Dump(castkey)
log.Println("Keys:")
log.Println("[0]", e.PrimaryKey.KeyIdString() + " (primary)")
for i := 0; i < len(e.Subkeys); i++ {
log.Println(fmt.Sprintf("[%d]", i + 1), e.Subkeys[i].PublicKey.KeyIdString() + " (subkey)")
}
log.Println("Please choose a key by index (default: 0):")
var keyIndex int
_, err = fmt.Scanf("%d", &keyIndex)
if err != nil && err.Error() == "unexpected newline" {
keyIndex = 0
} else if err != nil {
log.Fatal(err)
}
var targetKey *packet.PrivateKey
if keyIndex == 0 {
log.Println(fmt.Sprintf("Continuing with key [%d]", keyIndex), e.PrimaryKey.KeyIdString())
targetKey = e.PrivateKey
} else if keyIndex > 0 {
var subkey = e.Subkeys[keyIndex - 1]
log.Println(fmt.Sprintf("Continuing with key [%d]", keyIndex), subkey.PublicKey.KeyIdString())
targetKey = subkey.PrivateKey
} else {
log.Fatal("Invalid key index")
}
if targetKey.Encrypted {
log.Println("Please enter passphrase to decrypt PGP key:")
bytePassphrase, err := term.ReadPassword(int(syscall.Stdin))
if err != nil {
log.Fatal(err)
}
targetKey.Decrypt(bytePassphrase)
}
log.Println("private key type:", reflect.TypeOf(targetKey.PrivateKey))
castkey, ok := targetKey.PrivateKey.(*eddsa.PrivateKey)
if !ok {
log.Fatal("failed to cast")
}
// spew.Dump(castkey)
// get public key as OpenSSH key
log.Println("public key type:", reflect.TypeOf(castkey.PublicKey))
var pubkey ed25519.PublicKey = castkey.PublicKey.X
agePub, err := bech32.Encode("age", pubkey)
if err != nil {
log.Fatal(err)
}
log.Println("public age key:", string(agePub))
sshPub, err := ssh.NewPublicKey(pubkey)
if err != nil {
log.Fatal(err)
}
// log.Println("public key SSH key wire format:", sshPub.Marshal())
// log.Println("public key SHA256:", ssh.FingerprintSHA256(sshPub))
log.Println("public SSH key:", string(ssh.MarshalAuthorizedKey(sshPub)))
// TODO: are these the correct bytes?
var privkey ed25519.PrivateKey = castkey.D
var privkey ed25519.PrivateKey = castkey.D
// var privkey ed25519.PrivateKey = castkey.MarshalByteSecret()
// var privkey = ed25519.NewKeyFromSeed(castkey.D)
// TODO is this right?
bytes, err := ed25519PrivateKeyToCurve25519(privkey)
if err != nil {
log.Fatal(err)
}
agekey, err := SSHPrivateKeyToAge(bytes, []byte{})
// TODO trying to get private key as age key
agekey, err := SSHPrivateKeyToAge(bytes)
if err != nil {
log.Fatal(err)
}
fmt.Println(*agekey)
// TODO trying to get private key as OpenSSH key
privPem, err := ssh.MarshalPrivateKey(privkey, "")
if err != nil {
log.Fatal(err)
}
if err := pem.Encode(os.Stdout, privPem); err != nil {
log.Fatal(err)
}
// TODO make sure public key is still the same
var priv ed25519.PrivateKey = bytes
var pubkey2 = priv.Public()
// var pubkey2 = privkey.Public()
sshPub2, err := ssh.NewPublicKey(pubkey2)
if err != nil {
log.Fatal(err)
}
log.Println("verify public SSH key:", string(ssh.MarshalAuthorizedKey(sshPub2)))
}