C #: Blowfish Encipher ein einzelnes dword

Question

Ich bin ein C ++ TCP-Client in C # .Der Client übersetzt wird verwendet 4 Bytes eines Arrays zu kodieren blowfish verwenden.

C ++ Blowfish

C # Blowfish (C # NET)

C ++

    BYTE response[6] = 
    {
        0x00, 0x80, 0x01, 0x61, 0xF8, 0x17
    };

    // Encrypt the last 4 bytes of the packet only(0x01,0x061,0xF8,0x17)
    blowfish.Encode(responce + 2, responce + 2, 4); 

    // Send the packet
    send(s, (char*)sendPtr, sendSize, 0);

C #

    responce  = new byte[6] { 0x00, 0x80, 0x01, 0x61, 0xF8, 0x17};

    // Encrypt the last 4 bytes of the packet only(0x01,0x061,0xF8,0x17)
    Handshake.blowfish.Encrypt(responce, 2, responce, 2, 4);

    // Send the packet
    WS.sock.Send(encrypted);

In der C ++ Code, wenn die Zeile "Blowfish.Encode" mit diesen Parametern aufgerufen wird, geht es in die cBlowfish.Encrypt Funktion

DWORD cBlowFish::Encode(BYTE * pInput, BYTE * pOutput, DWORD lSize)
{
DWORD   lCount, lOutSize, lGoodBytes;
BYTE    *pi, *po;
int     i, j;
int     SameDest =(pInput == pOutput ? 1 : 0);

lOutSize = GetOutputLength(lSize);
for(lCount = 0; lCount < lOutSize; lCount += 8)
{
    if(SameDest)    // if encoded data is being written into input buffer
    {
        if(lCount < lSize - 7)  // if not dealing with uneven bytes at end
        {
            Blowfish_encipher((DWORD *) pInput, (DWORD *)(pInput + 4));
        }
        else        // pad end of data with null bytes to complete encryption
        {
            po = pInput + lSize;    // point at byte past the end of actual data
            j =(int)(lOutSize - lSize); // number of bytes to set to null
            for(i = 0; i < j; i++)
                *po++ = 0;
            Blowfish_encipher((DWORD *) pInput, (DWORD *)(pInput + 4));
        }
        pInput += 8;
    }
    else            // output buffer not equal to input buffer, so must copy
    {               // input to output buffer prior to encrypting
        if(lCount < lSize - 7)  // if not dealing with uneven bytes at end
        {
            pi = pInput;
            po = pOutput;
            for(i = 0; i < 8; i++)
                // copy bytes to output
                *po++ = *pi++;
            // now encrypt them
            Blowfish_encipher((DWORD *) pOutput, (DWORD *)(pOutput + 4));
        }
        else        // pad end of data with null bytes to complete encryption
        {
            lGoodBytes = lSize - lCount;    // number of remaining data bytes
            po = pOutput;
            for(i = 0; i <(int) lGoodBytes; i++)
                *po++ = *pInput++;
            for(j = i; j < 8; j++)
                *po++ = 0;
            Blowfish_encipher((DWORD *) pOutput, (DWORD *)(pOutput + 4));
        }
        pInput += 8;
        pOutput += 8;
    }
}
return lOutSize;
}

Um es klar zu machen, wird die Schleife nur einmal aufgrund der kurzen Länge des Bytes geführt ausgeführt (4).

Nur ein Anruf von diesem großen Code (nur einmal) ausgeführt wird, der Anruf ist:

Blowfish_encipher((DWORD *) pInput, (DWORD *)(pInput + 4));

// der Code mit der Bedeutung der ersten beiden if-Anweisungen ist vorbei und verlässt dann die Schleife und die Funktion.

Aus meiner Sicht wird die Lösung irgendwo in der encipher Funktion versteckt:

