Comment extraire un mot de passe enregistré de Remmina?

32

Je ne me souviens pas de mon mot de passe pour l'un de mes serveurs. J'ai une connexion de travail enregistrée et je veux en obtenir le mot de passe.

De Remmina faq:

Q: Comment sont stockés mes mots de passe? Sont-ils sécurisés?
R: Ils sont cryptés avec 3DES avec une clé générée aléatoirement de 256 bits. Vous devriez garder votre clé en sécurité.

Alors, où puis-je obtenir la clé et où les mots de passe seront-ils stockés?

EDIT: Ok ont ​​constaté qu’ils ne figurent que dans le dossier d’accueil de votre utilisateur sous .remmina. les deux clés privées sont en base64 et je n'arrive pas à obtenir le mot de passe correct lors du déchiffrement ......

linuxnewb
la source

Réponses:

51

J'ai pu utiliser la solution Go de @michaelcochez pour la déchiffrer avec Python:

import base64
from Crypto.Cipher import DES3

secret = base64.decodestring('<STRING FROM remmina.prefs>')
password = base64.decodestring('<STRING FROM XXXXXXX.remmina>')

print DES3.new(secret[:24], DES3.MODE_CBC, secret[24:]).decrypt(password)
Sean Reifschneider
la source
3
Pour des raisons qui me font me déteste me fallait une seule ligne: /: python -c "import base64,sys;from Crypto.Cipher import DES3;pc=open('/home/admalledd/.remmina/remmina.pref').read();pci=pc.index('secret=');secret=pc[pci:pc.index('\n',pci)].split('=',1)[1];cc=open(sys.argv[1]).read();cci=cc.index('password');password=cc[cci:cc.index('\n',cci)].split('=',1)[1];secret,password=base64.decodestring(secret),base64.decodestring(password); print DES3.new(secret[:24], DES3.MODE_CBC, secret[24:]).decrypt(password)" .remmina/1474332312568.remmina. Laissé ici pour la prochaine fois, je pourrais en avoir besoin.
admalledd
Nice one .. Fonctionne très bien
user169015
4
La dernière version de remmina a changé l'emplacement de ces fichiers. Le fichier pref est maintenant à: $ HOME / .config / remmina / et le fichier de connexion est répertorié en bas dans remmina lorsque vous cliquez sur la connexion (par exemple: ~ / .local / share / remmina / 4823893432523.remmina)
Anneau
3
Merci passé, une ligne légèrement mise à jour qui prend deux arguments pour les fichiers. python -c "import base64,sys;from Crypto.Cipher import DES3;pc=open(sys.argv[1]).read();pci=pc.index('secret=');secret=pc[pci:pc.index('\n',pci)].split('=',1)[1];cc=open(sys.argv[2]).read();cci=cc.index('password');password=cc[cci:cc.index('\n',cci)].split('=',1)[1];secret,password=base64.decodestring(secret),base64.decodestring(password); print DES3.new(secret[:24], DES3.MODE_CBC, secret[24:]).decrypt(password)" /tmp/remmina/remmina.pref /tmp/remmina/00000000000.remmina
admalledd
@admalledd Vous devriez vraiment poster ça comme une réponse!
Michael
20

J'ai trouvé la clé dans un fichier appelé ~/.remmina/remmina.prefset les mots de passe cryptés sont dans ~/.remmina/nnnnnnnnnnn.remmina.

J'ai écrit un code (en Go) qui peut être utilisé pour le décryptage:

//Decrypts obfuscated passwords by Remmina - The GTK+ Remote Desktop Client
//written by Michael Cochez
package main

import (
    "crypto/cipher"
    "crypto/des"
    "encoding/base64"
    "fmt"
    "log"
)

//set the variables here

var base64secret = "yoursecret"
var base64password = "theconnectionpassword"

//The secret is used for encrypting the passwords. This can typically be found from ~/.remmina/remmina.pref on the line containing 'secret='.
//"The encrypted password used for the connection. This can typically be found from /.remmina/dddddddddddd.remmina " on the line containing 'password='.
//Copy everything after the '=' sign. Also include final '=' signs if they happen to be there.

//returns a function which can be used for decrypting passwords
func makeRemminaDecrypter(base64secret string) func(string) string {
    //decode the secret
    secret, err := base64.StdEncoding.DecodeString(base64secret)
    if err != nil {
        log.Fatal("Base 64 decoding failed:", err)
    }
    if len(secret) != 32 {
        log.Fatal("the secret is not 32 bytes long")
    }
    //the key is the 24 first bits of the secret
    key := secret[:24]
    //3DES cipher
    block, err := des.NewTripleDESCipher(key)
    if err != nil {
        log.Fatal("Failed creating the 3Des cipher block", err)
    }
    //the rest of the secret is the iv
    iv := secret[24:]
    decrypter := cipher.NewCBCDecrypter(block, iv)

    return func(encodedEncryptedPassword string) string {
        encryptedPassword, err := base64.StdEncoding.DecodeString(encodedEncryptedPassword)
        if err != nil {
            log.Fatal("Base 64 decoding failed:", err)
        }
        //in place decryption
        decrypter.CryptBlocks(encryptedPassword, encryptedPassword)
        return string(encryptedPassword)
    }
}

func main() {

    if base64secret == "yoursecret" || base64password == "theconnectionpassword" {

        log.Fatal("both base64secret and base64password variables must be set")
    }

    decrypter := makeRemminaDecrypter(base64secret)

    fmt.Printf("Passwd : %v\n", decrypter(base64password))

}

Le code peut être exécuté en ligne, mais alors vous faites confiance à golang.org.

