Qlyra/test/chat_crypto_roundtrip_test.dart

import 'dart:io';

import 'package:flutter_rust_bridge/flutter_rust_bridge_for_generated.dart';
import 'package:flutter_test/flutter_test.dart';
import 'package:qlyra_crypto/qlyra_crypto.dart' as kc;

const _libPath = 'build/linux/x64/debug/bundle/lib/libqlyra_crypto.so';

void main() {
  if (!File(_libPath).existsSync()) {
    // ignore: avoid_print
    print('skipping: run `flutter build linux --debug` first');
    return;
  }

  setUpAll(() async {
    await kc.RustLib.init(externalLibrary: ExternalLibrary.open(_libPath));
  });

  test('round-trips through the native bridge', () async {
    final key = await kc.deriveKey(password: 'общий ключ');
    expect(key.length, 32);

    const plaintext = 'встречаемся в 19:00 у метро';
    final encrypted = await kc.encryptMessage(plaintext: plaintext, key: key);

    expect(encrypted, isNot(contains(RegExp(r'[a-zA-Z0-9]'))));
    expect(encrypted, contains(' '));
    expect(await kc.decryptMessage(text: encrypted, key: key), plaintext);
  });

  test('derives the same key from the same password', () async {
    final a = await kc.deriveKey(password: 'один ключ');
    final b = await kc.deriveKey(password: 'один ключ');
    expect(a, b);
  });

  test('rejects a wrong key', () async {
    final key = await kc.deriveKey(password: 'правильный');
    final wrong = await kc.deriveKey(password: 'неправильный');
    final encrypted = await kc.encryptMessage(plaintext: 'секрет', key: key);

    expect(
      () => kc.decryptMessage(text: encrypted, key: wrong),
      throwsA(predicate((e) => e.toString().contains('wrong_key'))),
    );
  });

  test('reports plain text as not encrypted', () async {
    final key = await kc.deriveKey(password: 'ключ');
    expect(await kc.looksEncrypted(text: 'привет как дела'), isFalse);
    expect(
      () => kc.decryptMessage(text: 'привет как дела', key: key),
      throwsA(predicate((e) => e.toString().contains('not_encrypted'))),
    );
  });

  group('images', _imageTests);

  test('survives whitespace mangling', () async {
    final key = await kc.deriveKey(password: 'ключ');
    final encrypted = await kc.encryptMessage(
      plaintext: 'пробелы декоративные',
      key: key,
    );
    final mangled = '  ${encrypted.replaceAll(' ', '   ')}\n';
    expect(
      await kc.decryptMessage(text: mangled, key: key),
      'пробелы декоративные',
    );
  });
}

const List<int> _tinyPng = [
  137,
  80,
  78,
  71,
  13,
  10,
  26,
  10,
  0,
  0,
  0,
  13,
  73,
  72,
  68,
  82,
  0,
  0,
  0,
  4,
  0,
  0,
  0,
  4,
  8,
  2,
  0,
  0,
  0,
  38,
  147,
  9,
  41,
  0,
  0,
  0,
  63,
  73,
  68,
  65,
  84,
  120,
  156,
  1,
  52,
  0,
  203,
  255,
  0,
  0,
  40,
  80,
  120,
  160,
  200,
  240,
  24,
  64,
  104,
  144,
  184,
  0,
  17,
  57,
  97,
  137,
  177,
  217,
  1,
  41,
  81,
  121,
  161,
  201,
  0,
  34,
  74,
  114,
  154,
  194,
  234,
  18,
  58,
  98,
  138,
  178,
  218,
  0,
  51,
  91,
  131,
  171,
  211,
  251,
  35,
  75,
  115,
  155,
  195,
  235,
  36,
  246,
  23,
  9,
  123,
  15,
  58,
  142,
  0,
  0,
  0,
  0,
  73,
  69,
  78,
  68,
  174,
  66,
  96,
  130,
];

void _imageTests() {
  late Directory tmp;

  setUp(() => tmp = Directory.systemTemp.createTempSync('qlyra_img'));
  tearDown(() => tmp.deleteSync(recursive: true));

  File writePlain() =>
      File('${tmp.path}/plain.png')..writeAsBytesSync(_tinyPng);

  test('round-trips a photo through the native bridge', () async {
    final key = await kc.deriveKey(password: 'фото-ключ');
    final plain = writePlain();
    final enc = '${tmp.path}/enc.png';
    final out = '${tmp.path}/out.png';

    await kc.encryptImageFile(sourcePath: plain.path, destPath: enc, key: key);

    final encBytes = File(enc).readAsBytesSync();
    expect(encBytes.sublist(1, 4), 'PNG'.codeUnits);
    expect(encBytes, isNot(_tinyPng));
    expect(await kc.looksEncryptedImageFile(path: enc), isTrue);
    expect(await kc.looksEncryptedImageFile(path: plain.path), isFalse);

    await kc.decryptImageFile(sourcePath: enc, destPath: out, key: key);
    expect(File(out).readAsBytesSync(), _tinyPng);
  });

  test('rejects a photo decrypted with a wrong key', () async {
    final key = await kc.deriveKey(password: 'правильный');
    final wrong = await kc.deriveKey(password: 'неправильный');
    final enc = '${tmp.path}/enc.png';

    await kc.encryptImageFile(
      sourcePath: writePlain().path,
      destPath: enc,
      key: key,
    );
    expect(
      () => kc.decryptImageFile(
        sourcePath: enc,
        destPath: '${tmp.path}/out.png',
        key: wrong,
      ),
      throwsA(predicate((e) => e.toString().contains('wrong_key'))),
    );
  });
}