Grcov report - lib.rs

1

#![deny(unsafe_code)]

2

#![warn(

3

	clippy::cargo,

4

	clippy::nursery,

5

	clippy::pedantic,

6

	clippy::restriction,

7

	future_incompatible,

8

	rust_2018_idioms

9

)]

10

#![warn(

11

	box_pointers,

12

	macro_use_extern_crate,

13

	meta_variable_misuse,

14

	missing_copy_implementations,

15

	missing_debug_implementations,

16

	missing_docs,

17

	non_ascii_idents,

18

	single_use_lifetimes,

19

	trivial_casts,

20

	trivial_numeric_casts,

21

	unaligned_references,

22

	unreachable_pub,

23

	unused_import_braces,

24

	unused_lifetimes,

25

	unused_qualifications,

26

	variant_size_differences

27

)]

28

#![allow(

29

	clippy::blanket_clippy_restriction_lints,

30

	clippy::else_if_without_else,

31

	clippy::exhaustive_enums,

32

	clippy::exhaustive_structs,

33

	clippy::expect_used,

34

	clippy::future_not_send,

35

	clippy::implicit_return,

36

	clippy::map_err_ignore,

37

	clippy::missing_inline_in_public_items,

38

	clippy::non_ascii_literal,

39

	clippy::pattern_type_mismatch,

40

	clippy::redundant_pub_crate,

41

	clippy::shadow_reuse,

42

	clippy::shadow_unrelated,

43

	clippy::tabs_in_doc_comments,

44

	clippy::unreachable,

45

	clippy::wildcard_enum_match_arm,

46

	unreachable_pub,

47

	variant_size_differences

48

)]

49

#![cfg_attr(

50

	doc,

51

	warn(rustdoc::all),

52

	allow(rustdoc::missing_doc_code_examples, rustdoc::private_doc_tests)

53

)]

54

#![cfg_attr(

55

	test,

56

	allow(

57

		box_pointers,

58

		clippy::integer_arithmetic,

59

		clippy::panic,

60

		clippy::panic_in_result_fn,

61

		clippy::similar_names,

62

		clippy::unwrap_used,

63

64

)]

65

66

//! TODO

67

// TODO: start registration and login process from `Server/ClientConfig`

68

// TODO: implement credential identifier

69

// TODO: option to save credential identifier in plaintext to support renaming

70

// TODO: expose custom identifier

71

// TODO: start `custodian-shared` for keypair types, algorithms and whatnot

72

// TODO: start `custodian-pki` for shared pki system and key generation

73

// TODO: expose server keypair with types from `custodian-shared` and enable

74

// optional external keypairs

75

76

pub(crate) mod cipher_suite;

77

mod client;

78

mod config;

79

pub mod error;

80

mod export_key;

81

mod message;

82

mod public_key;

83

mod server;

84

85

pub use arrayvec;

86

pub use serde;

87

88

#[cfg(feature = "pbkdf2")]

89

pub use crate::config::{Pbkdf2Hash, Pbkdf2Params};

90

pub use crate::{

91

	client::{ClientConfig, ClientFile, ClientLogin, ClientRegistration},

92

	config::{Ake, Argon2Algorithm, Argon2Params, Config, Group, Hash, Mhf},

93

	error::{Error, Result},

94

	export_key::ExportKey,

95

	message::{

96

		LoginFinalization, LoginRequest, LoginResponse, RegistrationFinalization,

97

		RegistrationRequest, RegistrationResponse,

98

},

99

	public_key::PublicKey,

100

	server::{ServerConfig, ServerFile, ServerLogin, ServerRegistration},

101

};

102

103

1

#[test]

104

1

