Data Encryption Standard: Difference between revisions

=={{header|C}}==

{{trans|D}}

#include <stdlib.h>

#include <string.h>

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

return 0;

{{out}}

<pre>Key : 133457799BBCDFF1

 

=={{header|C sharp|C#}}==

using System.IO;

using System.Security.Cryptography;

}

}

{{out}}

<pre>Encoded: 0000000000000000A913F4CB0BD30F97

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

{{trans|D}}

#include <array>

#include <bitset>

 

return 0;

{{out}}

<pre>Key : 133457799BBCDFF1

=={{header|D}}==

{{trans|kotlin}}

import std.bitmanip;

import std.stdio;

}

}

{{out}}

<pre>Key : 133457799BBCDFF1

=={{header|F Sharp|F#}}==

{{trans|C#}}

open System.Security.Cryptography

open System.IO

printfn "Decoded: %s" (ByteArrayToString decBytes)

 

{{out}}

<pre>Encoded: 0000000000000000A913F4CB0BD30F97

 

=={{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

=={{header|Julia}}==

===Using the MbedTLS library===

 

const testdata = [

println("Decoded : $(bytes2hex(decoded))\n")

end

<pre>

Key : 133457799bbcdff1

===Base Julia only===

{{trans|Phix}}

1, 58, 50, 42, 34, 26, 18,

10, 2, 59, 51, 43, 35, 27,

println("Decoded : $(bytes2hex(decoded))\n")

end

Output: same as MbedTLS library version above.

 

===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

Compared to the D (and Kotlin versions), we avoided to use an array to compute left and right part when executing the rounds. We simply switched left and right part at each round. This is the main difference with these two versions.

 

 

 

let decoded = decrypt(Keys[i], encoded)

echo "Decoded: ", decoded.toHex()

 

{{out}}

 

=={{header|Perl}}==

 

use strict;

print "Encoded : ", unpack("H*", $ciphertext), "\n";

print "Decoded : ", unpack("H*", $cipher->decrypt($ciphertext)), "\n";

{{out}}

<pre>

easier to debug/verify, probably sidestep a few fiddly endian issues, and certainly

simplify bit-wise permutations.

<span style="color: #000080;font-style:italic;">-- demo\rosetta\Data_Encryption_Standard.exw</span>

<span style="color: #008080;">constant</span> <span style="color: #000000;">PC1</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{</span><span style="color: #000000;">57</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">49</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">41</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">33</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">25</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">17</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">9</span><span style="color: #0000FF;">,</span>

<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"Decoded : %s%s\n\n"</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">dectxt</span><span style="color: #0000FF;">,</span><span style="color: #000000;">derror</span><span style="color: #0000FF;">})</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>

{{out}}

<pre>

 

=={{header|PicoLisp}}==

*PC1

(57 49 41 33 25 17 9

16

(hex

{{out}}

<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

Thanks to SqrtNegInf for pointing out that \r\n is a single grapheme. ([https://docs.raku.org/type/Str#routine_chomp link 1], [https://docs.raku.org/language/newline link 2])

{{trans|Phix}}

 

my \PC1 = <

say h2B des "0E329232EA6D0D73", h2B("C0999FDDE378D7ED727DA00BCA5A84EE47F269A4D6438190D9D52F78F535849980A2E7453703513E"), True;

say h2B des "0E329232EA6D0D73", h2B("C0999FDDE378D7ED727DA00BCA5A84EE47F269A4D6438190D9D52F78F53584997F922CCB5B068D99"), True;

{{out}}

<pre>Encryption examples:

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

{{libheader|Wren-math}}

The second Kotlin version.

import "/math" for Boolean

 

System.print("Decoded : %(decoded)")

System.print()

 

{{out}}