Cómo generar pares de claves SSH con Python

Question

Estoy intentando escribir un script para generar pares de claves de identidad SSH para mí.

from M2Crypto import RSA 
key = RSA.gen_key(1024, 65337) 
key.save_key("/tmp/my.key", cipher=None) 

El archivo /tmp/my.key se ve muy bien ahora.

Ejecutando ssh-keygen -y -f /tmp/my.key > /tmp/my.key.pub Puedo extraer la clave pública.

Mi pregunta es ¿cómo puedo extraer la clave pública de python? Usando key.save_pub_key("/tmp/my.key.pub") ahorra algo como:

-----BEGIN PUBLIC KEY----- 
MFwwDQYJKoZIhvcNAQEBBQADASDASDASDASDBarYRsmMazM1hd7a+u3QeMP 
... 
FZQ7Ic+BmmeWHvvVP4Yjyu1t6vAut7mKkaDeKbT3yiGVUgAEUaWMXqECAwEAAQ== 
-----END PUBLIC KEY----- 

cuando estoy buscando algo como:

ssh-rsa AAAABCASDDBM$%3WEAv/3%$F ..... OSDFKJSL43$%^DFg== 

Answer 1

se puede obtener el AAAA ... Dfg == cadena fuera de él, mientras que es un objeto? Si es así, simplemente puede abrir un archivo usted mismo y guardarlo en lugar de usar la función incorporada save_pub_key.

Answer 2

sólo una suposición ... pero ¿ha intentado algo como esto ?:

print "ssh-rsa " + "".join([ l.strip() for l in open('/tmp/my.key.pub') if not l.startswith('-----')]) 

Answer 3

No sé de tal biblioteca en Python.

Puede que la biblioteca paramiko sea útil (también available from PyPI). Implementa el protocolo SSH, y tiene funcionalidad para manejar claves existentes, pero no las genera.

La generación de claves puede ser una adición útil a esa biblioteca (podría work with the developers incorporarla en la biblioteca), y un inicio más fácil que hacerlo desde cero.

Answer 4

¿Qué le parece usar subprocess para invocar ssh-keygen?

from subprocess import Popen, PIPE 
import shlex 

def get_pub_key(path): 
    args = shlex.split('ssh-keygen -y -f') 
    args.append(path) 
    p = Popen(args, stdout=PIPE) 
    stdout = p.communicate()[0] 
    if p.returncode != 0: 
     raise Exception("Error handling would be nice, eh?") 
    return stdout.strip() 

print get_pub_key('/tmp/my.key') 

El pequeño programa anterior producirá una salida como esta:

ssh-rsa AAAAB3NzaC1yc2EAAAABIwAAAQEA ... 9Jbn6D74JOKpaOU050ltyNRw== 

Answer 5

La clave usada por ssh es sólo base64, no sé M2Crypto mucho, pero después de una rápida visión general se parece que podría hacer lo que quiere de esta manera:

import os 
from base64 import b64encode 
from M2Crypto import RSA    

key = RSA.gen_key(1024, 65537) 
raw_key = key.pub()[1] 
b64key = b64encode(raw_key) 

username = os.getlogin() 
hostname = os.uname()[1] 
keystring = 'ssh-rsa %s %s@%s' % (b64key, username, hostname) 

with open(os.getenv('HOME')+'/.ssh/id_rsa.pub') as keyfile: 
    keyfile.write(keystring) 

no he probado la clave generada con SSH, así que por favor, hágamelo saber si funciona (que debe pensar i)

Answer 6

La base 64 decodifica versión de salida de ssh-keygen al contenido de key.pub() el formato del archivo de claves es

b64encode('\x00\x00\x00\x07ssh-rsa%s%s' % (key.pub()[0], key.pub()[1])) 

Answer 7

Edición 05/09/2012:

me di cuenta de que pycrypto ya con esto:

import os 
from Crypto.PublicKey import RSA 

key = RSA.generate(2048, os.urandom) 
print key.exportKey('OpenSSH') 

este código funciona para mí:

import os 
from Crypto.PublicKey import RSA 

key = RSA.generate(2048, os.urandom) 

# Create public key.                                    
ssh_rsa = '00000007' + base64.b16encode('ssh-rsa') 

# Exponent.                                       
exponent = '%x' % (key.e,) 
if len(exponent) % 2: 
    exponent = '0' + exponent 

ssh_rsa += '%08x' % (len(exponent)/2,) 
ssh_rsa += exponent 

modulus = '%x' % (key.n,) 
if len(modulus) % 2: 
    modulus = '0' + modulus 

if modulus[0] in '89abcdef': 
    modulus = '00' + modulus 

ssh_rsa += '%08x' % (len(modulus)/2,) 
ssh_rsa += modulus 

public_key = 'ssh-rsa %s' % (
    base64.b64encode(base64.b16decode(ssh_rsa.upper())),) 

Answer 8

Aquí hay un ejemplo que usa la biblioteca Twisted Conch que aprovecha PyCrypto debajo de las cubiertas.Puede encontrar la documentación de la API en http://twistedmatrix.com/documents/current/api/twisted.conch.ssh.keys.html:

from twisted.conch.ssh import keys 

# one-time use key 
k="""-----BEGIN RSA PRIVATE KEY----- 
PRIVATE KEY STUFF 
-----END RSA PRIVATE KEY-----""" 

# create pycrypto RSA object 
rsa = keys.RSA.importKey(k) 

# create `twisted.conch.ssh.keys.Key` instance which has some nice helpers 
key = keys.Key(rsa) 

# pull the public part of the key and export an openssh version 
ssh_public = key.public().toString("openssh") 
print ssh_public 

Answer 9

Por si acaso hay algún futuros viajeros que buscan hacer esto. El módulo RSA admite la escritura de la clave pública en formato OpenSSH ahora (posiblemente no en el momento de las publicaciones anteriores). Así que creo que puede hacer lo que necesita con:

from os import chmod 
from Crypto.PublicKey import RSA 

key = RSA.generate(2048) 
with open("/tmp/private.key", 'w') as content_file: 
    chmod("/tmp/private.key", 0600) 
    content_file.write(key.exportKey('PEM')) 
pubkey = key.publickey() 
with open("/tmp/public.key", 'w') as content_file: 
    content_file.write(pubkey.exportKey('OpenSSH')) 

Obviamente no almacenan estás clave privada en/tmp ...

Answer 10

Uso cryptography! pycrypto ya no se encuentra en desarrollo activo y, si es posible, debería estar utilizando la criptografía. Desde junio que es posible generar claves públicas SSH, así:

from cryptography.hazmat.primitives import serialization as crypto_serialization 
from cryptography.hazmat.primitives.asymmetric import rsa 
from cryptography.hazmat.backends import default_backend as crypto_default_backend 

key = rsa.generate_private_key(
    backend=crypto_default_backend(), 
    public_exponent=65537, 
    key_size=2048 
) 
private_key = key.private_bytes(
    crypto_serialization.Encoding.PEM, 
    crypto_serialization.PrivateFormat.PKCS8, 
    crypto_serialization.NoEncryption()) 
public_key = key.public_key().public_bytes(
    crypto_serialization.Encoding.OpenSSH, 
    crypto_serialization.PublicFormat.OpenSSH 
) 

Nota: Se necesita al menos la versión 1.4.0.