void cBlowFish::Blowfish_encipher(DWORD *xl, DWORD *xr)
{
union aword Xl, Xr;

Xl.dword = *xl;
Xr.dword = *xr;

Xl.dword ^= PArray [0];
ROUND(Xr, Xl, 1);  
ROUND(Xl, Xr, 2);
ROUND(Xr, Xl, 3);  
ROUND(Xl, Xr, 4);
ROUND(Xr, Xl, 5);  
ROUND(Xl, Xr, 6);
ROUND(Xr, Xl, 7);  
ROUND(Xl, Xr, 8);
ROUND(Xr, Xl, 9);  
ROUND(Xl, Xr, 10);
ROUND(Xr, Xl, 11); 
ROUND(Xl, Xr, 12);
ROUND(Xr, Xl, 13); 
ROUND(Xl, Xr, 14);
ROUND(Xr, Xl, 15); 
ROUND(Xl, Xr, 16);
Xr.dword ^= PArray [17];

*xr = Xl.dword;
*xl = Xr.dword;
}

Die Definitionen:

#define S(x,i)          (SBoxes[i][x.w.byte##i])
#define bf_F(x)         (((S(x,0) + S(x,1)) ^ S(x,2)) + S(x,3))
#define ROUND(a,b,n)    (a.dword ^= bf_F(b) ^ PArray[n])

Das Problem ist, dass die Blowfish_Encipher Funktion in C ++ hat zwei Parameter:. Input (xl) als dword und Ausgabe (xr) als dword

Die C # Blowfish Encrypt_Block Funktion hat vier Parameter, warum?

        public void EncryptBlock(uint hi,uint lo,out uint outHi,out uint outLo)

Im Gegensatz zu dem C ++ blowfish, ruft EncryptBlock Encrypt stattdessen rufen Verschlüsseln zu EncryptBlock.Maybe EncryptBlock ist nicht die C ++ Blowfish_Encipher?

Wie auch immer, mein Problem ist, dass, wenn ich den C ++ Code mit dieser Anordnung von 6 Bytes Anfordern der Blowfish rufe nur das letzte 4 Bytes zu kodieren, sie tut es.

Während Wenn ich die Verschlüsselungsfunktion in C # mit diesen 4 Bytes aufrufen, gibt sie 0x00 (Wenn Sie möchten, dass die C # Blowfish sehen, die meine ersten Zeilen - Ich habe einen Hyperlink dort hinzugefügt.).

Hinweis: Ich kann die Paketstruktur ändern, sollte es einfach so sein, aber verschlüsselt.

Ich habe auch versucht dies:

die C ++ Encrpypt Funktionen Wissen führt nur einen Anruf - Blowfish Encipher.I versuchte direkt EncryptBlock in C # zu nennen, aber es gibt Hallo Uint32 und Low Uint32 als Ein- und Ausgang, wie sie in HALLO oder LO zu verbreiten? Wird diese Arbeit, wenn die Encrypt_Block Blowfish Verschlüsselung in C # ruft? Ich bin mir ziemlich sicher nicht.

Vielen Dank im Voraus!

Answer 1

Blowfish funktioniert auf acht Byte-Blöcken. Der einzige Weg, um Daten zu verschlüsseln, die kurz von acht Bytes fällt (oder ein Vielfaches von acht) zu polstern es (in diesem Fall mit Nullen).

Sie benötigen einen Acht-Byte-Puffer in C ++ Funktion zu übergeben, da man an Ort und Stelle ist, verschlüsselt werden. Der Code gepostet Du tatsächlich vier zusätzliches Bytes benachbarten Speicher ((DWORD *)(pInput + 4)) verschlüsselt, das ist offensichtlich nicht das, was Sie wollen. Darüber hinaus sind alle acht Ausgangsbytes erforderlich, um zu entschlüsseln -. So, leider können Sie nicht nur vier des verschlüsselten Bytes übergeben und erwartet, dass sie am anderen Ende erfolgreich entschlüsselt werden

Ich weiß, das Problem nicht lösen - ich sehe keinen Weg, es zu lösen, da nur vier Bytes von verschlüsselten Daten senden möchten, und Blowfish erzeugt immer ein Minimum von acht

!