~zooko/cryptopp/trunk : revision 106

32

The "DL_" prefix means an implementation using group operations (in groups where discrete log is hard).

33

*/

34

35

#include "modarith.h"

35

#include "integer.h"

36

#include "filters.h"

37

#include "eprecomp.h"

38

#include "fips140.h"

44

45

NAMESPACE_BEGIN(CryptoPP)

46

47

//! _

47

//! .

48

class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE TrapdoorFunctionBounds

49

{

50

public:

56

virtual Integer MaxImage() const {return --ImageBound();}

57

};

58

59

//! _

59

//! .

60

class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE RandomizedTrapdoorFunction : public TrapdoorFunctionBounds

61

{

62

public:

64

virtual bool IsRandomized() const {return true;}

65

};

66

67

//! _

67

//! .

68

class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE TrapdoorFunction : public RandomizedTrapdoorFunction

69

{

70

public:

75

virtual Integer ApplyFunction(const Integer &x) const =0;

76

};

77

78

//! _

78

//! .

79

class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE RandomizedTrapdoorFunctionInverse

80

{

81

public:

85

virtual bool IsRandomized() const {return true;}

86

};

87

88

//! _

88

//! .

89

class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE TrapdoorFunctionInverse : public RandomizedTrapdoorFunctionInverse

90

{

91

public:

109

virtual bool ParameterSupported(const char *name) const {return false;}

110

111

//! max size of unpadded message in bytes, given max size of padded message in bits (1 less than size of modulus)

112

virtual size_t MaxUnpaddedLength(size_t paddedLength) const =0;

113

114

virtual void Pad(RandomNumberGenerator &rng, const byte *raw, size_t inputLength, byte *padded, size_t paddedBitLength, const NameValuePairs &parameters) const =0;

115

116

virtual DecodingResult Unpad(const byte *padded, size_t paddedBitLength, byte *raw, const NameValuePairs &parameters) const =0;

112

virtual unsigned int MaxUnpaddedLength(unsigned int paddedLength) const =0;

113

114

virtual void Pad(RandomNumberGenerator &rng, const byte *raw, unsigned int inputLength, byte *padded, unsigned int paddedBitLength, const NameValuePairs &parameters) const =0;

115

116

virtual DecodingResult Unpad(const byte *padded, unsigned int paddedBitLength, byte *raw, const NameValuePairs &parameters) const =0;

117

};

118

119

// ********************************************************

120

121

//! _

121

//! .

122

template <class TFI, class MEI>

123

class CRYPTOPP_NO_VTABLE TF_Base

124

{

134

135

// ********************************************************

136

137

//! _

138

137

template <class BASE>

139

138

class CRYPTOPP_NO_VTABLE PK_FixedLengthCryptoSystemImpl : public BASE

140

139

{

141

140

public:

142

size_t MaxPlaintextLength(size_t ciphertextLength) const

141

unsigned int MaxPlaintextLength(unsigned int ciphertextLength) const

143

142

{return ciphertextLength == FixedCiphertextLength() ? FixedMaxPlaintextLength() : 0;}

144

size_t CiphertextLength(size_t plaintextLength) const

143

unsigned int CiphertextLength(unsigned int plaintextLength) const

145

144

{return plaintextLength <= FixedMaxPlaintextLength() ? FixedCiphertextLength() : 0;}

146

145

147

virtual size_t FixedMaxPlaintextLength() const =0;

148

virtual size_t FixedCiphertextLength() const =0;

146

virtual unsigned int FixedMaxPlaintextLength() const =0;

147

virtual unsigned int FixedCiphertextLength() const =0;

149

148

};

150

149

151

//! _

150

//! .

152

151

template <class INTERFACE, class BASE>

153

152

class CRYPTOPP_NO_VTABLE TF_CryptoSystemBase : public PK_FixedLengthCryptoSystemImpl<INTERFACE>, protected BASE

154

153

{

155

154

public:

156

bool ParameterSupported(const char *name) const {return this->GetMessageEncodingInterface().ParameterSupported(name);}

157

size_t FixedMaxPlaintextLength() const {return this->GetMessageEncodingInterface().MaxUnpaddedLength(PaddedBlockBitLength());}

158

size_t FixedCiphertextLength() const {return this->GetTrapdoorFunctionBounds().MaxImage().ByteCount();}

155

bool ParameterSupported(const char *name) const {return GetMessageEncodingInterface().ParameterSupported(name);}

156

unsigned int FixedMaxPlaintextLength() const {return GetMessageEncodingInterface().MaxUnpaddedLength(PaddedBlockBitLength());}

157

unsigned int FixedCiphertextLength() const {return GetTrapdoorFunctionBounds().MaxImage().ByteCount();}

159

158

160

159

protected:

161

size_t PaddedBlockByteLength() const {return BitsToBytes(PaddedBlockBitLength());}

162

size_t PaddedBlockBitLength() const {return this->GetTrapdoorFunctionBounds().PreimageBound().BitCount()-1;}

160

unsigned int PaddedBlockByteLength() const {return BitsToBytes(PaddedBlockBitLength());}

161

unsigned int PaddedBlockBitLength() const {return GetTrapdoorFunctionBounds().PreimageBound().BitCount()-1;}

163

162

};

164

163

165

//! _

164

//! .

166

165

class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE TF_DecryptorBase : public TF_CryptoSystemBase<PK_Decryptor, TF_Base<TrapdoorFunctionInverse, PK_EncryptionMessageEncodingMethod> >

167

166

{

168

167

public:

169

DecodingResult Decrypt(RandomNumberGenerator &rng, const byte *ciphertext, size_t ciphertextLength, byte *plaintext, const NameValuePairs &parameters = g_nullNameValuePairs) const;

168

DecodingResult Decrypt(RandomNumberGenerator &rng, const byte *ciphertext, unsigned int ciphertextLength, byte *plaintext, const NameValuePairs &parameters = g_nullNameValuePairs) const;

170

169

};

171

170

172

//! _

171

//! .

173

172

class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE TF_EncryptorBase : public TF_CryptoSystemBase<PK_Encryptor, TF_Base<RandomizedTrapdoorFunction, PK_EncryptionMessageEncodingMethod> >

174

173

{

175

174

public:

176

void Encrypt(RandomNumberGenerator &rng, const byte *plaintext, size_t plaintextLength, byte *ciphertext, const NameValuePairs &parameters = g_nullNameValuePairs) const;

175

void Encrypt(RandomNumberGenerator &rng, const byte *plaintext, unsigned int plaintextLength, byte *ciphertext, const NameValuePairs &parameters = g_nullNameValuePairs) const;

177

176

};

178

177

179

178

// ********************************************************

180

179

181

typedef std::pair<const byte *, size_t> HashIdentifier;

180

typedef std::pair<const byte *, unsigned int> HashIdentifier;

182

181

183

//! interface for message encoding method for public key signature schemes

182

//! .

184

183

class CRYPTOPP_NO_VTABLE PK_SignatureMessageEncodingMethod

185

184

{

186

185

public:

187

186

virtual ~PK_SignatureMessageEncodingMethod() {}

188

187

189

virtual size_t MinRepresentativeBitLength(size_t hashIdentifierLength, size_t digestLength) const

190

{return 0;}

191

virtual size_t MaxRecoverableLength(size_t representativeBitLength, size_t hashIdentifierLength, size_t digestLength) const

188

virtual unsigned int MaxRecoverableLength(unsigned int representativeBitLength, unsigned int hashIdentifierLength, unsigned int digestLength) const

192

189

{return 0;}

193

190

194

191

bool IsProbabilistic() const

199

196

{throw NotImplemented("PK_MessageEncodingMethod: this signature scheme does not support message recovery");}

200

197

201

198

// for verification, DL

202

virtual void ProcessSemisignature(HashTransformation &hash, const byte *semisignature, size_t semisignatureLength) const {}

199

virtual void ProcessSemisignature(HashTransformation &hash, const byte *semisignature, unsigned int semisignatureLength) const {}

203

200

204

201

// for signature

205

202

virtual void ProcessRecoverableMessage(HashTransformation &hash,

206

const byte *recoverableMessage, size_t recoverableMessageLength,

207

const byte *presignature, size_t presignatureLength,

203

const byte *recoverableMessage, unsigned int recoverableMessageLength,

204

const byte *presignature, unsigned int presignatureLength,

208

205

SecByteBlock &semisignature) const

209

206

{

210

207

if (RecoverablePartFirst())

212

209

}

213

210

214

211

virtual void ComputeMessageRepresentative(RandomNumberGenerator &rng,

215

const byte *recoverableMessage, size_t recoverableMessageLength,

212

const byte *recoverableMessage, unsigned int recoverableMessageLength,

216

213

HashTransformation &hash, HashIdentifier hashIdentifier, bool messageEmpty,

217

byte *representative, size_t representativeBitLength) const =0;

214

byte *representative, unsigned int representativeBitLength) const =0;

218

215

219

216

virtual bool VerifyMessageRepresentative(

220

217

HashTransformation &hash, HashIdentifier hashIdentifier, bool messageEmpty,

221

byte *representative, size_t representativeBitLength) const =0;

218

byte *representative, unsigned int representativeBitLength) const =0;

222

219

223

220

virtual DecodingResult RecoverMessageFromRepresentative( // for TF

224

221

HashTransformation &hash, HashIdentifier hashIdentifier, bool messageEmpty,

225

byte *representative, size_t representativeBitLength,

222

byte *representative, unsigned int representativeBitLength,

226

223

byte *recoveredMessage) const

227

224

{throw NotImplemented("PK_MessageEncodingMethod: this signature scheme does not support message recovery");}

228

225

229

226

virtual DecodingResult RecoverMessageFromSemisignature( // for DL

230

227

HashTransformation &hash, HashIdentifier hashIdentifier,

231

const byte *presignature, size_t presignatureLength,

232

const byte *semisignature, size_t semisignatureLength,

228

const byte *presignature, unsigned int presignatureLength,

229

const byte *semisignature, unsigned int semisignatureLength,

233

230

byte *recoveredMessage) const