fn basic() -> anyhow::Result<()> {

105

1

	const PASSWORD: &[u8] = b"password";

106

1

	let server_config = ServerConfig::default();

107

1

	let client_config = ClientConfig::new(Config::default(), Some(server_config.public_key()))?;

108

109

	// registration process

110

1

	let (client, request) = ClientRegistration::register(client_config, PASSWORD)?;

111

112

1

	let (server, response) = ServerRegistration::register(&server_config, request)?;

113

114

1

	let (client_file, finalization, _) = client.finish(response)?;

115

116

1

	let server_file = server.finish(finalization)?;

117

118

	// login process

119

1

	let (client, request) = ClientLogin::login(client_config, Some(client_file), PASSWORD)?;

120

121

1

	let (server, response) = ServerLogin::login(&server_config, Some(server_file), request)?;

122

123

1

	let (_, finalization, _) = client.finish(response)?;

124

125

1

	server.finish(finalization)?;

126

127

1

	Ok(())

128

1

129

130

1

#[test]

131

1

fn consistency() -> anyhow::Result<()> {

132

1

	const PASSWORD: &[u8] = b"password";

133

1

	let server_config = ServerConfig::default();

134

1

	let client_config = ClientConfig::default();

135

136

1

	let (client, request) = ClientRegistration::register(client_config, PASSWORD)?;

137

1

	let (server, response) = ServerRegistration::register(&server_config, request)?;

138

1

	let (client_file, finalization, export_key) = client.finish(response)?;

139

1

	let server_file = server.finish(finalization)?;

140

141

1

	let (client, request) = ClientLogin::login(client_config, None, PASSWORD)?;

142

1

	let (server, response) = ServerLogin::login(&server_config, Some(server_file), request)?;

143

1

	let (new_client_file, finalization, new_export_key) = client.finish(response)?;

144

1

	server.finish(finalization)?;

145

146

1

	assert_eq!(client_file, new_client_file);

147

1

	assert_eq!(export_key, new_export_key);

148

149

1

	Ok(())

150

1

151

152

1

#[test]

153

1

fn not_validated() -> anyhow::Result<()> {

154

1

	const PASSWORD: &[u8] = b"password";

155

1

	let server_config = ServerConfig::default();

156

1

	let client_config = ClientConfig::default();

157

1

158

1

	assert_eq!(client_config.public_key(), None);

159

160

1

	let (client, request) = ClientRegistration::register(client_config, PASSWORD)?;

161

162

1

	assert_eq!(client.config().public_key(), None);

163

164

1

	let (server, response) = ServerRegistration::register(&server_config, request)?;

165

1

	let (_, finalization, _) = client.finish(response)?;

166

1

	let server_file = server.finish(finalization)?;

167

168

1

	let (client, request) = ClientLogin::login(client_config, None, PASSWORD)?;

169

170

1

	assert_eq!(client.config().public_key(), None);

171

172

1

	let (server, response) = ServerLogin::login(&server_config, Some(server_file), request)?;

173

1

	let (_, finalization, _) = client.finish(response)?;

174

1

	server.finish(finalization)?;

175

176

1

	Ok(())

177

1

178

179

1

#[test]

180

1

fn wrong_password() -> anyhow::Result<()> {

181

1

	let client_config = ClientConfig::default();

182

1

	let server_config = ServerConfig::default();

183

184

1

	let (client, request) = ClientRegistration::register(client_config, "right password")?;

185

1

	let (server, response) = ServerRegistration::register(&server_config, request)?;

186

1

	let (_, finalization, _) = client.finish(response)?;

187

1

	let server_file = server.finish(finalization)?;

188

189

1

	let (client, request) = ClientLogin::login(client_config, None, "wrong password")?;

190

1

	let (_, response) = ServerLogin::login(&server_config, Some(server_file), request)?;

191

1

	assert_eq!(client.finish(response), Err(Error::Credentials));

192

193

1

	Ok(())

194

1

195

196

1

#[test]

197

1

fn no_client() -> anyhow::Result<()> {

198

1

	let client_config = ClientConfig::default();

199

1

	let server_config = ServerConfig::default();

200

201

1

	let (client, request) = ClientLogin::login(client_config, None, "password")?;

202

1

	let (_, response) = ServerLogin::login(&server_config, None, request)?;

203

1

	assert_eq!(client.finish(response), Err(Error::Credentials));

204

205

1

	Ok(())

206

1

207

208

1

#[test]

209

1

fn wrong_server_register() -> anyhow::Result<()> {

210

1

	let server_config = ServerConfig::default();

211

1

	let server_config_wrong = ServerConfig::default();

212

1

	let client_config =

213

1

		ClientConfig::new(Config::default(), Some(server_config_wrong.public_key()))?;

214

215

1

	let (client, request) = ClientRegistration::register(client_config, "password")?;

216

1

	let (_, response) = ServerRegistration::register(&server_config, request)?;

217

1

	assert_eq!(client.finish(response), Err(Error::InvalidServer));

218

219

1

	Ok(())

220

1

221

222

1

#[test]

223

1

fn wrong_server_login() -> anyhow::Result<()> {

224

1

	const PASSWORD: &[u8] = b"password";

225

1

	let server_config = ServerConfig::default();

226

1

	let server_config_wrong = ServerConfig::default();

227

228

1

	let client_config = ClientConfig::new(Config::default(), None)?;

229

1

	let (client, request) = ClientRegistration::register(client_config, PASSWORD)?;

230

1

	let (server, response) = ServerRegistration::register(&server_config, request)?;

231

1

	let (_, finalization, _) = client.finish(response)?;

232

1

	let server_file = server.finish(finalization)?;

233

234

1

	let client_config =

235

1

		ClientConfig::new(Config::default(), Some(server_config_wrong.public_key()))?;

236

1

	let (client, request) = ClientLogin::login(client_config, None, PASSWORD)?;

237

1

	let (_, response) = ServerLogin::login(&server_config, Some(server_file), request)?;

238

1

	assert_eq!(client.finish(response), Err(Error::InvalidServer));

239

240

1

	Ok(())

241

1

242

243

1

#[test]

244

1

fn wrong_server_config() -> anyhow::Result<()> {

245

1

	const PASSWORD: &[u8] = b"password";

246

1

	let client_config = ClientConfig::default();

247

1

	let server_config = ServerConfig::default();

248

1

	let server_config_wrong = ServerConfig::default();

249

250

1

	let (client, request) = ClientRegistration::register(client_config, PASSWORD)?;

251

1

	let (server, response) = ServerRegistration::register(&server_config, request)?;

252

1

	let (_, finalization, _) = client.finish(response)?;

253

1

	let server_file = server.finish(finalization)?;

254

255

1

	let (_, request) = ClientLogin::login(client_config, None, PASSWORD)?;

256

1

	assert_eq!(

257

1

		ServerLogin::login(&server_config_wrong, Some(server_file), request),

258

1

		Err(Error::ServerFile)

259

1

);

260

261

1

	Ok(())

262

1

263

264

1

#[test]

265

1

fn wrong_client_config() -> anyhow::Result<()> {

266

1

	const PASSWORD: &[u8] = b"password";

267

1

	let server_config = ServerConfig::default();

268

1

	let client_config = ClientConfig::new(Config::default(), Some(server_config.public_key()))?;

269

1

	let server_config_wrong = ServerConfig::default();

270

1

	let client_config_wrong =

271

1

		ClientConfig::new(Config::default(), Some(server_config_wrong.public_key()))?;

272

273

1

	let (client, request) = ClientRegistration::register(client_config, PASSWORD)?;

274

1

	let (server, response) = ServerRegistration::register(&server_config, request)?;

275

1

	let (client_file, finalization, _) = client.finish(response)?;

276

1

	let _server_file = server.finish(finalization)?;

277

278

1

	let (client, request) = ClientRegistration::register(client_config_wrong, PASSWORD)?;

279

1

	let (server, response) = ServerRegistration::register(&server_config_wrong, request)?;

280

1

	let (client_file_wrong, finalization, _) = client.finish(response)?;

281

1

	let _server_file_wrong = server.finish(finalization)?;

282

283

1

	assert_eq!(

284

1

		ClientLogin::login(client_config, Some(client_file_wrong), PASSWORD),

285

1

		Err(Error::ConfigPublicKey)

286

1

);

287

1

	assert_eq!(

288

1

		ClientLogin::login(client_config_wrong, Some(client_file), PASSWORD),

289

1

		Err(Error::ConfigPublicKey)

290

1

);

291

292

1

	Ok(())

293

1

294

295

1

#[test]

296

#[allow(clippy::too_many_lines)]

297

1

fn cipher_suites() -> anyhow::Result<()> {

298

	use std::fmt::Debug;

299

300

	use serde::{de::DeserializeOwned, Serialize};

301

302

	const PASSWORD: &[u8] = b"password";

303

304

72

	fn cipher_suite(ake: Ake, group: Group, hash: Hash, mhf: Mhf) -> anyhow::Result<()> {

305

1224

		fn serialize<T: Debug + DeserializeOwned + PartialEq<T> + Serialize>(

306

1224

			value: &T,

307

1224

		) -> anyhow::Result<T> {

308

1224

			let new = bincode::deserialize::<T>(&bincode::serialize(value)?)?;

309

1224

			assert_eq!(&new, value);

310

1224

			let new = bincode::deserialize_from(bincode::serialize(value)?.as_slice())?;

311

1224

			assert_eq!(&new, value);

312

1224

			Ok(new)

313

1224

314

315

72

		let config = serialize(&Config::new(ake, group, hash, mhf))?;

316

317

72

		assert_eq!(config.ake(), ake);

318

72

		assert_eq!(config.group(), group);

319

72

		assert_eq!(config.crypto_hash(), hash);

320

72

		assert_eq!(config.mhf(), mhf);

321

322

72

		let server_config = serialize(&ServerConfig::new(config))?;

323

72

		let client_config = serialize(&ClientConfig::new(

324

72

			config,

325

72

			Some(server_config.public_key()),

326

72

		)?)?;

327

328

72

		let (client, request) = ClientRegistration::register(client_config, PASSWORD)?;

329

72

		let (client, request) = (serialize(&client)?, serialize(&request)?);

330

72

		let (server, response) = ServerRegistration::register(&server_config, request)?;

331

72

		let (server, response) = (serialize(&server)?, serialize(&response)?);

332

72

		let (client_file, finalization, export_key) = client.finish(response)?;

333

72

		let (client_file, finalization) = (serialize(&client_file)?, serialize(&finalization)?);

334

72

		let server_file = serialize(&server.finish(finalization)?)?;

335

336

72

		let (client, request) = ClientLogin::login(client_config, Some(client_file), PASSWORD)?;

337

72

		let (client, request) = (serialize(&client)?, serialize(&request)?);

338

72

		let (server, response) =

339

72

			ServerLogin::login(&server_config, Some(server_file.clone()), request)?;

340

72

		let (server, response) = (serialize(&server)?, serialize(&response)?);

341

72

		let (new_client_file, finalization, new_export_key) = client.finish(response)?;

342

72

		let (new_client_file, finalization, new_export_key) = (

343

72

			serialize(&new_client_file)?,

344

72

			serialize(&finalization)?,

345

72

			serialize(&new_export_key)?,

346

);

347

72

		server.finish(finalization)?;

348

349

72

		assert_eq!(client_file, new_client_file);

350

72

		assert_eq!(

351

72

			client_config.public_key().unwrap().to_bytes(),

352

72

			client_config.public_key().unwrap().to_bytes()

353

72

);

354

72

		assert_eq!(

355

72

			client_file.public_key().to_bytes(),

356

72

			new_client_file.public_key().to_bytes()

357

72

);

358

72

		assert_eq!(

359

72

			server_config.public_key().to_bytes(),

360

72

			server_config.public_key().to_bytes()

361

72

);

362

72

		assert_eq!(

363

72

			server_file.public_key().to_bytes(),

364

72

			server_file.public_key().to_bytes()

365

72

);

366

72

		assert_eq!(export_key, new_export_key);

367

72

		assert_eq!(export_key.as_bytes(), new_export_key.as_bytes());

368

72

		assert_eq!(export_key.as_ref(), new_export_key.as_ref());

369

72

		assert_eq!(&*export_key, &*new_export_key);

370

371

72

		Ok(())

372

72

373

374

1

	let argon2id = Mhf::Argon2(Argon2Params::new(

375

1

		Argon2Algorithm::Argon2id,

376

1

		None,

377

1

		None,

378

1

		None,

379

1

	)?);

380

1

	let argon2d = Mhf::Argon2(Argon2Params::new(

381

1

		Argon2Algorithm::Argon2d,

382

1

		None,

383

1

		None,

384

1

		None,

385

1

	)?);

386

	#[cfg(feature = "pbkdf2")]

387

1

	let pbkdf2sha256 = Mhf::Pbkdf2(Pbkdf2Params::new(Pbkdf2Hash::Sha256, None)?);

388

	#[cfg(feature = "pbkdf2")]

389

1

	let pbkdf2sha512 = Mhf::Pbkdf2(Pbkdf2Params::new(Pbkdf2Hash::Sha512, None)?);

390

391

1

	let akes = [

392

1

		Ake::Ristretto255,

393

1

		Ake::X25519,

394

1

		#[cfg(feature = "p256")]

395

1

		Ake::P256,

396

1

];

397

1

398

1

	let groups = [

399

1

		Group::Ristretto255,

400

1

		#[cfg(feature = "p256")]

401

1

		Group::P256,

402

1

];

403

1

404

1

	let hashs = [

405

1

		Hash::Sha2,

406

1

		#[cfg(feature = "sha3")]

407

1

		Hash::Sha3,

408

1

		#[cfg(feature = "blake3")]

409

1

		Hash::Blake3,

410

1

];

411

1

412

1

	let mhfs = [

413

1

		argon2id,

414

1

		argon2d,

415

1

		#[cfg(feature = "pbkdf2")]

416

1

		pbkdf2sha256,

417

1

		#[cfg(feature = "pbkdf2")]

418

1

		pbkdf2sha512,

419

1

];

420

421

4

	for ake in akes {

422

9

		for group in groups {

423

24

			for hash in hashs {

424

90

				for mhf in mhfs {

425

72

					cipher_suite(ake, group, hash, mhf)?;

426

427

428

429

430

431

1

	Ok(())

432

1

433

434

1

#[test]

435

1

fn wrong_config() -> anyhow::Result<()> {

436

	// Configuration

437

	const PASSWORD: &[u8] = b"password";

438

439

1

	let config = Config::new(

440

1

		Ake::default(),

441

1

		Group::default(),

442

1

		Hash::default(),

443

1

		Mhf::Argon2(Argon2Params::new(

444

1

			Argon2Algorithm::Argon2id,

445

1

			None,

446

1

			None,

447

1

			None,

448

1

		)?),

449

);

450

1

	let wrong_config = Config::new(

451

1

		Ake::default(),

452

1

		Group::default(),

453

1

		Hash::default(),

454

1

		Mhf::Argon2(Argon2Params::new(

455

1

			Argon2Algorithm::Argon2d,

456

1

			None,

457

1

			None,

458

1

			None,

459

1

		)?),

460

);

461

1

	let server_config = ServerConfig::new(config);

462

1

	let wrong_server_config = ServerConfig::new(wrong_config);

463

1

	let client_config = ClientConfig::new(config, Some(server_config.public_key()))?;

464

1

	let wrong_client_config =

465

1

		ClientConfig::new(wrong_config, Some(wrong_server_config.public_key()))?;

466

467

1

	assert_eq!(

468

1

		ClientConfig::new(config, Some(wrong_server_config.public_key())),

469

1

		Err(Error::Config)

470

1

);

471

472

	// Registration

473

1

	let (client, request) = ClientRegistration::register(client_config, PASSWORD)?;

474

1

	let (server, response) = ServerRegistration::register(&server_config, request.clone())?;

475

1

	let (client_file, finalization, _) = client.clone().finish(response.clone())?;

476

1

	let server_file = server.clone().finish(finalization.clone())?;

477

478

1

	let (wrong_client, wrong_request) =

479

1

		ClientRegistration::register(wrong_client_config, PASSWORD)?;

480

1

	let (wrong_server, wrong_response) =

481

1

		ServerRegistration::register(&wrong_server_config, wrong_request.clone())?;

482

1

	let (wrong_client_file, wrong_finalization, _) =

483

1

		wrong_client.clone().finish(wrong_response.clone())?;

484

1

	let wrong_server_file = wrong_server.clone().finish(wrong_finalization.clone())?;

485

486

1

	assert_eq!(

487

1

		ServerRegistration::register(&wrong_server_config, request),

488

1

		Err(Error::Config)

489

1

);

490

1

	assert_eq!(

491

1

		ServerRegistration::register(&server_config, wrong_request),

492

1

		Err(Error::Config)

493

1

);

494

495

1

	assert_eq!(wrong_client.finish(response), Err(Error::Config));

496

1

	assert_eq!(client.finish(wrong_response), Err(Error::Config));

497

498

1

	assert_eq!(wrong_server.finish(finalization), Err(Error::Config));

499

1

	assert_eq!(server.finish(wrong_finalization), Err(Error::Config));

500

501

	// Login

502

1

	let (client, request) = ClientLogin::login(client_config, Some(client_file), PASSWORD)?;

503

1

	let (server, response) =

504

1

		ServerLogin::login(&server_config, Some(server_file.clone()), request.clone())?;

505

1

	let (_, finalization, _) = client.clone().finish(response.clone())?;

506

1

	server.clone().finish(finalization.clone())?;

507

508

1

	let (wrong_client, wrong_request) =

509

1

		ClientLogin::login(wrong_client_config, Some(wrong_client_file), PASSWORD)?;

510

1

	let (wrong_server, wrong_response) = ServerLogin::login(

511

1

		&wrong_server_config,

512

1

		Some(wrong_server_file.clone()),

513

1

		wrong_request.clone(),

514

1

)?;

515

1

	let (_, wrong_finalization, _) = wrong_client.clone().finish(wrong_response.clone())?;

516

1

	wrong_server.clone().finish(wrong_finalization.clone())?;

517

518

1

	assert_eq!(

519

1

		ClientLogin::login(wrong_client_config, Some(client_file), PASSWORD),

520

1

		Err(Error::Config)

521

1

);

522

1

	assert_eq!(

523

1

		ClientLogin::login(client_config, Some(wrong_client_file), PASSWORD),

524

1

		Err(Error::Config)

525

1

);

526

527

1

	assert_eq!(

528

1

		ServerLogin::login(

529

1

			&wrong_server_config,

530

1

			Some(server_file.clone()),

531

1

			request.clone()

532

1

),

533

1

		Err(Error::Config)

534

1

);

535

1

	assert_eq!(

536

1

		ServerLogin::login(&server_config, Some(wrong_server_file), request),

537

1

		Err(Error::ServerFile)

538

1

);

539

1

	assert_eq!(

540

1

		ServerLogin::login(&server_config, Some(server_file), wrong_request),

541

1

		Err(Error::Config)

542

1

);

543

544

1

	assert_eq!(wrong_client.finish(response), Err(Error::Config));

545

1

	assert_eq!(client.finish(wrong_response), Err(Error::Config));

546

547

1

	assert_eq!(wrong_server.finish(finalization), Err(Error::Config));

548

1

	assert_eq!(server.finish(wrong_finalization), Err(Error::Config));

549

550

1

	Ok(())

551

1

552

553

1

#[test]

554

#[allow(clippy::cognitive_complexity)]

555

1

fn getters() -> anyhow::Result<()> {

556

1

	// Configuration

557

1

	const PASSWORD: &[u8] = b"password";

558

1

559

1

	let config = Config::default();

560

1

	let server_config = ServerConfig::new(config);

561

1

	let client_config = ClientConfig::new(config, Some(server_config.public_key()))?;

562

1

	let public_key = server_config.public_key();

563

1

564

1

	assert_eq!(server_config.config(), config);

565

1

	assert_eq!(client_config.config(), config);

566

1

	assert_eq!(client_config.public_key(), Some(server_config.public_key()));

567

1

	assert_eq!(public_key.config(), config);

568

569

1

	let (client, request) = ClientRegistration::register(client_config, PASSWORD)?;

570

571

1

	assert_eq!(client.config().config(), config);

572

1

	assert_eq!(client.config().public_key(), Some(public_key));

573

1

	assert_eq!(request.config(), config);

574

575

1

	let (server, response) = ServerRegistration::register(&server_config, request)?;

576

577

1

	assert_eq!(server.config(), config);

578

1

	assert_eq!(server.public_key(), public_key);

579

1

	assert_eq!(response.config(), config);

580

581

1

	let (client_file, finalization, export_key) = client.finish(response)?;

582

583

1

	assert_eq!(client_file.config(), config);

584

1

	assert_eq!(client_file.public_key(), public_key);

585

1

	assert_eq!(export_key.as_ref(), export_key.as_bytes());

586

1

	assert_eq!(&*export_key, export_key.as_bytes());

587

1

	assert_eq!(finalization.config(), config);

588

589

1

	let server_file = server.finish(finalization)?;

590

591

1

	assert_eq!(server_file.config(), config);

592

1

	assert_eq!(server_file.public_key(), public_key);

593

594

1

	let (client, request) = ClientLogin::login(client_config, Some(client_file), PASSWORD)?;

595

596

1

	assert_eq!(client.config().config(), config);

597

1

	assert_eq!(client.config().public_key(), Some(public_key));

598

1

	assert_eq!(request.config(), config);

599

600

1

	let (server, response) = ServerLogin::login(&server_config, Some(server_file), request)?;

601

602

1

	assert_eq!(server.config(), config);

603

1

	assert_eq!(response.config(), config);

604

605

1

	let (new_client_file, finalization, export_key) = client.finish(response)?;

606

607

1

	assert_eq!(new_client_file.config(), config);

608

1

	assert_eq!(new_client_file.public_key(), public_key);

609

1

	assert_eq!(export_key.as_ref(), export_key.as_bytes());

610

1

	assert_eq!(&*export_key, export_key.as_bytes());

611

1

	assert_eq!(finalization.config(), config);

612

613

1

	server.finish(finalization)?;

614

615

1

	Ok(())

616

1