रेमिना से सेव्ड पासवर्ड कैसे निकाले?

Question

मुझे अपने किसी सर्वर के लिए अपना पासवर्ड याद नहीं है। मेरे पास एक कार्यशील कनेक्शन सहेजा गया है और इससे पासवर्ड प्राप्त करना चाहते हैं।

रेमिना फैक से:

प्रश्न: मेरे पासवर्ड कैसे संग्रहीत किए जाते हैं? क्या वे सुरक्षित हैं?
एक: वे एक 256bit बेतरतीब ढंग से उत्पन्न कुंजी के साथ 3DES का उपयोग कर एन्क्रिप्टेड हैं। आपको अपनी चाबी सुरक्षित रखनी चाहिए।

तो मुझे कुंजी कहां मिलेगी और पासवर्ड कहां संग्रहीत किए जाएंगे?

संपादित करें: ओके ने पाया कि वे केवल आपके उपयोगकर्ता के होम फ़ोल्डर में .remmina के तहत हैं। दोनों निजी कुंजी base64 में हैं और मैं डिक्रिप्टिंग करते समय पासवर्ड ठीक से प्राप्त नहीं कर सकता ......

Answer 1

मैं पायथन के साथ इसे डिक्रिप्ट करने के लिए @michaelcochez द्वारा गो समाधान का उपयोग करने में सक्षम था:

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)

Comments

उन कारणों के लिए जो मुझे खुद से नफरत करते हैं मुझे एक-लाइनर की आवश्यकता थी: / 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:। अगली बार जब मुझे इसकी आवश्यकता होगी तो यहां छोड़ दिया जाएगा।

— 16 दाखिला लिया

अच्छा एक .. ठीक काम करता है

— user169015

रीमिना के नवीनतम संस्करण ने इन फाइलों का स्थान बदल दिया है। प्रीफ़ फ़ाइल अब यहाँ है: $ HOME / .config / remmina / और कनेक्शन फ़ाइल को रिमाइना में सबसे नीचे सूचीबद्ध किया जाता है जब आप कनेक्शन पर क्लिक करते हैं (उदाहरण के लिए: ~ / .local / share / remmina / 483893432523.remmina)

— रिंग

पिछले स्वयं धन्यवाद, थोड़ा अद्यतन एक-लाइनर कि फ़ाइलों के लिए दो args लेता है। 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 आपको वास्तव में उत्तर के रूप में पोस्ट करना चाहिए!

— माइकल

Answer 2

मुझे एक फ़ाइल में चाबी मिली ~/.remmina/remmina.prefsऔर एन्क्रिप्टेड पासवर्ड अंदर हैं ~/.remmina/nnnnnnnnnnn.remmina।

मैंने एक कोड (गो में) लिखा था जिसका उपयोग डिक्रिप्शन के लिए किया जा सकता है:

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

}

कोड को ऑनलाइन चलाया जा सकता है, लेकिन फिर आप golang.org पर भरोसा कर रहे हैं।

Answer 3

वे ग्नोम-कीरिंग में संग्रहीत हैं।

डैश-> टाइप "कीज़" -> पासवर्ड और कीज़।

सीहोर के नए संस्करणों में (उर्फ "पासवर्ड और कीज़") में से एक को "व्यू" -> "कोई भी दिखाना" कुंजी को देखना है। "रेमिना" के लिए खोजें।

Comments

कोशिश की कि पहले से ही ..... मैं भी lxde का उपयोग कर रहा हूँ

— linuxnewb

यह कुछ मामलों में सच है। इस प्रयास करें यदि में सूचीबद्ध पासवर्ड ~/.remmina/nnnnnnnnnnn.remminaबस है .।

— कुपियाकोस 15

Answer 4

मैंने एक स्क्रिप्ट बनाई जो स्वचालित रूप से आपकी पासवर्ड फ़ाइलों को डिक्रिप्ट करती है। सबसे हाल का संस्करण 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]

Answer 5

मैंने रीमिना पासवर्ड को डिकोड करने के लिए एक पर्ल स्क्रिप्ट बनाई। यह आपकी कुंजी को निकालता है और आपके सभी सहेजे गए पासवर्ड (स्थानीय रूप से) को डीकोड करता है।

https://github.com/lepe/scripts/blob/master/decode_remmina.pl (अपडेट किए गए संस्करण के लिए जांच करें)

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

आप (, का उपयोग कर उदाहरण के लिए इन पैकेजों को स्थापित करना होगा cpan <PACKAGE>): Crypt::CBC, Crypt::DES_EDE3, MIME::Base64,File::Slurp

नमूना उत्पादन:

(नाम, होस्ट, उपयोगकर्ता, पासवर्ड: टैब अलग)

Server1 192.168.1.25    administrator   jM822Azss2fake
Server2 192.168.1.88:2899   admin   JaxHaxFakez90

Answer 6

मुझे पायथन स्क्रिप्ट का उपयोग करके रेमिना के लिए रिवर्स और एन्क्रिप्ट पासवर्ड करने की आवश्यकता थी। यदि किसी को इसकी आवश्यकता है तो यहां यह कोड है:

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