234

231

{throw NotImplemented("PK_MessageEncodingMethod: this signature scheme does not support message recovery");}

235

232

238

235

{

239

236

template <class H> struct HashIdentifierLookup2

240

237

{

241

static HashIdentifier CRYPTOPP_API Lookup()

238

static HashIdentifier Lookup()

242

239

{

243

240

return HashIdentifier(NULL, 0);

244

241

}

251

248

public:

252

249

bool VerifyMessageRepresentative(

253

250

HashTransformation &hash, HashIdentifier hashIdentifier, bool messageEmpty,

254

byte *representative, size_t representativeBitLength) const;

251

byte *representative, unsigned int representativeBitLength) const;

255

252

};

256

253

257

254

class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE PK_RecoverableSignatureMessageEncodingMethod : public PK_SignatureMessageEncodingMethod

259

256

public:

260

257

bool VerifyMessageRepresentative(

261

258

HashTransformation &hash, HashIdentifier hashIdentifier, bool messageEmpty,

262

byte *representative, size_t representativeBitLength) const;

259

byte *representative, unsigned int representativeBitLength) const;

263

260

};

264

261

265

262

class CRYPTOPP_DLL DL_SignatureMessageEncodingMethod_DSA : public PK_DeterministicSignatureMessageEncodingMethod

266

263

{

267

264

public:

268

265

void ComputeMessageRepresentative(RandomNumberGenerator &rng,

269

const byte *recoverableMessage, size_t recoverableMessageLength,

266

const byte *recoverableMessage, unsigned int recoverableMessageLength,

270

267

HashTransformation &hash, HashIdentifier hashIdentifier, bool messageEmpty,

271

byte *representative, size_t representativeBitLength) const;

268

byte *representative, unsigned int representativeBitLength) const;

272

269

};

273

270

274

271

class CRYPTOPP_DLL DL_SignatureMessageEncodingMethod_NR : public PK_DeterministicSignatureMessageEncodingMethod

275

272

{

276

273

public:

277

274

void ComputeMessageRepresentative(RandomNumberGenerator &rng,

278

const byte *recoverableMessage, size_t recoverableMessageLength,

275

const byte *recoverableMessage, unsigned int recoverableMessageLength,

279

276

HashTransformation &hash, HashIdentifier hashIdentifier, bool messageEmpty,

280

byte *representative, size_t representativeBitLength) const;

277

byte *representative, unsigned int representativeBitLength) const;

281

278

};

282

279

283

280

class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE PK_MessageAccumulatorBase : public PK_MessageAccumulator

287

284

288

285

virtual HashTransformation & AccessHash() =0;

289

286

290

void Update(const byte *input, size_t length)

287

void Update(const byte *input, unsigned int length)

291

288

