对按字节预算的人进行简单加密


17

总览

您的目标是实施RC4加密。RC4加密技术是由RSA著名的Ron Rivest发明的,旨在确保安全性,但又足够简单,可以由战场上的军人从内存中实施。如今,RC4受到多种攻击,但今天仍在许多地方使用。

您的程序应接受包含键和一些数据的单个字符串。它将以这种格式显示。

\x0Dthis is a keythis is some data to encrypt

第一个字节代表密钥多长时间。可以假设密钥将不超过255个字节,并且不小于1个字节。数据可以任意长。

您的程序应处理密钥,然后返回加密的数据。RC4加密和解密是相同的,因此使用相同的密钥“加密”密文应返回原始明文。

RC4如何工作

初始化

RC4的初始化非常简单。256字节的状态数组被初始化为0到255之间的所有字节。

S = [0, 1, 2, 3, ..., 253, 254, 255]

密钥处理

状态值将根据键进行交换。

j = 0
for i from 0 to 255
    j = (j + S[i] + key[i mod keylength]) mod 256
    swap S[i] and S[j]

加密

通过使用状态生成伪随机字节来完成加密,然后将其与数据进行XOR。状态中的值会不断交换。

i = j = 0
for each byte B in data
    i = (i + 1) mod 256
    j = (j + S[i]) mod 256
    swap S[i] and S[j]
    K = S[(S[i] + S[j]) mod 256]
    output K XOR B

预期的投入和产出

不可打印字符将以\xAB格式显示。

输入:\x01\x00\x00\x00\x00\x00\x00
输出:\xde\x18\x89A\xa3
输出(十六进制):de188941a3

