Utilisation de java pour chiffrer des entiers

Question

J'essaie de chiffrer certains entiers dans java en utilisant java.security et javax.crypto.

Le problème semble être que la classe Cipher crypte uniquement les tableaux d'octets. Je ne peux pas convertir directement un entier en une chaîne d'octets (ou puis-je?). Quelle est la meilleure façon de procéder?

Devrais-je convertir l'entier en une chaîne et la chaîne en octets []? Cela semble trop inefficace.

Est-ce que quelqu'un connaît une manière rapide/facile ou efficace de le faire?

Faites-le moi savoir s'il vous plaît.

Merci d'avance.

JBU

Answer 1

Vous pouvez activer ints dans un octet [] à l'aide d'un DataOutputStream, comme ceci:

ByteArrayOutputStream baos = new ByteArrayOutputStream(); 
DataOutputStream dos = new DataOutputStream (baos); 
dos.writeInt (i); 
byte[] data = baos.toByteArray(); 
// do encryption 

ensuite pour le déchiffrer plus tard:

byte[] decrypted = decrypt (data); 
ByteArrayInputStream bais = new ByteArrayInputStream (data); 
DataInputStream dis = new DataInputStream (bais); 
int j = dis.readInt(); 

Answer 2

J'ai trouvé ce qui suit code qui peut vous aider, puisque Integer dans Java est toujours de 4 octets.

public static byte[] intToFourBytes(int i, boolean bigEndian) { 
    if (bigEndian) { 
     byte[] data = new byte[4]; 
     data[3] = (byte) (i & 0xFF); 
     data[2] = (byte) ((i >> 8) & 0xFF); 
     data[1] = (byte) ((i >> 16) & 0xFF); 
     data[0] = (byte) ((i >> 24) & 0xFF); 
     return data; 

    } else { 
     byte[] data = new byte[4]; 
     data[0] = (byte) (i & 0xFF); 
     data[1] = (byte) ((i >> 8) & 0xFF); 
     data[2] = (byte) ((i >> 16) & 0xFF); 
     data[3] = (byte) ((i >> 24) & 0xFF); 
     return data; 
    } 
} 

Vous pouvez trouver plus d'informations sur le paramètre bigEndian ici: http://en.wikipedia.org/wiki/Endianness

Answer 3

Vous pouvez également utiliser BigInteger pour la conversion:

BigInteger.valueOf(integer).toByteArray(); 

Answer 4

utiliser juste NIO. Il est conçu pour ce but spécifique. ByteBuffer et IntBuffer feront ce dont vous avez besoin rapidement, efficacement et avec élégance. Il va gérer la conversion big/little endian, les tampons "directs" pour les E/S haute performance, et vous pouvez même mélanger les types de données dans le tampon d'octets.

entiers convertir en octets:

ByteBuffer bbuffer = ByteBuffer.allocate(4*theIntArray.length); 
IntBuffer ibuffer = bbuffer.asIntBuffer(); //wrapper--doesn't allocate more memory 
ibuffer.put(theIntArray);     //add your int's here; can use 
              //array if you want 
byte[] rawBytes = bbuffer.array();   //returns array backed by bbuffer-- 
              //i.e. *doesn't* allocate more memory 

Convertir octets en des nombres entiers:

ByteBuffer bbuffer = ByteBuffer.wrap(rawBytes); 
IntBuffer ibuffer = bbuffer.asIntBuffer(); 
while(ibuffer.hasRemaining()) 
    System.out.println(ibuffer.get());  //also has bulk operators 

Answer 5

créer un tableau de 4 octets et copier le int à la matrice en 4 étapes, avec ANDs bits et bithifting, comme Paulo a dit. Mais rappelez-vous que les algorithmes de blocs tels que AES et DES fonctionnent avec des blocs de 8 ou 16 octets. Vous devrez donc adapter le tableau aux besoins de l'algorithme. Peut-être laisser les 4 premiers octets d'un tableau de 8 octets en tant que 0, et les 4 autres octets contiennent l'entier.

Answer 6

utiliser Just:

Integer.toString(int).getBytes(); 

Assurez-vous que vous utilisez votre int original et getBytes() retourne un tableau d'octets. Pas besoin de faire autre chose compliqué.

Pour reconvertir:

Integer.parseInt(encryptedString);