Java:Base64使用键对字符串进行编码

嗨，我有数据和一个键（两个字符串）。数据需要使用Base64键进行编码。有人能给我一个示例代码吗。

您可以使用apache commons编解码器库的类。下面是它的用法。

Base64不适用于“使用密钥编码”。它只是一种编码方案：您可以使用Base64对字符串进行加密和解密，而无需任何额外的。它只是用于非常（非常）基本的安全用途。

您可以使用密钥对数据进行异或运算，然后对其进行base64编码

var key = "mykey";
var mydata = "some long text here";
var output = '';

for (var i = 0, len = mydata.length; i < len; i++) {
   output += String.fromCharCode(mydata.charCodeAt(i) ^ key.charCodeAt(i % key.length));
}

var key=“mykey”；
var mydata=“此处有一些长文本”；
var输出=“”；
对于（var i=0，len=mydata.length；i

---

然后使用某个地方的某个函数将“输出”编码到base64

您可以使用对称二进制加密算法，如Twofish或RC4，该算法使用这样的密钥，然后将结果编码到base-64。

base64不包括使用密钥加密的功能。您可以先使用AES、DES等进行加密，然后使用base64进行编码。

如果需要使用密钥使用base64进行编码，那么即使标准中没有定义，实际上也不难做到这一点

Base64使用由64个符号组成的字母表。前62个符号是英文字母的小写和大写字母，加上0到9之间的数字。最后两个字符通常是+和/，但它们在不同的实现中可能有所不同

现在请理解，当您将字符串拆分为位，并使用6位而不是每个符号8位对其进行重新分组时，您将始终能够在字母表中查找符号，因为6位数字正好有64个不同的可能值。Base64仅枚举从%000000（0）到111111（63）的符号。但您可以在此符号查找过程中使用密钥。假设您的6位数字是%000011（3），那么它将索引字母表中的第4个符号。但现在您可以使用密钥修改索引，将其向左或向右移动（例如）等于密钥字符ASCII码的位置数（8位数字）。当你的索引超出范围（低于0或高于63）时，你只需将它传送到范围的另一侧。如果在编码过程中向右移动索引，则使用左方向进行解码（反之亦然）。基本上，您是在使用由键的字符定义的模式对符号查找进行置乱

现在，您只需使用带有密钥的Base64编码（而不是先为输入设置密钥，然后进行编码）。不客气

既然您要求一个代码示例，下面是我编写的对象Pascal中的一个快速示例。如果您首先为最终字符串分配内存，然后将其写入，而不是在循环中连接到字符串，循环每次都会重新分配内存，那么这段代码可能会更快—但如果您需要更好的性能，您可以自己解决：

