One-time pad: Difference between revisions

=={{header|Go}}==

{{trans|Kotlin}}

 

import (

}

}

 

{{out}}

 

=={{header|Haskell}}==

-- ghc -main-is OneTimePad OneTimePad.hs

-- To run:

-- Decrypt first parameter's contents, using the second parameter as a key.

decrypt :: T.Text -> T.Text -> T.Text

 

{{out}}

Implementation (assumes linux and also uses ascii85 encoding to avoid character set problems):

 

randseq=: {{ 2!:0'dd 2>/dev/null if=/dev/urandom count=1 bs=',":y }}

genpad=: {{ EMPTY [ (randseq y) fwrite x }}

encrypt=: {{ toascii85 (fread x) 0 vig a. y }}

 

Example:

 

'example' encrypt 'this is a test'

hc>*>I2nEB,6b#MdE;~>

 

'example' decrypt 'hc>*>I2nEB,6b#MdE;~>'

 

One time pads are files, and can managed by linux file utilities (<code>ls</code>, <code>mv</code>, <code>rm</code>, ...).

Implementation also includes the start and end ASCII characters. One usage shows support for uppercase only, a second usage shows allowing spaces, upper case, and lower case in the input text.

 

import java.io.BufferedReader;

import java.io.BufferedWriter;

 

}

 

{{out}}

=={{header|Kotlin}}==

This uses the JDK's SecureRandom class for generating cryptographically strong random numbers. For convenience all three sub-tasks are catered for by a single, menu-based, program.

 

import java.io.File

}

}

 

{{out}}

{{trans|Python}}

{{libheader|nimcrypto}}

import nimcrypto

 

 

else:

 

{{out}}

 

=={{header|Perl}}==

 

use strict;

print "Ord(Cipher) : ", ( map { ord($_).' ' } (split //, $cipher) ) , "\n";

 

{{out}}

<pre>Message : show me the monKey

 

=={{header|Python}}==

"""One-time pad using an XOR cipher. Requires Python >=3.6."""

 

import secrets

import sys

 

# One-time pad file signature.

"""Generate ``n`` secure, random keys of ``size`` bytes."""

# We're generating and storing keys in their hexadecimal form to make

# can not start with a hyphen.

return (secrets.token_hex(size) for _ in range(n))

Args:

path (pathlib.Path): Path to write one-time pad to.

"""

if path.exists():

else:

write_pad(pad, args.length, args.key_size)

 

{{out}}

This is a fairly basic otp file generator. Uses Crypt::Random for decently high quality random numbers. (Random bytes are drawn from /dev/urandom on Unix-like systems, and CryptGenRandom() on Windows.) It will ask for a file name to save to, and the number of lines you want. Each line can be used to encode up to 48 characters of data. Default is 1000 lines, Only generating 4 lines here for demonstration purposes. Saving the file to 'rosettacode.1tp'.

 

put "Generate data for one time pad encryption.\n" ~

"File will have .1tp extension.";

xx $lines).join;

}

{{out}}

<pre>Generate data for one time pad encryption.

One-time-pad encryption gets it's security from the fact that the pads are used '''one time'''. As a line is used in the otp file, it needs to be marked as used, or removed so it doesn't get reused. Theoretically, you would make a copy of rosettacode.1tp and send it by secure means to the receiver of your encrypted text so that they can use it to decrypt. Since we are encrypting and decrypting on the same computer, we'll make a copy of the otp file named rosettacopy.1tp and use that for decryption so the encrypt and decrypt functions don't conflict.

 

sub v2s (@v) { (@v »%» 26 »+» 65)».chr.join }

 

say "Secret:\n$secret\n\nEncrypted:";

say my $encrypted = otp-encrypt $secret, $otp-encrypt-fn;

 

{{out}}

With "randInt" from Tcl'ers wiki [http://wiki.tcl.tk/29163 Cryptographically secure random numbers using /dev/urandom]

 

 

proc randInt { min max } {

close $fh

 

 

{{out}}

{{libheader|Wren-dynamic}}

{{libheader|Wren-str}}

 

var CHARS_PER_LINE = 48

return // Quit

}

 

{{out}}

 

=={{header|TypeScript}}==

#!/usr/bin/env node

import { writeFileSync, existsSync, readFileSync, unlinkSync } from 'node:fs';

 

main();

 

{{out}}

fileName.key

_________________________________________________

_________________________________________________

</pre>