Introdução

Há algum tempo, deparei-me com o pequeno algoritmo de criptografia ( TEA ) e, desde então, o recomendo sempre que as propriedades de segurança criptográfica especiais são desnecessárias e uma auto-implementação é um requisito.
Agora, hoje, queremos levar o nome * tiny * algoritmo de criptografia literalmente e sua tarefa será implementar o menor algoritmo de criptografia!

Especificação

Entrada

A entrada é uma lista de 8 bytes (ou seu idioma equivalente), este é o texto sem formatação e outra lista de 16 bytes (ou seu idioma equivalente), essa é a chave .
É permitida a conversão de entrada de decimal, hexadecimal, octal ou binário.
É permitida a leitura de 1 número inteiro de 64 bits, 2 de 32 bits ou 4 de 16 bits como saída (opcionalmente como uma lista) (para o texto sem formatação, dobre os números da chave)

Resultado

A saída é uma lista de 8 bytes (ou seu idioma equivalente), este é o texto cifrado .
A conversão de saída para decimal, hexadecimal, octal ou binária é permitida, mas não obrigatória.
É permitido escrever 1 número inteiro de 64 bits, 2 32 bits ou 4 16 bits como saída (opcionalmente como uma lista).

O que fazer?

Sua tarefa é implementar a direção de criptografia do pequeno algoritmo de criptografia ( TEA ), observe que XTEA e XXTEA são outros algoritmos.
A Wikipedia possui um exemplo de código C e uma lista de referências a algumas implementações em outros idiomas. Essa é a descrição original (PDF) .

Mais formalmente:

Let k1, k2, k3, k4, v1, v2, sum be unsigned 32-bit integers.
(k1,k2,k3,k4) <- key input
(v1,v2) <- plaintext input
sum <- 0
repeat 32 times:
    sum <- ( sum + 0x9e3779b9 ) mod 2^32
    v0  <- ( v0 + ( ((v1 << 4) + k0) XOR (v1 + sum) XOR ((v1 >> 5) + k1) ) ) mod 2^32
    v1  <- ( v1 + ( ((v0 << 4) + k2) XOR (v0 + sum) XOR ((v0 >> 5) + k3) ) ) mod 2^32
output <- (v0,v1)

where 0x9e3779b9 is a hexadecimal constant and
"<<" denotes logical left shift and ">>" denotes logical right shift.

Casos de canto em potencial

\0é um caractere válido e você não pode reduzir sua entrada nem saída.
Supõe-se que a codificação inteira seja little-endian (por exemplo, o que você provavelmente já possui).

Quem ganha?

Isso é código-golfe, então a resposta mais curta em bytes vence!
Regras padrão se aplicam, é claro.

Casos de teste

Os vetores de teste foram gerados usando o exemplo de código C da Wikipedia.

Key: all zero (16x \0)
Plaintext -> Ciphertext (all values as two 32-bit hexadecimal words)
00000000 00000000 -> 41ea3a0a 94baa940
3778001e 2bf2226f -> 96269d3e 82680480
48da9c6a fbcbe120 -> 2cc31f2e 228ad143
9bf3ceb8 1e076ffd -> 4931fc15 22550a01
ac6dd615 9c593455 -> 392eabb4 505e0755
ebad4b59 7b962f3c -> b0dbe165 cfdba177
ca2d9099 a18d3188 -> d4641d84 a4bccce6
b495318a 23a1d131 -> 39f73ca0 bda2d96c
bd7ce8da b69267bf -> e80efb71 84336af3
235eaa32 c670cdcf -> 80e59ecd 6944f065
762f9c23 f767ea2c -> 3f370ca2 23def34c

Aqui estão alguns vetores de teste auto-gerados com chaves diferentes de zero:

format: ( 4x 32-bit word key , 2x 32-bit word plaintext ) -> ( 2x 32-bit word ciphertext )
(all in hexadecimal)

