Une fois pad, le chiffrement et le déchiffrement

Ici vous avez un exemple de travail:

    //convert secret text to byte array
    final byte[] secret = "secret".getBytes()

    final byte[] encoded = new byte[secret.length];
    final byte[] decoded = new byte[secret.length];

    //Generate random key (has to be exchanged)
    final byte[] key = new byte[secret.length];
    new SecureRandom().nextBytes(key);

    //Encrypt
    for (int i = 0; i < secret.length; i++) {
        encoded[i] = (byte) (secret[i] ^ key[i]);
    }

    //Decrypt
    for (int i = 0; i < encoded.length; i++) {
        decoded[i] = (byte) (encoded[i] ^ key[i]);
    }

    assertTrue(Arrays.equals(secret, decoded));

OriginalL'auteur Maciej A. Bednarz

D'abord voici un OTP algorithme spécifié appelé HOTP qui est une norme RFC. Presque tous les autres OTP sont la propriété et nous ne savons pas l'algorithme pour ceux.

http://tools.ietf.org/html/rfc4226

Il y a certains de code java dans la vous pouvez utiliser pour apprendre son fait. Deuxième, si vous allez faire de chiffrement n'utilisez pas de Hasard. Aléatoire est agréable pour les pseudo aléatoire, mais si vous voulez vraiment une bonne source de données aléatoires vous avez besoin d'adopter SecureRandom. C'est une bien meilleure source de nombres aléatoires qui sont adaptés pour les cryto algorithmes.

Pour la conversion de choses à Hex, vous pouvez facilement utiliser

http://docs.oracle.com/javase/1.5.0/docs/api/java/math/BigInteger.html#toString(int)

Ou l'une des variétés de Long.toString(valeur,radix), Entier.toString(valeur,radix), ou d'Octets.toString(valeur,radix).

byte[] bytes = ...;
for( int i = 0; i < bytes.length; i++ ) {
    System.out.println( Integer.toString( bytes[i], 16 );
}

OriginalL'auteur chubbsondubs

https://en.wikipedia.org/wiki/One-time_pad

public static String crypt(String string, String keyString) {
    //convert secret text to byte array
    byte[] bytes = string != null ? string.getBytes() : new byte[0];
    int size = bytes != null ? bytes.length : 0;
    final byte[] encoded = new byte[size];
    final byte[] key = keyString != null ? keyString.getBytes() : new byte[0];
    //loop on input  bytes
    for (int i = 0; i < size; i++) {
        //shift key index 
        //(we assume key can be smaller or equal if larger then adjust)
        int keyi = i >= keySize ? size % (keySize-1) : i;
        //pad
        encoded[i] = (byte) (bytes[i] ^ key[keyi]);
    }
    return new String(encoded);
}

public static void test(String string, String keyString) {
    String encrypt = crypt(string, keyString);
    String decrypt = crypt(encrypt, keyString);
    assert(string.equals(decrypt));
}

• test("test","1234");
• test("test","123");

ps. vous pouvez restructurer par la méthode de tirer des chaînes et de les remplacer par des octets

public static byte[] crypt(byte[] bytes, byte[] key) {
    int size = bytes != null ? bytes.length : 0;
    final byte[] encoded = new byte[size];
    int keySize = key != null ? key.length : 0;
    //loop on input bytes 
    for (int i = 0; i < size; i++) {
        //shift key index (assuming key <= bytes)
        int keyi = i >= keySize ? size % (keySize-1) : i;
        //pad 
        encoded[i] = (byte) (bytes[i] ^ key[keyi]);
    }
    return encoded;
}

OriginalL'auteur ceph3us