Data Encryption Standard: Difference between revisions

 

Bonus (optional): add standard padding to match the C#, Java, Modula-2, Kotlin, and Phix entries, so the above encrypted result would instead be 0000000000000000A913F4CB0BD30F97.

 

=={{header|C}}==

{{trans|D}}

#include <stdlib.h>

#include <string.h>

len = sizeof(message3) / sizeof(ubyte);

driver(keys[2], message3, len);

return 0;

{{out}}

<pre>Key : 133457799BBCDFF1

Encoded : C0999FDDE378D7ED727DA00BCA5A84EE47F269A4D6438190D9D52F78F53584997F922CCB5B068D99

Decoded : 596F7572206C6970732061726520736D6F6F74686572207468616E20766173656C696E650D0A</pre>

 

=={{header|C++}}==

{{trans|D}}

#include <array>

#include <bitset>

 

return 0;

{{out}}

<pre>Key : 133457799BBCDFF1

Encoded : C0999FDDE378D7ED727DA00BCA5A84EE47F269A4D6438190D9D52F78F53584997F922CCB5B068D99

Decoded : 596F7572206C6970732061726520736D6F6F74686572207468616E20766173656C696E650D0A</pre>

 

=={{header|D}}==

{{trans|kotlin}}

 

immutable PC1 = [

immutable SHIFTS = [1, 1, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 1];

 

bool[] buffer = new bool[count];

return BitArray(buffer);

ubyte[] encrypt(const ubyte[] key, const ubyte[] message) in {

assert(key.length == 8, "Incorrect key size");

BitArray[] ks = getSubKeys(key);

ubyte[] m = message.dup;

ubyte[] decrypt(const ubyte[] key, const ubyte[] encoded) in {

assert(key.length == 8, "Incorrect key size");

BitArray[] ks = getSubKeys(key);

// reverse the subkeys

private BitArray[] getSubKeys(const ubyte[] key) in {

assert(key.length == 8);

auto k = key.toBitArray();

 

[0x0E, 0x32, 0x92, 0x32, 0xEA, 0x6D, 0x0D, 0x73],

];

immutable ubyte[][] messages = [

[cast(ubyte)0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF],

[0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87],

];

assert(keys.length == messages.length);

 

writefln("Key : %(%02X%)", keys[i]);

writefln("Message : %(%02X%)", messages[i]);

ubyte[] encoded = encrypt(keys[i], messages[i]);

writefln("Encoded : %(%02X%)", encoded);

ubyte[] decoded = decrypt(keys[i], encoded);

writefln("Decoded : %(%02X%)", decoded);

writeln;

}

}

{{out}}

<pre>Key : 133457799BBCDFF1

Decoded : 596F7572206C6970732061726520736D6F6F74686572207468616E20766173656C696E650D0A</pre>

 

{{trans|C#}}

open System.Security.Cryptography

open System.IO

printfn "Decoded: %s" (ByteArrayToString decBytes)

 

{{out}}

<pre>Encoded: 0000000000000000A913F4CB0BD30F97

Decoded: 8787878787878787</pre>

=={{header|FreeBASIC}}==

' compile with: fbc -s console

 

Print : Print "hit any key to end program"

Sleep

{{out}}

<pre> key 133457799BBCDFF1

=={{header|Go}}==

'''Library solution:'''

 

import (

c.Encrypt(dst, src)

fmt.Printf("%x\n", dst)

{{out}}

<pre>

=={{header|Java}}==

{{trans|Kotlin}}

import javax.crypto.spec.SecretKeySpec;

 

printHexBytes(decBytes, "Decoded");

}

{{out}}

<pre>Encoded: 0000000000000000a913f4cb0bd30f97

Decoded: 8787878787878787</pre>

 

=={{header|Kotlin}}==

===Version 1 (using library functions)===

Presumably, one can use library functions to demonstrate DES as it would be very tedious to implement it from scratch:

 

import javax.crypto.Cipher

val decBytes = decCipher.doFinal(encBytes)

decBytes.printHexBytes("Decoded")

 

{{out}}

===Version 2 (from scratch)===

It wasn't as tedious as I expected due to the admirably clear article linked to above:

 

import java.util.BitSet

println()

}

{{out}}

<pre>Key : 133457799BBCDFF1

 

=={{header|Modula-2}}==

FROM SYSTEM IMPORT BYTE,ADR;

FROM DES IMPORT DES,Key1,Create,Destroy,EncryptECB,DecryptECB;

Destroy(cipher);

ReadChar

{{out}}

<pre>plain: 8787878787878787

plain: 8787878787878787</pre>

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

{{out}}

<pre>

Encoded : C0999FDDE378D7ED727DA00BCA5A84EE47F269A4D6438190D9D52F78F53584997F922CCB5B068D99

Decoded : "Your lips are smoother than vaseline\r\n"

</pre>

 

implemented like in the article linked in description. <br>

really good article btw

#!/usr/bin/python

 

prove(k2, m2)

 

{{Out}}

Note: This is just the algorithm for single 64-bit blocks. No padding or block chipher operation mode

encrypted: 85e813540f0ab405

decrypted: 123456789abcdef</pre>

 

=={{header|REXX}}==

Implementation of the algorithm described in the cited article.

<br>Decryption is now supported as well

Parse Upper Arg action

Select

Return r

 

{{out}}

<pre>I:\>rexx des2

 

=={{header|Scala}}==

import javax.crypto.spec.SecretKeySpec

 

printHexBytes(decBytes, "Decoded")

 

{{Out}}See it running in your browser by [https://scastie.scala-lang.org/t6nGq1ebShKEA42LSIQ6Hg Scastie (JVM)].

=={{header|Symsyn}}==

: 48

: 40

endif

call Wds2Data

A trivial solution using the des encryption instruction:

data : x'8787878787878787'

 

$s [] | output result - 0000000000000000

 

{{out}}

<pre>0000000000000000</pre>

=={{header|Visual Basic .NET}}==

{{trans|C#}}

Imports System.Security.Cryptography

 

End Sub

 

{{out}}

<pre>Encoded: 0000000000000000A913F4CB0BD30F97

Decoded: 8787878787878787</pre>