( 4300e123 e39877ae 7c4d7a3c 98335923 , a9afc671 79dcdb73 ) -> ( 5d357799 2ac30c80 )
( 4332fe8f 3a127ee4 a9ca9de9 dad404ad , d1fe145a c84694ee ) -> ( a70b1d53 e7a9c00e )
( 7f62ac9b 2a0771f4 647db7f8 62619859 , 618f1ac2 67c3e795 ) -> ( 0780b34d 2ca7d378 )
( 0462183a ce7edfc6 27abbd9a a634d96e , 887a585d a3f83ef2 ) -> ( d246366c 81b87462 )
( 34c7b65d 78aa9068 599d1582 c42b7e33 , 4e81fa1b 3d22ecd8 ) -> ( 9d5ecc3b 947fa620 )
( f36c977a 0606b8a0 9e3fe947 6e46237b , 5d8e0fbe 2d3b259a ) -> ( f974c6b3 67e2decf )
( cd4b3820 b2f1e5a2 485dc7b3 843690d0 , 48db41bb 5ad77d7a ) -> ( b4add44a 0c401e70 )
( ee2744ac ef5f53ec 7dab871d d58b3f70 , 70c94e92 802f6c66 ) -> ( 61e14e3f 89408981 )
( 58fda015 c4ce0afb 49c71f9c 7e0a16f0 , 6ecdfbfa a705a912 ) -> ( 8c2a9f0c 2f56c18e )
( 87132255 41623986 bcc3fb61 7e6142ce , 9d0eff09 55ac6631 ) -> ( 8919ea55 c7d430c6 )

JavaScript (ES6), 122 118 114 113 bytes

f=
(v,w,k,l,m,n)=>{for(s=0;s<84e9;v+=w*16+k^w+s^(w>>>5)+l,w+=v*16+m^v+s^(v>>>5)+n)s+=0x9e3779b9;return[v>>>0,w>>>0]}
;

<div oninput="[r0.value,r1.value]=f(...[v0,v1,k0,k1,k2,k3].map(i=>parseInt(i.value,16))).map(i=>(i+(1<<30)*4).toString(16).slice(1))">
Plain 0: <input id=v0><br>
Plain 1: <input id=v1><br>
Key 0: <input id=k0><br>
Key 1: <input id=k1><br>
Key 2: <input id=k2><br>
Key 3: <input id=k3><br>
</div>
Cipher 0: <input id=r0 readonly><br>
Cipher 1: <input id=r1 readonly><br>

Nota: Usa aritmética little-endian. Aceita e retorna valores inteiros de 32 bits não assinados. Editar: salvou 4 bytes usando multiplicação em vez de deslocamento para a esquerda. Economizou 4 bytes testando para sevitar uma variável de loop separada. Economizou 1 byte movendo os +=s dentro do for.

Ruby, 114 113 106 bytes

Como o Ruby não possui aritmética de 32 bits, as operações extras de modificação quase causaram o mesmo empate com o Javascript, apesar das outras operações de economia de bytes que o Ruby ...

• (-1 byte de ponto e vírgula extra)
• (-7 bytes de remoção de operações desnecessárias de modificação e mudança de material)

Experimente online!

->v,w,a,b,c,d{s=0
32.times{s+=0x9e3779b9;v+=w*16+a^w+s^w/32+b;v%=m=2**32;w+=v*16+c^v+s^v/32+d;w%=m}
[v,w]}

C, 116 bytes

T(v,w,k,l,m,n,s)unsigned*v,*w;{for(s=0;s+957401312;*v+=*w*16+k^*w+s^*w/32+l,*w+=*v*16+m^*v+s^*v/32+n)s+=2654435769;}

Aceita texto simples como v e w ; chave como k , l , m e n ; e armazena o texto cifrado em v e w .

Teste em Ideone .

J, 149 bytes

4 :0
'u v'=.y
s=.0
m=.2x^32
for.i.32
do.s=.m|s+2654435769
u=.m|u+(22 b.)/(s+v),(2{.x)+4 _5(33 b.)v
v=.m|v+(22 b.)/(s+u),(2}.x)+4 _5(33 b.)u
end.u,v
)

Yay! explícito (Boo!) J! Eu acho que há uma maneira de fazer isso tacitamente, mas provavelmente se tornaria ilegível.

Uso

Leva as chaves como quatro números inteiros de 32 bits no LHS e o texto sem formatação como dois números inteiros de 32 bits no RHS. O prefixo 16bé equivalente 0xem outros idiomas e representa um valor hexadecimal. O builtin hfdformata a saída em uma sequência hexadecimal para facilitar o teste.

    f =: 4 :0
'u v'=.y
s=.0
m=.2x^32
for.i.32
do.s=.m|s+2654435769
u=.m|u+(22 b.)/(s+v),(2{.x)+4 _5(33 b.)v
v=.m|v+(22 b.)/(s+u),(2}.x)+4 _5(33 b.)u
end.u,v
)
   hfd 0 0 0 0 f 0 0
41ea3a0a
94baa940
   hfd 0 0 0 0 f 16b3778001e 16b2bf2226f
96269d3e
82680480
   hfd 16b4300e123 16be39877ae 16b7c4d7a3c 16b98335923 f 16ba9afc671 16b79dcdb73 
5d357799
2ac30c80