hashirama/goldendict-ng
hashirama/goldendict-ng
0
0
Fork 0
mirror of https://github.com/xiaoyifang/goldendict-ng.git synced 2024-11-28 03:44:07 +00:00
Code Issues Actions 1 Projects Releases Wiki Activity

Merge pull request #633 from 0x1997/mdict

Browse source 
Update the MDict parser
This commit is contained in:
Abs62 2015-10-11 19:40:52 +03:00
parent b4bb1e9635 a04917833c
commit 52a91991c4
5 changed files with 412 additions and 184 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

10
goldendict.pro
View file

@ -106,7 +106,7 @@ unix:!mac {
CONFIG += link_pkgconfig
PKGCONFIG += vorbisfile \
vorbis \
vorbis \
ogg \
hunspell
isEmpty(DISABLE_INTERNAL_PLAYER) {
@ -294,7 +294,8 @@ HEADERS += folding.hh \
ftshelpers.hh \
dictserver.hh \
helpwindow.hh \
slob.hh
slob.hh \
ripemd.hh
FORMS += groups.ui \
dictgroupwidget.ui \
@ -417,10 +418,11 @@ SOURCES += folding.cc \
ftshelpers.cc \
dictserver.cc \
helpwindow.cc \
slob.cc
slob.cc \
ripemd.cc
win32 {
FORMS += texttospeechsource.ui
FORMS += texttospeechsource.ui
SOURCES += mouseover_win32/ThTypes.c \
wordbyauto.cc \
guids.c \

348
mdictparser.cc
View file

@ -1,8 +1,10 @@
// https://bitbucket.org/xwang/mdict-analysis
// https://github.com/zhansliu/writemdict/blob/master/fileformat.md
// Octopus MDict Dictionary File (.mdx) and Resource File (.mdd) Analyser
//
// Copyright (C) 2012, 2013 Xiaoqiang Wang <xiaoqiangwang AT gmail DOT com>
// Copyright (C) 2013 Timon Wong <timon86.wang AT gmail DOT com>
// Copyright (C) 2015 Zhe Wang <0x1998 AT gmail DOT com>
//
// This program is a free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
@ -23,9 +25,6 @@
#include <iconv.h>
#include <lzo/lzo1x.h>
#include <algorithm>
#include <iterator>
#include <QtEndian>
#include <QStringList>
#include <QByteArray>
@ -34,13 +33,19 @@
#include <QDomDocument>
#include <QTextDocumentFragment>
#include <QDebug>
#include "decompress.hh"
#include "gddebug.hh"
#include "ripemd.hh"
namespace Mdict
{
enum EncryptedSection
{
EcryptedHeadWordHeader = 1,
EcryptedHeadWordIndex = 2
};
static inline int u16StrSize( const ushort * unicode )
{
int size = 0;
@ -103,9 +108,8 @@ MdictParser::MdictParser() :
recordPos_( 0 ),
wordCount_( 0 ),
numberTypeSize_( 0 ),
rtl_( false ),
bruteForce_( false ),
bruteForceEnd_( true )
encrypted_( 0 ),
rtl_( false )
{
}
@ -114,7 +118,7 @@ bool MdictParser::open( const char * filename )
filename_ = QString::fromUtf8( filename );
file_ = new QFile( filename_ );
qDebug() << "MdictParser: open " << filename_;
GD_DPRINTF( "MdictParser: open %s\n", filename );
if ( file_.isNull() || !file_->exists() )
return false;
@ -139,62 +143,35 @@ bool MdictParser::open( const char * filename )
bool MdictParser::readNextHeadWordIndex( MdictParser::HeadWordIndex & headWordIndex )
{
if ( bruteForce_ )
{
if ( bruteForceEnd_ )
return false;
if ( headWordBlockInfosIter_ == headWordBlockInfos_.end() )
return false;
headWordIndex.clear();
qint64 compressedSize = headWordBlockInfosIter_->first;
qint64 decompressedSize = headWordBlockInfosIter_->second;
ScopedMemMap mapping( *file_, headWordPos_, headWordBlockSize_ );
if ( !mapping.startAddress() )
return false;
if ( compressedSize < 8 )
return false;
const char * pDataStart = ( const char * )mapping.startAddress();
const char * pDataEnd = pDataStart + headWordBlockSize_;
const char pattern[] = {0x02, 0x00, 0x00, 0x00};
const char * patternBegin = pattern;
const char * patternEnd = pattern + 4;
const char * p;
ScopedMemMap compressed( *file_, headWordPos_, compressedSize );
if ( !compressed.startAddress() )
return false;
do
{
p = std::search( pDataStart + 4, pDataEnd, patternBegin, patternEnd );
QByteArray decompressed = zlibDecompress( pDataStart + 8, p - ( pDataStart + 8 ) );
HeadWordIndex currentIndex = splitHeadWordBlock( decompressed );
headWordIndex.insert( headWordIndex.end(), currentIndex.begin(), currentIndex.end() );
pDataStart = p;
}
while ( p != pDataEnd );
headWordPos_ += compressedSize;
QByteArray decompressed;
if ( !parseCompressedBlock( compressedSize, ( char * )compressed.startAddress(),
decompressedSize, decompressed ) )
return false;
bruteForceEnd_ = true;
return true;
}
else
{
if ( headWordBlockInfosIter_ == headWordBlockInfos_.end() )
return false;
headWordIndex = splitHeadWordBlock( decompressed );
headWordBlockInfosIter_++;
return true;
}
qint64 compressedSize = headWordBlockInfosIter_->first;
qint64 decompressedSize = headWordBlockInfosIter_->second;
if ( compressedSize < 8 )
return false;
ScopedMemMap compressed( *file_, headWordPos_, compressedSize );
if ( !compressed.startAddress() )
return false;
headWordPos_ += compressedSize;
QByteArray decompressed;
if ( !parseCompressedBlock( compressedSize, ( char * )compressed.startAddress(),
decompressedSize, decompressed ) )
return false;
headWordIndex = splitHeadWordBlock( decompressed );
headWordBlockInfosIter_++;
return true;
}
bool MdictParser::checkAdler32(const char * buffer, unsigned int len, quint32 checksum)
{
uLong adler = adler32( 0L, Z_NULL, 0 );
adler = adler32( adler, ( const Bytef * ) buffer, len );
return (adler & 0xFFFFFFFF) == checksum;
}
QString MdictParser::toUtf16( const char * fromCode, const char * from, size_t fromSize )
@ -236,78 +213,97 @@ QString MdictParser::toUtf16( const char * fromCode, const char * from, size_t f
return QString::fromUtf16( ( const ushort * )&result.front() );
}
bool MdictParser::parseCompressedBlock( qint64 compressedBlockSize, const char * compressedBlockPtr,
qint64 decompressedBlockSize, QByteArray & decompressedBlock )
bool MdictParser::decryptHeadWordIndex(char * buffer, qint64 len)
{
RIPEMD128 ripemd;
ripemd.update( ( const uchar * ) buffer + 4, 4 );
ripemd.update( ( const uchar * ) "\x95\x36\x00\x00", 4 );
uint8_t key[16];
ripemd.digest( key );
buffer += 8;
len -= 8;
uint8_t prev = 0x36;
for (qint64 i = 0; i < len; ++i)
{
uint8_t byte = buffer[i];
byte = (byte >> 4) | (byte << 4);
byte = byte ^ prev ^ (i & 0xFF) ^ key[i % 16];
prev = buffer[i];
buffer[i] = byte;
}
return true;
}
bool MdictParser::parseCompressedBlock( qint64 compressedBlockSize,
const char * compressedBlockPtr,
qint64 decompressedBlockSize,
QByteArray & decompressedBlock )
{
if ( compressedBlockSize <= 8 )
return false;
qint64 dataSize = compressedBlockSize - 8;
const char * dataPtr = compressedBlockPtr + 8;
// 4bytes - type
// 4bytes - checksum
quint32 type;
quint32 checksum;
type = qFromBigEndian<quint32>( ( const uchar * ) compressedBlockPtr );
checksum = qFromBigEndian<quint32>( ( const uchar * )compressedBlockPtr + sizeof( quint32 ) );
// compression type
quint32 type = qFromBigEndian<quint32>( ( const uchar * ) compressedBlockPtr );
quint32 checksum = qFromBigEndian<quint32>( ( const uchar * )compressedBlockPtr + 4 );
const char * buf = compressedBlockPtr + 8;
qint64 size = compressedBlockSize - 8;
if ( type == 0x00000000 )
switch ( type )
{
// No compression
checksum &= 0xffff;
quint16 sum = 0;
for ( qint64 i = 0; i < dataSize; i++ )
{
sum += dataPtr[i];
}
sum += 1;
case 0x00000000:
// No compression
if ( !checkAdler32( buf, size, checksum ) )
{
gdWarning( "MDict: parseCompressedBlock: plain: checksum not match" );
return false;
}
if ( checksum != sum )
{
qWarning() << "MDict: parseCompressedBlock: plain: checksum not match";
decompressedBlock = QByteArray( buf, size );
return true;
case 0x01000000:
{
// LZO compression
int result;
lzo_uint blockSize = ( lzo_uint )decompressedBlockSize;
decompressedBlock.resize( blockSize );
result = lzo1x_decompress_safe( ( const uchar * ) buf, size,
( uchar * )decompressedBlock.data(),
&blockSize, NULL );
if ( result != LZO_E_OK || blockSize != ( lzo_uint )decompressedBlockSize )
{
gdWarning( "MDict: parseCompressedBlock: decompression failed" );
return false;
}
if ( checksum != lzo_adler32( lzo_adler32( 0, NULL, 0 ),
( const uchar * )decompressedBlock.constData(),
blockSize ) )
{
gdWarning( "MDict: parseCompressedBlock: lzo: checksum does not match" );
return false;
}
}
break;
case 0x02000000:
// zlib compression
decompressedBlock = zlibDecompress( buf, size );
if ( !checkAdler32( decompressedBlock.constData(), decompressedBlock.size(),
checksum ) )
{
gdWarning( "MDict: parseCompressedBlock: zlib: checksum does not match" );
return false;
}
break;
default:
gdWarning( "MDict: parseCompressedBlock: unknown type" );
return false;
}
decompressedBlock = QByteArray( dataPtr, dataSize );
}
else if ( type == 0x01000000 )
{
// LZO compression
int result;
lzo_uint blockSize = ( lzo_uint )decompressedBlockSize;
decompressedBlock.resize( blockSize );
result = lzo1x_decompress_safe( ( const uchar * )dataPtr, dataSize,
( uchar * )decompressedBlock.data(), &blockSize, NULL );
if ( result != LZO_E_OK || blockSize != ( lzo_uint )decompressedBlockSize )
{
qWarning() << "MDict: parseCompressedBlock: decompression failed";
return false;
}
if ( checksum != lzo_adler32( lzo_adler32( 0, NULL, 0 ),
( const uchar * )decompressedBlock.constData(),
blockSize ) )
{
qWarning() << "MDict: parseCompressedBlock: lzo: checksum not match";
return false;
}
}
else if ( type == 0x02000000 )
{
// zlib compression
if ( checksum != qFromBigEndian<quint32>( ( const uchar * )dataPtr + dataSize - 4 ) )
{
qWarning() << "MDict: parseCompressedBlock: zlib: checksum not match";
return false;
}
decompressedBlock = zlibDecompress( dataPtr, dataSize );
}
else
{
qWarning() << "MDict: parseCompressedBlock: unknown type";
return false;
}
return true;
@ -355,7 +351,18 @@ bool MdictParser::readHeader( QDataStream & in )
return false;
QString headerText = toUtf16( "UTF-16LE", headerTextUtf16.constData(), headerTextUtf16.size() );
// Adler-32 checksum of the header text (little-endian)
quint32 checksum;
in.setByteOrder( QDataStream::LittleEndian );
in >> checksum;
if ( !checkAdler32( headerTextUtf16.constData(), headerTextUtf16.size(), checksum ) )
{
gdWarning( "MDict: readHeader: checksum does not match" );
return false;
}
headerTextUtf16.clear();
in.setByteOrder( QDataStream::BigEndian );
QDomNamedNodeMap headerAttributes = parseHeaderAttributes( headerText );
@ -391,9 +398,8 @@ bool MdictParser::readHeader( QDataStream & in )
else
numberTypeSize_ = 8;
// 4 bytes unknown
if ( in.skipRawData( 4 ) != 4 )
return false;
// Encrypted ?
encrypted_ = headerAttributes.namedItem("Encrypted").toAttr().value().toInt();
// Read metadata
rtl_ = headerAttributes.namedItem( "Left2Right" ).toAttr().value() != "Yes";
@ -418,87 +424,77 @@ bool MdictParser::readHeader( QDataStream & in )
bool MdictParser::readHeadWordBlockInfos( QDataStream & in )
{
QByteArray header = file_->read( version_ >= 2.0 ? 40 : 32 );
QDataStream stream( header );
// number of headword blocks
numHeadWordBlocks_ = readNumber( in );
numHeadWordBlocks_ = readNumber( stream );
// number of entries
wordCount_ = readNumber( in );
wordCount_ = readNumber( stream );
// unknown field
// number of bytes of a headword block info after decompression
qint64 decompressedSize;
if ( version_ >= 2.0 )
{
if ( in.skipRawData( numberTypeSize_ ) != numberTypeSize_ )
return false;
}
stream >> decompressedSize;
// number of bytes of a headword block info
headWordBlockInfoSize_ = readNumber( in );
// number of bytes of a headword block info before decompression
headWordBlockInfoSize_ = readNumber( stream );
// number of bytes of a headword block
headWordBlockSize_ = readNumber( in );
headWordBlockSize_ = readNumber( stream );
// unknown field
// Adler-32 checksum of the header. If those are encrypted, it is
// the checksum of the decrypted version
if ( version_ >= 2.0 )
{
if ( in.skipRawData( 4 ) != 4 )
quint32 checksum;
in >> checksum;
if ( !checkAdler32( header.constData(), 40, checksum ) )
return false;
}
headWordBlockInfoPos_ = file_->pos();
// read headword block info, which indicates headword block's compressed and decompressed size
// read headword block info
QByteArray headWordBlockInfo = file_->read( headWordBlockInfoSize_ );
if ( headWordBlockInfo.size() != headWordBlockInfoSize_ )
return false;
if ( version_ >= 2.0 )
{
quint32 type;
quint32 checksum;
quint32 value;
QDataStream headWordBlockInfoStream( headWordBlockInfo );
headWordBlockInfoStream.setByteOrder( QDataStream::BigEndian );
headWordBlockInfoStream >> type >> checksum;
headWordBlockInfoStream.skipRawData( headWordBlockInfoSize_ - 8 - 4 );
headWordBlockInfoStream >> value;
// 02 00 00 00
if ( type != 0x02000000 )
// decrypt
if ( encrypted_ & EcryptedHeadWordIndex )
{
qWarning() << "MDict: readHeadWordBlockInfos: type not match";
if ( !decryptHeadWordIndex( headWordBlockInfo.data(),
headWordBlockInfo.size() ) )
return false;
}
QByteArray decompressed;
if ( !parseCompressedBlock( headWordBlockInfo.size(), headWordBlockInfo.data(),
decompressedSize, decompressed) )
return false;
}
if ( checksum == value )
{
// Decompress
headWordBlockInfo = zlibDecompress( headWordBlockInfo.data() + 8,
headWordBlockInfo.size() - 8 );
}
else
{
qWarning() << "MDict: readHeadWordBlockInfos: checksum not match, try brute force...";
headWordPos_ = file_->pos();
bruteForce_ = true;
bruteForceEnd_ = false;
return true;
}
headWordBlockInfos_ = decodeHeadWordBlockInfo( decompressed );
}
else
{
headWordBlockInfos_ = decodeHeadWordBlockInfo( headWordBlockInfo );
}
headWordPos_ = file_->pos();
headWordBlockInfos_ = decodeHeadWordBlockInfo( headWordBlockInfo );
headWordBlockInfosIter_ = headWordBlockInfos_.begin();
return true;
}
bool MdictParser::readRecordBlockInfos()
{
file_->seek( headWordBlockInfoPos_ + headWordBlockInfoSize_ + headWordBlockSize_ );
file_->seek( headWordBlockInfoPos_ + headWordBlockInfoSize_ +
headWordBlockSize_ );
QDataStream in( file_ );
in.setByteOrder( QDataStream::BigEndian );
qint64 numRecordBlocks = readNumber( in );
readNumber( in ); // entry count, skip
readNumber( in ); // total number of records, skip
qint64 recordInfoSize = readNumber( in );
totalRecordsSize_ = readNumber( in );
recordPos_ = file_->pos() + recordInfoSize;
@ -544,18 +540,18 @@ MdictParser::BlockInfoVector MdictParser::decodeHeadWordBlockInfo( QByteArray co
while ( !s.atEnd() )
{
// unknown
// Number of keywords in the block
s.skipRawData( numberTypeSize_ );
// Text head size
// Size of the first headword in the block
quint32 textHeadSize = readU8OrU16( s, isU16 );
// Text head
// The first headword
if ( encoding_ != "UTF-16LE" )
s.skipRawData( textHeadSize + textTermSize );
else
s.skipRawData( ( textHeadSize + textTermSize ) * 2 );
// Text tail Size
// Size of the last headword in the block
quint32 textTailSize = readU8OrU16( s, isU16 );
// Text tail
// The last headword
if ( encoding_ != "UTF-16LE" )
s.skipRawData( textTailSize + textTermSize );
else

10
mdictparser.hh
View file

@ -1,8 +1,10 @@
// https://bitbucket.org/xwang/mdict-analysis
// https://github.com/zhansliu/writemdict/blob/master/fileformat.md
// Octopus MDict Dictionary File (.mdx) and Resource File (.mdd) Analyser
//
// Copyright (C) 2012, 2013 Xiaoqiang Wang <xiaoqiangwang AT gmail DOT com>
// Copyright (C) 2013 Timon Wong <timon86.wang AT gmail DOT com>
// Copyright (C) 2015 Zhe Wang <0x1998 AT gmail DOT com>
//
// This program is a free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
@ -165,8 +167,7 @@ public:
return toUtf16( fromCode.toLatin1().constData(), from, fromSize );
}
static bool parseCompressedBlock( qint64 compressedBlockSize, const char * compressedBlockPtr,
qint64 decompressedBlockSize, QByteArray & decompressedBlock );
qint64 decompressedBlockSize, QByteArray & decompressedBlock);
static QString & substituteStylesheet( QString & article, StyleSheets const & styleSheets );
static inline string substituteStylesheet( string const & article, StyleSheets const & styleSheets )
{
@ -178,6 +179,8 @@ public:
protected:
qint64 readNumber( QDataStream & in );
static quint32 readU8OrU16( QDataStream & in, bool isU16 );
static bool checkAdler32(const char * buffer, unsigned int len, quint32 checksum);
static bool decryptHeadWordIndex(char * buffer, qint64 len);
bool readHeader( QDataStream & in );
bool readHeadWordBlockInfos( QDataStream & in );
bool readRecordBlockInfos();
@ -207,9 +210,8 @@ protected:
quint32 wordCount_;
int numberTypeSize_;
int encrypted_;
bool rtl_;
bool bruteForce_;
bool bruteForceEnd_;
};
}

183
ripemd.cc Normal file
View file

@ -0,0 +1,183 @@
// Copyright (C) 2007 Michael Niedermayer <michaelni@gmx.at>
// Copyright (C) 2013 James Almer <jamrial@gmail.com>
// Copyright (C) 2015 Zhe Wang <0x1998@gmail.com>
//
// Based on the RIPEMD-128 implementation from libavutil
//
// This program is a free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, version 3 of the License.
//
// You can get a copy of GNU General Public License along this program
// But you can always get it from http://www.gnu.org/licenses/gpl.txt
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
#include "ripemd.hh"
#include <string.h>
#include <QtEndian>
static const uint32_t KA[4] = {
0x5a827999, 0x6ed9eba1, 0x8f1bbcdc, 0xa953fd4e
};
static const uint32_t KB[4] = {
0x50a28be6, 0x5c4dd124, 0x6d703ef3, 0x7a6d76e9
};
static const int ROTA[80] = {
11, 14, 15, 12, 5, 8, 7 , 9, 11, 13, 14, 15, 6, 7, 9, 8,
7 , 6, 8, 13, 11, 9, 7, 15, 7, 12, 15, 9, 11, 7, 13, 12,
11, 13, 6, 7, 14, 9, 13, 15, 14, 8, 13, 6, 5, 12, 7, 5,
11, 12, 14, 15, 14, 15, 9, 8, 9, 14, 5, 6, 8, 6, 5, 12,
9, 15, 5, 11, 6, 8, 13, 12, 5, 12, 13, 14, 11, 8, 5, 6
};
static const int ROTB[80] = {
8, 9, 9, 11, 13, 15, 15, 5, 7, 7, 8, 11, 14, 14, 12, 6,
9, 13, 15, 7, 12, 8, 9, 11, 7, 7, 12, 7, 6, 15, 13, 11,
9, 7, 15, 11, 8, 6, 6, 14, 12, 13, 5, 14, 13, 13, 7, 5,
15, 5, 8, 11, 14, 14, 6, 14, 6, 9, 12, 9, 12, 5, 15, 8,
8, 5, 12, 9, 12, 5, 14, 6, 8, 13, 6, 5, 15, 13, 11, 11
};
static const int WA[80] = {
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
7, 4, 13, 1, 10, 6, 15, 3, 12, 0, 9, 5, 2, 14, 11, 8,
3, 10, 14, 4, 9, 15, 8, 1, 2, 7, 0, 6, 13, 11, 5, 12,
1, 9, 11, 10, 0, 8, 12, 4, 13, 3, 7, 15, 14, 5, 6, 2,
4, 0, 5, 9, 7, 12, 2, 10, 14, 1, 3, 8, 11, 6, 15, 13
};
static const int WB[80] = {
5, 14, 7, 0, 9, 2, 11, 4, 13, 6, 15, 8, 1, 10, 3, 12,
6, 11, 3, 7, 0, 13, 5, 10, 14, 15, 8, 12, 4, 9, 1, 2,
15, 5, 1, 3, 7, 14, 6, 9, 11, 8, 12, 2, 10, 0, 4, 13,
8, 6, 4, 1, 3, 11, 15, 0, 5, 12, 2, 13, 9, 7, 10, 14,
12, 15, 10, 4, 1, 5, 8, 7, 6, 2, 13, 14, 0, 3, 9, 11
};
#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits))))
#define ROUND128_0_TO_15(a,b,c,d,e,f,g,h) \
a = rol(a + (( b ^ c ^ d) + block[WA[n]]), ROTA[n]); \
e = rol(e + ((((f ^ g) & h) ^ g) + block[WB[n]] + KB[0]), ROTB[n]); \
n++
#define ROUND128_16_TO_31(a,b,c,d,e,f,g,h) \
a = rol(a + ((((c ^ d) & b) ^ d) + block[WA[n]] + KA[0]), ROTA[n]); \
e = rol(e + (((~g | f) ^ h) + block[WB[n]] + KB[1]), ROTB[n]); \
n++
#define ROUND128_32_TO_47(a,b,c,d,e,f,g,h) \
a = rol(a + (((~c | b) ^ d) + block[WA[n]] + KA[1]), ROTA[n]); \
e = rol(e + ((((g ^ h) & f) ^ h) + block[WB[n]] + KB[2]), ROTB[n]); \
n++
#define ROUND128_48_TO_63(a,b,c,d,e,f,g,h) \
a = rol(a + ((((b ^ c) & d) ^ c) + block[WA[n]] + KA[2]), ROTA[n]); \
e = rol(e + (( f ^ g ^ h) + block[WB[n]]), ROTB[n]); \
n++
#define R128_0 \
ROUND128_0_TO_15(a,b,c,d,e,f,g,h); \
ROUND128_0_TO_15(d,a,b,c,h,e,f,g); \
ROUND128_0_TO_15(c,d,a,b,g,h,e,f); \
ROUND128_0_TO_15(b,c,d,a,f,g,h,e)
#define R128_16 \
ROUND128_16_TO_31(a,b,c,d,e,f,g,h); \
ROUND128_16_TO_31(d,a,b,c,h,e,f,g); \
ROUND128_16_TO_31(c,d,a,b,g,h,e,f); \
ROUND128_16_TO_31(b,c,d,a,f,g,h,e)
#define R128_32 \
ROUND128_32_TO_47(a,b,c,d,e,f,g,h); \
ROUND128_32_TO_47(d,a,b,c,h,e,f,g); \
ROUND128_32_TO_47(c,d,a,b,g,h,e,f); \
ROUND128_32_TO_47(b,c,d,a,f,g,h,e)
#define R128_48 \
ROUND128_48_TO_63(a,b,c,d,e,f,g,h); \
ROUND128_48_TO_63(d,a,b,c,h,e,f,g); \
ROUND128_48_TO_63(c,d,a,b,g,h,e,f); \
ROUND128_48_TO_63(b,c,d,a,f,g,h,e)
RIPEMD128::RIPEMD128()
: count(0)
, buffer()
, state()
{
state[0] = 0x67452301;
state[1] = 0xEFCDAB89;
state[2] = 0x98BADCFE;
state[3] = 0x10325476;
}
void RIPEMD128::transform( const uint8_t buffer[64] )
{
uint32_t a, b, c, d, e, f, g, h;
uint32_t block[16];
int n;
a = e = state[0];
b = f = state[1];
c = g = state[2];
d = h = state[3];
for (n = 0; n < 16; n++)
block[n] = qFromLittleEndian<uint32_t>( buffer + 4 * n );
n = 0;
R128_0; R128_0; R128_0; R128_0;
R128_16; R128_16; R128_16; R128_16;
R128_32; R128_32; R128_32; R128_32;
R128_48; R128_48; R128_48; R128_48;
h += c + state[1];
state[1] = state[2] + d + e;
state[2] = state[3] + a + f;
state[3] = state[0] + b + g;
state[0] = h;
}
void RIPEMD128::update( const uint8_t * data, size_t len )
{
size_t i, j;
j = count & 63;
count += len;
if ( ( j + len ) > 63 )
{
memcpy( &buffer[j], data, ( i = 64 - j ) );
transform( buffer );
for ( ; i + 63 < len; i += 64 )
transform( &data[i] );
j = 0;
}
else
{
i = 0;
}
memcpy( &buffer[j], &data[i], len - i );
}
void RIPEMD128::digest( uint8_t * digest )
{
uint64_t finalcount = qFromLittleEndian( count << 3 );
update( (const uint8_t *) "\200", 1 );
while ( ( count & 63 ) != 56 )
update( ( const uint8_t * ) "", 1 );
update( ( uint8_t * ) &finalcount, 8 ); /* Should cause a transform() */
for ( int i = 0; i < 4; i++ )
qToLittleEndian( state[i], digest + i*4 );
}

45
ripemd.hh Normal file
View file

@ -0,0 +1,45 @@
// Copyright (C) 2007 Michael Niedermayer <michaelni@gmx.at>
// Copyright (C) 2013 James Almer <jamrial@gmail.com>
// Copyright (C) 2015 Zhe Wang <0x1998@gmail.com>
//
// Based on the RIPEMD-128 implementation from libavutil
//
// This program is a free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, version 3 of the License.
//
// You can get a copy of GNU General Public License along this program
// But you can always get it from http://www.gnu.org/licenses/gpl.txt
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
#ifndef __RIPEMD_HH_INCLUDED__
#define __RIPEMD_HH_INCLUDED__
#include <stdint.h>
#include <stddef.h>
class RIPEMD128
{
public:
RIPEMD128();
// Update hash value
void update( const uint8_t * data, size_t len );
// Finish hashing and output digest value.
void digest( uint8_t * digest );
private:
uint64_t count; // number of bytes in buffer
uint8_t buffer[64]; // 512-bit buffer of input values used in hash updating
uint32_t state[10]; // current hash value
void transform( const uint8_t buffer[64] );
};
#endif // __RIPEMD_HH_INCLUDED__