Fließtext verschluesseln

M

Maddimini

Mitglied
Hallo :),

ich habe eine Implementiereung von RSA gemacht und dazu eine GUI erstellt. Leider kann ich mit meinem Code nur Zahlen verschlüsseln. Ich möchte aber gerne einen Text verschluesseln, wie zB
einen String "Das ist eine geheime Nachricht."
Also muss ich dafür den String in Teile zerlegen, die in ein Array speichern und dann bearbeiten?
Das Ergebnis ist dann aber nicht wieder entschluesselbar :(

Wie kann ich das anstellen?

Vielen Dank schoneinmal! :)
 
M

Maddimini

Mitglied
ja ;)

hier der Code:
Java: 
import java.math.BigInteger;
import java.util.Random;

public class RSAone
{
    BigInteger p,q;  // Primzahlen
    BigInteger n;    // n = p * q
    BigInteger phin; // Eulersche Phi-Funktion
    BigInteger e;    // beliebig mit ggT(e,phi(n))=1 und 1<e<phi(n)
    BigInteger d;    // multiplikativ Inverses zu e bzgl. phi(n)
    
    
    public RSAone()
    {
        // rsa_setup von Hand aufrufen
    }
    
    public void rsa_setup()
    {
        rsa_setup(100);     
    }
        
    public void rsa_setup(int bitLength)
    {
        Random rnd = new Random();
        
        p = BigInteger.probablePrime(bitLength, rnd); 
        q = BigInteger.probablePrime(bitLength, rnd); 
        
        n = p.multiply(q);
        
        phin = p.subtract(BigInteger.ONE).multiply( (q.subtract(BigInteger.ONE)) );
        
        e = new BigInteger(phin.bitLength(), rnd); 
        BigInteger[] xy = new BigInteger[2];
        BigInteger ggT;
        do 
        {
           e = new BigInteger(phin.bitLength(), rnd).add(BigInteger.ONE);  
           xy = erwEuklAlg(e, phin);
           ggT = (e.multiply(xy[0])).add(phin.multiply(xy[1])); 
        }
        while( !(ggT.equals(BigInteger.ONE) && e.compareTo(phin) == -1 && e.compareTo(BigInteger.ONE) == 1 ) );
        
        d = xy[0];
        
        while (d.compareTo(BigInteger.ZERO) < 0) {d = d.add(phin);}
        
    }
    
     /**
     * Erweiterter euklidischer Algorithmus
     */ 
    
    public BigInteger[] erwEuklAlg(BigInteger m, BigInteger n)
    {
        BigInteger[] xy = new BigInteger[2];
        BigInteger[] oldxy =  new BigInteger[2];
        BigInteger[] dr = new BigInteger[2];
        
        dr = n.divideAndRemainder(m);
        
        if (dr[1].equals(BigInteger.ZERO))
        {
           xy[0] = BigInteger.ONE;
           xy[1] = BigInteger.ZERO;
        }
        else
        {
            oldxy = erwEuklAlg(dr[1],m);
            xy[0] = oldxy[1].subtract(oldxy[0].multiply(dr[0]));
            xy[1] = oldxy[0];
        }
        return xy;
    }
    
    /**
     * binaere modulare Exponentiation
     */
    
    
    public BigInteger bme_1(BigInteger geheimText, BigInteger e, BigInteger m)
    {
        e =d;
        return bme(geheimText,  e,  n);
    }
    
    public BigInteger bme(BigInteger b, BigInteger e, BigInteger m)
    {
        BigInteger two = new BigInteger("2"); // Erzeugung einer BigInteger-Konstanten 2.
        BigInteger r = BigInteger.ONE;
        BigInteger p = b;
        BigInteger[] dr = new BigInteger[2];
        
        while (e.compareTo(BigInteger.ZERO) == 1)
        {
            dr = e.divideAndRemainder(two);
            if (!(dr[1].equals(BigInteger.ZERO))) 
            {    
                r = r.multiply(p).mod(m);
            }
            p = p.multiply(p).mod(m);
            e = dr[0];
        }
        
        return r;
    }
    
    /**
     * RSA-Verschluesselung
     */
    
    public BigInteger encrypt(BigInteger y)
    {
        if (y.compareTo(n) == 1) 
        {
            System.out.println("Die Klartext-Zahl muss kleiner n sein!");
            return y;
        }
        else
        {
            return bme(y,e,n);
        }     
    }    
      
    /**
     * RSA-Entschluesselung
     */
    
    public BigInteger decrypt(BigInteger y)
    {
         return bme(y,d,n);        
    }
        
    // Methode, die einen int-Wert in einen BitInteger umwandelt
    public BigInteger int2big(int x)
    {
        return new BigInteger((new Integer(x)).toString());
    }
    
}

und jetzt würde ich gerne anstatt hier einen "BigInteger" zu verschlüsseln einen String erst durch einen BigInteger ausrücken, um ihn zu verschlüsseln und nacher wieder zu entschlüsseln.
 
A

Andi_CH

Top Contributor
Ein char ist nichts anderes als ein Byte, also ein Zahl - wo ist das Problem?

So nebenbei: Ich bin mir nicht ganz sicher, aber ich meine mich daran zu erinnern dass RSA ein Blockcipher ist - damit wäre der nicht besonders gut geeinget für dich.
 

Aktuelle Jobs

Neue Themen


Oben