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

3 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

using System;
using System.Linq;

namespace One_Time_Pad
{
    class Program
    {
        static void Main(string[] args)
        {
            while(true)
            {
                Console.WriteLine("[V]erschlüsseln / [E]ntschlüsseln?");
                string Type = Console.ReadLine().ToLower();

                if (Type != "v" && Type != "e") { Console.WriteLine("Der Input ist ungültig."); continue; }

                Console.WriteLine("Schreibe den Text und den Schlüssel (Text;Schlüssel)");
                string[] Inhalt = Console.ReadLine().Split(';');
                string Text = "";
                int Space = 0;

                if (Inhalt[0].Replace(" ",string.Empty).Length > Inhalt[1].Length) { Console.WriteLine("Der Schlüssel darf nicht kürzer als der Text sein"); continue; }

                if (Type == "v")
                {
                    for (int i = 0; i < Inhalt[0].Length; i++)
                    {
                        int ASCII = Convert.ToInt32(Convert.ToChar(Inhalt[0].ToLower()[i]));

                        if (ASCII != 32)
                        {
                            ASCII += Convert.ToChar(Inhalt[1].ToLower()[i-Space]) - 96;

                            if (ASCII - 96 > 26)
                            {
                                ASCII -= 26;
                            }
                        }
                        else Space++;

                        Text += Convert.ToChar(ASCII);

                    }
                }
                else if (Type == "e")
                {
                    for (int i = 0; i < Inhalt[0].Length; i++)
                    {
                        int ASCII = Convert.ToInt32(Convert.ToChar(Inhalt[0].ToLower()[i]));

                        if (ASCII != 32)
                        {
                            ASCII -= Convert.ToChar(Inhalt[1].ToLower()[i-Space]) - 96;

                            if (ASCII - 96 <= 0)
                            {
                                ASCII += 26;
                            }
                        }
                        else Space++;

                        Text += Convert.ToChar(ASCII);
                    }
                }

                Console.WriteLine(Text);
                Console.WriteLine("------------------------------------------");
            }
        }
    }
}
                

Lösung von: Tobias Golz (Adolf Kolping Berufskolleg)

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