const 
      C_ALPHABIG      = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
      C_ALPHASMALL    = 'abcdefghijklmnopqrstuvwxyz';
      C_ALPHA         = C_ALPHABIG+C_ALPHASMALL;
      C_DIGITS        = '0123456789';
      C_SYMBOLS       = '+/';
      C_ALPHABET      = C_ALPHA+C_DIGITS+C_SYMBOLS;

    type 
      TIndexShiftDirection = (isdLeft, isdRight);

      Function ShiftSymbolIndex(const AIndex: integer; const AKey: string; var ACurrentKeyPos: integer; const ADirection: TIndexShiftDirection): integer;
       begin
         Result := AIndex; if(AKey='')then exit;
         if(ACurrentKeyPosLength(AKey))then ACurrentKeyPos := 1;
         if(ADirection=isdRight)
           then begin
                  Result := Result+Ord(AKey[ACurrentKeyPos]);
                  if(Result>64)then Result := Result mod 64;
                  if(Result=0)then Result :=64;
                end
           else begin
                  Result := Result-Ord(AKey[ACurrentKeyPos]);
                  if(Result=Length(AKey))
           then ACurrentKeyPos := 1
           else inc(ACurrentKeyPos);
       end;

      Function  Encode64(const s: string; const Key: string): string;
       var
         i,n,p,k : integer;
         a,b,c,d : byte;
       begin
         Result   := ''; k := 1; if(s='')then exit;
         n := Length(s)div 3;
         if(n>0)then for i:=0 to n-1 do
           begin
             p := (i*3)+1;
             a := (ord(s[p])shr 2); inc(a);
             b := ((ord(s[p])and %00000011)shl 4)+(ord(s[p+1])shr 4); inc(b);
             c := ((ord(s[p+1])and %00001111)shl 2)+(ord(s[p+2])shr 6); inc(c);
             d := ord(s[p+2])and %00111111; inc(d);
           //
             a := ShiftSymbolIndex(a,key,k, isdRight);
             b := ShiftSymbolIndex(b,key,k, isdRight);
             c := ShiftSymbolIndex(c,key,k, isdRight);
             d := ShiftSymbolIndex(d,key,k, isdRight);
           //
             Result := Result
                     + C_ALPHABET[a]
                     + C_ALPHABET[b]
                     + C_ALPHABET[c]
                     + C_ALPHABET[d];
           end;
         n := Length(s)-(n*3);
         if(n=0)then begin {Result := Result+'0';} exit; end;
         case n of
           1: begin
                p := Length(s);
                a := (ord(s[p])shr 2);         inc(a); a := ShiftSymbolIndex(a,key,k, isdRight);
                b := (ord(s[p])and %00000011); inc(b); b := ShiftSymbolIndex(b,key,k, isdRight);
                Result := Result
                        + C_ALPHABET[a]
                        + C_ALPHABET[b]
                        {+ '2'};//if Length(endoced_str)mod 4 = 2, then this case is true
              end;
           2: begin
                p := Length(s)-1;
                a := (ord(s[p])shr 2);
                b := ((ord(s[p])and %00000011)shl 4)+(ord(s[p+1])shr 4);
                c := (ord(s[p+1])and %00001111);
                inc(a); a := ShiftSymbolIndex(a,key,k, isdRight);
                inc(b); b := ShiftSymbolIndex(b,key,k, isdRight);
                inc(c); c := ShiftSymbolIndex(c,key,k, isdRight);
                Result := Result
                        + C_ALPHABET[a]
                        + C_ALPHABET[b]
                        + C_ALPHABET[c]
                        {+ '4'};//if Length(endoced_str)mod 4 = 3, then this case is true
              end;
         end;
       end;

      Function  Decode64(const s: string; const Key: string): string;
       var
         n,i,p,k : integer;
         a,b,c,d : byte;
       begin
         Result := ''; k:=1; if(s='')then exit;
         n := Length(s)div 4;
         if(n>0)then for i:=0 to n-1 do
           begin
             p := (i*4)+1;
             a := Pos(s[p],C_ALPHABET);   a := ShiftSymbolIndex(a,key,k, isdLeft);
             b := Pos(s[p+1],C_ALPHABET); b := ShiftSymbolIndex(b,key,k, isdLeft);
             c := Pos(s[p+2],C_ALPHABET); c := ShiftSymbolIndex(c,key,k, isdLeft);
             d := Pos(s[p+3],C_ALPHABET); d := ShiftSymbolIndex(d,key,k, isdLeft);
             if(a*b*c*d=0)then begin Result := ''; exit; end; //cannot be, if symbols are valid
             Result := Result
                     + chr(((a-1)shl 2) + ((b-1)shr 4))
                     + chr((((b-1)and %001111)shl 4) + ((c-1)shr 2))
                     + chr((((c-1)and %000011)shl 6) + (d-1));
           end;
         n := Length(s)mod 4;
         if(n=0)then exit;
         case n of
           2: begin
                p := Length(s)-1;
                a := Pos(s[p],C_ALPHABET);   a := ShiftSymbolIndex(a,key,k, isdLeft);
                b := Pos(s[p+1],C_ALPHABET); b := ShiftSymbolIndex(b,key,k, isdLeft);
                if(a*b=0)then begin Result := ''; exit; end; //cannot be, if symbols are valid
                Result := Result
                        + chr(((a-1)shl 2) + (b-1));
              end;
           3: begin
                p := Length(s)-2;
                a := Pos(s[p],C_ALPHABET);
                b := Pos(s[p+1],C_ALPHABET);
                c := Pos(s[p+2],C_ALPHABET);
                if(a*b*c=0)
                  then begin Result := ''; exit; end; //cannot be, if symbols are valid
                a := ShiftSymbolIndex(a,key,k, isdLeft);
                b := ShiftSymbolIndex(b,key,k, isdLeft);
                c := ShiftSymbolIndex(c,key,k, isdLeft);
                Result := Result
                        + chr(((a-1)shl 2) + ((b-1)shr 4))
                        + chr((((b-1)and %001111)shl 4) + (c-1));
              end;
           else Result := '';
         end;
       end;  

注意功能ShiftSymbolIndex-这是符号查找扰频器，它可以向右或向左移动符号索引。我在编码器中使用右键，在编码器中使用左键，但这一切都取决于您。 如果跳过Encode64或Decode64函数中的键参数（或如果传递空字符串键），则最终将使用默认的Base64编码/解码

---

此外，此编码器不会将填充（=”字符）附加到base64编码的字符串。解码时不需要填充，除非解码器在严格模式下工作（此编码器不是）-但是，您可以自己确定。

Base64纯粹是编码；不能使用base64进行加密或解密，因为根据定义，加密是使用密钥进行编码的，并且由于不能将密钥与base64一起使用，因此它不能是任何类型的加密

Base64是编码，用于将数据转换为任何人都可以反转的新类型。你会听到人们告诉你这是为了混淆等等，其实不是；这不是编码的目的

因此，对于您的问题，base64不能接受密钥；它只能进行编码，而编码不使用密钥。有一些加密机制，比如最简单的XOR，可以接受密钥并进行加密

编码+密钥=加密 编码=将数据转换为任何人都可以反转的另一种类型，永远不使用密钥 哈希=数据的单向数学函数，用于“指纹”您的数据。它不可反转，用于验证数据未更改

---

这种混淆的根源是我们使用“编码”一词来表示特定的事情，而不是加密，我们还使用“编码”作为加密必须完成的过程。用同一个词来解释两个相关但不同的东西会造成很多混乱。

一个词不会用“键”编码。它（base64）是一种编码方案，而不是加密算法。话虽如此，我对真正的目标感到困惑——也许标题选择得很糟糕。+1对你来说，但可能是OP希望使用某种“密钥”（不管他是什么意思：PKCS的公钥或对称密钥等）进行编码，然后使用Base64对结果进行编码。