{

292

289

AccessHash().Update(input, length);

293

290

m_empty = m_empty && length == 0;

302

299

class PK_MessageAccumulatorImpl : public PK_MessageAccumulatorBase, protected ObjectHolder<HASH_ALGORITHM>

303

300

{

304

301

public:

305

HashTransformation & AccessHash() {return this->m_object;}

302

HashTransformation & AccessHash() {return m_object;}

306

303

};

307

304

308

//! _

305

//! .

309

306

template <class INTERFACE, class BASE>

310

307

class CRYPTOPP_NO_VTABLE TF_SignatureSchemeBase : public INTERFACE, protected BASE

311

308

{

312

309

public:

313

size_t SignatureLength() const

314

{return this->GetTrapdoorFunctionBounds().MaxPreimage().ByteCount();}

315

size_t MaxRecoverableLength() const

316

{return this->GetMessageEncodingInterface().MaxRecoverableLength(MessageRepresentativeBitLength(), GetHashIdentifier().second, GetDigestSize());}

317

size_t MaxRecoverableLengthFromSignatureLength(size_t signatureLength) const

318

{return this->MaxRecoverableLength();}

310

unsigned int SignatureLength() const

311

{return GetTrapdoorFunctionBounds().MaxPreimage().ByteCount();}

312

unsigned int MaxRecoverableLength() const

313

{return GetMessageEncodingInterface().MaxRecoverableLength(MessageRepresentativeBitLength(), GetHashIdentifier().second, GetDigestSize());}

314

unsigned int MaxRecoverableLengthFromSignatureLength(unsigned int signatureLength) const

315

{return MaxRecoverableLength();}

319

316

320

317

bool IsProbabilistic() const

321

{return this->GetTrapdoorFunctionInterface().IsRandomized() || this->GetMessageEncodingInterface().IsProbabilistic();}

318

{return GetTrapdoorFunctionInterface().IsRandomized() || GetMessageEncodingInterface().IsProbabilistic();}

322

319

bool AllowNonrecoverablePart() const

323

{return this->GetMessageEncodingInterface().AllowNonrecoverablePart();}

320

{return GetMessageEncodingInterface().AllowNonrecoverablePart();}

324

321

bool RecoverablePartFirst() const

325

{return this->GetMessageEncodingInterface().RecoverablePartFirst();}

322

{return GetMessageEncodingInterface().RecoverablePartFirst();}

326

323

327

324

protected:

328

size_t MessageRepresentativeLength() const {return BitsToBytes(MessageRepresentativeBitLength());}

329

size_t MessageRepresentativeBitLength() const {return this->GetTrapdoorFunctionBounds().ImageBound().BitCount()-1;}

325

unsigned int MessageRepresentativeLength() const {return BitsToBytes(MessageRepresentativeBitLength());}

326

unsigned int MessageRepresentativeBitLength() const {return GetTrapdoorFunctionBounds().ImageBound().BitCount()-1;}

330

327

virtual HashIdentifier GetHashIdentifier() const =0;

331

virtual size_t GetDigestSize() const =0;

328

virtual unsigned int GetDigestSize() const =0;

332

329

};

333

330

334

//! _

331

//! .

335

332

class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE TF_SignerBase : public TF_SignatureSchemeBase<PK_Signer, TF_Base<RandomizedTrapdoorFunctionInverse, PK_SignatureMessageEncodingMethod> >

336

333

{

337

334

public:

338

void InputRecoverableMessage(PK_MessageAccumulator &messageAccumulator, const byte *recoverableMessage, size_t recoverableMessageLength) const;

339

size_t SignAndRestart(RandomNumberGenerator &rng, PK_MessageAccumulator &messageAccumulator, byte *signature, bool restart=true) const;

335

void InputRecoverableMessage(PK_MessageAccumulator &messageAccumulator, const byte *recoverableMessage, unsigned int recoverableMessageLength) const;

336

unsigned int SignAndRestart(RandomNumberGenerator &rng, PK_MessageAccumulator &messageAccumulator, byte *signature, bool restart=true) const;

340

337

};

341

338

342

//! _

339

//! .

343

340

class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE TF_VerifierBase : public TF_SignatureSchemeBase<PK_Verifier, TF_Base<TrapdoorFunction, PK_SignatureMessageEncodingMethod> >

344

341

{

345

342

public:

346

void InputSignature(PK_MessageAccumulator &messageAccumulator, const byte *signature, size_t signatureLength) const;

343

void InputSignature(PK_MessageAccumulator &messageAccumulator, const byte *signature, unsigned int signatureLength) const;

347

344

bool VerifyAndRestart(PK_MessageAccumulator &messageAccumulator) const;

348

345

DecodingResult RecoverAndRestart(byte *recoveredMessage, PK_MessageAccumulator &recoveryAccumulator) const;

349

346

};

350

347

351

348

// ********************************************************

352

349

353

//! _

350

//! .

354

351

template <class T1, class T2, class T3>

355

352

struct TF_CryptoSchemeOptions

356

353

{

361

358

typedef T3 MessageEncodingMethod;

362

359

};

363

360

364

//! _

361

//! .

365

362

template <class T1, class T2, class T3, class T4>

366

363

struct TF_SignatureSchemeOptions : public TF_CryptoSchemeOptions<T1, T2, T3>

367

364

{

368

365

typedef T4 HashFunction;

369

366

};

370

367

371

//! _

372

template <class BASE, class SCHEME_OPTIONS, class KEY_CLASS>

368

//! .

369

template <class KEYS>

370

class CRYPTOPP_NO_VTABLE PublicKeyCopier

371

{

372

public:

373

typedef typename KEYS::PublicKey KeyClass;

374

virtual void CopyKeyInto(typename KEYS::PublicKey &key) const =0;

375

};

376

377

//! .

378

template <class KEYS>

379

class CRYPTOPP_NO_VTABLE PrivateKeyCopier

380

{

381

public:

382

typedef typename KEYS::PrivateKey KeyClass;

383

virtual void CopyKeyInto(typename KEYS::PublicKey &key) const =0;

384

virtual void CopyKeyInto(typename KEYS::PrivateKey &key) const =0;

385

};

386

387

//! .

388

template <class BASE, class SCHEME_OPTIONS, class KEY>

373

389

class CRYPTOPP_NO_VTABLE TF_ObjectImplBase : public AlgorithmImpl<BASE, typename SCHEME_OPTIONS::AlgorithmInfo>

374

390

{

375

391

public:

376

392

typedef SCHEME_OPTIONS SchemeOptions;

377

typedef KEY_CLASS KeyClass;

393

typedef KEY KeyClass;

378

394

379

395

PublicKey & AccessPublicKey() {return AccessKey();}

380

396

const PublicKey & GetPublicKey() const {return GetKey();}

407

423

// for signature scheme

408

424

HashIdentifier GetHashIdentifier() const

409

425

{

410

typedef CPP_TYPENAME SchemeOptions::MessageEncodingMethod::HashIdentifierLookup::template HashIdentifierLookup2<CPP_TYPENAME SchemeOptions::HashFunction> L;

411

return L::Lookup();

426

typedef CPP_TYPENAME SchemeOptions::MessageEncodingMethod::HashIdentifierLookup::HashIdentifierLookup2<CPP_TYPENAME SchemeOptions::HashFunction> L;

427

return L::Lookup();

412

428

}

413

size_t GetDigestSize() const

429

unsigned int GetDigestSize() const

414

430

{

415

431

typedef CPP_TYPENAME SchemeOptions::HashFunction H;

416

432

return H::DIGESTSIZE;

417

433

}

418

434

};

419

435

420

//! _

436

//! .

421

437

template <class BASE, class SCHEME_OPTIONS, class KEY>

422

438

class TF_ObjectImplExtRef : public TF_ObjectImplBase<BASE, SCHEME_OPTIONS, KEY>

423

439

{

432

448

const KEY * m_pKey;

433

449

};

434

450

435

//! _

436

template <class BASE, class SCHEME_OPTIONS, class KEY_CLASS>

437

class CRYPTOPP_NO_VTABLE TF_ObjectImpl : public TF_ObjectImplBase<BASE, SCHEME_OPTIONS, KEY_CLASS>

451

//! .

452

template <class BASE, class SCHEME_OPTIONS, class KEY_COPIER>

453

class CRYPTOPP_NO_VTABLE TF_ObjectImpl : public TF_ObjectImplBase<TwoBases<BASE, KEY_COPIER>, SCHEME_OPTIONS, typename KEY_COPIER::KeyClass>

438

454

{

439

455

public:

440

typedef KEY_CLASS KeyClass;

456

typedef typename KEY_COPIER::KeyClass KeyClass;

441

457

442

458

const KeyClass & GetKey() const {return m_trapdoorFunction;}

443

459

KeyClass & AccessKey() {return m_trapdoorFunction;}

444

460

461

void CopyKeyInto(typename SCHEME_OPTIONS::PrivateKey &key) const {key = GetKey();}

462

void CopyKeyInto(typename SCHEME_OPTIONS::PublicKey &key) const {key = GetKey();}

463

445

464

private:

446

465

KeyClass m_trapdoorFunction;

447

466

};

448

467

449

//! _

450

template <class SCHEME_OPTIONS>

451

class TF_DecryptorImpl : public TF_ObjectImpl<TF_DecryptorBase, SCHEME_OPTIONS, typename SCHEME_OPTIONS::PrivateKey>

452

{

453

};

454

455

//! _

456

template <class SCHEME_OPTIONS>

457

class TF_EncryptorImpl : public TF_ObjectImpl<TF_EncryptorBase, SCHEME_OPTIONS, typename SCHEME_OPTIONS::PublicKey>

458

{

459

};

460

461

//! _

462

template <class SCHEME_OPTIONS>

463

class TF_SignerImpl : public TF_ObjectImpl<TF_SignerBase, SCHEME_OPTIONS, typename SCHEME_OPTIONS::PrivateKey>

464

{

465

};

466

467

//! _

468

template <class SCHEME_OPTIONS>

469

class TF_VerifierImpl : public TF_ObjectImpl<TF_VerifierBase, SCHEME_OPTIONS, typename SCHEME_OPTIONS::PublicKey>

468

//! .

469

template <class SCHEME_OPTIONS>

470

class TF_DecryptorImpl : public TF_ObjectImpl<TF_DecryptorBase, SCHEME_OPTIONS, PrivateKeyCopier<typename SCHEME_OPTIONS::Keys> >

471

{

472

};

473

474

//! .

475

template <class SCHEME_OPTIONS>

476

class TF_EncryptorImpl : public TF_ObjectImpl<TF_EncryptorBase, SCHEME_OPTIONS, PublicKeyCopier<typename SCHEME_OPTIONS::Keys> >

477

{

478

};

479

480

//! .

481

template <class SCHEME_OPTIONS>

482

class TF_SignerImpl : public TF_ObjectImpl<TF_SignerBase, SCHEME_OPTIONS, PrivateKeyCopier<typename SCHEME_OPTIONS::Keys> >

483

{

484

};

485

486

//! .

487

template <class SCHEME_OPTIONS>

488

class TF_VerifierImpl : public TF_ObjectImpl<TF_VerifierBase, SCHEME_OPTIONS, PublicKeyCopier<typename SCHEME_OPTIONS::Keys> >

470

489

{

471

490

};

472

491

473

492

// ********************************************************

474

493

475

//! _

476

494

class CRYPTOPP_NO_VTABLE MaskGeneratingFunction

477

495

{

478

496

public:

479

497

virtual ~MaskGeneratingFunction() {}

480

virtual void GenerateAndMask(HashTransformation &hash, byte *output, size_t outputLength, const byte *input, size_t inputLength, bool mask = true) const =0;

498

virtual void GenerateAndMask(HashTransformation &hash, byte *output, unsigned int outputLength, const byte *input, unsigned int inputLength, bool mask = true) const =0;

481

499

};

482

500

483

CRYPTOPP_DLL void CRYPTOPP_API P1363_MGF1KDF2_Common(HashTransformation &hash, byte *output, size_t outputLength, const byte *input, size_t inputLength, const byte *derivationParams, size_t derivationParamsLength, bool mask, unsigned int counterStart);

501

CRYPTOPP_DLL void P1363_MGF1KDF2_Common(HashTransformation &hash, byte *output, unsigned int outputLength, const byte *input, unsigned int inputLength, const byte *derivationParams, unsigned int derivationParamsLength, bool mask, unsigned int counterStart);

484

502

485

//! _

503

//! .

486

504

class P1363_MGF1 : public MaskGeneratingFunction

487

505

{

488

506

public:

489

static const char * CRYPTOPP_API StaticAlgorithmName() {return "MGF1";}

490

void GenerateAndMask(HashTransformation &hash, byte *output, size_t outputLength, const byte *input, size_t inputLength, bool mask = true) const

507

static const char * StaticAlgorithmName() {return "MGF1";}

508

void GenerateAndMask(HashTransformation &hash, byte *output, unsigned int outputLength, const byte *input, unsigned int inputLength, bool mask = true) const

491

509

{

492

510

P1363_MGF1KDF2_Common(hash, output, outputLength, input, inputLength, NULL, 0, mask, 0);

493

511

}

495

513

496

514

// ********************************************************

497

515

498

//! _

516

//! .

499

517

template <class H>

500

518

class P1363_KDF2

501

519

{

502

520

public:

503

static void CRYPTOPP_API DeriveKey(byte *output, size_t outputLength, const byte *input, size_t inputLength, const byte *derivationParams, size_t derivationParamsLength)

521

static void DeriveKey(byte *output, unsigned int outputLength, const byte *input, unsigned int inputLength, const byte *derivationParams, unsigned int derivationParamsLength)

504

522

{

505

523

H h;

506

524

P1363_MGF1KDF2_Common(h, output, outputLength, input, inputLength, derivationParams, derivationParamsLength, false, 1);

509

527

510

528

// ********************************************************

511

529

512

//! to be thrown by DecodeElement and AgreeWithStaticPrivateKey

530

// to be thrown by DecodeElement and AgreeWithStaticPrivateKey

513

531

class DL_BadElement : public InvalidDataFormat

514

532

{

515

533

public:

516

534

DL_BadElement() : InvalidDataFormat("CryptoPP: invalid group element") {}

517

535

};

518

536

519

//! interface for DL group parameters

537

//! .

520

538

template <class T>

521

539

class CRYPTOPP_NO_VTABLE DL_GroupParameters : public CryptoParameters

522

540

{

608

626

mutable unsigned int m_validationLevel;

609

627

};

610

628

611

//! _

629

//! .

612

630

template <class GROUP_PRECOMP, class BASE_PRECOMP = DL_FixedBasePrecomputationImpl<CPP_TYPENAME GROUP_PRECOMP::Element>, class BASE = DL_GroupParameters<CPP_TYPENAME GROUP_PRECOMP::Element> >

613

631

class DL_GroupParametersImpl : public BASE

614

632

{

626

644

BASE_PRECOMP m_gpc;

627

645

};

628

646

629

//! _

647

//! .

630

648

template <class T>

631

649

class CRYPTOPP_NO_VTABLE DL_Key

632

650

{

635

653

virtual DL_GroupParameters<T> & AccessAbstractGroupParameters() =0;

636

654

};

637

655

638

//! interface for DL public keys

656

//! .

639

657

template <class T>

640

658

class CRYPTOPP_NO_VTABLE DL_PublicKey : public DL_Key<T>

641

659

{

646

664

647

665

bool GetVoidValue(const char *name, const std::type_info &valueType, void *pValue) const

648

666

{

649

return GetValueHelper(this, name, valueType, pValue, &this->GetAbstractGroupParameters())

667

return GetValueHelper(this, name, valueType, pValue, &GetAbstractGroupParameters())

650

668

CRYPTOPP_GET_FUNCTION_ENTRY(PublicElement);

651

669

}

652

670

653

671

void AssignFrom(const NameValuePairs &source);

654

672

655

673

// non-inherited

656

virtual const Element & GetPublicElement() const {return GetPublicPrecomputation().GetBase(this->GetAbstractGroupParameters().GetGroupPrecomputation());}

657

virtual void SetPublicElement(const Element &y) {AccessPublicPrecomputation().SetBase(this->GetAbstractGroupParameters().GetGroupPrecomputation(), y);}

674

virtual const Element & GetPublicElement() const {return GetPublicPrecomputation().GetBase(GetAbstractGroupParameters().GetGroupPrecomputation());}

675

virtual void SetPublicElement(const Element &y) {AccessPublicPrecomputation().SetBase(GetAbstractGroupParameters().GetGroupPrecomputation(), y);}

658

676

virtual Element ExponentiatePublicElement(const Integer &exponent) const

659

677

{

660

const DL_GroupParameters<T> &params = this->GetAbstractGroupParameters();

678

const DL_GroupParameters<T> &params = GetAbstractGroupParameters();

661

679

return GetPublicPrecomputation().Exponentiate(params.GetGroupPrecomputation(), exponent);

662

680

}

663

681

virtual Element CascadeExponentiateBaseAndPublicElement(const Integer &baseExp, const Integer &publicExp) const

664

682

{

665

const DL_GroupParameters<T> &params = this->GetAbstractGroupParameters();

683

const DL_GroupParameters<T> &params = GetAbstractGroupParameters();

666

684

return params.GetBasePrecomputation().CascadeExponentiate(params.GetGroupPrecomputation(), baseExp, GetPublicPrecomputation(), publicExp);

667

685

}

668

686

670

688

virtual DL_FixedBasePrecomputation<T> & AccessPublicPrecomputation() =0;

671

689

};

672

690

673

//! interface for DL private keys

691

//! .

674

692

template <class T>

675

693

class CRYPTOPP_NO_VTABLE DL_PrivateKey : public DL_Key<T>

676

694

{

681

699

682

700

void MakePublicKey(DL_PublicKey<T> &pub) const

683

701

{

684

pub.AccessAbstractGroupParameters().AssignFrom(this->GetAbstractGroupParameters());

685

pub.SetPublicElement(this->GetAbstractGroupParameters().ExponentiateBase(GetPrivateExponent()));

702

pub.AccessAbstractGroupParameters().AssignFrom(GetAbstractGroupParameters());

703

pub.SetPublicElement(GetAbstractGroupParameters().ExponentiateBase(GetPrivateExponent()));

686

704

}

687

705

688

706

bool GetVoidValue(const char *name, const std::type_info &valueType, void *pValue) const

689

707

{

690

return GetValueHelper(this, name, valueType, pValue, &this->GetAbstractGroupParameters())

708

return GetValueHelper(this, name, valueType, pValue, &GetAbstractGroupParameters())

691

709

CRYPTOPP_GET_FUNCTION_ENTRY(PrivateExponent);

692

710

}

693

711

694

712

void AssignFrom(const NameValuePairs &source)

695

713

{

696

this->AccessAbstractGroupParameters().AssignFrom(source);

714

AccessAbstractGroupParameters().AssignFrom(source);

697

715

AssignFromHelper(this, source)

698

716

CRYPTOPP_SET_FUNCTION_ENTRY(PrivateExponent);

699

717

}

710

728

pPrivateKey->MakePublicKey(*this);

711

729

else

712

730

{

713

this->AccessAbstractGroupParameters().AssignFrom(source);

731

AccessAbstractGroupParameters().AssignFrom(source);

714

732

AssignFromHelper(this, source)

715

733

CRYPTOPP_SET_FUNCTION_ENTRY(PublicElement);

716

734

}

718

736

719

737

class OID;

720

738

721

//! _

739

//! .

722

740

template <class PK, class GP, class O = OID>

723

741

class DL_KeyImpl : public PK

724

742

{

745

763

class X509PublicKey;

746

764

class PKCS8PrivateKey;

747

765

748

//! _

766

//! .

749

767

template <class GP>

750

768

class DL_PrivateKeyImpl : public DL_PrivateKey<CPP_TYPENAME GP::Element>, public DL_KeyImpl<PKCS8PrivateKey, GP>

751

769

{

778

796

779

797

void GenerateRandom(RandomNumberGenerator &rng, const NameValuePairs &params)

780

798

{

781

if (!params.GetThisObject(this->AccessGroupParameters()))

782

this->AccessGroupParameters().GenerateRandom(rng, params);

799

if (!params.GetThisObject(AccessGroupParameters()))

800

AccessGroupParameters().GenerateRandom(rng, params);

783

801

// std::pair<const byte *, int> seed;

784

802

Integer x(rng, Integer::One(), GetAbstractGroupParameters().GetMaxExponent());

785

803

// Integer::ANY, Integer::Zero(), Integer::One(),

799

817

{GetAbstractGroupParameters().SavePrecomputation(storedPrecomputation);}

800

818

801

819

// DL_Key

802

const DL_GroupParameters<Element> & GetAbstractGroupParameters() const {return this->GetGroupParameters();}

803

DL_GroupParameters<Element> & AccessAbstractGroupParameters() {return this->AccessGroupParameters();}

820

const DL_GroupParameters<Element> & GetAbstractGroupParameters() const {return GetGroupParameters();}

821

DL_GroupParameters<Element> & AccessAbstractGroupParameters() {return AccessGroupParameters();}

804

822

805

823

// DL_PrivateKey

806

824

const Integer & GetPrivateExponent() const {return m_x;}

816

834

Integer m_x;

817

835

};

818

836

819

//! _

837

//! .

820

838

template <class BASE, class SIGNATURE_SCHEME>

821

839

class DL_PrivateKey_WithSignaturePairwiseConsistencyTest : public BASE

822

840

{

834

852

}

835

853

};

836

854

837

//! _

855

//! .

838

856

template <class GP>

839

857

class DL_PublicKeyImpl : public DL_PublicKey<typename GP::Element>, public DL_KeyImpl<X509PublicKey, GP>

840

858

{

845

863

bool Validate(RandomNumberGenerator &rng, unsigned int level) const

846

864

{

847

865

bool pass = GetAbstractGroupParameters().Validate(rng, level);

848

pass = pass && GetAbstractGroupParameters().ValidateElement(level, this->GetPublicElement(), &GetPublicPrecomputation());

866

pass = pass && GetAbstractGroupParameters().ValidateElement(level, GetPublicElement(), &GetPublicPrecomputation());

849

867

return pass;

850

868

}

851

869

880

898

}

881

899

882

900

// DL_Key

883

const DL_GroupParameters<Element> & GetAbstractGroupParameters() const {return this->GetGroupParameters();}

884

DL_GroupParameters<Element> & AccessAbstractGroupParameters() {return this->AccessGroupParameters();}

901

const DL_GroupParameters<Element> & GetAbstractGroupParameters() const {return GetGroupParameters();}

902

DL_GroupParameters<Element> & AccessAbstractGroupParameters() {return AccessGroupParameters();}

885

903

886

904

// DL_PublicKey

887

905

const DL_FixedBasePrecomputation<Element> & GetPublicPrecomputation() const {return m_ypc;}

889

907

890

908

// non-inherited

891

909

bool operator==(const DL_PublicKeyImpl<GP> &rhs) const

892

{return this->GetGroupParameters() == rhs.GetGroupParameters() && this->GetPublicElement() == rhs.GetPublicElement();}

910

{return GetGroupParameters() == rhs.GetGroupParameters() && GetPublicElement() == rhs.GetPublicElement();}

893

911

894

912

private:

895

913

typename GP::BasePrecomputation m_ypc;

896

914

};

897

915

898

//! interface for Elgamal-like signature algorithms

916

//! .

899

917

template <class T>

900

918

class CRYPTOPP_NO_VTABLE DL_ElgamalLikeSignatureAlgorithm

901

919

{

904

922

virtual bool Verify(const DL_GroupParameters<T> &params, const DL_PublicKey<T> &publicKey, const Integer &e, const Integer &r, const Integer &s) const =0;

905

923

virtual Integer RecoverPresignature(const DL_GroupParameters<T> &params, const DL_PublicKey<T> &publicKey, const Integer &r, const Integer &s) const

906

924

{throw NotImplemented("DL_ElgamalLikeSignatureAlgorithm: this signature scheme does not support message recovery");}

907

virtual size_t RLen(const DL_GroupParameters<T> &params) const

925

virtual unsigned int RLen(const DL_GroupParameters<T> &params) const

908

926

{return params.GetSubgroupOrder().ByteCount();}

909

virtual size_t SLen(const DL_GroupParameters<T> &params) const

927

virtual unsigned int SLen(const DL_GroupParameters<T> &params) const

910

928

{return params.GetSubgroupOrder().ByteCount();}

911

929

};

912

930

913

//! interface for DL key agreement algorithms

931

//! .

914

932

template <class T>

915

933

class CRYPTOPP_NO_VTABLE DL_KeyAgreementAlgorithm

916

934

{

921

939

virtual Element AgreeWithStaticPrivateKey(const DL_GroupParameters<Element> &params, const Element &publicElement, bool validateOtherPublicKey, const Integer &privateExponent) const =0;

922

940

};

923

941

924

//! interface for key derivation algorithms used in DL cryptosystems

942

//! .

925

943

template <class T>

926

944

class CRYPTOPP_NO_VTABLE DL_KeyDerivationAlgorithm

927

945

{

928

946

public:

929

947

virtual bool ParameterSupported(const char *name) const {return false;}

930

virtual void Derive(const DL_GroupParameters<T> &groupParams, byte *derivedKey, size_t derivedLength, const T &agreedElement, const T &ephemeralPublicKey, const NameValuePairs &derivationParams) const =0;

948

virtual void Derive(const DL_GroupParameters<T> &groupParams, byte *derivedKey, unsigned int derivedLength, const T &agreedElement, const T &ephemeralPublicKey, const NameValuePairs &derivationParams) const =0;

931

949

};

932

950

933

//! interface for symmetric encryption algorithms used in DL cryptosystems

951

//! .

934

952

class CRYPTOPP_NO_VTABLE DL_SymmetricEncryptionAlgorithm

935

953

{

936

954

public:

937

955

virtual bool ParameterSupported(const char *name) const {return false;}

938

virtual size_t GetSymmetricKeyLength(size_t plaintextLength) const =0;

939

virtual size_t GetSymmetricCiphertextLength(size_t plaintextLength) const =0;

940

virtual size_t GetMaxSymmetricPlaintextLength(size_t ciphertextLength) const =0;

941

virtual void SymmetricEncrypt(RandomNumberGenerator &rng, const byte *key, const byte *plaintext, size_t plaintextLength, byte *ciphertext, const NameValuePairs &parameters) const =0;

942

virtual DecodingResult SymmetricDecrypt(const byte *key, const byte *ciphertext, size_t ciphertextLength, byte *plaintext, const NameValuePairs &parameters) const =0;

956

virtual unsigned int GetSymmetricKeyLength(unsigned int plaintextLength) const =0;

957

virtual unsigned int GetSymmetricCiphertextLength(unsigned int plaintextLength) const =0;

958

virtual unsigned int GetMaxSymmetricPlaintextLength(unsigned int ciphertextLength) const =0;

959

virtual void SymmetricEncrypt(RandomNumberGenerator &rng, const byte *key, const byte *plaintext, unsigned int plaintextLength, byte *ciphertext, const NameValuePairs &parameters) const =0;

960

virtual DecodingResult SymmetricDecrypt(const byte *key, const byte *ciphertext, unsigned int ciphertextLength, byte *plaintext, const NameValuePairs &parameters) const =0;

943

961

};

944

962

945

//! _

963

//! .

946

964

template <class KI>

947

965

class CRYPTOPP_NO_VTABLE DL_Base

948

966

{

957

975

virtual const KeyInterface & GetKeyInterface() const =0;

958

976

};

959

977

960

//! _

978

//! .

961

979

template <class INTERFACE, class KEY_INTERFACE>

962

980

class CRYPTOPP_NO_VTABLE DL_SignatureSchemeBase : public INTERFACE, public DL_Base<KEY_INTERFACE>

963

981

{

964

982

public:

965

size_t SignatureLength() const

983

unsigned int SignatureLength() const

966

984

{

967

return GetSignatureAlgorithm().RLen(this->GetAbstractGroupParameters())

968

+ GetSignatureAlgorithm().SLen(this->GetAbstractGroupParameters());

985

return GetSignatureAlgorithm().RLen(GetAbstractGroupParameters())

986

+ GetSignatureAlgorithm().SLen(GetAbstractGroupParameters());

969

987

}

970

size_t MaxRecoverableLength() const

988

unsigned int MaxRecoverableLength() const

971

989

{return GetMessageEncodingInterface().MaxRecoverableLength(0, GetHashIdentifier().second, GetDigestSize());}

972

size_t MaxRecoverableLengthFromSignatureLength(size_t signatureLength) const

990

unsigned int MaxRecoverableLengthFromSignatureLength(unsigned int signatureLength) const

973

991

{assert(false); return 0;} // TODO

974

992

975

993

bool IsProbabilistic() const

980

998

{return GetMessageEncodingInterface().RecoverablePartFirst();}

981

999

982

1000

protected:

983

size_t MessageRepresentativeLength() const {return BitsToBytes(MessageRepresentativeBitLength());}

984

size_t MessageRepresentativeBitLength() const {return this->GetAbstractGroupParameters().GetSubgroupOrder().BitCount();}

1001

unsigned int MessageRepresentativeLength() const {return BitsToBytes(MessageRepresentativeBitLength());}

1002

unsigned int MessageRepresentativeBitLength() const {return GetAbstractGroupParameters().GetSubgroupOrder().BitCount();}

985

1003

986

1004

virtual const DL_ElgamalLikeSignatureAlgorithm<CPP_TYPENAME KEY_INTERFACE::Element> & GetSignatureAlgorithm() const =0;

987

1005

virtual const PK_SignatureMessageEncodingMethod & GetMessageEncodingInterface() const =0;

988

1006

virtual HashIdentifier GetHashIdentifier() const =0;

989

virtual size_t GetDigestSize() const =0;

1007

virtual unsigned int GetDigestSize() const =0;

990

1008

};

991

1009

992

//! _

1010

//! .

993

1011

template <class T>

994

1012

class CRYPTOPP_NO_VTABLE DL_SignerBase : public DL_SignatureSchemeBase<PK_Signer, DL_PrivateKey<T> >

995

1013

{

997

1015

// for validation testing

998

1016

void RawSign(const Integer &k, const Integer &e, Integer &r, Integer &s) const

999

1017

{

1000

const DL_ElgamalLikeSignatureAlgorithm<T> &alg = this->GetSignatureAlgorithm();

1001

const DL_GroupParameters<T> &params = this->GetAbstractGroupParameters();

1002

const DL_PrivateKey<T> &key = this->GetKeyInterface();

1018

const DL_ElgamalLikeSignatureAlgorithm<T> &alg = GetSignatureAlgorithm();

1019

const DL_GroupParameters<T> &params = GetAbstractGroupParameters();

1020

const DL_PrivateKey<T> &key = GetKeyInterface();

1003

1021

1004

1022

r = params.ConvertElementToInteger(params.ExponentiateBase(k));

1005

1023

alg.Sign(params, key.GetPrivateExponent(), k, e, r, s);

1006

1024

}

1007

1025

1008

void InputRecoverableMessage(PK_MessageAccumulator &messageAccumulator, const byte *recoverableMessage, size_t recoverableMessageLength) const

1026

void InputRecoverableMessage(PK_MessageAccumulator &messageAccumulator, const byte *recoverableMessage, unsigned int recoverableMessageLength) const

1009

1027

{

1010

1028

PK_MessageAccumulatorBase &ma = static_cast<PK_MessageAccumulatorBase &>(messageAccumulator);

1011

1029

ma.m_recoverableMessage.Assign(recoverableMessage, recoverableMessageLength);

1012

this->GetMessageEncodingInterface().ProcessRecoverableMessage(ma.AccessHash(),

1030

GetMessageEncodingInterface().ProcessRecoverableMessage(ma.AccessHash(),

1013

1031

recoverableMessage, recoverableMessageLength,

1014

1032

ma.m_presignature, ma.m_presignature.size(),

1015

1033

ma.m_semisignature);

1016

1034

}

1017

1035

1018

size_t SignAndRestart(RandomNumberGenerator &rng, PK_MessageAccumulator &messageAccumulator, byte *signature, bool restart) const

1036

unsigned int SignAndRestart(RandomNumberGenerator &rng, PK_MessageAccumulator &messageAccumulator, byte *signature, bool restart) const

1019

1037

{

1020

this->GetMaterial().DoQuickSanityCheck();

1038

GetMaterial().DoQuickSanityCheck();

1021

1039

1022

1040

PK_MessageAccumulatorBase &ma = static_cast<PK_MessageAccumulatorBase &>(messageAccumulator);

1023

const DL_ElgamalLikeSignatureAlgorithm<T> &alg = this->GetSignatureAlgorithm();

1024

const DL_GroupParameters<T> &params = this->GetAbstractGroupParameters();

1025

const DL_PrivateKey<T> &key = this->GetKeyInterface();

1041

const DL_ElgamalLikeSignatureAlgorithm<T> &alg = GetSignatureAlgorithm();

1042

const DL_GroupParameters<T> &params = GetAbstractGroupParameters();

1043

const DL_PrivateKey<T> &key = GetKeyInterface();

1026

1044

1027

SecByteBlock representative(this->MessageRepresentativeLength());

1028

this->GetMessageEncodingInterface().ComputeMessageRepresentative(

1045

SecByteBlock representative(MessageRepresentativeLength());

1046

GetMessageEncodingInterface().ComputeMessageRepresentative(

1029

1047

rng,

1030

1048

ma.m_recoverableMessage, ma.m_recoverableMessage.size(),

1031

ma.AccessHash(), this->GetHashIdentifier(), ma.m_empty,

1032

representative, this->MessageRepresentativeBitLength());

1049

ma.AccessHash(), GetHashIdentifier(), ma.m_empty,

1050

representative, MessageRepresentativeBitLength());

1033

1051

ma.m_empty = true;

1034

1052

Integer e(representative, representative.size());

1035

1053

1036

1054

Integer r;

1037

if (this->MaxRecoverableLength() > 0)

1055

if (MaxRecoverableLength() > 0)

1038

1056

r.Decode(ma.m_semisignature, ma.m_semisignature.size());

1039

1057

else

1040

1058

r.Decode(ma.m_presignature, ma.m_presignature.size());

1041

1059

Integer s;

1042

1060

alg.Sign(params, key.GetPrivateExponent(), ma.m_k, e, r, s);

1043

1061

1044

size_t rLen = alg.RLen(params);

1062

unsigned int rLen = alg.RLen(params);

1045

1063

r.Encode(signature, rLen);

1046

1064

s.Encode(signature+rLen, alg.SLen(params));

1047

1065

1048

1066

if (restart)

1049

1067

RestartMessageAccumulator(rng, ma);

1050

1068

1051

return this->SignatureLength();

1069

return SignatureLength();

1052

1070

}

1053

1071

1054

1072

protected:

1055

1073

void RestartMessageAccumulator(RandomNumberGenerator &rng, PK_MessageAccumulatorBase &ma) const

1056

1074

{

1057

const DL_ElgamalLikeSignatureAlgorithm<T> &alg = this->GetSignatureAlgorithm();

1058

const DL_GroupParameters<T> &params = this->GetAbstractGroupParameters();

1075

const DL_ElgamalLikeSignatureAlgorithm<T> &alg = GetSignatureAlgorithm();

1076

const DL_GroupParameters<T> &params = GetAbstractGroupParameters();

1059

1077

ma.m_k.Randomize(rng, 1, params.GetSubgroupOrder()-1);

1060

1078

ma.m_presignature.New(params.GetEncodedElementSize(false));

1061

1079

params.ConvertElementToInteger(params.ExponentiateBase(ma.m_k)).Encode(ma.m_presignature, ma.m_presignature.size());

1062

1080

}

1063

1081

};

1064

1082

1065

//! _

1083

//! .

1066

1084

template <class T>

1067

1085

class CRYPTOPP_NO_VTABLE DL_VerifierBase : public DL_SignatureSchemeBase<PK_Verifier, DL_PublicKey<T> >

1068

1086

{

1069

1087

public:

1070

void InputSignature(PK_MessageAccumulator &messageAccumulator, const byte *signature, size_t signatureLength) const

1088

void InputSignature(PK_MessageAccumulator &messageAccumulator, const byte *signature, unsigned int signatureLength) const

1071

1089

{

1072

1090

PK_MessageAccumulatorBase &ma = static_cast<PK_MessageAccumulatorBase &>(messageAccumulator);

1073

const DL_ElgamalLikeSignatureAlgorithm<T> &alg = this->GetSignatureAlgorithm();

1074

const DL_GroupParameters<T> &params = this->GetAbstractGroupParameters();

1091

const DL_ElgamalLikeSignatureAlgorithm<T> &alg = GetSignatureAlgorithm();

1092

const DL_GroupParameters<T> &params = GetAbstractGroupParameters();

1075

1093

1076

size_t rLen = alg.RLen(params);

1094

unsigned int rLen = alg.RLen(params);

1077

1095

ma.m_semisignature.Assign(signature, rLen);

1078

1096

ma.m_s.Decode(signature+rLen, alg.SLen(params));

1079

1097

1080

this->GetMessageEncodingInterface().ProcessSemisignature(ma.AccessHash(), ma.m_semisignature, ma.m_semisignature.size());

1098

GetMessageEncodingInterface().ProcessSemisignature(ma.AccessHash(), ma.m_semisignature, ma.m_semisignature.size());

1081

1099

}

1082

1100

1083

1101

bool VerifyAndRestart(PK_MessageAccumulator &messageAccumulator) const

1084

1102

{

1085

this->GetMaterial().DoQuickSanityCheck();

1103

GetMaterial().DoQuickSanityCheck();

1086

1104

1087

1105

PK_MessageAccumulatorBase &ma = static_cast<PK_MessageAccumulatorBase &>(messageAccumulator);

1088

const DL_ElgamalLikeSignatureAlgorithm<T> &alg = this->GetSignatureAlgorithm();

1089

const DL_GroupParameters<T> &params = this->GetAbstractGroupParameters();

1090

const DL_PublicKey<T> &key = this->GetKeyInterface();

1106

const DL_ElgamalLikeSignatureAlgorithm<T> &alg = GetSignatureAlgorithm();

1107

const DL_GroupParameters<T> &params = GetAbstractGroupParameters();

1108

const DL_PublicKey<T> &key = GetKeyInterface();

1091

1109

1092

SecByteBlock representative(this->MessageRepresentativeLength());

1093

this->GetMessageEncodingInterface().ComputeMessageRepresentative(NullRNG(), ma.m_recoverableMessage, ma.m_recoverableMessage.size(),

1094

ma.AccessHash(), this->GetHashIdentifier(), ma.m_empty,

1095

representative, this->MessageRepresentativeBitLength());

1110

SecByteBlock representative(MessageRepresentativeLength());

1111

GetMessageEncodingInterface().ComputeMessageRepresentative(NullRNG(), ma.m_recoverableMessage, ma.m_recoverableMessage.size(),

1112

ma.AccessHash(), GetHashIdentifier(), ma.m_empty,

1113

representative, MessageRepresentativeBitLength());

1096

1114

ma.m_empty = true;

1097

1115

Integer e(representative, representative.size());

1098

1116

1102

1120

1103

1121

DecodingResult RecoverAndRestart(byte *recoveredMessage, PK_MessageAccumulator &messageAccumulator) const

1104

1122

{

1105

this->GetMaterial().DoQuickSanityCheck();

1123

GetMaterial().DoQuickSanityCheck();

1106

1124

1107

1125

PK_MessageAccumulatorBase &ma = static_cast<PK_MessageAccumulatorBase &>(messageAccumulator);

1108

const DL_ElgamalLikeSignatureAlgorithm<T> &alg = this->GetSignatureAlgorithm();

1109

const DL_GroupParameters<T> &params = this->GetAbstractGroupParameters();

1110

const DL_PublicKey<T> &key = this->GetKeyInterface();

1126

const DL_ElgamalLikeSignatureAlgorithm<T> &alg = GetSignatureAlgorithm();

1127

const DL_GroupParameters<T> &params = GetAbstractGroupParameters();

1128

const DL_PublicKey<T> &key = GetKeyInterface();

1111

1129

1112

SecByteBlock representative(this->MessageRepresentativeLength());

1113

this->GetMessageEncodingInterface().ComputeMessageRepresentative(

1130

SecByteBlock representative(MessageRepresentativeLength());

1131

GetMessageEncodingInterface().ComputeMessageRepresentative(

1114

1132

NullRNG(),

1115

1133

ma.m_recoverableMessage, ma.m_recoverableMessage.size(),

1116

ma.AccessHash(), this->GetHashIdentifier(), ma.m_empty,

1117

representative, this->MessageRepresentativeBitLength());

1134

ma.AccessHash(), GetHashIdentifier(), ma.m_empty,

1135

representative, MessageRepresentativeBitLength());

1118

1136

ma.m_empty = true;

1119

1137

Integer e(representative, representative.size());

1120

1138

1122

1140

Integer r(ma.m_semisignature, ma.m_semisignature.size());

1123

1141

alg.RecoverPresignature(params, key, r, ma.m_s).Encode(ma.m_presignature, ma.m_presignature.size());

1124

1142

1125

return this->GetMessageEncodingInterface().RecoverMessageFromSemisignature(

1126

ma.AccessHash(), this->GetHashIdentifier(),

1143

return GetMessageEncodingInterface().RecoverMessageFromSemisignature(

1144

ma.AccessHash(), GetHashIdentifier(),

1127

1145

ma.m_presignature, ma.m_presignature.size(),

1128

1146

ma.m_semisignature, ma.m_semisignature.size(),

1129

1147

recoveredMessage);

1130

1148

}

1131

1149

};

1132

1150

1133

//! _

1151

//! .

1134

1152

template <class PK, class KI>

1135

1153

class CRYPTOPP_NO_VTABLE DL_CryptoSystemBase : public PK, public DL_Base<KI>

1136

1154

{

1137

1155

public:

1138

1156

typedef typename DL_Base<KI>::Element Element;

1139

1157

1140

size_t MaxPlaintextLength(size_t ciphertextLength) const

1158

unsigned int MaxPlaintextLength(unsigned int ciphertextLength) const

1141

1159

{

1142

unsigned int minLen = this->GetAbstractGroupParameters().GetEncodedElementSize(true);

1160

unsigned int minLen = GetAbstractGroupParameters().GetEncodedElementSize(true);

1143

1161

return ciphertextLength < minLen ? 0 : GetSymmetricEncryptionAlgorithm().GetMaxSymmetricPlaintextLength(ciphertextLength - minLen);

1144

1162

}

1145

1163

1146

size_t CiphertextLength(size_t plaintextLength) const

1164

unsigned int CiphertextLength(unsigned int plaintextLength) const

1147

1165

{

1148

size_t len = GetSymmetricEncryptionAlgorithm().GetSymmetricCiphertextLength(plaintextLength);

1149

return len == 0 ? 0 : this->GetAbstractGroupParameters().GetEncodedElementSize(true) + len;

1166

unsigned int len = GetSymmetricEncryptionAlgorithm().GetSymmetricCiphertextLength(plaintextLength);

1167

return len == 0 ? 0 : GetAbstractGroupParameters().GetEncodedElementSize(true) + len;

1150

1168

}

1151

1169

1152

1170

bool ParameterSupported(const char *name) const

1158

1176

virtual const DL_SymmetricEncryptionAlgorithm & GetSymmetricEncryptionAlgorithm() const =0;

1159

1177

};

1160

1178

1161

//! _

1179

//! .

1162

1180

template <class T>

1163

1181

class CRYPTOPP_NO_VTABLE DL_DecryptorBase : public DL_CryptoSystemBase<PK_Decryptor, DL_PrivateKey<T> >

1164

1182

{

1165

1183

public:

1166

1184

typedef T Element;

1167

1185

1168

DecodingResult Decrypt(RandomNumberGenerator &rng, const byte *ciphertext, size_t ciphertextLength, byte *plaintext, const NameValuePairs &parameters = g_nullNameValuePairs) const

1186

DecodingResult Decrypt(RandomNumberGenerator &rng, const byte *ciphertext, unsigned int ciphertextLength, byte *plaintext, const NameValuePairs &parameters = g_nullNameValuePairs) const

1169

1187

{

1170

1188

try

1171

1189

{

1172

const DL_KeyAgreementAlgorithm<T> &agreeAlg = this->GetKeyAgreementAlgorithm();

1173

const DL_KeyDerivationAlgorithm<T> &derivAlg = this->GetKeyDerivationAlgorithm();

1174

const DL_SymmetricEncryptionAlgorithm &encAlg = this->GetSymmetricEncryptionAlgorithm();

1175

const DL_GroupParameters<T> &params = this->GetAbstractGroupParameters();

1176

const DL_PrivateKey<T> &key = this->GetKeyInterface();

1190

const DL_KeyAgreementAlgorithm<T> &agreeAlg = GetKeyAgreementAlgorithm();

1191

const DL_KeyDerivationAlgorithm<T> &derivAlg = GetKeyDerivationAlgorithm();

1192

const DL_SymmetricEncryptionAlgorithm &encAlg = GetSymmetricEncryptionAlgorithm();

1193

const DL_GroupParameters<T> &params = GetAbstractGroupParameters();

1194

const DL_PrivateKey<T> &key = GetKeyInterface();

1177

1195

1178

1196

Element q = params.DecodeElement(ciphertext, true);

1179

size_t elementSize = params.GetEncodedElementSize(true);

1197

unsigned int elementSize = params.GetEncodedElementSize(true);

1180

1198

ciphertext += elementSize;

1181

1199

ciphertextLength -= elementSize;

1182

1200

1194

1212

}

1195

1213

};

1196

1214

1197

//! _

1215

//! .

1198

1216

template <class T>

1199

1217

class CRYPTOPP_NO_VTABLE DL_EncryptorBase : public DL_CryptoSystemBase<PK_Encryptor, DL_PublicKey<T> >

1200

1218

{

1201

1219

public:

1202

1220

typedef T Element;

1203

1221

1204

void Encrypt(RandomNumberGenerator &rng, const byte *plaintext, size_t plaintextLength, byte *ciphertext, const NameValuePairs &parameters = g_nullNameValuePairs) const

1222

void Encrypt(RandomNumberGenerator &rng, const byte *plaintext, unsigned int plaintextLength, byte *ciphertext, const NameValuePairs &parameters = g_nullNameValuePairs) const

1205

1223

{

1206

const DL_KeyAgreementAlgorithm<T> &agreeAlg = this->GetKeyAgreementAlgorithm();

1207

const DL_KeyDerivationAlgorithm<T> &derivAlg = this->GetKeyDerivationAlgorithm();

1208

const DL_SymmetricEncryptionAlgorithm &encAlg = this->GetSymmetricEncryptionAlgorithm();

1209

const DL_GroupParameters<T> &params = this->GetAbstractGroupParameters();

1210

const DL_PublicKey<T> &key = this->GetKeyInterface();

1224

const DL_KeyAgreementAlgorithm<T> &agreeAlg = GetKeyAgreementAlgorithm();

1225

const DL_KeyDerivationAlgorithm<T> &derivAlg = GetKeyDerivationAlgorithm();

1226

const DL_SymmetricEncryptionAlgorithm &encAlg = GetSymmetricEncryptionAlgorithm();

1227

const DL_GroupParameters<T> &params = GetAbstractGroupParameters();

1228

const DL_PublicKey<T> &key = GetKeyInterface();

1211

1229

1212

1230

Integer x(rng, Integer::One(), params.GetMaxExponent());

1213

1231

Element q = params.ExponentiateBase(x);

1224

1242

}

1225

1243

};

1226

1244

1227

//! _

1245

//! .

1228

1246

template <class T1, class T2>

1229

1247

struct DL_SchemeOptionsBase

1230

1248

{

1233

1251

typedef typename GroupParameters::Element Element;

1234

1252

};

1235

1253

1236

//! _

1254

//! .

1237

1255

template <class T1, class T2>

1238

1256

struct DL_KeyedSchemeOptions : public DL_SchemeOptionsBase<T1, typename T2::PublicKey::GroupParameters>

1239

1257

{

1242

1260

typedef typename Keys::PublicKey PublicKey;

1243

1261

};

1244

1262

1245

//! _

1263

//! .

1246

1264

template <class T1, class T2, class T3, class T4, class T5>

1247

1265

struct DL_SignatureSchemeOptions : public DL_KeyedSchemeOptions<T1, T2>

1248

1266

{

1251

1269

typedef T5 HashFunction;

1252

1270

};

1253

1271

1254

//! _

1272

//! .

1255

1273

template <class T1, class T2, class T3, class T4, class T5>

1256

1274

struct DL_CryptoSchemeOptions : public DL_KeyedSchemeOptions<T1, T2>

1257

1275

{

1260

1278

typedef T5 SymmetricEncryptionAlgorithm;

1261

1279

};

1262

1280

1263

//! _

1281

//! .

1264

1282

template <class BASE, class SCHEME_OPTIONS, class KEY>

1265

1283

class CRYPTOPP_NO_VTABLE DL_ObjectImplBase : public AlgorithmImpl<BASE, typename SCHEME_OPTIONS::AlgorithmInfo>

1266

1284

{

1282

1300

// for signature scheme

1283

1301

HashIdentifier GetHashIdentifier() const

1284

1302

{

1285

typedef typename SchemeOptions::MessageEncodingMethod::HashIdentifierLookup HashLookup;

1286

return HashLookup::template HashIdentifierLookup2<CPP_TYPENAME SchemeOptions::HashFunction>::Lookup();

1303

typedef CPP_TYPENAME SchemeOptions::MessageEncodingMethod::HashIdentifierLookup::HashIdentifierLookup2<CPP_TYPENAME SchemeOptions::HashFunction> L;

1304

return L::Lookup();

1287

1305

}

1288

size_t GetDigestSize() const

1306

unsigned int GetDigestSize() const

1289

1307

{

1290

1308

typedef CPP_TYPENAME SchemeOptions::HashFunction H;

1291

1309

return H::DIGESTSIZE;

1295

1313

KEY m_key;

1296

1314

};

1297

1315

1298

//! _

1316

//! .

1299

1317

template <class BASE, class SCHEME_OPTIONS, class KEY>

1300

1318

class CRYPTOPP_NO_VTABLE DL_ObjectImpl : public DL_ObjectImplBase<BASE, SCHEME_OPTIONS, KEY>

1301

1319

{

1317

1335

{return Singleton<CPP_TYPENAME SCHEME_OPTIONS::MessageEncodingMethod>().Ref();}

1318

1336

};

1319

1337

1320

//! _

1338

//! .

1339

template <class BASE, class SCHEME_OPTIONS>

1340

class CRYPTOPP_NO_VTABLE DL_PublicObjectImpl : public DL_ObjectImpl<BASE, SCHEME_OPTIONS, typename SCHEME_OPTIONS::PublicKey>, public PublicKeyCopier<SCHEME_OPTIONS>

1341

{

1342

public:

1343

void CopyKeyInto(typename SCHEME_OPTIONS::PublicKey &key) const

1344

{key = GetKey();}

1345

};

1346

1347

//! .

1348

template <class BASE, class SCHEME_OPTIONS>

1349

class CRYPTOPP_NO_VTABLE DL_PrivateObjectImpl : public DL_ObjectImpl<BASE, SCHEME_OPTIONS, typename SCHEME_OPTIONS::PrivateKey>, public PrivateKeyCopier<SCHEME_OPTIONS>

1350

{

1351

public:

1352

void CopyKeyInto(typename SCHEME_OPTIONS::PublicKey &key) const

1353

{GetKey().MakePublicKey(key);}

1354

void CopyKeyInto(typename SCHEME_OPTIONS::PrivateKey &key) const

1355

{key = GetKey();}

1356

};

1357

1358

//! .

1321

1359

template <class SCHEME_OPTIONS>

1322

class DL_SignerImpl : public DL_ObjectImpl<DL_SignerBase<typename SCHEME_OPTIONS::Element>, SCHEME_OPTIONS, typename SCHEME_OPTIONS::PrivateKey>

1360

class DL_SignerImpl : public DL_PrivateObjectImpl<DL_SignerBase<typename SCHEME_OPTIONS::Element>, SCHEME_OPTIONS>

1323

1361

{

1324

1362

public:

1325

1363

PK_MessageAccumulator * NewSignatureAccumulator(RandomNumberGenerator &rng) const

1326

1364

{

1327

1365

std::auto_ptr<PK_MessageAccumulatorBase> p(new PK_MessageAccumulatorImpl<CPP_TYPENAME SCHEME_OPTIONS::HashFunction>);

1328

this->RestartMessageAccumulator(rng, *p);

1366

RestartMessageAccumulator(rng, *p);

1329

1367

return p.release();

1330

1368

}

1331

1369

};

1332

1370

1333

//! _

1371

//! .

1334

1372

template <class SCHEME_OPTIONS>

1335

class DL_VerifierImpl : public DL_ObjectImpl<DL_VerifierBase<typename SCHEME_OPTIONS::Element>, SCHEME_OPTIONS, typename SCHEME_OPTIONS::PublicKey>

1373

class DL_VerifierImpl : public DL_PublicObjectImpl<DL_VerifierBase<typename SCHEME_OPTIONS::Element>, SCHEME_OPTIONS>

1336

1374

{

1337

1375

public:

1338

1376

PK_MessageAccumulator * NewVerificationAccumulator() const

1341

1379

}

1342

1380

};

1343

1381

1344

//! _

1382

//! .

1345

1383

template <class SCHEME_OPTIONS>

1346

class DL_EncryptorImpl : public DL_ObjectImpl<DL_EncryptorBase<typename SCHEME_OPTIONS::Element>, SCHEME_OPTIONS, typename SCHEME_OPTIONS::PublicKey>

1384

class DL_EncryptorImpl : public DL_PublicObjectImpl<DL_EncryptorBase<typename SCHEME_OPTIONS::Element>, SCHEME_OPTIONS>

1347

1385

{

1348

1386

};

1349

1387

1350

//! _

1388

//! .

1351

1389

template <class SCHEME_OPTIONS>

1352

class DL_DecryptorImpl : public DL_ObjectImpl<DL_DecryptorBase<typename SCHEME_OPTIONS::Element>, SCHEME_OPTIONS, typename SCHEME_OPTIONS::PrivateKey>

1390

class DL_DecryptorImpl : public DL_PrivateObjectImpl<DL_DecryptorBase<typename SCHEME_OPTIONS::Element>, SCHEME_OPTIONS>

1353

1391

{

1354

1392

};

1355

1393

1356

1394

// ********************************************************

1357

1395

1358

//! _

1396

//! .

1359

1397

template <class T>

1360

1398

class CRYPTOPP_NO_VTABLE DL_SimpleKeyAgreementDomainBase : public SimpleKeyAgreementDomain

1361

1399

{

1420

1458

public:

1421

1459

typedef ELEMENT Element;

1422

1460

1423

static const char * CRYPTOPP_API StaticAlgorithmName()

1424

{return COFACTOR_OPTION::ToEnum() == INCOMPATIBLE_COFACTOR_MULTIPLICTION ? "DHC" : "DH";}

1461

static const char *StaticAlgorithmName()

1462

{return COFACTOR_OPTION::ToEnum() == NO_COFACTOR_MULTIPLICTION ? "DH" : "DHC";}

1425

1463

1426

1464

Element AgreeWithEphemeralPrivateKey(const DL_GroupParameters<Element> &params, const DL_FixedBasePrecomputation<Element> &publicPrecomputation, const Integer &privateExponent) const

1427

1465

{

1474

1512

public:

1475

1513

PK_FinalTemplate() {}

1476

1514

1477

PK_FinalTemplate(const CryptoMaterial &key)

1478

{this->AccessKey().AssignFrom(key);}

1479

1480

PK_FinalTemplate(BufferedTransformation &bt)

1481

{this->AccessKey().BERDecode(bt);}

1482

1483

PK_FinalTemplate(const AsymmetricAlgorithm &algorithm)

1484

{this->AccessKey().AssignFrom(algorithm.GetMaterial());}

1485

1486

1515

PK_FinalTemplate(const Integer &v1)

1487

{this->AccessKey().Initialize(v1);}

1516

{AccessKey().Initialize(v1);}

1517

1518

PK_FinalTemplate(const typename BASE::KeyClass &key) {AccessKey().operator=(key);}

1519

1520

template <class T>

1521

PK_FinalTemplate(const PublicKeyCopier<T> &key)

1522

{key.CopyKeyInto(AccessKey());}

1523

1524

template <class T>

1525

PK_FinalTemplate(const PrivateKeyCopier<T> &key)

1526

{key.CopyKeyInto(AccessKey());}

1527

1528

PK_FinalTemplate(BufferedTransformation &bt) {AccessKey().BERDecode(bt);}

1488

1529

1489

1530

#if (defined(_MSC_VER) && _MSC_VER < 1300)

1490

1531

1491

1532

template <class T1, class T2>

1492

1533

PK_FinalTemplate(T1 &v1, T2 &v2)

1493

{this->AccessKey().Initialize(v1, v2);}

1534

{AccessKey().Initialize(v1, v2);}

1494

1535

1495

1536

template <class T1, class T2, class T3>

1496

1537

PK_FinalTemplate(T1 &v1, T2 &v2, T3 &v3)

1497

{this->AccessKey().Initialize(v1, v2, v3);}

1538

{AccessKey().Initialize(v1, v2, v3);}

1498

1539

1499

1540

template <class T1, class T2, class T3, class T4>

1500

1541

PK_FinalTemplate(T1 &v1, T2 &v2, T3 &v3, T4 &v4)

1501

{this->AccessKey().Initialize(v1, v2, v3, v4);}

1542

{AccessKey().Initialize(v1, v2, v3, v4);}

1502

1543

1503

1544

template <class T1, class T2, class T3, class T4, class T5>

1504

1545

PK_FinalTemplate(T1 &v1, T2 &v2, T3 &v3, T4 &v4, T5 &v5)

1505

{this->AccessKey().Initialize(v1, v2, v3, v4, v5);}

1546

{AccessKey().Initialize(v1, v2, v3, v4, v5);}

1506

1547

1507

1548

template <class T1, class T2, class T3, class T4, class T5, class T6>

1508

1549

PK_FinalTemplate(T1 &v1, T2 &v2, T3 &v3, T4 &v4, T5 &v5, T6 &v6)

1509

{this->AccessKey().Initialize(v1, v2, v3, v4, v5, v6);}

1550

{AccessKey().Initialize(v1, v2, v3, v4, v5, v6);}

1510

1551

1511

1552

template <class T1, class T2, class T3, class T4, class T5, class T6, class T7>

1512

1553

PK_FinalTemplate(T1 &v1, T2 &v2, T3 &v3, T4 &v4, T5 &v5, T6 &v6, T7 &v7)

1513

{this->AccessKey().Initialize(v1, v2, v3, v4, v5, v6, v7);}

1554

{AccessKey().Initialize(v1, v2, v3, v4, v5, v6, v7);}

1514

1555

1515

1556

template <class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8>

1516

1557

PK_FinalTemplate(T1 &v1, T2 &v2, T3 &v3, T4 &v4, T5 &v5, T6 &v6, T7 &v7, T8 &v8)

1517

{this->AccessKey().Initialize(v1, v2, v3, v4, v5, v6, v7, v8);}

1558

{AccessKey().Initialize(v1, v2, v3, v4, v5, v6, v7, v8);}

1518

1559

1519

1560

#else

1520

1561

1521

1562

template <class T1, class T2>

1522

1563

PK_FinalTemplate(const T1 &v1, const T2 &v2)

1523

{this->AccessKey().Initialize(v1, v2);}

1564

{AccessKey().Initialize(v1, v2);}

1524

1565

1525

1566

template <class T1, class T2, class T3>

1526

1567

PK_FinalTemplate(const T1 &v1, const T2 &v2, const T3 &v3)

1527

{this->AccessKey().Initialize(v1, v2, v3);}

1568

{AccessKey().Initialize(v1, v2, v3);}

1528

1569

1529

1570

template <class T1, class T2, class T3, class T4>

1530

1571

PK_FinalTemplate(const T1 &v1, const T2 &v2, const T3 &v3, const T4 &v4)

1531

{this->AccessKey().Initialize(v1, v2, v3, v4);}

1572

{AccessKey().Initialize(v1, v2, v3, v4);}

1532

1573

1533

1574

template <class T1, class T2, class T3, class T4, class T5>

1534

1575

PK_FinalTemplate(const T1 &v1, const T2 &v2, const T3 &v3, const T4 &v4, const T5 &v5)

1535

{this->AccessKey().Initialize(v1, v2, v3, v4, v5);}

1576

{AccessKey().Initialize(v1, v2, v3, v4, v5);}

1536

1577

1537

1578

template <class T1, class T2, class T3, class T4, class T5, class T6>

1538

1579

PK_FinalTemplate(const T1 &v1, const T2 &v2, const T3 &v3, const T4 &v4, const T5 &v5, const T6 &v6)

1539

{this->AccessKey().Initialize(v1, v2, v3, v4, v5, v6);}

1580

{AccessKey().Initialize(v1, v2, v3, v4, v5, v6);}

1540

1581

1541

1582

template <class T1, class T2, class T3, class T4, class T5, class T6, class T7>

1542

1583

PK_FinalTemplate(const T1 &v1, const T2 &v2, const T3 &v3, const T4 &v4, const T5 &v5, const T6 &v6, const T7 &v7)

1543

{this->AccessKey().Initialize(v1, v2, v3, v4, v5, v6, v7);}

1584

{AccessKey().Initialize(v1, v2, v3, v4, v5, v6, v7);}

1544

1585

1545

1586

template <class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8>

1546

1587

PK_FinalTemplate(const T1 &v1, const T2 &v2, const T3 &v3, const T4 &v4, const T5 &v5, const T6 &v6, const T7 &v7, const T8 &v8)

1547

{this->AccessKey().Initialize(v1, v2, v3, v4, v5, v6, v7, v8);}

1588

{AccessKey().Initialize(v1, v2, v3, v4, v5, v6, v7, v8);}

1548

1589

1549

1590

template <class T1, class T2>

1550

1591

PK_FinalTemplate(T1 &v1, const T2 &v2)

1551

{this->AccessKey().Initialize(v1, v2);}

1592

{AccessKey().Initialize(v1, v2);}

1552

1593

1553

1594

template <class T1, class T2, class T3>

1554

1595

PK_FinalTemplate(T1 &v1, const T2 &v2, const T3 &v3)

1555

{this->AccessKey().Initialize(v1, v2, v3);}

1596

{AccessKey().Initialize(v1, v2, v3);}

1556

1597

1557

1598

template <class T1, class T2, class T3, class T4>

1558

1599

PK_FinalTemplate(T1 &v1, const T2 &v2, const T3 &v3, const T4 &v4)

1559

{this->AccessKey().Initialize(v1, v2, v3, v4);}

1600

{AccessKey().Initialize(v1, v2, v3, v4);}

1560

1601

1561

1602

template <class T1, class T2, class T3, class T4, class T5>

1562

1603

PK_FinalTemplate(T1 &v1, const T2 &v2, const T3 &v3, const T4 &v4, const T5 &v5)

1563

{this->AccessKey().Initialize(v1, v2, v3, v4, v5);}

1604

{AccessKey().Initialize(v1, v2, v3, v4, v5);}

1564

1605

1565

1606

template <class T1, class T2, class T3, class T4, class T5, class T6>

1566

1607

PK_FinalTemplate(T1 &v1, const T2 &v2, const T3 &v3, const T4 &v4, const T5 &v5, const T6 &v6)

1567

{this->AccessKey().Initialize(v1, v2, v3, v4, v5, v6);}

1608

{AccessKey().Initialize(v1, v2, v3, v4, v5, v6);}

1568

1609

1569

1610

template <class T1, class T2, class T3, class T4, class T5, class T6, class T7>

1570

1611

PK_FinalTemplate(T1 &v1, const T2 &v2, const T3 &v3, const T4 &v4, const T5 &v5, const T6 &v6, const T7 &v7)

1571

{this->AccessKey().Initialize(v1, v2, v3, v4, v5, v6, v7);}

1612

{AccessKey().Initialize(v1, v2, v3, v4, v5, v6, v7);}

1572

1613

1573

1614

template <class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8>

1574

1615

PK_FinalTemplate(T1 &v1, const T2 &v2, const T3 &v3, const T4 &v4, const T5 &v5, const T6 &v6, const T7 &v7, const T8 &v8)

1575

{this->AccessKey().Initialize(v1, v2, v3, v4, v5, v6, v7, v8);}

1616

{AccessKey().Initialize(v1, v2, v3, v4, v5, v6, v7, v8);}

1576

1617

1577

1618

#endif

1578

1619

};

1597

1638

typedef STANDARD Standard;

1598

1639

typedef TF_CryptoSchemeOptions<ALG_INFO, KEYS, MessageEncodingMethod> SchemeOptions;

1599

1640

1600

static std::string CRYPTOPP_API StaticAlgorithmName() {return std::string(KEYS::StaticAlgorithmName()) + "/" + MessageEncodingMethod::StaticAlgorithmName();}

1641

static std::string StaticAlgorithmName() {return KEYS::StaticAlgorithmName() + "/" + MessageEncodingMethod::StaticAlgorithmName();}

1601

1642

1602

1643

//! implements PK_Decryptor interface

1603

1644

typedef PK_FinalTemplate<TF_DecryptorImpl<SchemeOptions> > Decryptor;

1618

1659

typedef typename Standard::SignatureMessageEncodingMethod MessageEncodingMethod;

1619

1660

typedef TF_SignatureSchemeOptions<ALG_INFO, KEYS, MessageEncodingMethod, H> SchemeOptions;

1620

1661

1621

static std::string CRYPTOPP_API StaticAlgorithmName() {return std::string(KEYS::StaticAlgorithmName()) + "/" + MessageEncodingMethod::StaticAlgorithmName() + "(" + H::StaticAlgorithmName() + ")";}

1662

static std::string StaticAlgorithmName() {return KEYS::StaticAlgorithmName() + "/" + MessageEncodingMethod::StaticAlgorithmName() + "(" + H::StaticAlgorithmName() + ")";}

1622

1663

1623

1664

//! implements PK_Signer interface

1624

1665

typedef PK_FinalTemplate<TF_SignerImpl<SchemeOptions> > Signer;