Criptare stringhe

**Dreamer89** · 20-08-2008, 10:51

Salve. Esiste qualche metodo che consente di criptare e decriptare delle stringhe? Ad esempio, se io volessi salvare del testo su un file di testo, e vorrei rendere illeggibile questo testo... esiste qualcosa del genere? Altrimenti devo creare io un metodo :P

**ziz** · 20-08-2008, 11:39

Esistono vari algoritmi di criptaggio, come l'RSA, il DES, il 3DES, ecc...
Il migliore, per quel che ne so io, è il 3DES, ma non mi pare sia supportato dall'apposita libreria java, quindi dovresti implementarlo tu...
Comunque ti basta fare una googlata e li trovi già implementati!!

Spero di esserti stato utile, ciao!!

**andbin** · 20-08-2008, 16:55

Originariamente inviato da Dreamer89
Esiste qualche metodo che consente di criptare e decriptare delle stringhe? Ad esempio, se io volessi salvare del testo su un file di testo, e vorrei rendere illeggibile questo testo... esiste qualcosa del genere? Altrimenti devo creare io un metodo :P

Puoi usare le API per la crittografia, ad esempio gli stream crittografici CipherOutputStream/CipherInputStream (package javax.crypto).
Non sono difficilissimi da usare (ma bisogna conoscere almeno qualcosina di base sulla crittografia), fai qualche ricerca in rete. Ti posso suggerire il libro "Java I/O" della O'Reilly, che spiega moltissime cose sull'I/O e anche l'uso di queste API (non completamente comunque ... è focalizzato sull'I/O, non sulla crittografia!).

Chiaramente se usi queste API, quello che otterrai non è un file di "testo" ma un file "binario" ovviamente incomprensibile.

**Dreamer89** · 20-08-2008, 17:01

A me servirebbe semplicemente trasformare delle stringhe... credo che mi creerò un sistema io, grazie mille

**Alex'87** · 20-08-2008, 17:17

Io usavo questa classe:

codice:

import java.io.UnsupportedEncodingException;