输入:\x0Dthis is a keythis is some data to encrypt
输出:\xb5\xdb?i\x1f\x92\x96\x96e!\xf3\xae(!\xf3\xeaC\xd4\x9fS\xbd?d\x82\x84{\xcdN
输出(十六进制):b5db3f691f9296966521f3ae2821f3ea43d49f53bd3f6482847bcd4e

输入:\x0dthis is a key\xb5\xdb?i\x1f\x92\x96\x96e!\xf3\xae(!\xf3\xeaC\xd4\x9fS\xbd?d\x82\x84{\xcdN
输入(十六进制):0d746869732069732061206b6579b5db3f691f9296966521f3ae2821f3ea43d49f53bd3f6482847bcd4e
输出:this is some data to encrypt

输入:Sthis is a rather long key because the value of S is 83 so the key length must matchand this is the data to be encrypted
输出:\x96\x1f,\x8f\xa3%\x9b\xa3f[mk\xdf\xbc\xac\x8b\x8e\xfa\xfe\x96B=!\xfc;\x13`c\x16q\x04\x11\xd8\x86\xee\x07
输出(十六进制):961f2c8fa3259ba3665b6d6bdfbcac8b8efafe96423d21fc3b13606316710411d886ee07


您想要哪种输出方式,或者我们可以选择哪种输出方式?十六进制将是首选
andrewarchi

@andrewarchi输出应该以字节为单位,因此可以循环回进行解密。
Daffy

1
我们也可以将输入作为字节数组吗?
Arnauld

1
@andrewarchi这些表示法只是为了提高可读性。如果您的程序应该输出\xde,则它应为1个字节长,并将其转换为数字(通过python ord()或javascript .charCodeAt(0))应返回222(0xDE)。
Daffy

1
@Arnauld考虑到在许多语言中两者基本上是无法区分的,是的。
Daffy

Answers:


3

的JavaScript(ES6),169个 168字节

将输入作为字节数组。返回另一个字节数组。

([l,...s])=>s.slice(l).map(b=>b^S[(S[S[J=J+(t=S[I=I+1&m])&m,I]=x=S[J],J]=t)+x&m],[...S=[...Array(m=255).keys(),m]].map(i=>S[S[i]=S[j=j+(t=S[i])+s[i%l]&m],j]=t,I=J=j=0))

怎么样?

这本质上是规范的字面实现。

我们首先将输入数组分为l(键的长度)和s(有效载荷数据:键+消息)。然后,按执行顺序:

  • 我们初始化状态数组S并定义m = 255,以后将其重复用作位掩码。

    S = [...Array(m = 255).keys(), m]
  • 我们重新整理状态数组。在下一步中实际使用在此初始化的索引IJ。

    [...S].map(i =>
      S[S[i] = S[j = j + (t = S[i]) + s[i % l] & m], j] = t,
      I = J = j = 0
    )
  • 我们应用加密。

    s.slice(l).map(b =>
      b ^ S[
        (S[S[J = J + (t = S[I = I + 1 & m]) & m, I] = x = S[J], J] = t) +
        x & m
      ]
    )
    

测试用例


13

138个字节,机器代码(16位x86)

000000 88 9f 00 02 fe c3 75 f8 b9 01 00 89 fa b4 3f cd
000010 21 86 0d ba 00 03 b4 3f cd 21 89 dd 01 f6 02 9e
000020 00 03 8a 04 00 c3 86 87 00 02 88 04 46 45 39 cd
000030 75 02 31 ed 81 fe 00 03 75 e4 81 ee 00 01 31 db
000040 31 d2 ff c6 81 fe 00 03 75 04 81 ee 00 01 8a 04
000050 00 c3 88 c2 86 87 00 02 88 04 00 c2 89 d7 81 c7
000060 00 02 8a 15 89 d7 89 dd 31 db ba 00 03 b9 01 00
000070 b8 00 3f cd 21 87 fa 30 15 85 c0 74 0b 87 fa 43
000080 b4 40 cd 21 89 eb eb b8 cd 20

运行:保存到codegolf.com,dosbox:

codegolf.com < input.bin

成功尝试

我不知道这是否算作一项,但我决定 使用十六进制编辑器手动进行。没有编译器用于执行此操作。

该编辑器实际上具有汇编程序,但老实说,直到完成后我才知道。

为什么和如何

原因:主要是因为我想检查一下是否能够做到这一点。

如何:我首先创建NOP了一个用s 填充的字节,然后是一个简单的部分:尝试编写第一个循环,S以0..255的值填充tate。我切换到python并迅速编写了python版本,只是为了进行测试。接下来,我将python代码简化为伪代码/伪汇编。然后,我试图写一些小片段。我认为从stdin读取内容最容易,因此我从读取单个字节的小内容开始,然后添加了密码读取和密钥初始化功能。弄清楚该选哪个寄存器花了我一些时间。

虽然添加de / encryption循环会很容易,但是首先我实际上得到了单字节解码,然后又添加了整个循环。

最后一步是摆脱nops编写指令时在指令之间留下的其他内容(ofc也需要修复跳转)。

您可以看到我在这里前进时尝试制作的小画廊

解剖

该程序在启动后依赖于一些初始值(请参见下面的资源)。

00000000 889f0002                  mov         [bx+0200], bl
00000004 fec3                      inc         bl
00000006 75f8                      jnz         0x0

填写州(0x200)

00000008 b90100                    mov         cx, 0x1
0000000b 89fa                      mov         dx, di
0000000d b43f                      mov         ah, 0x3f
0000000f cd21                      int         0x21
00000011 860d                      xchg        [di], cl
00000013 ba0003                    mov         dx, 0300
00000016 b43f                      mov         ah, 0x3f
00000018 cd21                      int         0x21

读取长度,读取密码,将密码存储在ds:0x300

0000001a 89dd                      mov         bp, bx
0000001c 01f6                      add         si, si
0000001e 029e0003                  add         bl, [bp+0300]
00000022 8a04                      mov         al, [si]
00000024 00c3                      add         bl, al
00000026 86870002                  xchg        [bx+0200], al
0000002a 8804                      mov         [si], al
0000002c 46                        inc         si
0000002d 45                        inc         bp
0000002e 39cd                      cmp         bp, cx
00000030 7502                      jnz         0x34
00000032 31ed                      xor         bp, bp
00000034 81fe0003                  cmp         si, 0300
00000038 75e4                      jnz         0x1e

用键初始化状态(BP用于遍历键,SI用于遍历状态)

0000003a 81ee0001                  sub         si, 0100
0000003e 31db                      xor         bx, bx
00000040 31d2                      xor         dx, dx
00000042 ffc6                      inc         si
00000044 81fe0003                  cmp         si, 0300
00000048 7504                      jnz         0x4e
0000004a 81ee0001                  sub         si, 0100
0000004e 8a04                      mov         al, [si]
00000050 00c3                      add         bl, al
00000052 88c2                      mov         dl, al
00000054 86870002                  xchg        [bx+0200], al
00000058 8804                      mov         [si], al
0000005a 00c2                      add         dl, al
0000005c 89d7                      mov         di, dx
0000005e 81c70002                  add         di, 0200
00000062 8a15                      mov         dl, [di]

生成伪随机值(in DLDH是0x140处xor的0 thx)

00000064 89d7                      mov         di, dx      
00000066 89dd                      mov         bp, bx      
00000068 31db                      xor         bx, bx      
0000006a ba0003                    mov         dx, 0300    
0000006d b90100                    mov         cx, 0x1     
00000070 b8003f                    mov         ax, 3f00    
00000073 cd21                      int         0x21        
00000075 87fa                      xchg        dx, di      
00000077 3015                      xor         [di], dl    
00000079 85c0                      test        ax, ax      
0000007b 740b                      jz          0x88        
0000007d 87fa                      xchg        dx, di      
0000007f 43                        inc         bx          
00000080 b440                      mov         ah, 0x40    
00000082 cd21                      int         0x21        
00000084 89eb                      mov         bx, bp      
00000086 ebb8                      jmp         0x40        
00000088 cd20                      int         0x20        
  • 存储我们需要保留的值(SI-不会碰到它,BX
  • 从输入读取字符,对其进行异或
  • 流结束时退出
  • 输出解码的字符
  • 恢复值
  • 循环到0x40(在上重用xor DX

PS:这可能会更短,但是这花了四个晚上,所以不确定我是否要再花一个...

工具和资源


4

C(gcc)193188182178171172字节

f(x,l)int*x;{unsigned char*X=x,i=0,j=0,S[256],t;for(;S[i]=++i;);for(;t=S[i],S[i]=S[j+=t+X[1+i%*X]],S[j]=t,t=++i;);for(X+=*X;l--;S[i]-=S[t]=j)*++X^=S[S[i]+=S[t+=j=S[++i]]];}

在线尝试!

编辑:现在可以使用超过127个字节的密钥。

Edit2:向TIO链接添加了具有129字节密钥的测试用例。

高尔夫版本略少

f(x,l)int*x;{
  unsigned char*X=x,i=0,j=0,S[256],t;
  // initialize state
  for(;S[i]=++i;);
  // key processing
  for(;t=S[i],S[i]=S[j+=t+X[1+i%*X]],S[j]=t,t=++i;);
  // encrypt
  for(X+=*X;l--;S[i]-=S[t]=j)
    *++X^=S[S[i]+=S[t+=j=S[++i]]];
}

您不担心通用C编译器的错误吗?是未定义的行为s [i] = ++ i?是的,我知道可能唯一重要的是编译器的一种用途……
RosLuP

对于在“密钥处理”中编写的内容,部分密钥必须小于等于256字节...(因为其他字符不会影响计算和交换)
RosLuP

以及为什么在参数中使用char *而不是int *是不可能的(仅使用较少的字符)?即使对于129个字节长的键,我似乎也可以。。。似乎未定义的行为
RosLuP

4

CPU x86指令集,133个字节

000009F8  53                push ebx
000009F9  56                push esi
000009FA  57                push edi
000009FB  55                push ebp
000009FC  55                push ebp
000009FD  BF00010000        mov edi,0x100
00000A02  29FC              sub esp,edi
00000A04  8B6C3C18          mov ebp,[esp+edi+0x18]
00000A08  31DB              xor ebx,ebx
00000A0A  8A5D00            mov bl,[ebp+0x0]
00000A0D  45                inc ebp
00000A0E  31C0              xor eax,eax
00000A10  880404            mov [esp+eax],al
00000A13  40                inc eax
00000A14  39F8              cmp eax,edi
00000A16  72F8              jc 0xa10
00000A18  31F6              xor esi,esi
00000A1A  31C9              xor ecx,ecx
00000A1C  89F0              mov eax,esi
00000A1E  31D2              xor edx,edx
00000A20  F7F3              div ebx
00000A22  8A0434            mov al,[esp+esi]
00000A25  02441500          add al,[ebp+edx+0x0]
00000A29  00C1              add cl,al
00000A2B  8A0434            mov al,[esp+esi]
00000A2E  8A140C            mov dl,[esp+ecx]
00000A31  88040C            mov [esp+ecx],al
00000A34  881434            mov [esp+esi],dl
00000A37  46                inc esi
00000A38  39FE              cmp esi,edi
00000A3A  72E0              jc 0xa1c
00000A3C  8B443C1C          mov eax,[esp+edi+0x1c]
00000A40  01E8              add eax,ebp
00000A42  722F              jc 0xa73
00000A44  48                dec eax
00000A45  89C6              mov esi,eax
00000A47  01DD              add ebp,ebx
00000A49  31C0              xor eax,eax
00000A4B  31D2              xor edx,edx
00000A4D  31C9              xor ecx,ecx
00000A4F  39F5              cmp ebp,esi
00000A51  7320              jnc 0xa73
00000A53  FEC2              inc dl
00000A55  8A0414            mov al,[esp+edx]
00000A58  00C1              add cl,al
00000A5A  8A1C0C            mov bl,[esp+ecx]
00000A5D  88040C            mov [esp+ecx],al
00000A60  881C14            mov [esp+edx],bl
00000A63  00D8              add al,bl
00000A65  8A1C04            mov bl,[esp+eax]
00000A68  8A4500            mov al,[ebp+0x0]
00000A6B  30D8              xor al,bl
00000A6D  884500            mov [ebp+0x0],al
00000A70  45                inc ebp
00000A71  EBDC              jmp short 0xa4f
00000A73  01FC              add esp,edi
00000A75  5D                pop ebp
00000A76  5D                pop ebp
00000A77  5F                pop edi
00000A78  5E                pop esi
00000A79  5B                pop ebx
00000A7A  C20800            ret 0x8
00000A7D

A7D-9F8 = 85h = 133字节,但我不知道计算是否可以,因为同一函数的前置字节数为130字节...我命名为“ cript”的函数的第一个参数是字符串,第二个参数是字符串长度(第一个字节+密钥长度+消息长度)。下面是用于获取该cript例程的汇编语言文件:

; nasmw -fobj  this.asm

section _DATA use32 public class=DATA
global cript
section _TEXT use32 public class=CODE

cript:    
      push    ebx
      push    esi
      push    edi
      push    ebp
      push    ebp
      mov     edi,  256
      sub     esp,  edi
      mov     ebp,  dword[esp+  edi+24]
      xor     ebx,  ebx
      mov     bl,  [ebp]
      inc     ebp
      xor     eax,  eax
.1:   mov     [esp+eax],  al
      inc     eax
      cmp     eax,  edi
      jb      .1
      xor     esi,  esi
      xor     ecx,  ecx
.2:   mov     eax,  esi
      xor     edx,  edx
      div     ebx
      mov     al,  [esp+esi]
      add     al,  [ebp+edx]
      add     cl,  al
      mov     al,  [esp+esi]
      mov     dl,  [esp+ecx]
      mov     [esp+ecx],  al
      mov     [esp+esi],  dl
      inc     esi
      cmp     esi,  edi
      jb      .2
      mov     eax,  dword[esp+  edi+28]
      add     eax,  ebp
      jc      .z
      dec     eax
      mov     esi,  eax
      add     ebp,  ebx
      xor     eax,  eax
      xor     edx,  edx
      xor     ecx,  ecx
.3:   cmp     ebp,  esi
      jae     .z
      inc     dl
      mov     al,  [esp+edx]
      add     cl,  al
      mov     bl,  [esp+ecx]
      mov     [esp+ecx],  al
      mov     [esp+edx],  bl ; swap S[c] S[r]
      add     al,  bl
      mov     bl,  [esp+eax]
      mov     al,  [ebp]
      xor     al,  bl
      mov     [ebp],  al
      inc     ebp
      jmp     short  .3
.z:       
      add     esp,  edi
      pop     ebp
      pop     ebp
      pop     edi
      pop     esi
      pop     ebx
      ret     8

C文件下方的检查结果:

// Nasmw  -fobj  fileasm.asm
// bcc32 -v filec.c fileasm.obj
#include <stdio.h>

void _stdcall cript(char*,unsigned);

char es1[]="\x01\x00\x00\x00\x00\x00\x00";
char es2[]="\x0Dthis is a keythis is some data to encrypt";
char es3[]="\x0dthis is a key\xb5\xdb?i\x1f\x92\x96\226e!\xf3\xae(!\xf3\xea\x43\xd4\x9fS\xbd?d\x82\x84{\xcdN";
char es4[]="Sthis is a rather long key because the value of S is 83 so the key length must matchand this is the data to be encrypted";

void printMSGKeyC(unsigned char* a, unsigned len)
{unsigned i,j,k;
 unsigned char *p,*end;

 printf("keylen = %u\nKey    = [", (unsigned)*a);
 for(i=1, j=*a;i<=j;++i) printf("%c", a[i]);
 printf("]\nMessage= [");
 for(p=a+i,end=a+len-1;p<end;++p)printf("%c", *p);
 printf("]\n");
}

void printMSGKeyHex(unsigned  char* a, unsigned len)
{unsigned i,j,k;
 unsigned char *p,*end;

 printf("keylen = %u\nKey    = [", (unsigned)*a);
 for(i=1, j=*a;i<=j;++i) printf("%02x", a[i]);
 printf("]\nMessage= [");
 for(p=a+i,end=a+len-1;p<end;++p)printf("%02x", *p);
 printf("]\n");
}


main()
{printf("sizeof \"%s\"= %u [so the last byte 0 is in the count]\n", "this", sizeof "this");

 printf("Input:\n");
 printMSGKeyHex(es1, sizeof es1);
 cript(es1,  (sizeof es1)-1);
 printf("Afther I cript:\n");
 printMSGKeyHex(es1, sizeof es1);

 printf("Input:\n");
 printMSGKeyC(es2, sizeof es2);
 printMSGKeyHex(es2, sizeof es2);
 cript(es2,  (sizeof es2)-1);
 printf("Afther I cript:\n");
 printMSGKeyC(es2, sizeof es2);
 printMSGKeyHex(es2, sizeof es2);
 cript(es2,  (sizeof es2)-1);
 printf("Afther II cript:\n");
 printMSGKeyC(es2, sizeof es2);
 printMSGKeyHex(es2, sizeof es2);
 printf("----------------------\n");

 printf("Input:\n");
 printMSGKeyHex(es3, sizeof es3);
 cript(es3,  (sizeof es3)-1);
 printf("Afther I cript:\n");
 printMSGKeyHex(es3, sizeof es3);
 printf("----------------------\n");

 printf("Input:\n");
 printMSGKeyHex(es4, sizeof es4);
 cript(es4,  (sizeof es4)-1);
 printf("Afther I cript:\n");
 printMSGKeyHex(es4, sizeof es4);
 cript(es4,  (sizeof es4)-1);
 printf("Afther II cript:\n");
 printMSGKeyHex(es4, sizeof es4);

 return 0;
}

结果:

 sizeof "this"= 5 [so the last byte 0 is in the count]
Input:
keylen = 1
Key    = [00]
Message= [0000000000]
Afther I cript:
keylen = 1
Key    = [00]
Message= [de188941a3]
Input:
keylen = 13
Key    = [this is a key]
Message= [this is some data to encrypt]
keylen = 13
Key    = [746869732069732061206b6579]
Message= [7468697320697320736f6d65206461746120746f20656e6372797074]
Afther I cript:
keylen = 13
Key    = [this is a key]
Message= [Á█?iÆûûe!¾«(!¾ÛCȃS¢?déä{═N]
keylen = 13
Key    = [746869732069732061206b6579]
Message= [b5db3f691f9296966521f3ae2821f3ea43d49f53bd3f6482847bcd4e]
Afther II cript:
keylen = 13
Key    = [this is a key]
Message= [this is some data to encrypt]
keylen = 13
Key    = [746869732069732061206b6579]
Message= [7468697320697320736f6d65206461746120746f20656e6372797074]
----------------------
Input:
keylen = 13
Key    = [746869732069732061206b6579]
Message= [b5db3f691f9296966521f3ae2821f3ea43d49f53bd3f6482847bcd4e]
Afther I cript:
keylen = 13
Key    = [746869732069732061206b6579]
Message= [7468697320697320736f6d65206461746120746f20656e6372797074]
----------------------
Input:
keylen = 83
Key    = [74686973206973206120726174686572206c6f6e67206b65792062656361757365207468652076616c7565206f66205320697320383320736f20746865206b6579206c656e677468206d757374206d61746368]
Message= [616e64207468697320697320746865206461746120746f20626520656e63727970746564]
Afther I cript:
keylen = 83
Key    = [74686973206973206120726174686572206c6f6e67206b65792062656361757365207468652076616c7565206f66205320697320383320736f20746865206b6579206c656e677468206d757374206d61746368]
Message= [961f2c8fa3259ba3665b6d6bdfbcac8b8efafe96423d21fc3b13606316710411d886ee07]
Afther II cript:
keylen = 83
Key    = [74686973206973206120726174686572206c6f6e67206b65792062656361757365207468652076616c7565206f66205320697320383320736f20746865206b6579206c656e677468206d757374206d61746368]
Message= [616e64207468697320697320746865206461746120746f20626520656e63727970746564]

3

JavaScript(ES6),262个字节

我考虑只使用链接函数,但选择对此处给出的算法进行高尔夫化:https ://gist.github.com/farhadi/2185197 。

A=>eval(`for(C=A[c='charCodeAt']
(),K=A.slice(1,++C),T=A.slice(C),i=j=k=l=m=y=0,s=[],r=[],a=256;i<a;)s[i]=i++
for(;j<a;){t=s[k=(k+s[j]+K[c](j%K.length))%a]
s[k]=s[j]
s[j++]=t}for(;y<T.length;){r[y]=T[c](y++)^s[((t=s[m=(m+s[l=++l%a])%a])+
(s[m]=s[l]))%a]
s[l]=t}r`)

少打高尔夫球

A=>{
  C=A.charCodeAt()
  K=A.slice(1,++C)
  T=A.slice(C)
  for(i=j=k=l=m=y=0,s=[],r=[];i<256;)s[i]=i++
  for(;j<256;){
    t=s[k=(k+s[j]+K.charCodeAt(j%K.length))%256];
    s[k]=s[j];
    s[j++]=t;
  }
  for(;y<T.length;){
    t=s[m=(m+s[l=(l+1)%256])%256];
    s[m]=s[l];
    s[l]=t;
    r[y]=T.charCodeAt(y++)^s[(s[l]+s[m])%256];
  }
  return r;
}


2
+1当人们提供高尔夫球编码说明时,我总是很感激。
达菲(Daffy),

2

Python 2,203字节

def f(x):
	def h():S[i],S[j]=S[j],S[i]
	m=256;x=map(ord,x);S=range(m);l=x.pop(0);j=0
	for i in S[:]:j=(j+S[i]+x[i%l])%m;h()
	i=j=0
	for b in x[l:]:i=(i+1)%m;j=(j+S[i])%m;h();yield chr(S[(S[i]+S[j])%m]^b)

在线尝试!

f 是字符串的生成器(可迭代)。

取消高尔夫:

def f(x):
    def h():
        S[i], S[j] = S[j], S[i]  # we have to do this two times
    m = 256  # used often
    x = map(ord, x)  # get numbers to do stuff with
    S = range(m)  # init State
    l = x.pop(0)  # get key length and remove the first byte in one go
    j = 0
    for i in S[:]:  # shorter than range(256)
        j = (j + S[i] + x[i%l]) % m
        h()
    i = j = 0
    for b in x[l:]:  # data comes after the key
        i = (i+1) % m
        j = (j+S[i]) % m
        h()
        yield chr(S[(S[i]+S[j]) % m] ^ b)  # convert to str again

1

Ruby,234个字节

未经测试。

->s{l=s[0].ord;k=s[1..l];i=s[l+1..-1];o='';s=[*0..255];i,j,q=0;256.times{|i|j=(j+s[i]+k[i%k.size].ord)%256;s[i],s[j]=s[j],s[i]};i.size.times{|k|i=(i+1)%256;q=(q+s[i])%256;s[i],s[q]=s[q],s[i];b=s[(s[i]+s[q])%256];o<<(b^i[k].ord).chr;o}

1

C,181字节

f(a,n)char*a;{unsigned char A=*a++,i=-1,j=0,k,s[256];for(;s[i]=i;--i);for(;k=s[i],s[i]=s[j+=k+a[i%A]],s[j]=k,k=++i;);for(n-=A,a+=A;--n;*a++^=s[j+=A])j=s[++i],A=s[i]=s[k+=j],s[k]=j;}

多亏了ceilingcat少了一些字节:

f(a,n)char*a;
{unsigned char A=*a++,i=-1,j=0,k,s[256];
 for(;s[i]=i;--i);
 for(;k=s[i],s[i]=s[j+=k+a[i%A]],s[j]=k,k=++i;);
 for(n-=A,a+=A;--n;*a++^=s[j+=A])j=s[++i],A=s[i]=s[k+=j],s[k]=j;
}

在“ a”中的f(a,n)将有1个字节的字符数组len + key + message;在n中,存在“ a”的所有数组的大小,不计最后一个'\ 0'。用于测试和结果的代码将作为用于汇编功能的代码。


@ceilingcat函数n的参数,这里是所有字符数组的长度(1byte +键+消息)...它的消息长度必须为:nk-1,其中k是键的长度,n是所有字符数组的长度。
RosLuP

@ceilingcat给我打电话“ f(a,sizeof a);” 是错误的,因为sizeof将字符串末尾的附加字符'\ 0'计算为'a'的长度...因此它必须是f(a,(sizeof a)-1)
RosLuP

我不同意这个“,* ++ a ^ = s [j + = s [i]])”在我看来,这里对s数组读取了2次,而在另一条类似的指令中,结果却不同。 ..
RosLuP

1

APL(NARS),329个字符,658个字节

xor←{⍺<0:¯1⋄⍵<0:¯1⋄⍺=0:⍵⋄⍵=0:⍺⋄k←⌈/{⌊1+2⍟⍵}¨⍺⍵⋄(2⍴⍨≢m)⊥m←↑≠/{(k⍴2)⊤⍵}¨⍺⍵}
∇r←C w;s;i;j;l;t;b;x
k←256⋄s←¯1+⍳k⋄i←j←0⋄l←¯1+⎕AV⍳↑w
t←s[1+i]⋄j←k∣¯1+j+t+⎕AV⍳w[2+l∣i]⋄s[1+i]←s[1+j]⋄s[1+j]←t⋄i+←1⋄→2×⍳i<k
i←j←0⋄b←≢w⋄l+←1
l+←1⋄→6×⍳l>b⋄i←k∣i+1⋄t←s[1+i]⋄j←k∣j+t⋄s[1+i]←s[1+j]⋄s[1+j]←t
x←s[1+k∣t+s[1+i]] xor ¯1+⎕AV⍳w[l]⋄w[l]←⎕AV[1+x]⋄→4
r←w
∇

像往常一样,将错误检查要求给其他人...这似乎可以在输入和输出上进行测试:

  str2Hex←{∊{'0123456789ABCDEF'[1+{(2⍴16)⊤⍵}⍵]}¨{¯1+⎕AV⍳⍵}⍵}
  str2Hex ⎕AV[2,1,1,1,1,1,1]
01000000000000
  str2Hex C ⎕AV[2,1,1,1,1,1,1]
0100DE188941A3
  str2Hex C C ⎕AV[2,1,1,1,1,1,1]
01000000000000
  str2Hex C ⎕AV[14],'this is a keythis is some data to encrypt'
0D746869732069732061206B6579B5DB3F691F9296966521F3AE2821F3EA43D49F53BD3F6482847BCD4E
  C C ⎕AV[14],'this is a keythis is some data to encrypt'

this is a keythis is some data to encrypt

  str2Hex C 'Sthis is a rather long key because the value of S is 83 so the key length must matchand this is the data to be encrypted'
5374686973206973206120726174686572206C6F6E67206B65792062656361757365207468652076616C7565206F662053
  20697320383320736F20746865206B6579206C656E677468206D757374206D61746368961F2C8FA3259BA3665B6D
  6BDFBCAC8B8EFAFE96423D21FC3B13606316710411D886EE07

  C C 'Sthis is a rather long key because the value of S is 83 so the key length must matchand this is the data to be encrypted'
Sthis is a rather long key because the value of S is 83 so the key length must matchand this is th
  e data to be encrypted

是的,所有这些都可以减少...但是例如,减少xor函数的功能可能意味着减少通用性...


0

锈348

fn rc4(n:Vec<u8>)->Vec<u8>{let(mut s,mut j,mut t,l)=((0..256).collect::<Vec<usize>>(),0,0,n[0] as usize);let(key,msg)=n[1..].split_at(l);(0..256).fold(0,|a,i|{j=(a+s[i]+key[i%l] as usize)%256;t=s[i];s[i]=s[j];s[j]=t;j});j=0;(1..).zip(msg.iter()).map(|(i,b)|{j=(j+s[i])%256;t=s[i];s[i]=s[j];s[j]=t;s[(s[i]+s[j])%256]as u8^b}).collect::<Vec<u8>>()}

这非常大,我希望也许有人可以提供一些建议。

取消高尔夫:在play.rust-lang.org操场上


建议k而不是,keym不是,msgfoo&255不是(foo)%256
ceilingcat '19
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.