mirror of
https://github.com/Xevion/easy7zip.git
synced 2025-12-15 00:11:40 -06:00
3.13
This commit is contained in:
Igor Pavlov
Kornel Lesiński
157
7zip/Crypto/RarAES/RarAES.cpp
Executable file
157
7zip/Crypto/RarAES/RarAES.cpp
Executable file
@@ -0,0 +1,157 @@
|
||||
// Crypto/RarAES/RarAES.h
|
||||
// This code is based on UnRar sources
|
||||
|
||||
#include "StdAfx.h"
|
||||
|
||||
#include "../../Common/StreamObjects.h"
|
||||
#include "../../Archive/Common/CoderLoader.h"
|
||||
|
||||
#include "Windows/Defs.h"
|
||||
|
||||
#include "RarAES.h"
|
||||
#include "sha1.h"
|
||||
|
||||
extern void GetCryptoFolderPrefix(TCHAR *path);
|
||||
|
||||
// {23170F69-40C1-278B-0601-010000000000}
|
||||
DEFINE_GUID(CLSID_CCrypto_AES128_Decoder,
|
||||
0x23170F69, 0x40C1, 0x278B, 0x06, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00);
|
||||
|
||||
namespace NCrypto {
|
||||
namespace NRar29 {
|
||||
|
||||
CDecoder::CDecoder():
|
||||
_thereIsSalt(false),
|
||||
_needCalculate(true)
|
||||
{
|
||||
for (int i = 0; i < sizeof(_salt); i++)
|
||||
_salt[i] = 0;
|
||||
}
|
||||
|
||||
STDMETHODIMP CDecoder::SetDecoderProperties(ISequentialInStream *inStream)
|
||||
{
|
||||
bool thereIsSaltPrev = _thereIsSalt;
|
||||
_thereIsSalt = false;
|
||||
UINT32 processedSize;
|
||||
BYTE salt[8];
|
||||
RINOK(inStream->Read(salt, sizeof(salt), &processedSize));
|
||||
if (processedSize == 0)
|
||||
_thereIsSalt = false;
|
||||
if (processedSize != sizeof(salt))
|
||||
return E_INVALIDARG;
|
||||
_thereIsSalt = true;
|
||||
bool same = false;
|
||||
if (_thereIsSalt == thereIsSaltPrev)
|
||||
{
|
||||
same = true;
|
||||
if (_thereIsSalt)
|
||||
{
|
||||
for (int i = 0; i < sizeof(_salt); i++)
|
||||
if (_salt[i] != salt[i])
|
||||
{
|
||||
same = false;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
for (int i = 0; i < sizeof(_salt); i++)
|
||||
_salt[i] = salt[i];
|
||||
if (!_needCalculate && !same)
|
||||
_needCalculate = true;
|
||||
return S_OK;
|
||||
}
|
||||
|
||||
STDMETHODIMP CDecoder::CryptoSetPassword(const BYTE *data, UINT32 size)
|
||||
{
|
||||
bool same = false;
|
||||
if (size == buffer.GetCapacity())
|
||||
{
|
||||
same = true;
|
||||
for (UINT32 i = 0; i < size; i++)
|
||||
if (data[i] != buffer[i])
|
||||
{
|
||||
same = false;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (!_needCalculate && !same)
|
||||
_needCalculate = true;
|
||||
buffer.SetCapacity(size);
|
||||
memcpy(buffer, data, size);
|
||||
return S_OK;
|
||||
}
|
||||
|
||||
STDMETHODIMP CDecoder::Code(ISequentialInStream *inStream,
|
||||
ISequentialOutStream *outStream, UINT64 const *inSize,
|
||||
const UINT64 *outSize,ICompressProgressInfo *progress)
|
||||
{
|
||||
if (_needCalculate)
|
||||
{
|
||||
const MAXPASSWORD = 128;
|
||||
const SALT_SIZE = 8;
|
||||
|
||||
BYTE rawPassword[2 * MAXPASSWORD+ SALT_SIZE];
|
||||
|
||||
memcpy(rawPassword, buffer, buffer.GetCapacity());
|
||||
|
||||
int rawLength = buffer.GetCapacity();
|
||||
|
||||
if (_thereIsSalt)
|
||||
{
|
||||
memcpy(rawPassword + rawLength, _salt, SALT_SIZE);
|
||||
rawLength += SALT_SIZE;
|
||||
}
|
||||
|
||||
hash_context c;
|
||||
hash_initial(&c);
|
||||
|
||||
const int hashRounds = 0x40000;
|
||||
int i;
|
||||
for (i = 0; i < hashRounds; i++)
|
||||
{
|
||||
hash_process(&c, rawPassword, rawLength);
|
||||
BYTE pswNum[3];
|
||||
pswNum[0] = (BYTE)i;
|
||||
pswNum[1] = (BYTE)(i >> 8);
|
||||
pswNum[2] = (BYTE)(i >> 16);
|
||||
hash_process(&c, pswNum, 3);
|
||||
if (i % (hashRounds / 16) == 0)
|
||||
{
|
||||
hash_context tempc = c;
|
||||
UINT32 digest[5];
|
||||
hash_final(&tempc, digest);
|
||||
aesInit[i / (hashRounds / 16)] = (BYTE)digest[4];
|
||||
}
|
||||
}
|
||||
UINT32 digest[5];
|
||||
hash_final(&c, digest);
|
||||
for (i = 0; i < 4; i++)
|
||||
for (int j = 0; j < 4; j++)
|
||||
aesKey[i * 4 + j] = (BYTE)(digest[i] >> (j * 8));
|
||||
}
|
||||
_needCalculate = false;
|
||||
|
||||
TCHAR aesLibPath[MAX_PATH + 64];
|
||||
GetCryptoFolderPrefix(aesLibPath);
|
||||
lstrcat(aesLibPath, TEXT("AES.dll"));
|
||||
CCoderLibrary aesLib;
|
||||
CMyComPtr<ICompressCoder2> aesDecoder;
|
||||
RINOK(aesLib.LoadAndCreateCoder2(aesLibPath, CLSID_CCrypto_AES128_Decoder, &aesDecoder));
|
||||
|
||||
CSequentialInStreamImp *ivStreamSpec = new CSequentialInStreamImp;
|
||||
CMyComPtr<ISequentialInStream> ivStream(ivStreamSpec);
|
||||
ivStreamSpec->Init(aesInit, 16);
|
||||
|
||||
CSequentialInStreamImp *keyStreamSpec = new CSequentialInStreamImp;
|
||||
CMyComPtr<ISequentialInStream> keyStream(keyStreamSpec);
|
||||
keyStreamSpec->Init(aesKey, 16);
|
||||
|
||||
ISequentialInStream *inStreams[3] = { inStream, ivStream, keyStream };
|
||||
UINT64 ivSize = 16;
|
||||
UINT64 keySize = 16;
|
||||
const UINT64 *inSizes[3] = { inSize, &ivSize, &ivSize, };
|
||||
return aesDecoder->Code(inStreams, inSizes, 3,
|
||||
&outStream, &outSize, 1, progress);
|
||||
}
|
||||
|
||||
}}
|
||||
48
7zip/Crypto/RarAES/RarAES.h
Executable file
48
7zip/Crypto/RarAES/RarAES.h
Executable file
@@ -0,0 +1,48 @@
|
||||
// Crypto/CRarAES/RarAES.h
|
||||
|
||||
#ifndef __CRYPTO_RARAES_H
|
||||
#define __CRYPTO_RARAES_H
|
||||
|
||||
#include "Common/MyCom.h"
|
||||
#include "../../ICoder.h"
|
||||
#include "../../IPassword.h"
|
||||
|
||||
#include "Common/Types.h"
|
||||
#include "Common/Buffer.h"
|
||||
|
||||
namespace NCrypto {
|
||||
namespace NRar29 {
|
||||
|
||||
class CDecoder:
|
||||
public ICompressCoder,
|
||||
public ICompressSetDecoderProperties,
|
||||
public ICryptoSetPassword,
|
||||
public CMyUnknownImp
|
||||
{
|
||||
BYTE _salt[8];
|
||||
bool _thereIsSalt;
|
||||
CByteBuffer buffer;
|
||||
BYTE aesKey[16];
|
||||
BYTE aesInit[16];
|
||||
bool _needCalculate;
|
||||
public:
|
||||
|
||||
MY_UNKNOWN_IMP2(
|
||||
ICryptoSetPassword,
|
||||
ICompressSetDecoderProperties)
|
||||
|
||||
STDMETHOD(Code)(ISequentialInStream *inStream,
|
||||
ISequentialOutStream *outStream, UINT64 const *inSize,
|
||||
const UINT64 *outSize,ICompressProgressInfo *progress);
|
||||
|
||||
STDMETHOD(CryptoSetPassword)(const BYTE *aData, UINT32 aSize);
|
||||
|
||||
// ICompressSetDecoderProperties
|
||||
STDMETHOD(SetDecoderProperties)(ISequentialInStream *inStream);
|
||||
|
||||
CDecoder();
|
||||
};
|
||||
|
||||
}}
|
||||
|
||||
#endif
|
||||
214
7zip/Crypto/RarAES/sha1.cpp
Executable file
214
7zip/Crypto/RarAES/sha1.cpp
Executable file
@@ -0,0 +1,214 @@
|
||||
// sha1.cpp
|
||||
// This file from UnRar sources
|
||||
|
||||
#include "StdAfx.h"
|
||||
|
||||
#include "sha1.h"
|
||||
|
||||
/*
|
||||
SHA-1 in C
|
||||
By Steve Reid <steve@edmweb.com>
|
||||
100% Public Domain
|
||||
|
||||
Test Vectors (from FIPS PUB 180-1)
|
||||
"abc"
|
||||
A9993E36 4706816A BA3E2571 7850C26C 9CD0D89D
|
||||
"abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq"
|
||||
84983E44 1C3BD26E BAAE4AA1 F95129E5 E54670F1
|
||||
A million repetitions of "a"
|
||||
34AA973C D4C4DAA4 F61EEB2B DBAD2731 6534016F
|
||||
*/
|
||||
|
||||
#if !defined(LITTLE_ENDIAN) && !defined(BIG_ENDIAN)
|
||||
#if defined(_M_IX86) || defined(_M_I86) || defined(__alpha)
|
||||
#define LITTLE_ENDIAN
|
||||
#else
|
||||
#error "LITTLE_ENDIAN or BIG_ENDIAN must be defined"
|
||||
#endif
|
||||
#endif
|
||||
|
||||
/* #define SHA1HANDSOFF * Copies data before messing with it. */
|
||||
|
||||
#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits))))
|
||||
|
||||
/* blk0() and blk() perform the initial expand. */
|
||||
/* I got the idea of expanding during the round function from SSLeay */
|
||||
#ifdef LITTLE_ENDIAN
|
||||
#define blk0(i) (block->l[i] = (rol(block->l[i],24)&0xFF00FF00) \
|
||||
|(rol(block->l[i],8)&0x00FF00FF))
|
||||
#else
|
||||
#define blk0(i) block->l[i]
|
||||
#endif
|
||||
#define blk(i) (block->l[i&15] = rol(block->l[(i+13)&15]^block->l[(i+8)&15] \
|
||||
^block->l[(i+2)&15]^block->l[i&15],1))
|
||||
|
||||
/* (R0+R1), R2, R3, R4 are the different operations used in SHA1 */
|
||||
#define R0(v,w,x,y,z,i) {z+=((w&(x^y))^y)+blk0(i)+0x5A827999+rol(v,5);w=rol(w,30);}
|
||||
#define R1(v,w,x,y,z,i) {z+=((w&(x^y))^y)+blk(i)+0x5A827999+rol(v,5);w=rol(w,30);}
|
||||
#define R2(v,w,x,y,z,i) {z+=(w^x^y)+blk(i)+0x6ED9EBA1+rol(v,5);w=rol(w,30);}
|
||||
#define R3(v,w,x,y,z,i) {z+=(((w|x)&y)|(w&x))+blk(i)+0x8F1BBCDC+rol(v,5);w=rol(w,30);}
|
||||
#define R4(v,w,x,y,z,i) {z+=(w^x^y)+blk(i)+0xCA62C1D6+rol(v,5);w=rol(w,30);}
|
||||
|
||||
|
||||
/* Hash a single 512-bit block. This is the core of the algorithm. */
|
||||
|
||||
void SHA1Transform(UINT32 state[5], unsigned char buffer[64])
|
||||
{
|
||||
UINT32 a, b, c, d, e;
|
||||
typedef union {
|
||||
unsigned char c[64];
|
||||
UINT32 l[16];
|
||||
} CHAR64LONG16;
|
||||
CHAR64LONG16* block;
|
||||
#ifdef SHA1HANDSOFF
|
||||
static unsigned char workspace[64];
|
||||
block = (CHAR64LONG16*)workspace;
|
||||
memcpy(block, buffer, 64);
|
||||
#else
|
||||
block = (CHAR64LONG16*)buffer;
|
||||
#endif
|
||||
#ifdef SFX_MODULE
|
||||
static int pos[80][5];
|
||||
static bool pinit=false;
|
||||
if (!pinit)
|
||||
{
|
||||
for (int I=0,P=0;I<80;I++,P=(P ? P-1:4))
|
||||
{
|
||||
pos[I][0]=P;
|
||||
pos[I][1]=(P+1)%5;
|
||||
pos[I][2]=(P+2)%5;
|
||||
pos[I][3]=(P+3)%5;
|
||||
pos[I][4]=(P+4)%5;
|
||||
}
|
||||
pinit=true;
|
||||
}
|
||||
UINT32 s[5];
|
||||
for (int I=0;I<sizeof(s)/sizeof(s[0]);I++)
|
||||
s[I]=state[I];
|
||||
|
||||
for (int I=0;I<16;I++)
|
||||
R0(s[pos[I][0]],s[pos[I][1]],s[pos[I][2]],s[pos[I][3]],s[pos[I][4]],I);
|
||||
for (int I=16;I<20;I++)
|
||||
R1(s[pos[I][0]],s[pos[I][1]],s[pos[I][2]],s[pos[I][3]],s[pos[I][4]],I);
|
||||
for (int I=20;I<40;I++)
|
||||
R2(s[pos[I][0]],s[pos[I][1]],s[pos[I][2]],s[pos[I][3]],s[pos[I][4]],I);
|
||||
for (int I=40;I<60;I++)
|
||||
R3(s[pos[I][0]],s[pos[I][1]],s[pos[I][2]],s[pos[I][3]],s[pos[I][4]],I);
|
||||
for (int I=60;I<80;I++)
|
||||
R4(s[pos[I][0]],s[pos[I][1]],s[pos[I][2]],s[pos[I][3]],s[pos[I][4]],I);
|
||||
|
||||
for (int I=0;I<sizeof(s)/sizeof(s[0]);I++)
|
||||
state[I]+=s[I];
|
||||
#else
|
||||
/* Copy context->state[] to working vars */
|
||||
a = state[0];
|
||||
b = state[1];
|
||||
c = state[2];
|
||||
d = state[3];
|
||||
e = state[4];
|
||||
/* 4 rounds of 20 operations each. Loop unrolled. */
|
||||
R0(a,b,c,d,e, 0); R0(e,a,b,c,d, 1); R0(d,e,a,b,c, 2); R0(c,d,e,a,b, 3);
|
||||
R0(b,c,d,e,a, 4); R0(a,b,c,d,e, 5); R0(e,a,b,c,d, 6); R0(d,e,a,b,c, 7);
|
||||
R0(c,d,e,a,b, 8); R0(b,c,d,e,a, 9); R0(a,b,c,d,e,10); R0(e,a,b,c,d,11);
|
||||
R0(d,e,a,b,c,12); R0(c,d,e,a,b,13); R0(b,c,d,e,a,14); R0(a,b,c,d,e,15);
|
||||
R1(e,a,b,c,d,16); R1(d,e,a,b,c,17); R1(c,d,e,a,b,18); R1(b,c,d,e,a,19);
|
||||
R2(a,b,c,d,e,20); R2(e,a,b,c,d,21); R2(d,e,a,b,c,22); R2(c,d,e,a,b,23);
|
||||
R2(b,c,d,e,a,24); R2(a,b,c,d,e,25); R2(e,a,b,c,d,26); R2(d,e,a,b,c,27);
|
||||
R2(c,d,e,a,b,28); R2(b,c,d,e,a,29); R2(a,b,c,d,e,30); R2(e,a,b,c,d,31);
|
||||
R2(d,e,a,b,c,32); R2(c,d,e,a,b,33); R2(b,c,d,e,a,34); R2(a,b,c,d,e,35);
|
||||
R2(e,a,b,c,d,36); R2(d,e,a,b,c,37); R2(c,d,e,a,b,38); R2(b,c,d,e,a,39);
|
||||
R3(a,b,c,d,e,40); R3(e,a,b,c,d,41); R3(d,e,a,b,c,42); R3(c,d,e,a,b,43);
|
||||
R3(b,c,d,e,a,44); R3(a,b,c,d,e,45); R3(e,a,b,c,d,46); R3(d,e,a,b,c,47);
|
||||
R3(c,d,e,a,b,48); R3(b,c,d,e,a,49); R3(a,b,c,d,e,50); R3(e,a,b,c,d,51);
|
||||
R3(d,e,a,b,c,52); R3(c,d,e,a,b,53); R3(b,c,d,e,a,54); R3(a,b,c,d,e,55);
|
||||
R3(e,a,b,c,d,56); R3(d,e,a,b,c,57); R3(c,d,e,a,b,58); R3(b,c,d,e,a,59);
|
||||
R4(a,b,c,d,e,60); R4(e,a,b,c,d,61); R4(d,e,a,b,c,62); R4(c,d,e,a,b,63);
|
||||
R4(b,c,d,e,a,64); R4(a,b,c,d,e,65); R4(e,a,b,c,d,66); R4(d,e,a,b,c,67);
|
||||
R4(c,d,e,a,b,68); R4(b,c,d,e,a,69); R4(a,b,c,d,e,70); R4(e,a,b,c,d,71);
|
||||
R4(d,e,a,b,c,72); R4(c,d,e,a,b,73); R4(b,c,d,e,a,74); R4(a,b,c,d,e,75);
|
||||
R4(e,a,b,c,d,76); R4(d,e,a,b,c,77); R4(c,d,e,a,b,78); R4(b,c,d,e,a,79);
|
||||
/* Add the working vars back into context.state[] */
|
||||
state[0] += a;
|
||||
state[1] += b;
|
||||
state[2] += c;
|
||||
state[3] += d;
|
||||
state[4] += e;
|
||||
|
||||
/* Wipe variables */
|
||||
a = b = c = d = e = 0;
|
||||
memset(&a,0,sizeof(a));
|
||||
#endif
|
||||
}
|
||||
|
||||
|
||||
/* Initialize new context */
|
||||
|
||||
void hash_initial(hash_context* context)
|
||||
{
|
||||
/* SHA1 initialization constants */
|
||||
context->state[0] = 0x67452301;
|
||||
context->state[1] = 0xEFCDAB89;
|
||||
context->state[2] = 0x98BADCFE;
|
||||
context->state[3] = 0x10325476;
|
||||
context->state[4] = 0xC3D2E1F0;
|
||||
context->count[0] = context->count[1] = 0;
|
||||
}
|
||||
|
||||
|
||||
/* Run your data through this. */
|
||||
void hash_process( hash_context * context, unsigned char * data, unsigned len )
|
||||
{
|
||||
unsigned int i, j;
|
||||
UINT32 blen = ((UINT32)len)<<3;
|
||||
|
||||
j = (context->count[0] >> 3) & 63;
|
||||
if ((context->count[0] += blen) < blen ) context->count[1]++;
|
||||
context->count[1] += (len >> 29);
|
||||
if ((j + len) > 63) {
|
||||
memcpy(&context->buffer[j], data, (i = 64-j));
|
||||
SHA1Transform(context->state, context->buffer);
|
||||
for ( ; i + 63 < len; i += 64) {
|
||||
SHA1Transform(context->state, &data[i]);
|
||||
}
|
||||
j = 0;
|
||||
}
|
||||
else i = 0;
|
||||
if (len > i)
|
||||
memcpy(&context->buffer[j], &data[i], len - i);
|
||||
}
|
||||
|
||||
|
||||
/* Add padding and return the message digest. */
|
||||
|
||||
void hash_final( hash_context* context, UINT32 digest[5] )
|
||||
{
|
||||
UINT32 i, j;
|
||||
unsigned char finalcount[8];
|
||||
|
||||
for (i = 0; i < 8; i++) {
|
||||
finalcount[i] = (unsigned char)((context->count[(i >= 4 ? 0 : 1)]
|
||||
>> ((3-(i & 3)) * 8) ) & 255); /* Endian independent */
|
||||
}
|
||||
unsigned char ch='\200';
|
||||
hash_process(context, &ch, 1);
|
||||
while ((context->count[0] & 504) != 448) {
|
||||
ch=0;
|
||||
hash_process(context, &ch, 1);
|
||||
}
|
||||
hash_process(context, finalcount, 8); /* Should cause a SHA1Transform() */
|
||||
for (i = 0; i < 5; i++) {
|
||||
digest[i] = context->state[i] & 0xffffffff;
|
||||
}
|
||||
/* Wipe variables */
|
||||
memset(&i,0,sizeof(i));
|
||||
memset(&j,0,sizeof(j));
|
||||
memset(context->buffer, 0, 64);
|
||||
memset(context->state, 0, 20);
|
||||
memset(context->count, 0, 8);
|
||||
memset(&finalcount, 0, 8);
|
||||
#ifdef SHA1HANDSOFF /* make SHA1Transform overwrite it's own static vars */
|
||||
SHA1Transform(context->state, context->buffer);
|
||||
#endif
|
||||
}
|
||||
|
||||
|
||||
19
7zip/Crypto/RarAES/sha1.h
Executable file
19
7zip/Crypto/RarAES/sha1.h
Executable file
@@ -0,0 +1,19 @@
|
||||
// sha1.h
|
||||
// This file from UnRar sources
|
||||
|
||||
#ifndef _RAR_SHA1_
|
||||
#define _RAR_SHA1_
|
||||
|
||||
#define HW 5
|
||||
|
||||
typedef struct {
|
||||
UINT32 state[5];
|
||||
UINT32 count[2];
|
||||
unsigned char buffer[64];
|
||||
} hash_context;
|
||||
|
||||
void hash_initial( hash_context * c );
|
||||
void hash_process( hash_context * c, unsigned char * data, unsigned len );
|
||||
void hash_final( hash_context * c, UINT32[HW] );
|
||||
|
||||
#endif
|
||||
Reference in New Issue
Block a user