public class CodeEncodeString
    {
        private static final String[] DEFAULT_KEYS =
        {
        "01210ACB39201293948ABE4839201CDF",
        "123219843895AFDE3920291038103839",
        "89128912093908120983980981098309",
        "AABBCCDD019201920384383728298109"
        };
        
        private static boolean updatedProps = false;
        private static final char[] hexDigits =
        {
        '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C',
        'D', 'E', 'F'
        };
        
        private byte[][] keys = null;
        
        public CodeEncodeString()
        {
            init(CodeEncodeString.DEFAULT_KEYS);
        }
        
        public CodeEncodeString(String[] keystrs)
        {
            init(keystrs);
        }
        
        private void init(String[] keystrs)
        {
            keys = new byte[keystrs.length][];
            for (int i = 0; i < keys.length; i++)
            {
                keys[i] = fromString(keystrs[i]);
            }
        }
        
        private String toString(byte[] ba)
        {
            char[] buf = new char[ba.length * 2];
            int j = 0;
            int k;
            
            for (int i = 0; i < ba.length; i++)
            {
                k = ba[i];
                buf[j++] = hexDigits[(k >>> 4) & 0x0F];
                buf[j++] = hexDigits[k & 0x0F];
            }
            
            return new String(buf);
        }
        
        private int fromDigit(char ch)
        {
            if (ch >= '0' && ch <= '9')
            {
                return ch - '0';
            }
            if (ch >= 'A' && ch <= 'F')
            {
                return ch - 'A' + 10;
            }
            if (ch >= 'a' && ch <= 'f')
            {
                return ch - 'a' + 10;
            }
            
            throw new IllegalArgumentException("invalid hex digit '" + ch + "'");
        }
        
        private byte[] fromString(String hex)
        {
            int len = hex.length();
            byte[] buf = new byte[((len + 1) / 2)];
            
            int i = 0, j = 0;
            if ((len % 2) == 1)
            {
                buf[j++] = (byte) fromDigit(hex.charAt(i++));
            }
            
            while (i < len)
            {
                buf[j++] = (byte) ((fromDigit(hex.charAt(i++)) << 4) |
                                   fromDigit(hex.charAt(i++)));
            }
            
            return buf;
        }
        
        private byte encrypt(byte d, byte[] key)
        {
            byte e;
            
            e = d;
            for (int i = 0; i < key.length; i++)
            {
                e = (byte) ((int) e ^ (int) key[i]);
            }
            
            return e;
        }
        
        private byte decrypt(byte e, byte[] key)
        {
            byte d;
            
            d = e;
            for (int i = key.length - 1; i >= 0; i--)
            {
                d = (byte) ((int) d ^ (int) key[i]);
            }
            
            return d;
        }
        
        public String encrypt(String orig)
        {
            byte[] ect = null;
            int size;
            byte[] origBytes = null;
            
            try
            {
                origBytes = orig.getBytes("UTF-8");
            }
            catch (UnsupportedEncodingException e)
            {
                e.printStackTrace();
                throw new RuntimeException(e.toString());
            }
            
            ect = new byte[origBytes.length];
            for (int i = 0; i < origBytes.length; i += keys.length)
            {
                for (int j = 0; j < keys.length; j++)
                {
                    if ((i + j) >= origBytes.length)
                    {
                        break;
                    }
                    else
                    {
                        ect[i + j] = encrypt(origBytes[i + j], keys[j]);
                    }
                }
            }
            
            return toString(ect);
        }
        
        public String decrypt(String ectstr)
        {
            byte[] ect = null;
            int size;
            byte[] origBytes = null;
            String dctStr = null;
            
            ect = fromString(ectstr);
            origBytes = new byte[ect.length];
            for (int i = 0; i < origBytes.length; i += keys.length)
            {
                for (int j = 0; j < keys.length; j++)
                {
                    if ((i + j) >= origBytes.length)
                    {
                        break;
                    }
                    else
                    {
                        origBytes[i + j] = decrypt(ect[i + j], keys[j]);
                    }
                }
            }
            
            try
            {
                dctStr = new String(origBytes, "UTF-8");
            }
            catch (UnsupportedEncodingException e)
            {
                e.printStackTrace();
                throw new RuntimeException(e.toString());
            }
            
            return dctStr;
        }
        
    }

Vedi se ti è utile. L'utilizzo è molto semplice:

codice:

CodeEncodeString ces = new CodeEncodeString();

String s = "Ciao";
s = ces.encrypt(s);
ces.decrypt(s);

**ziz** · 22-08-2008, 16:15

Originariamente inviato da Alex'87
Io usavo questa classe:

codice:

import java.io.UnsupportedEncodingException;