michaelcochez
la source
14

Ils sont stockés dans Gnome-Keyring.

Dash-> tapez "clés" -> Mots de passe et clés.

Dans les nouvelles versions de seahorse (alias "Mots de passe et clés"), il faut sélectionner "Affichage" -> "Afficher tout" pour afficher les clés. Recherchez "remmina".

Rinzwind
la source
1
essayé cela déjà ..... aussi je suis en utilisant lxde
linuxnewb
2
Cela est vrai dans certains cas. Essayez ceci si le mot de passe indiqué dans ~/.remmina/nnnnnnnnnnn.remminaest juste ..
Kupiakos
11

J'ai créé un script qui déchiffre automatiquement vos fichiers de mots de passe. La version la plus récente est disponible sur https://github.com/peppelinux/remmina_password_exposer .

#!/usr/bin/python
from Crypto.Cipher import DES3
import base64
import os
import re

from os.path import expanduser
home = expanduser("~")

# costanti :)
REMMINA_FOLDER = os.getenv('REMMINA_FOLDER', home+'/'+'.remmina/')
REMMINA_PREF   = 'remmina.pref'

REGEXP_ACCOUNTS = r'[0-9]{13}\.remmina(.swp)?'
REGEXP_PREF     = r'remmina.pref'

diz = {}

fs = open(REMMINA_FOLDER+REMMINA_PREF)
fso = fs.readlines()
fs.close()

for i in fso:
    if re.findall(r'secret=', i):
        r_secret = i[len(r'secret='):][:-1]
        print 'found secret', r_secret

for f in os.listdir(REMMINA_FOLDER):
    if re.findall(REGEXP_ACCOUNTS, f): 

        o = open( REMMINA_FOLDER+f, 'r')
        fo = o.readlines()
        o.close()

        for i in fo:
            if re.findall(r'password=', i):
                r_password = i[len(r'password='):][:-1]
            if re.findall(r'^name=', i):
                r_name = i.split('=')[1][:-1]
            if re.findall(r'username=', i):
                r_username = i.split('=')[1][:-1]
        #~ print fo
        #~ print 'found', f

        password = base64.decodestring(r_password)
        secret = base64.decodestring(r_secret)

        diz[r_name] = DES3.new(secret[:24], DES3.MODE_CBC, secret[24:]).decrypt(password)
        # print the username and password of the last decryption
        print r_name, r_username, diz[r_name]
peppelinux
la source
2

J'ai créé un script Perl pour décoder les mots de passe remmina. Il extrait votre clé et décode tous vos mots de passe enregistrés (localement).

https://github.com/lepe/scripts/blob/master/decode_remmina.pl (recherchez la version mise à jour)

#!/usr/bin/perl

use strict;
use warnings;
use Crypt::CBC; #Crypt::DES_EDE3
use MIME::Base64;
use File::Slurp;

my $remmina_dir = $ENV{"HOME"} . "/.remmina";
my $remmina_cfg = $remmina_dir . "/remmina.pref";

my $content = read_file($remmina_cfg);
if($content) {
    my ($secret) = $content =~ /^secret=(.*)/m;
    if($secret) {
        my $secret_bin = decode_base64($secret);
        my ($key, $iv) = ( $secret_bin =~ /.{0,24}/gs );
        my @files = <$remmina_dir/*.remmina>;

        my $des = Crypt::CBC->new( 
                -cipher=>'DES_EDE3', 
                -key=>$key, 
                -iv=>$iv,
                -header=>'none', 
                -literal_key=>1,
                -padding=>'null'
        ); 
        if(@files > 0) {
            foreach my $file (@files) {
                my $config = read_file($file);
                my ($password) = $config =~ /^password=(.*)/m;
                my ($name) = $config =~ /^name=(.*)/m;
                my ($host) = $config =~ /^server=(.*)/m;
                my ($user) = $config =~ /^username=(.*)/m;
                my $pass_bin = decode_base64($password);
                my $pass_plain = $des->decrypt( $pass_bin );
                if($pass_plain) {
                    print "$name    $host   $user   $pass_plain\n";
                }
            }
        } else {
            print "Unable to find *.remmina files \n";
        }
    } else {
        print "No secret key found...\n";
    }
} else {
    print "Unable to read content from remmina.pref\n";
}

Vous devrez installer ces paquets (par exemple, en utilisant cpan <PACKAGE>): Crypt::CBC, Crypt::DES_EDE3, MIME::Base64,File::Slurp

Exemple de sortie:

(Nom, hôte, utilisateur, mot de passe: séparés par des tabulations)

Server1 192.168.1.25    administrator   jM822Azss2fake
Server2 192.168.1.88:2899   admin   JaxHaxFakez90
lepe
la source
1

Je devais faire l'inverse et chiffrer les mots de passe pour Remmina en utilisant un script Python. Au cas où quelqu'un en aurait besoin, voici le code:

import base64    
from Crypto.Cipher import DES3

REMMINAPREF_SECRET_B64=b'G5XKhImmX+3MaRAWU920B31AtQLDcWEq+Geq4L+7sES='

def encryptRemminaPass(plain):
    plain = plain.encode('utf-8')
    secret = base64.b64decode(REMMINAPREF_SECRET_B64)
    key = secret[:24]
    iv = secret[24:]
    plain = plain + b"\0" * (8 - len(plain) % 8)
    cipher = DES3.new(key, DES3.MODE_CBC, iv)
    result = cipher.encrypt(plain)
    result = base64.b64encode(result)
    result = result.decode('utf-8')
    return result
PhilippN
la source