Wie extrahiere ich ein gespeichertes Passwort aus Remmina?

32

Ich erinnere mich nicht an mein Passwort für einen meiner Server. Ich habe eine funktionierende Verbindung gespeichert und möchte das Passwort erhalten.

Aus Remmina FAQ:

F: Wie werden meine Passwörter gespeichert? Sind sie sicher?
A: Sie werden mit 3DES mit einem zufällig generierten 256-Bit-Schlüssel verschlüsselt. Sie sollten Ihren Schlüssel sicher aufbewahren.

Woher bekomme ich den Schlüssel und wo werden die Passwörter gespeichert?

EDIT: Ok festgestellt, dass sie nur in Ihrem Benutzerordner unter .remmina sind. beide der private Schlüssel sind in base64 und ich kann nicht scheinen, das Kennwort richtig beim Entschlüsseln zu erhalten ......

linuxnewb
quelle

Antworten:

51

Ich konnte die Go-Lösung von @michaelcochez verwenden, um sie mit Python zu entschlüsseln:

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
quelle
3
Aus Gründen , die ich mich hassen brauchte ich einen Einzeiler: /: 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. Habe ich das nächste Mal hier gelassen, könnte ich es brauchen.
17.
Schön .. Funktioniert ganz gut
user169015
4
Die neueste Version von remmina hat den Speicherort dieser Dateien geändert. Die pref Datei ist jetzt auf: $ HOME / .config / Remmina / und die Verbindungsdatei an der Unterseite in Remmina aufgeführt wird , wenn Sie auf der Verbindung klicken (zB ~ / .local / share / Remmina / 4823893432523.remmina)
Ring
3
Vielen Dank an Sie selbst, ein leicht aktualisierter Einzeiler, der zwei Argumente für die Dateien benötigt. 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
10.
@admalledd Das solltest du wirklich als Antwort posten!
Michael
20

Ich fand den Schlüssel in einer Datei namens ~/.remmina/remmina.prefsund die verschlüsselten Passwörter sind in~/.remmina/nnnnnnnnnnn.remmina .

Ich habe einen Code (in Go) geschrieben, der zur Entschlüsselung verwendet werden kann:

//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))

}

Der Code kann online ausgeführt werden, aber dann vertrauen Sie golang.org.

Michaelcochez
quelle
14

Sie werden in Gnome-Keyring gespeichert.

Strich-> Typ "Schlüssel" -> Passwörter & Schlüssel.

In neueren Versionen von seahorse (auch "Passwörter und Schlüssel" genannt) muss man "Ansicht" -> "Beliebige anzeigen" auswählen, um die Schlüssel zu sehen. Suche nach "remmina".

Rinzwind
quelle
1
habe das schon probiert ..... auch ich benutze lxde
linuxnewb
2
Dies trifft in einigen Fällen zu. Versuchen Sie dies, wenn das in aufgeführte Passwort ~/.remmina/nnnnnnnnnnn.remminanur lautet ..
Kupiakos
11

Ich habe ein Skript erstellt, das Ihre Kennwortdateien automatisch entschlüsselt. Die neueste Version finden Sie unter 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
quelle
2

Ich habe ein Perl-Skript erstellt, um Remmina-Passwörter zu entschlüsseln. Es extrahiert Ihren Schlüssel und decodiert alle Ihre gespeicherten Passwörter (lokal).

https://github.com/lepe/scripts/blob/master/decode_remmina.pl (auf aktualisierte Version prüfen)

#!/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";
}

Sie werden diese Pakete installieren (zum Beispiel unter Verwendung cpan <PACKAGE>): Crypt::CBC, Crypt::DES_EDE3, MIME::Base64,File::Slurp

Beispielausgabe:

(Name, Host, Benutzer, Passwort: Tabulator getrennt)

Server1 192.168.1.25    administrator   jM822Azss2fake
Server2 192.168.1.88:2899   admin   JaxHaxFakez90
Lepe
quelle
1

Ich musste die Passwörter für Remmina mithilfe eines Python-Skripts umkehren und verschlüsseln. Für den Fall, dass es jemand braucht, hier der 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
quelle