Ankündigung

Einklappen
Keine Ankündigung bisher.

One-Time-Pad im Javascript Quellcode

Einklappen
X
  • Filter
  • Zeit
  • Anzeigen
Alles löschen
neue Beiträge

  • One-Time-Pad im Javascript Quellcode

    Hallo,

    Ich habe in der Schule ein Problem, ich muss das One Time Pad in einer Javascript form vorstellen.
    Also eine fertige HTML Seite, wo man den Klartext, den Schlüssel und den Geheimtext ablesen kann.
    So die Html Seite habe ich schon fertig


    <html>
    <head>
    <title>One-Time-Pad</title>
    <script src="onetimepad.js" language="JavaScript"></script>
    </head>
    <body>
    <h1>One-Time-Pad</h1>
    <h3>Chiffirirung durch addition der Buchstaben</h3>
    <form name="IT">
    <table>
    <tr>
    <td>Klartext</td>
    <td><input type="text" size=40 maxlength=40 name="Klartext"> </td>
    </tr>
    <tr>
    <td>Schluessel</td>
    <td><input size=40 maxlength=40 value="0" name="Schluessel">
    </tr>
    <tr colspan=2>
    <td>&nbsp;</td>
    </tr>
    <tr>
    <td>&nbsp;</td>
    <td><input type="button" value="Verschlüsseln" onclick="onetimepad.js"></td>
    </tr>
    <tr colspan=2>
    <td>&nbsp;</td>
    </tr>
    <tr>
    <td>Geheimtext</td>
    <td><input type="text" size=40 maxlength=40 readonly name="Geheimtext"> </td>
    </tr>
    </table>
    </form>
    </body>
    </html>

    So das habe ich schon fertig.
    Die Frage lautet kann mir jemand bei dem java script text helfen???

    Danke schon mal im Vorraus

    innformatiknoob

  • #2
    Hallo!

    Das Forum beschäftigt sich mit der Programmiersprache Java, nicht mit der Skriptsprache Javascript! Darüberhinaus erledigen wir hier keine Hausaufgaben.

    Ein One-Time-Pad (OTP) ist ein sehr einfach zu schreibender Algorithmus, weil man hier lediglich substituieren muss.

    Klicke auf die Grafik für eine vergrößerte Ansicht