public class CodeEncodeString
    {
        private static final String[] DEFAULT_KEYS =
        {
        "01210ACB39201293948ABE4839201CDF",
        "123219843895AFDE3920291038103839",
        "89128912093908120983980981098309",
        "AABBCCDD019201920384383728298109"
        };
        
        private static boolean updatedProps = false;
        private static final char[] hexDigits =
        {
        '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C',
        'D', 'E', 'F'
        };
        
        private byte[][] keys = null;
        
        public CodeEncodeString()
        {
            init(CodeEncodeString.DEFAULT_KEYS);
        }
        
        public CodeEncodeString(String[] keystrs)
        {
            init(keystrs);
        }
        
        private void init(String[] keystrs)
        {
            keys = new byte[keystrs.length][];
            for (int i = 0; i < keys.length; i++)
            {
                keys[i] = fromString(keystrs[i]);
            }
        }
        
        private String toString(byte[] ba)
        {
            char[] buf = new char[ba.length * 2];
            int j = 0;
            int k;
            
            for (int i = 0; i < ba.length; i++)
            {
                k = ba[i];
                buf[j++] = hexDigits[(k >>> 4) & 0x0F];
                buf[j++] = hexDigits[k & 0x0F];
            }
            
            return new String(buf);
        }
        
        private int fromDigit(char ch)
        {
            if (ch >= '0' && ch <= '9')
            {
                return ch - '0';
            }
            if (ch >= 'A' && ch <= 'F')
            {
                return ch - 'A' + 10;
            }
            if (ch >= 'a' && ch <= 'f')
            {
                return ch - 'a' + 10;
            }
            
            throw new IllegalArgumentException("invalid hex digit '" + ch + "'");
        }
        
        private byte[] fromString(String hex)
        {
            int len = hex.length();
            byte[] buf = new byte[((len + 1) / 2)];
            
            int i = 0, j = 0;
            if ((len % 2) == 1)
            {
                buf[j++] = (byte) fromDigit(hex.charAt(i++));
            }
            
            while (i < len)
            {
                buf[j++] = (byte) ((fromDigit(hex.charAt(i++)) << 4) |
                                   fromDigit(hex.charAt(i++)));
            }
            
            return buf;
        }
        
        private byte encrypt(byte d, byte[] key)
        {
            byte e;
            
            e = d;
            for (int i = 0; i < key.length; i++)
            {
                e = (byte) ((int) e ^ (int) key[i]);
            }
            
            return e;
        }
        
        private byte decrypt(byte e, byte[] key)
        {
            byte d;
            
            d = e;
            for (int i = key.length - 1; i >= 0; i--)
            {
                d = (byte) ((int) d ^ (int) key[i]);
            }
            
            return d;
        }
        
        public String encrypt(String orig)
        {
            byte[] ect = null;
            int size;
            byte[] origBytes = null;
            
            try
            {
                origBytes = orig.getBytes("UTF-8");
            }
            catch (UnsupportedEncodingException e)
            {
                e.printStackTrace();
                throw new RuntimeException(e.toString());
            }
            
            ect = new byte[origBytes.length];
            for (int i = 0; i < origBytes.length; i += keys.length)
            {
                for (int j = 0; j < keys.length; j++)
                {
                    if ((i + j) >= origBytes.length)
                    {
                        break;
                    }
                    else
                    {
                        ect[i + j] = encrypt(origBytes[i + j], keys[j]);
                    }
                }
            }
            
            return toString(ect);
        }
        
        public String decrypt(String ectstr)
        {
            byte[] ect = null;
            int size;
            byte[] origBytes = null;
            String dctStr = null;
            
            ect = fromString(ectstr);
            origBytes = new byte[ect.length];
            for (int i = 0; i < origBytes.length; i += keys.length)
            {
                for (int j = 0; j < keys.length; j++)
                {
                    if ((i + j) >= origBytes.length)
                    {
                        break;
                    }
                    else
                    {
                        origBytes[i + j] = decrypt(ect[i + j], keys[j]);
                    }
                }
            }
            
            try
            {
                dctStr = new String(origBytes, "UTF-8");
            }
            catch (UnsupportedEncodingException e)
            {
                e.printStackTrace();
                throw new RuntimeException(e.toString());
            }
            
            return dctStr;
        }
        
    }

Vedi se ti è utile. L'utilizzo è molto semplice:

codice:

CodeEncodeString ces = new CodeEncodeString();

String s = "Ciao";
s = ces.encrypt(s);
ces.decrypt(s);

Ottimo codice...complimenti!! è basato su qualche standard o è di tua invenzione?

**Alex'87** · 22-08-2008, 17:41

Originariamente inviato da ziz
Ottimo codice...complimenti!! è basato su qualche standard o è di tua invenzione?

Me lo ha passato qualche anno fa un utente di questo forum. Avevo bisogno di criptare il file delle risposte del compito del mio progetto d'esame

p.s.: Non era necessario quotare tutto il codice ^^'

**ziz** · 22-08-2008, 18:45

Originariamente inviato da Alex'87
p.s.: Non era necessario quotare tutto il codice ^^'

Era troppo bello e non ho saputo resistere!!!

La prossima volta non lo farò, promesso!!

Grazie mille per la risposta!! Ciao!!

Discussione: Criptare stringhe

Strumenti discussione

Ricerca discussione

Visualizza

Criptare stringhe

Re: Criptare stringhe

Permessi di invio