Try to expose RSA keygen

I've tried this out with my own linux server, and the RSA keys
generated by this with OpenSSH 9.4 are being accepted.

Author: vHanda

bin/git.dart

@@ -49,6 +49,12 @@ void main(List<String> arguments) {
           print("DefaultBranch: $branch");
           break;
       }
+      break;
+    case 'keygen':
+      var (publicKey, privateKey) = bindings.generateRsaKeys();
+      print('Public Key: $publicKey');
+      print('Private Key: $privateKey');
+
       break;
     default:
       print('Unknown command: $command');

lib/go_git_dart.dart

@@ -176,4 +176,27 @@ class GitBindings {
 
     return branch;
   }
+
+  (String, String) generateRsaKeys() {
+    var outputPublicKey = malloc.allocate<Pointer<Char>>(0);
+    var outputPrivateKey = malloc.allocate<Pointer<Char>>(0);
+
+    var retValue = lib.GJGenerateRSAKeys(outputPublicKey, outputPrivateKey);
+    if (retValue != nullptr) {
+      var err = retValue.cast<Utf8>().toDartString();
+      lib.free(retValue.cast());
+
+      throw Exception("GenerateRsaKeys failed with error code: $err");
+    }
+
+    var publicKey = outputPublicKey.value.cast<Utf8>().toDartString();
+    lib.free(outputPublicKey.value.cast());
+    malloc.free(outputPublicKey);
+
+    var privateKey = outputPrivateKey.value.cast<Utf8>().toDartString();
+    lib.free(outputPrivateKey.value.cast());
+    malloc.free(outputPrivateKey);
+
+    return (publicKey, privateKey);
+  }
 }

lib/go_git_dart_bindings_generated.dart

@@ -2190,6 +2190,24 @@ class GoGitDartBindings {
           int,
           ffi.Pointer<ffi.Char>,
           ffi.Pointer<ffi.Pointer<ffi.Char>>)>();
+
+  ffi.Pointer<ffi.Char> GJGenerateRSAKeys(
+    ffi.Pointer<ffi.Pointer<ffi.Char>> publicKey,
+    ffi.Pointer<ffi.Pointer<ffi.Char>> privateKey,
+  ) {
+    return _GJGenerateRSAKeys(
+      publicKey,
+      privateKey,
+    );
+  }
+
+  late final _GJGenerateRSAKeysPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Pointer<ffi.Char>>,
+              ffi.Pointer<ffi.Pointer<ffi.Char>>)>>('GJGenerateRSAKeys');
+  late final _GJGenerateRSAKeys = _GJGenerateRSAKeysPtr.asFunction<
+      ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Pointer<ffi.Char>>,
+          ffi.Pointer<ffi.Pointer<ffi.Char>>)>();
 }
 
 final class __mbstate_t extends ffi.Union {

src/gitjournal.go

@@ -50,6 +50,19 @@ func GitDefaultBranch(remoteUrl *C.char, privateKey *C.char, privateKeyLen C.int
 	return nil
 }
 
+//export GJGenerateRSAKeys
+func GJGenerateRSAKeys(publicKey **C.char, privateKey **C.char) *C.char {
+	publicKeyVal, privateKeyVal, err := generateRSAKeys()
+	if err != nil {
+		return C.CString(err.Error())
+	}
+
+	*publicKey = C.CString(publicKeyVal)
+	*privateKey = C.CString(privateKeyVal)
+
+	return nil
+}
+
 func main() {}
 
 /*

src/keygen.go

@@ -0,0 +1,98 @@
+package main
+
+import (
+	"crypto/rand"
+	"crypto/rsa"
+	"crypto/x509"
+	"encoding/base64"
+	"encoding/pem"
+	"fmt"
+
+	"errors"
+
+	"golang.org/x/crypto/ssh"
+)
+
+// generateRSAKeys generates an RSA public/private key pair
+// and returns them as PEM encoded strings.
+func generateRSAKeys() (string, string, error) {
+	// Generate the private key
+	privateKey, err := rsa.GenerateKey(rand.Reader, 2048*2)
+	if err != nil {
+		return "", "", err
+	}
+
+	// Marshal the private key to DER format
+	privateKeyDER := x509.MarshalPKCS1PrivateKey(privateKey)
+
+	// PEM encode the private key
+	privateKeyBlock := &pem.Block{
+		Type:  "RSA PRIVATE KEY",
+		Bytes: privateKeyDER,
+	}
+	privateKeyPEM := string(pem.EncodeToMemory(privateKeyBlock))
+
+	// Generate the public key
+	publicKey := &privateKey.PublicKey
+
+	// Marshal the public key to DER format
+	publicKeyDER, err := x509.MarshalPKIXPublicKey(publicKey)
+	if err != nil {
+		return "", "", err
+	}
+
+	// PEM encode the public key
+	publicKeyBlock := &pem.Block{
+		Type:  "PUBLIC KEY",
+		Bytes: publicKeyDER,
+	}
+	publicKeyPEM := string(pem.EncodeToMemory(publicKeyBlock))
+	publicKeyOpenSSH, err := PublicPEMtoOpenSSH([]byte(publicKeyPEM))
+	if err != nil {
+		return "", "", err
+	}
+
+	return publicKeyOpenSSH, privateKeyPEM, nil
+}
+
+// Converts PEM public key to OpenSSH format to be used in authorized_keys file
+// Similar to: "ssh-keygen", "-i", "-m", "pkcs8", "-f", auth_keys_new_path
+func PublicPEMtoOpenSSH(pemBytes []byte) (string, error) {
+	// Decode and get the first block in the PEM file.
+	// In our case it should be the Public key block.
+	pemBlock, rest := pem.Decode(pemBytes)
+	if pemBlock == nil {
+		return "", errors.New("invalid PEM public key passed, pem.Decode() did not find a public key")
+	}
+	if len(rest) > 0 {
+		return "", errors.New("PEM block contains more than just public key")
+	}
+
+	// Confirm we got the PUBLIC KEY block type
+	if pemBlock.Type != "PUBLIC KEY" {
+		return "", fmt.Errorf("ssh: unsupported key type %q", pemBlock.Type)
+	}
+
+	// Convert to rsa
+	rsaPubKey, err := x509.ParsePKIXPublicKey(pemBlock.Bytes)
+	if err != nil {
+		return "", fmt.Errorf("x509.parse pki public key: %w", err)
+	}
+
+	// Confirm we got an rsa public key. Returned value is an interface{}
+	sshKey, ok := rsaPubKey.(*rsa.PublicKey)
+	if !ok {
+		return "", fmt.Errorf("invalid PEM passed in from user: %w", err)
+	}
+
+	// Generate the ssh public key
+	pub, err := ssh.NewPublicKey(sshKey)
+	if err != nil {
+		return "", fmt.Errorf("new ssh public key from rsa: %w", err)
+	}
+
+	// Encode to store to file
+	sshPubKey := base64.StdEncoding.EncodeToString(pub.Marshal())
+
+	return "ssh-rsa " + sshPubKey, nil
+}