Buch Cover Buch Cover Buch Cover Buch Cover

Web-Code: - Webcode Help

One Time Pad (Algorithmen)

In dieser Aufgabe soll ein beliebiger Text durch das One Time Pad mit einem beliebigen Schlüssel verschlüsselt/ entschlüsselt werden. Dabei soll im Voraus gewählt werden können ob ver- oder entschlüsselt werden soll. Wenn der Schlüssel zu kurz ist, soll eine Fehlermeldung ausgegeben werden. Ist der Schlüssel zu lang, soll einfach der erste Teil genutzt werden.

Zusatz: Generator für zufällige Schlüssel, grafische Oberfläche, Schutz vor 2x verwendeten Schlüsseln

0 Kommentare

Bitte melde dich an um einen Kommentar abzugeben

2 Lösung(en)

import java.io.*;

/******************************************************************************
* <code>                          XORKrypt
* </code> 
* One-time-pad
*
* @author Philipp Gressly (phi)
* @version 0.99 -- 1999-Nov-23 08:00
*/
/* History: 1999-Nov-23 08:00 (first implementations)
*
*  Bugs   : none known.
*******************************************************************************/
public class XORKrypt
{
  byte key[];
  
  /******************************************************************************
  * <code>                          XORKrypt
  * </code> 
  * 
  *
  * @param 
  * @return 
  */
  /* History: 1999-Nov-23 08:00 (first implementations)
  *
  *  Bugs   : none known.
  *******************************************************************************/
  public  XORKrypt(File kFile) throws IOException
  {
    RandomAccessFile raf = new RandomAccessFile(kFile, "r");
    long length = raf.length();
    this.key = new byte[(int) length];
    raf.read(this.key);
    raf.close();
  }  // end method: XORKrypt

  /******************************************************************************
  * <code>                          enkrypt
  * </code> 
  * 
  *
  * @param 
  * @return 
  */
  /* History: 1999-Nov-23 08:08 (first implementations)
  *
  *  Bugs   : none known.
  *******************************************************************************/
  private void enkrypt(File inFile, File outFile) throws IOException
  {
    FileInputStream fis = new FileInputStream(inFile);
    FileOutputStream fos = new FileOutputStream(outFile);
    
    int read = fis.read();
    long pos = 0;
    
  // Anstelle einer Fehlermeldung wird der Schlüssel
  // hier einfach mehrfach verwendet.
  // Dies entspricht der Komplexität der Vigenere Chiffre.
  // Ist das Keyfile länger als der Klartext, dann
  // treten keine Probleme auf.
    while(read >= 0)
    {
      int modPos = (int) (pos % key.length);
      fos.write(read ^ key[modPos]);
      pos++;
      read = fis.read();
    }
    fos.close();
    fis.close();
  }  // end method: enkrypt


  /******************************************************************************
  * <code>                          enkrypt
  * </code> 
  * 
  *
  * @param inFileName 
  * @param outFileName
  */
  /* History: 2000-Aug-30 13:32 (first implementations)
  *
  *  Bugs   : none known.
  *******************************************************************************/
  public void enkrypt(String inFileName, String outFileName) throws Exception
  {
    File inFile  = new File(inFileName );
    File outFile = new File(outFileName);
    enkrypt(inFile, outFile);
  }  // end method: enkrypt


  /******************************************************************************
  * <code>                          main
  * </code> 
  * 
  *
  * @param 
  * @return 
  */
  /* History: 1999-Nov-23 08:00 (first implementations)
  *
  *  Bugs   : none known.
  *******************************************************************************/
  public static void main(String[] args)
  {
    boolean multi = false;
    XORKrypt xorKrypt;
    
    if(args.length != 3)
    {
      System.out.println("Usage: XORKrypt <keyfile> <inpostfix | infile> <outfilemask>");
      System.out.println("Example 1: java XORKrypt F1.key original.txt krypt.txt");
      System.out.println("Example 2: java XORKrypt F1.key \"*.txt\" \"*.kpt\"");

    }
    else
    {
      File keyFile = new File(args[0]);
     
      if(args[1].startsWith("*.") && args[2].startsWith("*."))
	multi = true;
     
      try {
	xorKrypt = new XORKrypt(keyFile);
      }
      catch(IOException ioe)
      {
	System.out.println("Error in Krypt-File: " + ioe);
	return;
      }

      if(! multi) {
        
        try {
          xorKrypt.enkrypt(args[1], args[2]);
	} catch (Exception e) {
	  System.out.println("Exception while converting: " + e);
	}
      }
      else {
	final String inFilterString = args[1].substring(1);
        final String outFilterString = args[2].substring(1);
	System.out.println("inFilterstring = " + inFilterString);
     
        FilenameFilter fnf = new FilenameFilter() {
                              public boolean accept(File dir, String name)
                              {
				return name.endsWith(inFilterString);
			      }
	  };
        File dir = new File (".");
	
	String inFileNames[] = dir.list(fnf);
	for(int i = 0; i < inFileNames.length; i++)
	{
	  System.out.println("InFileName = " + inFileNames[i]);
	  int li = inFileNames[i].lastIndexOf(inFilterString);
	  String base = inFileNames[i].substring(0, li);
	  //System.out.println("BaseFileName = " + base);
          String outFileName = base + outFilterString;
          System.out.println("processing " + outFileName);
          try {
            xorKrypt.enkrypt(inFileNames[i], outFileName);
           } catch (Exception ex) {
	    System.out.println("Exception while converting: " + ex);
	  }
	}
      }
    }
  } // end main 



}  // end class: XORKrypt
                

Lösung von: Philipp Gressly Freimann (SANTIS Training AG)

package Aufgaben.Encryption;

import java.util.Random;
import java.util.Scanner;

public class OTPEncryption
{

	public static void main(String[] args)
	{
		System.out.println("Geben Sie einen zu verschlüsselnden Text ein: ");
		Scanner scan = new Scanner(System.in);
		
		String teststring = scan.nextLine();
		
		System.out.println(teststring + "\n");
		
		StringBuilder keybuilder = new StringBuilder();
		for(int i = 0; i < teststring.length(); i++)
		{
			keybuilder.append((char)(new Random().nextInt(65535)));
			
		}
	
		System.out.println("Verwendeter Schlüssel: " + keybuilder + "\n");
		String key = new String(keybuilder);
		
		String encryptedString = crypt(teststring, key, true);
		System.out.println("Codierter Text: " + encryptedString + "\n");
		
		String decryptedString = crypt(encryptedString, key, false);
		System.out.println("Decodierter Text: " + decryptedString + "\n");
		
	}
	
	public static String crypt(String text, String key, boolean encrypt)
	{
		StringBuilder encrypted = new StringBuilder();
		char dummy;
		
		for(int i = 0; i < text.length(); i++)
		{
			dummy = text.charAt(i);
			if(encrypt)
			{
				dummy += key.charAt(i);					
			}
			
			else
			{
				dummy -= key.charAt(i);
			}
			encrypted.append(dummy); 
		}
		
		return new String(encrypted);
	}
	
}

                

Lösung von: Name nicht veröffentlicht

Verifikation/Checksumme:

Unverschlüsselt: "Hello World"

Schlüssel: "abaaaaaaay"

Verschlüsselt: "Igmmp Xpsmc" oder "igmmppsmc"

Aktionen

Bewertung

Durchschnittliche Bewertung:

Eigene Bewertung:
Bitte zuerst anmelden

Meta

Zeit: 0.5
Schwierigkeit: Mittel
Webcode: tsrn-xba4
Autor: ()

Download PDF

Download ZIP

Zu Aufgabenblatt hinzufügen