Name: 320px-Caesar3.svg_.png
Ansichten: 1
Größe: 17,8 KB
ID: 1559

    Eine einfache Funktion in Javascript kann folgendermaßen aussehen.

    Code:
    // One-Time Pad
    
    // This code was written by Tyler Akins and placed in the public domain.
    // It would be nice if you left this header intact.  http://rumkin.com
    
    
    // Implements a one-time pad for only alphabetic characters.  Preserves
    // the character case in the text (not the key).
    // encdec = -1 for decode, 1 for encode
    // text = the text to encode or decode.
    // key = the key (pad) to use
    function OneTimePad(encdec, text, key)
    {
       var pad, i, out, c, uc;
       
       pad = "";
       key = key.toUpperCase();
       for (i = 0; i < key.length; i ++)
       {
          c = key.charAt(i)
          if (c >= 'A' && c <= 'Z')
          {
             pad += c;
          }
       }
       
       out = "";
       for (i = 0; i < text.length; i ++)
       {
          c = text.charAt(i);
          uc = ' ';
          if (c >= 'A' && c <= 'Z')
          {
             uc = 'A';
          }
          if (c >= 'a' && c <= 'z')
          {
             uc = 'a';
          }
          if (uc != ' ')
          {
             if (pad.length == 0)
    	 {
    	    pad = "AAAAAAAA";
    	 }
             c = c.charCodeAt(0) - uc.charCodeAt(0) + encdec * (pad.charCodeAt(0) - 'A'.charCodeAt(0));
    	 c = (c + 26) % 26;
    	 c = String.fromCharCode(uc.charCodeAt(0) + c);
    	 pad = pad.slice(1, pad.length);
          }
          out += c;
       }
       
       return out;
    }
    
    document.OneTimePad_Loaded = 1;
    Wenn du auch Zufallsschlüssel erstellen willst, kann folgendes Skript genutzt werden.

    Code:
    <script type="text/javascript">
    //<![CDATA[
    
        loadTime = (new Date()).getTime();
    
    /*
    
        L'Ecuyer's two-sequence generator with a Bays-Durham shuffle
        on the back-end.  Schrage's algorithm is used to perform
        64-bit modular arithmetic within the 32-bit constraints of
        JavaScript.
    
        Bays, C. and S. D. Durham.  ACM Trans. Math. Software: 2 (1976)
            59-64.
    
        L'Ecuyer, P.  Communications of the ACM: 31 (1968) 742-774.
    
        Schrage, L.  ACM Trans. Math. Software: 5 (1979) 132-138.
    
    */
    
    function uGen(old, a, q, r, m) {      // Schrage's modular multiplication algorithm
        var t;
    
        t = Math.floor(old / q);
        t = a * (old - (t * q)) - (t * r);
        return Math.round((t < 0) ? (t + m) : t);
    }
    
    function LEnext() {                   // Return next raw value
        var i;
    
        this.gen1 = uGen(this.gen1, 40014, 53668, 12211, 2147483563);
        this.gen2 = uGen(this.gen2, 40692, 52774, 3791, 2147483399);
    
        /* Extract shuffle table index from most significant part
           of the previous result. */
    
        i = Math.floor(this.state / 67108862);
    
        // New state is sum of generators modulo one of their moduli
    
        this.state = Math.round((this.shuffle[i] + this.gen2) % 2147483563);
    
        // Replace value in shuffle table with generator 1 result
    
        this.shuffle[i] = this.gen1;
    
        return this.state;
    }
    
    //  Return next random integer between 0 and n inclusive
    
    function LEnint(n) {
        return Math.floor(this.next() / (1 + 2147483562 / (n + 1)));
    }
    
    //  Constructor.  Called with seed value
    
    function LEcuyer(s) {
        var i;
    
        this.shuffle = new Array(32);
        this.gen1 = this.gen2 = (s & 0x7FFFFFFF);
        for (i = 0; i < 19; i++) {
            this.gen1 = uGen(this.gen1, 40014, 53668, 12211, 2147483563);
        }
    
        // Fill the shuffle table with values
    
        for (i = 0; i < 32; i++) {
            this.gen1 = uGen(this.gen1, 40014, 53668, 12211, 2147483563);
            this.shuffle[31 - i] = this.gen1;
        }
        this.state = this.shuffle[0];
        this.next = LEnext;
        this.nextInt = LEnint;
    }
    
    function sepchar() {
        if (rsep) {
            var seps = "!#$%&()*+,-./:;<=>?@[]^_{|}~";
            return seps.charAt(sepran.nextInt(seps.length - 1));
        }
        return "-";
    }
    
    /*
     *  md5.jvs 1.0b 27/06/96
     *
     * Javascript implementation of the RSA Data Security, Inc. MD5
     * Message-Digest Algorithm.
     *
     * Copyright (c) 1996 Henri Torgemane. All Rights Reserved.
     *
     * Permission to use, copy, modify, and distribute this software
     * and its documentation for any purposes and without
     * fee is hereby granted provided that this copyright notice
     * appears in all copies. 
     *
     * Of course, this soft is provided "as is" without express or implied
     * warranty of any kind.
    
        This version contains some trivial reformatting modifications
        by John Walker.
    
     */
    
    function array(n) {
        for (i = 0; i < n; i++) {
            this[i] = 0;
        }
        this.length = n;
    }
    
    /* Some basic logical functions had to be rewritten because of a bug in
     * Javascript.. Just try to compute 0xffffffff >> 4 with it..
     * Of course, these functions are slower than the original would be, but
     * at least, they work!
     */
    
    function integer(n) {
        return n % (0xffffffff + 1);
    }
    
    function shr(a, b) {
        a = integer(a);
        b = integer(b);
        if (a - 0x80000000 >= 0) {
            a = a % 0x80000000;
            a >>= b;
            a += 0x40000000 >> (b - 1);
        } else {
            a >>= b;
        }
        return a;
    }
    
    function shl1(a) {
        a = a % 0x80000000;
        if (a & 0x40000000 == 0x40000000) {
            a -= 0x40000000;  
            a *= 2;
            a += 0x80000000;
        } else {
            a *= 2;
        }
        return a;
    }
    
    function shl(a, b) {
        a = integer(a);
        b = integer(b);
        for (var i = 0; i < b; i++) {
            a = shl1(a);
        }
        return a;
    }
    
    function and(a, b) {
        a = integer(a);
        b = integer(b);
        var t1 = a - 0x80000000;
        var t2 = b - 0x80000000;
        if (t1 >= 0) {
            if (t2 >= 0) {
                return ((t1 & t2) + 0x80000000);
            } else {
                return (t1 & b);
            }
        } else {
            if (t2 >= 0) {
                return (a & t2);
            } else {
                return (a & b);  
            }
        }
    }
    
    function or(a, b) {
        a = integer(a);
        b = integer(b);
        var t1 = a - 0x80000000;
        var t2 = b - 0x80000000;
        if (t1 >= 0) {
            if (t2 >= 0) {
                return ((t1 | t2) + 0x80000000);
            } else {
                return ((t1 | b) + 0x80000000);
            }
        } else {
            if (t2 >= 0) {
                return ((a | t2) + 0x80000000);
            } else {
                return (a | b);  
            }
        }
    }
    
    function xor(a, b) {
        a = integer(a);
        b = integer(b);
        var t1 = a - 0x80000000;
        var t2 = b - 0x80000000;
        if (t1 >= 0) {
            if (t2 >= 0) {
                return (t1 ^ t2);
            } else {
                return ((t1 ^ b) + 0x80000000);
            }
        } else {
            if (t2 >= 0) {
                return ((a ^ t2) + 0x80000000);
            } else {
                return (a ^ b);  
            }
        }
    }
    
    function not(a) {
        a = integer(a);
        return 0xffffffff - a;
    }
    
    /* Here begin the real algorithm */
    
    var state = new array(4); 
    var count = new array(2);
        count[0] = 0;
        count[1] = 0;                     
    var buffer = new array(64); 
    var transformBuffer = new array(16); 
    var digestBits = new array(16);
    
    var S11 = 7;
    var S12 = 12;
    var S13 = 17;
    var S14 = 22;
    var S21 = 5;
    var S22 = 9;
    var S23 = 14;
    var S24 = 20;
    var S31 = 4;
    var S32 = 11;
    var S33 = 16;
    var S34 = 23;
    var S41 = 6;
    var S42 = 10;
    var S43 = 15;
    var S44 = 21;
    
    function F(x, y, z) {
        return or(and(x, y), and(not(x), z));
    }
    
    function G(x, y, z) {
        return or(and(x, z), and(y, not(z)));
    }
    
    function H(x, y, z) {
        return xor(xor(x, y), z);
    }
    
    function I(x, y, z) {
        return xor(y ,or(x , not(z)));
    }
    
    function rotateLeft(a, n) {
        return or(shl(a, n), (shr(a, (32 - n))));
    }
    
    function FF(a, b, c, d, x, s, ac) {
        a = a + F(b, c, d) + x + ac;
        a = rotateLeft(a, s);
        a = a + b;
        return a;
    }
    
    function GG(a, b, c, d, x, s, ac) {
        a = a + G(b, c, d) + x + ac;
        a = rotateLeft(a, s);
        a = a + b;
        return a;
    }
    
    function HH(a, b, c, d, x, s, ac) {
        a = a + H(b, c, d) + x + ac;
        a = rotateLeft(a, s);
        a = a + b;
        return a;
    }
    
    function II(a, b, c, d, x, s, ac) {
        a = a + I(b, c, d) + x + ac;
        a = rotateLeft(a, s);
        a = a + b;
        return a;
    }
    
    function transform(buf, offset) { 
        var a = 0, b = 0, c = 0, d = 0; 
        var x = transformBuffer;
        
        a = state[0];
        b = state[1];
        c = state[2];
        d = state[3];
        
        for (i = 0; i < 16; i++) {
            x[i] = and(buf[i * 4 + offset], 0xFF);
            for (j = 1; j < 4; j++) {
                x[i] += shl(and(buf[i * 4 + j + offset] ,0xFF), j * 8);
            }
        }
    
        /* Round 1 */
        a = FF( a, b, c, d, x[ 0], S11, 0xd76aa478); /* 1 */
        d = FF( d, a, b, c, x[ 1], S12, 0xe8c7b756); /* 2 */
        c = FF( c, d, a, b, x[ 2], S13, 0x242070db); /* 3 */
        b = FF( b, c, d, a, x[ 3], S14, 0xc1bdceee); /* 4 */
        a = FF( a, b, c, d, x[ 4], S11, 0xf57c0faf); /* 5 */
        d = FF( d, a, b, c, x[ 5], S12, 0x4787c62a); /* 6 */
        c = FF( c, d, a, b, x[ 6], S13, 0xa8304613); /* 7 */
        b = FF( b, c, d, a, x[ 7], S14, 0xfd469501); /* 8 */
        a = FF( a, b, c, d, x[ 8], S11, 0x698098d8); /* 9 */
        d = FF( d, a, b, c, x[ 9], S12, 0x8b44f7af); /* 10 */
        c = FF( c, d, a, b, x[10], S13, 0xffff5bb1); /* 11 */
        b = FF( b, c, d, a, x[11], S14, 0x895cd7be); /* 12 */
        a = FF( a, b, c, d, x[12], S11, 0x6b901122); /* 13 */
        d = FF( d, a, b, c, x[13], S12, 0xfd987193); /* 14 */
        c = FF( c, d, a, b, x[14], S13, 0xa679438e); /* 15 */
        b = FF( b, c, d, a, x[15], S14, 0x49b40821); /* 16 */
    
        /* Round 2 */
        a = GG( a, b, c, d, x[ 1], S21, 0xf61e2562); /* 17 */
        d = GG( d, a, b, c, x[ 6], S22, 0xc040b340); /* 18 */
        c = GG( c, d, a, b, x[11], S23, 0x265e5a51); /* 19 */
        b = GG( b, c, d, a, x[ 0], S24, 0xe9b6c7aa); /* 20 */
        a = GG( a, b, c, d, x[ 5], S21, 0xd62f105d); /* 21 */
        d = GG( d, a, b, c, x[10], S22,  0x2441453); /* 22 */
        c = GG( c, d, a, b, x[15], S23, 0xd8a1e681); /* 23 */
        b = GG( b, c, d, a, x[ 4], S24, 0xe7d3fbc8); /* 24 */
        a = GG( a, b, c, d, x[ 9], S21, 0x21e1cde6); /* 25 */
        d = GG( d, a, b, c, x[14], S22, 0xc33707d6); /* 26 */
        c = GG( c, d, a, b, x[ 3], S23, 0xf4d50d87); /* 27 */
        b = GG( b, c, d, a, x[ 8], S24, 0x455a14ed); /* 28 */
        a = GG( a, b, c, d, x[13], S21, 0xa9e3e905); /* 29 */
        d = GG( d, a, b, c, x[ 2], S22, 0xfcefa3f8); /* 30 */
        c = GG( c, d, a, b, x[ 7], S23, 0x676f02d9); /* 31 */
        b = GG( b, c, d, a, x[12], S24, 0x8d2a4c8a); /* 32 */
    
        /* Round 3 */
        a = HH( a, b, c, d, x[ 5], S31, 0xfffa3942); /* 33 */
        d = HH( d, a, b, c, x[ 8], S32, 0x8771f681); /* 34 */
        c = HH( c, d, a, b, x[11], S33, 0x6d9d6122); /* 35 */
        b = HH( b, c, d, a, x[14], S34, 0xfde5380c); /* 36 */
        a = HH( a, b, c, d, x[ 1], S31, 0xa4beea44); /* 37 */
        d = HH( d, a, b, c, x[ 4], S32, 0x4bdecfa9); /* 38 */
        c = HH( c, d, a, b, x[ 7], S33, 0xf6bb4b60); /* 39 */
        b = HH( b, c, d, a, x[10], S34, 0xbebfbc70); /* 40 */
        a = HH( a, b, c, d, x[13], S31, 0x289b7ec6); /* 41 */
        d = HH( d, a, b, c, x[ 0], S32, 0xeaa127fa); /* 42 */
        c = HH( c, d, a, b, x[ 3], S33, 0xd4ef3085); /* 43 */
        b = HH( b, c, d, a, x[ 6], S34,  0x4881d05); /* 44 */
        a = HH( a, b, c, d, x[ 9], S31, 0xd9d4d039); /* 45 */
        d = HH( d, a, b, c, x[12], S32, 0xe6db99e5); /* 46 */
        c = HH( c, d, a, b, x[15], S33, 0x1fa27cf8); /* 47 */
        b = HH( b, c, d, a, x[ 2], S34, 0xc4ac5665); /* 48 */
    
        /* Round 4 */
        a = II( a, b, c, d, x[ 0], S41, 0xf4292244); /* 49 */
        d = II( d, a, b, c, x[ 7], S42, 0x432aff97); /* 50 */
        c = II( c, d, a, b, x[14], S43, 0xab9423a7); /* 51 */
        b = II( b, c, d, a, x[ 5], S44, 0xfc93a039); /* 52 */
        a = II( a, b, c, d, x[12], S41, 0x655b59c3); /* 53 */
        d = II( d, a, b, c, x[ 3], S42, 0x8f0ccc92); /* 54 */
        c = II( c, d, a, b, x[10], S43, 0xffeff47d); /* 55 */
        b = II( b, c, d, a, x[ 1], S44, 0x85845dd1); /* 56 */
        a = II( a, b, c, d, x[ 8], S41, 0x6fa87e4f); /* 57 */
        d = II( d, a, b, c, x[15], S42, 0xfe2ce6e0); /* 58 */
        c = II( c, d, a, b, x[ 6], S43, 0xa3014314); /* 59 */
        b = II( b, c, d, a, x[13], S44, 0x4e0811a1); /* 60 */
        a = II( a, b, c, d, x[ 4], S41, 0xf7537e82); /* 61 */
        d = II( d, a, b, c, x[11], S42, 0xbd3af235); /* 62 */
        c = II( c, d, a, b, x[ 2], S43, 0x2ad7d2bb); /* 63 */
        b = II( b, c, d, a, x[ 9], S44, 0xeb86d391); /* 64 */
    
        state[0] += a;
        state[1] += b;
        state[2] += c;
        state[3] += d;
    
    }
    
    function init() {
        count[0] = count[1] = 0;
        state[0] = 0x67452301;
        state[1] = 0xefcdab89;
        state[2] = 0x98badcfe;
        state[3] = 0x10325476;
        for (i = 0; i < digestBits.length; i++) {
            digestBits[i] = 0;
        }
    }
    
    function update(b) { 
        var index, i;
        
        index = and(shr(count[0],3) , 0x3F);
        if (count[0] < 0xFFFFFFFF - 7) {
          count[0] += 8;
        } else {
          count[1]++;
          count[0] -= 0xFFFFFFFF + 1;
          count[0] += 8;
        }
        buffer[index] = and(b, 0xff);
        if (index  >= 63) {
            transform(buffer, 0);
        }
    }
    
    function finish() {
        var bits = new array(8);
        var padding; 
        var i = 0, index = 0, padLen = 0;
    
        for (i = 0; i < 4; i++) {
            bits[i] = and(shr(count[0], (i * 8)), 0xFF);
        }
        for (i = 0; i < 4; i++) {
            bits[i + 4] = and(shr(count[1], (i * 8)), 0xFF);
        }
        index = and(shr(count[0], 3), 0x3F);
        padLen = (index < 56) ? (56 - index) : (120 - index);
        padding = new array(64); 
        padding[0] = 0x80;
        for (i = 0; i < padLen; i++) {
          update(padding[i]);
        }
        for (i = 0; i < 8; i++) {
          update(bits[i]);
        }
    
        for (i = 0; i < 4; i++) {
            for (j = 0; j < 4; j++) {
                digestBits[i * 4 + j] = and(shr(state[i], (j * 8)) , 0xFF);
            }
        } 
    }
    
    /* End of the MD5 algorithm */
    
    function gen() {
        window.status = "Generating...";
        document.getElementById('onetime').pad.value = "";
    
        lower = document.getElementById('onetime').textcase.selectedIndex == 0;
        upper = document.getElementById('onetime').textcase.selectedIndex == 1;
        mixed = document.getElementById('onetime').textcase.selectedIndex == 2;
        rsep = document.getElementById('onetime').rsep.checked;
        if (!(numeric = document.getElementById('onetime').keytype[0].checked)) {
            english = document.getElementById('onetime').keytype[1].checked;
            gibberish = document.getElementById('onetime').keytype[3].checked;
        }
        clockseed = document.getElementById('onetime').seedy[0].checked
        makesig = document.getElementById('onetime').dosig.checked;
        npass = document.getElementById('onetime').nkeys.value;
        pw_length = Math.round(document.getElementById('onetime').klength.value);
        sep = document.getElementById('onetime').sep.value;
        linelen = document.getElementById('onetime').linelen.value;
    //               01234567890123456789012345678901
        charcodes = " " +
                    "!\"#$%&'()*+,-./0123456789:;<=>?" +
                    "@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_" +
                    "`abcdefghijklmnopqrstuvwxyz{|}~";
    
        if (clockseed) {
            var n, j, ran0;
    
            /*  Obtain seed from the clock.  To reduce the likelihood
                of the seed being guessed, we create the seed by combining
                the time of the request with the time the page was loaded,
                then use that composite value to seed an auxiliary generator
                which is cycled between one and 32 times based on the time
                derived initial seed, with the output of the generator fed
                back into the seed we use to generate the pad.  */
    
            seed = Math.round((new Date()).getTime() % Math.pow(2, 31));
            ran0 = new LEcuyer((seed ^ Math.round(loadTime % Math.pow(2, 31))) & 0x7FFFFFFF);
            for (j = 0; j < (5 + ((seed >> 3) & 0xF)); j++) {
                n = ran0.nextInt(31);
            }
            while (n-- >= 0) {
                seed = ((seed << 11) | (seed >>> (32 - 11))) ^ ran0.next();
            }
            seed &= 0x7FFFFFFF;
            document.getElementById('onetime').seeder.value = seed;
        } else {
            var useed, seedNum;
    
            /* Obtain seed from user specification.  If the seed is a
               decimal number, use it as-is.  If it contains any
               non-numeric characters, construct a hash code and
               use that as the seed. */
    
            useed = document.getElementById('onetime').seeder.value;
            seedNum = true;
            for (i = 0; i < useed.length; i++) {
                if ("0123456789".indexOf(useed.charAt(i)) == -1) {
                    seedNum = false;
                    break;
                }
            }
            if (seedNum) {
                seed = Math.round(Math.floor(document.getElementById('onetime').seeder.value) % Math.pow(2, 31));
                document.getElementById('onetime').seeder.value = seed;
            } else {
                var s, t, iso, hex;
    
                iso = "";
                hex = "0123456789ABCDEF";
                for (i = 32; i < 256; i++) {
                    if (i < 127 || i >= 160) {
                        // Why not "s = i.toString(16);"?  Doesn't work in Netscape 3.0
                        iso += "%" + hex.charAt(i >> 4) + hex.charAt(i & 0xF);
                    }
                }
                iso = unescape(iso);
                s = 0;
                for (i = 0; i < useed.length; i++) {
                    t = iso.indexOf(useed.charAt(i));
                    if (t < 0) {
                        t = 17;
                    }
                    s = 0x7FFFFFFF & (((s << 5) | (s >> (32 - 5))) ^ t);
                }
                seed = s;
            }
        }
        ran1 = new LEcuyer(seed);
        ran2 = new LEcuyer(seed);
        if (rsep) {
            /*  Use a separate random generator for separators
                so that results are the same for a given seed
                for both choices of separators.  */
            sepran = new LEcuyer(seed);
        }
    
        ndig = 1;
        j = 10;
        while (npass >= j) {
            ndig++;
            j *= 10;
        }
        pw_item = pw_length + (sep > 0 ? (pw_length / sep) : 0);
        pw_item += ndig + 5;
        j = pw_item * 3;
        if (j < 132) {
            j = 132;
        }
        npline = Math.floor(linelen / pw_item);
        if (npline < 1) {
            npline = 0;
        }
        v = "";
        md5v = "";
        lineno = 0;
        if (!numeric) {
            letters = "abcdefghijklmnopqrstuvwxyz";
            if (upper) {
                letters = letters.toUpperCase();
            }
            if (english) {
    
                // Frequency of English digraphs (from D. Edwards 1/27/66)
    
                frequency = new Array( 
                    new Array(4, 20, 28, 52, 2, 11, 28, 4, 32, 4, 6, 62,
                              23, 167, 2, 14, 0, 83, 76, 127, 7, 25, 8, 1,
                              9, 1), /* aa - az */
    
                    new Array(13, 0, 0, 0, 55, 0, 0, 0, 8, 2, 0, 22, 0, 0,
                              11, 0, 0, 15, 4, 2, 13, 0, 0, 0, 15, 0), /* ba - bz */
    
                    new Array(32, 0, 7, 1, 69, 0, 0, 33, 17, 0, 10, 9, 1,
                              0, 50, 3, 0, 10, 0, 28, 11, 0, 0, 0, 3, 0), /* ca - cz */
    
                    new Array(40, 16, 9, 5, 65, 18, 3, 9, 56, 0, 1, 4, 15,
                              6, 16, 4, 0, 21, 18, 53, 19, 5, 15, 0, 3, 0), /* da - dz */
    
                    new Array(84, 20, 55, 125, 51, 40, 19, 16, 50, 1, 4,
                              55, 54, 146, 35, 37, 6, 191, 149, 65, 9, 26,
                              21, 12, 5, 0), /* ea - ez */
    
                    new Array(19, 3, 5, 1, 19, 21, 1, 3, 30, 2, 0, 11, 1,
                              0, 51, 0, 0, 26, 8, 47, 6, 3, 3, 0, 2, 0), /* fa - fz */
    
                    new Array(20, 4, 3, 2, 35, 1, 3, 15, 18, 0, 0, 5, 1,
                              4, 21, 1, 1, 20, 9, 21, 9, 0, 5, 0, 1, 0), /* ga - gz */
    
                    new Array(101, 1, 3, 0, 270, 5, 1, 6, 57, 0, 0, 0, 3,
                              2, 44, 1, 0, 3, 10, 18, 6, 0, 5, 0, 3, 0), /* ha - hz */
    
                    new Array(40, 7, 51, 23, 25, 9, 11, 3, 0, 0, 2, 38,
                              25, 202, 56, 12, 1, 46, 79, 117, 1, 22, 0,
                              4, 0, 3), /* ia - iz */
    
                    new Array(3, 0, 0, 0, 5, 0, 0, 0, 1, 0, 0, 0, 0, 0, 4,
                              0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0), /* ja - jz */
    
                    new Array(1, 0, 0, 0, 11, 0, 0, 0, 13, 0, 0, 0, 0, 2,
                              0, 0, 0, 0, 6, 2, 1, 0, 2, 0, 1, 0), /* ka - kz */
    
                    new Array(44, 2, 5, 12, 62, 7, 5, 2, 42, 1, 1, 53, 2,
                              2, 25, 1, 1, 2, 16, 23, 9, 0, 1, 0, 33, 0), /* la - lz */
    
                    new Array(52, 14, 1, 0, 64, 0, 0, 3, 37, 0, 0, 0, 7,
                              1, 17, 18, 1, 2, 12, 3, 8, 0, 1, 0, 2, 0), /* ma - mz */
    
                    new Array(42, 10, 47, 122, 63, 19, 106, 12, 30, 1, 6,
                              6, 9, 7, 54, 7, 1, 7, 44, 124, 6, 1, 15, 0,
                              12, 0), /* na - nz */
    
                    new Array(7, 12, 14, 17, 5, 95, 3, 5, 14, 0, 0, 19,
                              41, 134, 13, 23, 0, 91, 23, 42, 55, 16, 28,
                              0, 4, 1), /* oa - oz */
    
                    new Array(19, 1, 0, 0, 37, 0, 0, 4, 8, 0, 0, 15, 1, 0,
                              27, 9, 0, 33, 14, 7, 6, 0, 0, 0, 0, 0), /* pa - pz */
    
                    new Array(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
                              0, 0, 0, 0, 0, 17, 0, 0, 0, 0, 0), /* qa - qz */
    
                    new Array(83, 8, 16, 23, 169, 4, 8, 8, 77, 1, 10, 5,
                              26, 16, 60, 4, 0, 24, 37, 55, 6, 11, 4, 0,
                              28, 0), /* ra - rz */
    
                    new Array(65, 9, 17, 9, 73, 13, 1, 47, 75, 3, 0, 7,
                              11, 12, 56, 17, 6, 9, 48, 116, 35, 1, 28, 0,
                              4, 0), /* sa - sz */
    
                    new Array(57, 22, 3, 1, 76, 5, 2, 330, 126, 1, 0, 14,
                              10, 6, 79, 7, 0, 49, 50, 56, 21, 2, 27, 0,
                              24, 0), /* ta - tz */
    
                    new Array(11, 5, 9, 6, 9, 1, 6, 0, 9, 0, 1, 19, 5, 31,
                              1, 15, 0, 47, 39, 31, 0, 3, 0, 0, 0, 0), /* ua - uz */
    
                    new Array(7, 0, 0, 0, 72, 0, 0, 0, 28, 0, 0, 0, 0, 0,
                              5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0), /* va - vz */
    
                    new Array(36, 1, 1, 0, 38, 0, 0, 33, 36, 0, 0, 4, 1,
                              8, 15, 0, 0, 0, 4, 2, 0, 0, 1, 0, 0, 0), /* wa - wz */
    
                    new Array(1, 0, 2, 0, 0, 1, 0, 0, 3, 0, 0, 0, 0, 0, 1,
                              5, 0, 0, 0, 3, 0, 0, 1, 0, 0, 0), /* xa - xz */
    
                    new Array(14, 5, 4, 2, 7, 12, 12, 6, 10, 0, 0, 3, 7,
                              5, 17, 3, 0, 4, 16, 30, 0, 0, 5, 0, 0, 0), /* ya - yz */
    
                    new Array(1, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
                              0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0) /* za - zz */ );
    
                // This MUST be equal to the sum of the equivalent rows above.
    
                row_sums = new Array(
                    796,   160,    284,    401,    1276,   262,    199,    539,    777,    
                    16,    39,     351,    243,    751,    662,    181,    17,     683,    
                    662,   968,    248,    115,    180,    17,     162,    5
                );
    
                // Frequencies of starting characters.
    
                start_freq = new Array(
                    1299,  425,    725,    271,    375,    470,    93,     223,    1009,
                    24,    20,     355,    379,    319,    823,    618,    21,     317,
                    962,   1991,   271,    104,    516,    6,      16,     14
                );
    
                // This MUST be equal to the sum of all elements in the above array.
    
                total_sum = 11646;
            }
            if (gibberish) {
                gibber = "abcdefghijklmnopqrstuvwxyz" +
                         "ABCDEFGHIJKLMNOPQRSTUVWXYZ" +
                         "0123456789" +
                         "!#$%&()*+,-./:;<=>?@[]^_{|}~";
                if (upper) {
                    /*  Convert to upper case, leaving two copies of the
                        alphabet for two reasons: first, to favour letters
                        over gnarl, and second, to change only the letter case
                        when the mode is selected.  */
                    gibber = gibber.toUpperCase();
                } else if (lower) {
    	    	gibber = gibber.toLowerCase();
    	    }
            }
        }
        for (line = 1; line <= npass; line++) {
            password = "";
            if (numeric) {
                for (nchars = 0; nchars < pw_length; nchars++) {
                    if ((sep > 0) && ((nchars % sep) == 0) && (nchars > 0)) {
                        password += sepchar();
                    }
                    password += ran1.nextInt(9);
                }
            } else if (!english) {
                for (nchars = 0; nchars < pw_length; nchars++) {
                    if ((sep > 0) && ((nchars % sep) == 0) && (nchars > 0)) {
                        password += sepchar();
                    }
                    if (gibberish) {
                        password += gibber.charAt(ran1.nextInt(gibber.length - 1));
                    } else {
                        password += letters.charAt(ran1.nextInt(25));
                    }
                }
            } else {
                position = ran1.nextInt(total_sum - 1);
                for (row_position = 0, j = 0; position >= row_position;
                     row_position += start_freq[j], j++) {
                    continue;
                }
    
                password = letters.charAt(i = j - 1);
                nch = 1;
                for (nchars = pw_length - 1; nchars; --nchars) {
    
                    // Now find random position within the row.
    
                    position = ran1.nextInt(row_sums[i] - 1);
                    for (row_position = 0, j = 0;
                         position >= row_position;
                         row_position += frequency[i][j], j++) {
                    }
    
                    if ((sep > 0) && ((nch % sep) == 0)) {
                        password += sepchar();
                    }
                    nch++;
                    password += letters.charAt(i = j - 1);
                }
            }
    	
    	if ((!numeric) && (!gibberish) && mixed) {
    	    var pwm = '';
    	    var j;
    	    for (j = 0; j < password.length; j++) {
    	    	pwm += ran2.nextInt(1) ? (password.charAt(j)) : (password.charAt(j).toUpperCase());
    	    }
    	    password = pwm;
    	}
    
            /*  If requested, calculate the MD5 signature for this key and
                and save for later appending to the results.  */
    
            if (makesig) {
                var n, m, hex = "0123456789ABCDEF";
    
                init();
                for (m = 0; m < password.length; m++) {
                    update(32 + charcodes.indexOf(password.charAt(m)));
                }
                finish();
    
                for (n = 0; n < 16; n++) {
                    md5v += hex.charAt(digestBits[n] >> 4);
                    md5v += hex.charAt(digestBits[n] & 0xF);
                }
                md5v += "\n";
            }
    
            aline = "" + line;
            while (aline.length < ndig) {
                aline = " " + aline;
            }
            v += aline + ") " + password;
    
            if ((++lineno) >= npline) {
                v += "\n";
                lineno = 0;
            } else {
                v += "  ";
            }
        }
    
        if (makesig) {
            v += "\n----------  MD5 Signatures  ----------\n" + md5v;
        }
    
        document.getElementById('onetime').pad.value = v;
        window.status = "Done.";
    }
    
    //]]>
    </script>
    Grüße,
    GAGA

    Kommentar


    • #3
      Hallo,
      Danke erst mal für den Text

      Jetzt komme ich ab er nicht weiter, denn ich weiß nicht wie ich den Java text richtig in den HTML Code einbinden soll.

      Innformatiknoob

      Kommentar


      • #4
        Etwas mehr Eigeninitiative wäre vorteilhaft. Du hast die Lösung nun schon komplett erhalten und musst nur noch dein HMTL mit dem zur Verfügung gestellten Javascript kombinieren. Nicht wir hier sollen diese Aufgabe lösen, du sollst sie lösen!

        Das ist keine Hilfe mehr, das ist die Komplettlösung.

        PHP-Code:
        <html>
        <
        head>
        <
        title>One-Time-Pad</title>
        <
        script src="onetimepad.js" language="JavaScript"></script>
        </head>
        <body>
        <h1>One-Time-Pad</h1>
        <h3>Chiffrierung durch Addition der Buchstaben</h3>
        <form name="IT">
        <table>
        <tr>
        <td>Klartext:</td>
        <td><input type="text" size="40" maxlength="40" value="AAAAAAAA" name="Klartext" id="plaintext"></td>
        </tr>
        <tr>
        <td>Schlüssel:</td>
        <td><input type="text" size="40" maxlength="40" value="BBBBBBBB" name="Schluessel" id="key"></td>
        </tr>
        <tr colspan=2>
        <td>&nbsp;</td>
        </tr>
        <tr>
        <td>&nbsp;</td>
        <td><input type="button" value="Verschlüsseln" onclick="OneTimePad(1, document.getElementById('plaintext').value, document.getElementById('key').value);"></td>
        </tr>
        <tr colspan=2>
        <td>&nbsp;</td>
        </tr>
        <tr>
        <td>Geheimtext:</td>
        <td><textarea size="40" maxlength="40" id="ciphertext"></textarea> </td>
        </tr>
        </table>
        </form>
        </body>
        </html> 
        PHP-Code:
        // One-Time Pad

        // This code was written by Tyler Akins and placed in the public domain.
        // It would be nice if you left this header intact.  http://rumkin.com


        // Implements a one-time pad for only alphabetic characters.  Preserves
        // the character case in the text (not the key).
        // encdec = -1 for decode, 1 for encode
        // text = the text to encode or decode.
        // key = the key (pad) to use
        function OneTimePad(encdectextkey)
        {
           var 
        padioutcuc;
           
           
        pad "";
           
        key key.toUpperCase();
           for (
        0key.length++)
           {
              
        key.charAt(i)
              if (
        >= 'A' && <= 'Z')
              {
                 
        pad += c;
              }
           }
           
           
        out "";
           for (
        0text.length++)
           {
              
        text.charAt(i);
              
        uc ' ';
              if (
        >= 'A' && <= 'Z')
              {
                 
        uc 'A';
              }
              if (
        >= 'a' && <= 'z')
              {
                 
        uc 'a';
              }
              if (
        uc != ' ')
              {
                 if (
        pad.length == 0)
             {
                
        pad "AAAAAAAA";
             }
                 
        c.charCodeAt(0) - uc.charCodeAt(0) + encdec * (pad.charCodeAt(0) - 'A'.charCodeAt(0));
             
        = (26) % 26;
             
        String.fromCharCode(uc.charCodeAt(0) + c);
             
        pad pad.slice(1pad.length);
              }
              
        out += c;
           }
           
           
        document.getElementById('ciphertext').value out;
        }

        document.OneTimePad_Loaded 1
        Zuletzt geändert von GAGA; 16.12.2011, 19:55.

        Kommentar


        • #5
          Hallo,

          Ich weiß nicht wie ich dir danken kann

          Nur noch eine Frage:

          Was passiert genau wenn ich onclick drücke wie wird der Klartext und der Schlüssel zusammen gebracht??

          Danke Danke
          Innformatiknoob

          Kommentar


          • #6
            Nachdem der Button geklickt wurde, wird die Javascript-Funktion OneTimePad() mit den Inhalten des Klartextes und des Schlüssels aufgerufen. Dazu holt die Funktion den Inhalt aus dem HTML-Formular über getElementById.value. Der erste Parameter mit der "1" bewirkt das die Funktion den Text mit dem Schlüssel verschlüsselt. Bei "-1" würde eine Entschlüsselung stattfinden. Danach verschlüsselt die Funktion den Klartext und gibt den verschlüsselten Text an die Textarea zurück.

            Die Funktionsweise von OneTimePad() lässt sich aus dem Code ersehen.

            Kommentar


            • #7
              Hallo,

              Wo genau steht dieser Parameter um zu ändern wo man 1 bzw. -1 eingeben für entschlüsseln bzw. verschlüsseln ??

              danke innformatiknoob

              Kommentar


              • #8
                Der Parameter ist im Code fest einprogrammiert.

                <td><input type="button" value="Verschlüsseln" onclick="OneTimePad(1, document.getElementById('plaintext').value, document.getElementById('key').value);"></td>

                Kommentar

                Lädt...
                X